Serialize sensitivity

pom.xml

@@ -29,6 +29,13 @@
             <version>2023.3.3</version>
         </dependency>
 
+        <!-- Force sensitivity analysis api one version higher. Can probably be removed in next powsybl-starter release -->
+        <dependency>
+            <groupId>com.powsybl</groupId>
+            <artifactId>powsybl-sensitivity-analysis-api</artifactId>
+            <version>6.1.0</version>
+        </dependency>
+
         <dependency>
             <groupId>io.ktor</groupId>
             <artifactId>ktor-server-core-jvm</artifactId>

src/main/ApiDataModels.kt

@@ -2,6 +2,7 @@ package com.github.statnett.loadflowservice
 
 import com.powsybl.iidm.network.Network
 import com.powsybl.security.SecurityAnalysisResult
+import com.powsybl.sensitivity.SensitivityAnalysisResult
 import kotlinx.serialization.Serializable
 
 /**
@@ -69,4 +70,12 @@ data class LoadFlowServiceSecurityAnalysisResult(
     @Serializable(with = SecurityAnalysisResultSerializer::class)
     val securityAnalysisResult: SecurityAnalysisResult,
     val report: String
-) : ComputationResult()
+) : ComputationResult()
+
+
+@Serializable
+data class LoadFlowServiceSensitivityAnalysisResult(
+    @Serializable(with = SensitivityAnalysisResultSerializer::class)
+    val sensitivityAnalysisResult: SensitivityAnalysisResult,
+    val report: String
+): ComputationResult()

src/main/App.kt

@@ -98,13 +98,15 @@ fun Application.module() {
 
             sensParamCnt.parameters.setLoadFlowParameters(loadParamCnt.parameters)
             val network = networkFromFirstFile(files)
-            val result = runSensitivityAnalysis(
-                network,
-                sensFactorCnt.factors,
-                sensParamCnt.parameters,
-                contingencyCnt.contingencies
-            )
-            call.respondText(result, ContentType.Application.Json, HttpStatusCode.OK)
+            val result = createTask(taskManager) {
+                runSensitivityAnalysis(
+                    network,
+                    sensFactorCnt.factors,
+                    sensParamCnt.parameters,
+                    contingencyCnt.contingencies
+                )
+            }
+            call.respond(result)
         }
 
         post("/security-analysis") {

src/main/JavaSerializers.kt

@@ -3,6 +3,8 @@ package com.github.statnett.loadflowservice
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.powsybl.security.SecurityAnalysisResult
 import com.powsybl.security.json.SecurityAnalysisJsonModule
+import com.powsybl.sensitivity.SensitivityAnalysisResult
+import com.powsybl.sensitivity.json.SensitivityJsonModule
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.descriptors.PrimitiveKind
 import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
@@ -29,4 +31,24 @@ object SecurityAnalysisResultSerializer : KSerializer<SecurityAnalysisResult> {
         val string = decoder.decodeString()
         return mapper.readValue(string, SecurityAnalysisResult::class.java)
     }
+}
+
+object SensitivityAnalysisResultSerializer: KSerializer<SensitivityAnalysisResult> {
+    private val mapper = ObjectMapper()
+
+    init {
+        mapper.registerModule(SensitivityJsonModule())
+    }
+
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("sensitivity-analysis-result", PrimitiveKind.STRING)
+
+    override fun serialize(encoder: Encoder, value: SensitivityAnalysisResult) {
+        val string = mapper.writeValueAsString(value)
+        encoder.encodeString(string)
+    }
+
+    override fun deserialize(decoder: Decoder): SensitivityAnalysisResult {
+        val string = decoder.decodeString()
+        return mapper.readValue(string, SensitivityAnalysisResult::class.java)
+    }
 }

src/main/Solver.kt

@@ -21,6 +21,7 @@ import com.powsybl.security.monitor.StateMonitor
 import com.powsybl.security.strategy.OperatorStrategy
 import com.powsybl.sensitivity.*
 import io.github.oshai.kotlinlogging.KotlinLogging
+import kotlinx.serialization.Serializable
 import java.io.ByteArrayOutputStream
 import java.io.StringWriter
 
@@ -112,44 +113,32 @@ fun solve(
     )
 }
 
+
 fun runSensitivityAnalysis(
     network: Network,
     factors: List<SensitivityFactor>,
     params: SensitivityAnalysisParameters,
     contingenciesList: ContingencyList
-): String {
+): LoadFlowServiceSensitivityAnalysisResult {
     val reporter = ReporterModel("sensitivity", "")
     val variableSets: List<SensitivityVariableSet> = listOf()
     val contingencies = contingenciesList.getContingencies(network)
-    val factorReader = SensitivityFactorModelReader(factors, network)
 
-    val factory = JsonUtil.createJsonFactory()
-    val writer = StringWriter()
-    val jsonGenerator = factory.createGenerator(writer)
-    jsonGenerator.writeStartObject()
-    jsonGenerator.writeFieldName("sensitivity-results")
-    val resultWriter = SensitivityResultJsonWriter(jsonGenerator, contingencies)
 
-    SensitivityAnalysis.run(
+
+    val result = SensitivityAnalysis.run(
         network,
         network.variantManager.workingVariantId,
-        factorReader,
-        resultWriter,
+        factors,
         contingencies,
         variableSets,
         params,
         LocalComputationManager.getDefault(),
         reporter
     )
-    // Close the nested array created by Powsybl
-    jsonGenerator.writeEndArray()
-    jsonGenerator.writeEndArray()
-
-    // Add run report to the JSON
-    jsonGenerator.writeStringField("report", reporterToString(reporter))
-    jsonGenerator.writeEndObject()
-    jsonGenerator.close()
-    return writer.toString()
+    return LoadFlowServiceSensitivityAnalysisResult(
+        result, reporterToString(reporter)
+    )
 }
 
 fun runSecurityAnalysis(

src/test/AppTest.kt

@@ -310,16 +310,21 @@ class ApplicationTest {
                     formData = sensitivityFormData.formData(config)
                 )
                 assertEquals(HttpStatusCode.OK, response.status)
-                val body = response.bodyAsText()
+
+                val taskInfo = Json.decodeFromString<TaskInfo>(response.body())
+
+                val runResult = retryOnError(50, 10) {
+                    client.get(taskInfo.resultUrl)
+                }
+                assertEquals(HttpStatusCode.OK, runResult.status)
+
+                val result = json.decodeFromString<LoadFlowServiceSensitivityAnalysisResult>(runResult.body())
 
                 // There are two contingencies so when we have contingencies there should be three results
                 // Otherwise one
                 val numRes = if (config.withContingencies) 3 else 1
 
-                val regex = Regex(""""sensitivity-results":\[\[(.*)]]""")
-                val match = regex.find(body)!!
-                val content = match.groupValues[1]
-                assertEquals(numRes, content.count { c -> c == '{' })
+                assertEquals(numRes, result.sensitivityAnalysisResult.values.size)
             }
         }
     }