kleis-technology · pevab · Mar 26, 2026 · Mar 20, 2026 · Mar 20, 2026 · Mar 20, 2026
diff --git a/plugin/build.gradle.kts b/plugin/build.gradle.kts
@@ -47,7 +47,7 @@ sourceSets {
 }
 
 dependencies {
-    implementation("ch.kleis.lcaac:core:2.0.0")
+    implementation("ch.kleis.lcaac:core:2.3.0")
 
     implementation(files(layout.buildDirectory.dir("stdlib/ef3.1")) {
         builtBy("generateEmissionFactors31")

diff --git a/plugin/src/main/kotlin/ch/kleis/lcaac/plugin/actions/csv/CsvProcessor.kt b/plugin/src/main/kotlin/ch/kleis/lcaac/plugin/actions/csv/CsvProcessor.kt
@@ -32,32 +32,22 @@ class CsvProcessor(
         )
     )
     private val sourceOps = DefaultDataSourceOperations(ops, config, factory.buildConnectors())
-    private val evaluator = Evaluator(symbolTable, ops, sourceOps)
 
     fun process(request: CsvRequest): List<CsvResult> {
+        val globalParameters = parseOverrides(
+            symbolTable.globalParameters.toMap().mapKeys { it.key.name },
+            request,
+        )
         val reqName = request.processName
         val reqLabels = request.matchLabels
         val template =
             symbolTable.getTemplate(reqName, reqLabels)
                 ?: throw EvaluatorException("Could not get template for ${request.processName}")
+        val processParameters = parseOverrides(template.params, request)
 
-        val arguments = template.params
-            .mapValues { entry ->
-                when (val v = entry.value) {
-                    is QuantityExpression<*> -> request[entry.key]?.let {
-                        val amount = parseDouble(it)
-                        EQuantityScale(ops.pure(amount), EUnitOf(v))
-                    } ?: entry.value
-
-                    is StringExpression -> request[entry.key]?.let {
-                        EStringLiteral(it)
-                    } ?: entry.value
-
-                    else -> throw EvaluatorException("$v is not a supported data expression")
-                }
-            }
-
-        val trace = evaluator.trace(template, arguments)
+        val st = symbolTable.overrideGlobalParameters(globalParameters)
+        val evaluator = Evaluator(st, ops, sourceOps)
+        val trace = evaluator.trace(template, processParameters)
         val systemValue = trace.getSystemValue()
         val entryPoint = trace.getEntryPoint()
         val program = ContributionAnalysisProgram(systemValue, entryPoint)
@@ -73,4 +63,23 @@ class CsvProcessor(
                 )
             }
     }
+
+    private fun parseOverrides(
+        data: Map<String, DataExpression<BasicNumber>>,
+        request: CsvRequest
+    ): Map<String, DataExpression<BasicNumber>> = data
+        .mapValues { entry ->
+            when (val v = entry.value) {
+                is QuantityExpression<*> -> request[entry.key]?.let {
+                    val amount = parseDouble(it)
+                    EQuantityScale(ops.pure(amount), EUnitOf(v))
+                } ?: entry.value
+
+                is StringExpression -> request[entry.key]?.let {
+                    EStringLiteral(it)
+                } ?: entry.value
+
+                else -> throw EvaluatorException("$v is not a supported data expression")
+            }
+        }
 }
diff --git a/plugin/src/main/kotlin/ch/kleis/lcaac/plugin/actions/tasks/SensitivityAnalysisTask.kt b/plugin/src/main/kotlin/ch/kleis/lcaac/plugin/actions/tasks/SensitivityAnalysisTask.kt
@@ -56,12 +56,17 @@ class SensitivityAnalysisTask(
         indicator.isIndeterminate = true
 
         // nb params via psi
-        val nbQuantitativeParams = runReadAction {
+        val nbGlobalParams = runReadAction {
+            val collector = LcaFileCollector(file.project)
+            collector.collect(file).flatMap { it.getGlobalParameters() }.toList().size
+        }
+        val nbProcessQuantitativeParams = runReadAction {
             val fqn = "${file.getPackageName()}.$processName"
             ProcessStubKeyIndex.findProcesses(project, fqn, matchLabels).first().getParameters()
                 .filter { it.value !is LcaStringExpression }
                 .size
         }
+        val nbQuantitativeParams = nbGlobalParams + nbProcessQuantitativeParams
         val ops = DualOperations(nbQuantitativeParams)
         if (nbQuantitativeParams == 0) {
             NotificationGroupManager.getInstance()
@@ -101,10 +106,29 @@ class SensitivityAnalysisTask(
             )
         )
         val sourceOps = DefaultDataSourceOperations(ops, config, factory.buildConnectors())
-        val (arguments, parameters) =
-            prepareArguments(ops, sourceOps, symbolTable, template.params)
-        val trace = Evaluator(symbolTable, ops, sourceOps).trace(template, arguments)
-        this.analysis = SensitivityAnalysisProgram(trace.getSystemValue(), trace.getEntryPoint(), parameters).run()
+        val (globalArguments, globalParameters) =
+            prepareArguments(
+                ops, sourceOps, symbolTable,
+                symbolTable.globalParameters.toMap().mapKeys { it.key.name },
+                offset = 0,
+            )
+        val st = symbolTable.overrideGlobalParameters(globalArguments)
+        val evaluator = Evaluator(st, ops, sourceOps)
+        val (processArguments, processParameters) =
+            prepareArguments(
+                ops, sourceOps, symbolTable,
+                template.params,
+                offset = globalParameters.size(),
+            )
+        val trace = evaluator.trace(template, processArguments)
+        val allParameters = globalParameters + processParameters
+        this.analysis =
+            SensitivityAnalysisProgram(
+                trace.getSystemValue(),
+                trace.getEntryPoint(),
+                allParameters,
+                ops,
+            ).run()
     }
 
     override fun onSuccess() {
@@ -142,7 +166,8 @@ class SensitivityAnalysisTask(
         ops: DualOperations,
         sourceOps: DataSourceOperations<DualNumber>,
         symbolTable: SymbolTable<DualNumber>,
-        params: Map<String, DataExpression<DualNumber>>
+        params: Map<String, DataExpression<DualNumber>>,
+        offset: Int = 0,
     ): Pair<Map<String, DataExpression<DualNumber>>, ParameterVector<DualNumber>> {
         val dataReducer = DataExpressionReducer(symbolTable.data, symbolTable.dataSources, ops, sourceOps)
         val reduced = params.mapValues { dataReducer.reduce(it.value) }
@@ -151,7 +176,7 @@ class SensitivityAnalysisTask(
             .mapIndexed { index: Int, (name, value): Pair<String, EQuantityScale<DualNumber>> ->
                 with(ops) {
                     name to EQuantityScale(
-                        value.scale * (pure(1.0) + basis(index)),
+                        value.scale * (pure(1.0) + basis(offset + index)),
                         value.base,
                     )
                 }

diff --git a/plugin/src/main/kotlin/ch/kleis/lcaac/plugin/language/Lca.bnf b/plugin/src/main/kotlin/ch/kleis/lcaac/plugin/language/Lca.bnf
@@ -92,7 +92,7 @@
     LCA File
  */
 
-lcaFile ::= package? import* (process | test | dataSourceDefinition | unitDefinition | substance | globalVariables )*
+lcaFile ::= package? import* (process | test | dataSourceDefinition | unitDefinition | substance | globalParameters | globalVariables )*
 
 /*
     Package
@@ -129,6 +129,7 @@ columnDefinition ::= columnRef '=' dataExpression {
     Global variables
  */
 
+globalParameters ::= "params" '{' globalAssignment* '}'
 globalVariables ::= "variables" '{' globalAssignment* '}'
 globalAssignment ::= dataRef '=' dataExpression {
     implements=["ch.kleis.lcaac.plugin.language.psi.type.PsiGlobalAssignment"]

diff --git a/plugin/src/main/kotlin/ch/kleis/lcaac/plugin/language/loader/LcaLoader.kt b/plugin/src/main/kotlin/ch/kleis/lcaac/plugin/language/loader/LcaLoader.kt
@@ -50,7 +50,7 @@ class LcaLoader<Q>(
                 throw EvaluatorException("Duplicate substance ${e.duplicates} defined")
             }
 
-            val globals = try {
+            val globalVariables = try {
                 DataRegister.empty<DataKey, DataExpression<Q>>()
                     .plus(
                         unitDefinitions
@@ -66,20 +66,31 @@ class LcaLoader<Q>(
                     )
                     .plus(
                         files
-                            .flatMap { it.getGlobalAssignments() }
+                            .flatMap { it.getGlobalVariables() }
                             .map { DataKey(it.first) to dataExpression(it.second) }
                             .asIterable()
                     )
             } catch (e: RegisterException) {
                 throw EvaluatorException("Duplicate global variable ${e.duplicates} defined")
             }
 
+            val globalParameters = try {
+                DataRegister.empty<DataKey, DataExpression<Q>>()
+                    .plus(files
+                        .flatMap { it.getGlobalParameters() }
+                        .map { DataKey(it.first) to dataExpression(it.second) }
+                        .asIterable()
+                    )
+            } catch (e: RegisterException) {
+                throw EvaluatorException("Duplicate global variable ${e.duplicates} defined")
+            }
+
             val dataSources = try {
 
                 DataSourceRegister.empty<DataSourceKey, EDataSource<Q>>()
                     .plus(
                         dataSourceDefinitions.map { DataSourceKey(it.getDataSourceRef().name) to dataSourceDefinition(it) }
-                        .asIterable()
+                            .asIterable()
                     )
             } catch (e: RegisterException) {
                 throw EvaluatorException("Duplicate data source ${e.duplicates} defined")
@@ -89,15 +100,16 @@ class LcaLoader<Q>(
                 ProcessTemplateRegister.empty<ProcessKey, EProcessTemplate<Q>>()
                     .plus(
                         processDefinitions
-                            .map { Pair(it.buildUniqueKey(), process(it, globals, dataSources)) }
+                            .map { Pair(it.buildUniqueKey(), process(it, globalParameters, globalVariables, dataSources)) }
                             .asIterable()
                     )
             } catch (e: RegisterException) {
                 throw EvaluatorException("Duplicate process ${e.duplicates} defined")
             }
 
             return SymbolTable(
-                data = globals,
+                globalParameters = globalParameters,
+                globalVariables = globalVariables,
                 dataSources = dataSources,
                 processTemplates = processTemplates,
                 dimensions = dimensions,

diff --git a/plugin/src/main/kotlin/ch/kleis/lcaac/plugin/language/loader/LcaMapper.kt b/plugin/src/main/kotlin/ch/kleis/lcaac/plugin/language/loader/LcaMapper.kt
@@ -32,17 +32,19 @@ class LcaMapper<Q>(
 
     fun process(
         psiProcess: LcaProcess,
-        globals: DataRegister<Q>,
+        globalParameters: DataRegister<Q>,
+        globalVariables: DataRegister<Q>,
         dataSources: DataSourceRegister<Q>,
     ): EProcessTemplate<Q> {
         val name = psiProcess.name
         val labels = psiProcess.getLabels().mapValues { EStringLiteral<Q>(it.value) }
         val locals = psiProcess.getVariables().mapValues { dataExpression(it.value) }
         val params = psiProcess.getParameters().mapValues { dataExpression(it.value) }
         val symbolTable = SymbolTable(
-            data = try {
+            globalParameters,
+            globalVariables = try {
                 Register(
-                    globals
+                    globalVariables
                         .plus(params.mapKeys { DataKey(it.key) })
                         .plus(locals.mapKeys { DataKey(it.key) })
                 )

diff --git a/plugin/src/main/kotlin/ch/kleis/lcaac/plugin/language/psi/LcaFile.kt b/plugin/src/main/kotlin/ch/kleis/lcaac/plugin/language/psi/LcaFile.kt
@@ -51,7 +51,15 @@ class LcaFile(viewProvider: FileViewProvider) : PsiFileBase(viewProvider, LcaLan
         return PsiTreeUtil.getChildrenOfTypeAsList(this, LcaSubstance::class.java)
     }
 
-    fun getGlobalAssignments(): Collection<Pair<String, LcaDataExpression>> {
+    fun getGlobalParameters(): Collection<Pair<String, LcaDataExpression>> {
+        return PsiTreeUtil.getChildrenOfTypeAsList(this, LcaGlobalParameters::class.java)
+            .flatMap {
+                it.globalAssignmentList
+                    .map { a -> a.getDataRef().name to a.getValue() }
+            }
+    }
+
+    fun getGlobalVariables(): Collection<Pair<String, LcaDataExpression>> {
         return PsiTreeUtil.getChildrenOfTypeAsList(this, LcaGlobalVariables::class.java)
             .flatMap {
                 it.globalAssignmentList

diff --git a/plugin/src/main/kotlin/ch/kleis/lcaac/plugin/language/psi/stub/StubIndexVersion.kt b/plugin/src/main/kotlin/ch/kleis/lcaac/plugin/language/psi/stub/StubIndexVersion.kt
@@ -3,4 +3,4 @@ package ch.kleis.lcaac.plugin.language.psi.stub
 /**
  * Should be incremented when the stub structure is modified.
  */
-const val stubIndexVersion: Int = 8
+const val stubIndexVersion: Int = 9
diff --git a/plugin/src/test/kotlin/ch/kleis/lcaac/plugin/e2e/E2ETest.kt b/plugin/src/test/kotlin/ch/kleis/lcaac/plugin/e2e/E2ETest.kt
@@ -135,7 +135,7 @@ class E2ETest : BasePlatformTestCase() {
 
         // then
         Prelude.unitMap<BasicNumber>().forEach {
-            assertNotNull(symbolTable.getData(it.key))
+            assertNotNull(symbolTable.getGlobalVariable(it.key))
         }
     }
 
@@ -587,7 +587,7 @@ class E2ETest : BasePlatformTestCase() {
 
         // when
         val symbolTable = createFilesAndSymbols(vf)
-        val target = symbolTable.getData("q")!!
+        val target = symbolTable.getGlobalVariable("q")!!
         val reducer = DataExpressionReducer(symbolTable.data, symbolTable.dataSources, ops, mockk())
         val actual = with(ToValue(ops)) {
             reducer.reduce(target).toValue()

diff --git a/plugin/src/test/kotlin/ch/kleis/lcaac/plugin/language/ide/syntax/LanguageCompletionTest.kt b/plugin/src/test/kotlin/ch/kleis/lcaac/plugin/language/ide/syntax/LanguageCompletionTest.kt
@@ -21,15 +21,16 @@ class LanguageCompletionTest : LcaCompletionTestCase() {
         assertNotNull(lookupElementStrings)
         assertSameElements(
             lookupElementStrings!!,
+            "@cached",
+            "datasource",
             "import",
             "package",
+            "params",
             "process",
             "substance",
+            "test",
             "unit",
             "variables",
-            "test",
-            "datasource",
-            "@cached"
         )
     }
 
@@ -44,7 +45,7 @@ class LanguageCompletionTest : LcaCompletionTestCase() {
 
         // Then
         assertNotNull(lookupElementStrings)
-        assertSameElements(lookupElementStrings!!, "import", "package", "process")
+        assertSameElements(lookupElementStrings!!, "package", "params", "process", "import")
     }
 
     @Test