generate seperate c function for setting datarecon inputs

OMCompiler/Compiler/BackEnd/BackendDAE.mo

@@ -190,6 +190,7 @@ uniontype DataReconciliationData
   record DATA_RECON
     Jacobian symbolicJacobian "SET_S w.r.t ...";
     Variables setcVars "setc solved vars";
+    Variables datareconinputs;
     // ... maybe more DATA for the code generation
   end DATA_RECON;
 end DataReconciliationData;

OMCompiler/Compiler/BackEnd/Uncertainties.mo

@@ -435,7 +435,7 @@ algorithm
 
         /* Prepare Torn systems for Jacobians */
         //create the Set-S equation to BackendDae innerequation structure
-        sets_inner_equations=createInnerEquations(tempsetS,var,setS,knowns);
+        sets_inner_equations=createInnerEquations(tempsetS,var,setS,knowns,inputvarlist);
         //sets_inner_equations={BackendDAE.INNEREQUATION(eqn = 56, vars = {48}), BackendDAE.INNEREQUATION(eqn = 3, vars = {70}), BackendDAE.INNEREQUATION(eqn = 6, vars = {77}),BackendDAE.INNEREQUATION(eqn = 23, vars = {55}), BackendDAE.INNEREQUATION(eqn = 20, vars = {42}), BackendDAE.INNEREQUATION(eqn = 50, vars = {20})};
         (outDiffVars,outResidualVars,outOtherVars,outResidualEqns,outOtherEqns)=SymbolicJacobian.prepareTornStrongComponentData(allVars,allEqs,listReverse(knowns),setC,sets_inner_equations,shared.functionTree);
         // Dump the torn systems
@@ -449,7 +449,7 @@ algorithm
         (simcodejacobian,shared)=SymbolicJacobian.getSymbolicJacobian(outDiffVars,outResidualEqns,outResidualVars,outOtherEqns,outOtherVars,shared,BackendVariable.listVar(List.map1r(extractedvars,BackendVariable.getVarAt,allVars)),"F",false);
         // put the jacobian also into shared object
         setcVars=BackendVariable.listVar(List.map1r(getRemovedEquationSolvedVariables(tempsetC,var),BackendVariable.getVarAt,allVars));
-        shared.dataReconciliationData = SOME(BackendDAE.DATA_RECON(symbolicJacobian=simcodejacobian,setcVars=outResidualVars));
+        shared.dataReconciliationData = SOME(BackendDAE.DATA_RECON(symbolicJacobian=simcodejacobian,setcVars=outResidualVars,datareconinputs=outDiffVars));
         //BackendDump.dumpVariables(setcVars,"SET_C_SOLVEDVARS");
 
         // Prepare the final DAE System with Set-c equations as residual equations
@@ -496,16 +496,21 @@ public function createInnerEquations
    input list<tuple<Integer,Integer>> solvedeqvar;
    input list<Integer> sets;
    input list<Integer> knowns;
+   input list<Integer> inputlist;
    output BackendDAE.InnerEquations outequations={};
 protected
    Integer eqnumber,varnumber;
    Integer count=1;
+   Integer inpcount=1;
 algorithm
    for i in tempsets loop
       (eqnumber,varnumber):=getSolvedVariableNumber(i,solvedeqvar);
       // map the tempsets with setS, to get the correct equation index for example (26/37) in ordered equation list
       if not listMember(varnumber,knowns) then
         outequations:=BackendDAE.INNEREQUATION(listGet(sets, count),{varnumber})::outequations;
+      else
+        outequations:=BackendDAE.INNEREQUATION(listGet(sets, count),{listGet(inputlist, inpcount)})::outequations;
+        inpcount:=inpcount+1;
       end if;
       count:=count+1;
    end for;

OMCompiler/Compiler/SimCode/ReduceDAE.mo

@@ -2173,14 +2173,14 @@ algorithm
     local
      list<SimCodeVar.SimVar> states,derVar,alg,disAlg,intAlg,boolAlg,inVar,outVar,algAlias,intAlias,boolAlias,param,
                           intParam,boolParam,stringAlg,stringParam,stringAlias,extObjVar,const,intConst,boolConst,stringConst,jacobianVar,
-              seedVar,realOptConst,realOptFinalConst,sensVar,setcVar;
+              seedVar,realOptConst,realOptFinalConst,sensVar,setcVar,datareconinputvar;
      SimCodeVar.SimVar simVar_1,simVar_2;
      list<SimCodeVar.SimVar> param_1,param_2;
      Integer i,p;
      String name, name1, name2, indexStr;
     case (SimCodeVar.SIMVARS(states,derVar,alg,disAlg,intAlg,boolAlg,inVar,outVar,algAlias,intAlias,boolAlias,param,
                            intParam,boolParam,stringAlg,stringParam,stringAlias,extObjVar,const,intConst,boolConst,stringConst,jacobianVar,
-               seedVar,realOptConst,realOptFinalConst,sensVar,setcVar),p,i)
+               seedVar,realOptConst,realOptFinalConst,sensVar,setcVar,datareconinputvar),p,i)
 
       equation
         indexStr = intString(i);
@@ -2206,7 +2206,7 @@ algorithm
 
         (SimCodeVar.SIMVARS(states,derVar,alg,disAlg,intAlg,boolAlg,inVar,outVar,algAlias,intAlias,boolAlias,param_2,
                            intParam,boolParam,stringAlg,stringParam,stringAlias,extObjVar,const,intConst,boolConst,stringConst,jacobianVar,
-               seedVar,realOptConst,realOptFinalConst,sensVar,setcVar),name);
+               seedVar,realOptConst,realOptFinalConst,sensVar,setcVar,datareconinputvar),name);
 
   end matchcontinue;
 end createLabelVar;

OMCompiler/Compiler/SimCode/SimCode.mo

@@ -273,6 +273,7 @@ uniontype VarInfo "Number of variables of various types in a Modelica model."
     Integer numOptimizeFinalConstraints;
     Integer numSensitivityParameters;
     Integer numSetcVars;
+    Integer numDataReconVars;
   end VARINFO;
 end VarInfo;
 

OMCompiler/Compiler/SimCode/SimCodeUtil.mo

@@ -279,8 +279,8 @@ protected
   BackendDAE.Var dtVar;
   HashTableSimCodeEqCache.HashTable eqCache;
   BackendDAE.Jacobian dataReconJac;
-  BackendDAE.Variables setcVars;
-  list<SimCodeVar.SimVar> tmpsetcVars;
+  BackendDAE.Variables setcVars,datareconinputvars;
+  list<SimCodeVar.SimVar> tmpsetcVars,tmpdatareconinputvars;
   SimCode.JacobianMatrix dataReconSimJac;
   String fullPathPrefix;
 
@@ -525,7 +525,7 @@ algorithm
 
     // Generate jacobian code for DataReconciliation
     if Util.isSome(shared.dataReconciliationData) then
-      BackendDAE.DATA_RECON(dataReconJac,setcVars) := Util.getOption(shared.dataReconciliationData);
+      BackendDAE.DATA_RECON(dataReconJac,setcVars,datareconinputvars) := Util.getOption(shared.dataReconciliationData);
       (SOME(dataReconSimJac), uniqueEqIndex, tempvars) := createSymbolicSimulationJacobian(dataReconJac, uniqueEqIndex, tempvars);
       (SymbolicJacsdatarecon, modelInfo, SymbolicJacsTemp) := addAlgebraicLoopsModelInfoSymJacs({dataReconSimJac}, modelInfo);
       SymbolicJacsNLS := listAppend(SymbolicJacsTemp, SymbolicJacsNLS);
@@ -616,9 +616,17 @@ algorithm
         tmpsetcVars := rewriteIndex(tmpsetcVars, 0);
         tmpSimVars.dataReconSetcVars := tmpsetcVars;
         modelInfo.vars := tmpSimVars;
+
+        //add the input vars for dataReconciliation
+       ((tmpdatareconinputvars, _)) :=  BackendVariable.traverseBackendDAEVars(datareconinputvars, traversingdlowvarToSimvar, ({}, emptyVars));
+        tmpdatareconinputvars := rewriteIndex(listReverse(tmpdatareconinputvars), 0);
+        tmpSimVars.dataReconinputVars := tmpdatareconinputvars;
+        modelInfo.vars := tmpSimVars;  
+
         // set varInfo nsetcvars
         varInfo := modelInfo.varInfo;
         varInfo.numSetcVars := listLength(tmpsetcVars);
+        varInfo.numDataReconVars := listLength(tmpdatareconinputvars);
         modelInfo.varInfo := varInfo;
         //print("\n simcode gen setc:*****"+anyString(tmpsetcVars) + "\n lenght of vars :" +anyString(listLength(tmpsetcVars)));
     end if;
@@ -7247,7 +7255,7 @@ algorithm
   numTimeEvents := numTimeEvents;
   numRelations := numRelations;
   varInfo := SimCode.VARINFO(numZeroCrossings, numTimeEvents, numRelations, numMathEventFunctions, nx, ny, ndy, ny_int, ny_bool, na, na_int, na_bool, np, np_int, np_bool, numOutVars, numInVars,
-          next, ny_string, np_string, na_string, 0, 0, 0, 0, numStateSets,0,numOptimizeConstraints, numOptimizeFinalConstraints, 0,0);
+          next, ny_string, np_string, na_string, 0, 0, 0, 0, numStateSets,0,numOptimizeConstraints, numOptimizeFinalConstraints, 0,0,0);
 end createVarInfo;
 
 protected function evaluateStartValues"evaluates functions in the start values in the variableAttributes"
@@ -7700,6 +7708,7 @@ protected type SimVarsIndex = enumeration(
 
   sensitivity,
   setcvars,
+  datareconinputvars,
   jacobian,
   seed
 );
@@ -7831,7 +7840,8 @@ algorithm
     Dangerous.arrayGetNoBoundsChecking(simVars, Integer(SimVarsIndex.realOptimizeConstraints)),
     Dangerous.arrayGetNoBoundsChecking(simVars, Integer(SimVarsIndex.realOptimizeFinalConstraints)),
     Dangerous.arrayGetNoBoundsChecking(simVars, Integer(SimVarsIndex.sensitivity)),
-    Dangerous.arrayGetNoBoundsChecking(simVars, Integer(SimVarsIndex.setcvars))
+    Dangerous.arrayGetNoBoundsChecking(simVars, Integer(SimVarsIndex.setcvars)),
+    Dangerous.arrayGetNoBoundsChecking(simVars, Integer(SimVarsIndex.datareconinputvars))
   );
   GC.free(simVars);
 end createVars;
@@ -10665,11 +10675,11 @@ algorithm
                    paramVars, intParamVars, boolParamVars, stringParamVars,
                    constVars, intConstVars, boolConstVars, stringConstVars,
                    sensitivityVars, extObjVars, jacobianVars, seedVars,
-                   realOptimizeConstraintsVars, realOptimizeFinalConstraintsVars,setcVars;
+                   realOptimizeConstraintsVars, realOptimizeFinalConstraintsVars,setcVars,datareconinputvars;
      tpl intpl;
 
     case (SimCodeVar.SIMVARS(stateVars, derivativeVars, algVars, discreteAlgVars, intAlgVars, boolAlgVars, inputVars, outputVars, aliasVars, intAliasVars, boolAliasVars,
-                  paramVars, intParamVars, boolParamVars, stringAlgVars, stringParamVars, stringAliasVars, extObjVars, constVars, intConstVars, boolConstVars, stringConstVars, jacobianVars, seedVars, realOptimizeConstraintsVars, realOptimizeFinalConstraintsVars, sensitivityVars,setcVars), _, intpl)
+                  paramVars, intParamVars, boolParamVars, stringAlgVars, stringParamVars, stringAliasVars, extObjVars, constVars, intConstVars, boolConstVars, stringConstVars, jacobianVars, seedVars, realOptimizeConstraintsVars, realOptimizeFinalConstraintsVars, sensitivityVars,setcVars,datareconinputvars), _, intpl)
          equation
            (stateVars, intpl) = List.mapFoldTuple(stateVars, func, intpl);
            (derivativeVars, intpl) = List.mapFoldTuple(derivativeVars, func, intpl);
@@ -10698,10 +10708,10 @@ algorithm
            (realOptimizeFinalConstraintsVars, intpl) = List.mapFoldTuple(realOptimizeFinalConstraintsVars, func, intpl);
            (sensitivityVars, intpl) = List.mapFoldTuple(sensitivityVars, func, intpl);
            (setcVars, intpl) = List.mapFoldTuple(setcVars, func, intpl);
-
+           (datareconinputvars, intpl) = List.mapFoldTuple(datareconinputvars, func, intpl);
 
          then (SimCodeVar.SIMVARS(stateVars, derivativeVars, algVars, discreteAlgVars, intAlgVars, boolAlgVars, inputVars, outputVars, aliasVars, intAliasVars, boolAliasVars,
-                  paramVars, intParamVars, boolParamVars, stringAlgVars, stringParamVars, stringAliasVars, extObjVars, constVars, intConstVars, boolConstVars, stringConstVars, jacobianVars, seedVars, realOptimizeConstraintsVars, realOptimizeFinalConstraintsVars, sensitivityVars,setcVars), intpl);
+                  paramVars, intParamVars, boolParamVars, stringAlgVars, stringParamVars, stringAliasVars, extObjVars, constVars, intConstVars, boolConstVars, stringConstVars, jacobianVars, seedVars, realOptimizeConstraintsVars, realOptimizeFinalConstraintsVars, sensitivityVars,setcVars,datareconinputvars), intpl);
     case (_, _, _) then fail();
   end match;
 end traveseSimVars;

OMCompiler/Compiler/SimCode/SimCodeVar.mo

@@ -70,6 +70,7 @@ uniontype SimVars "Container for metadata about variables in a Modelica model."
     list<SimVar> realOptimizeFinalConstraintsVars;
     list<SimVar> sensitivityVars; // variable used to calculate sensitivities for parameters nSensitivitityParameters + nRealParam*nStates
     list<SimVar> dataReconSetcVars;
+    list<SimVar> dataReconinputVars;
   end SIMVARS;
 end SimVars;
 

OMCompiler/Compiler/Template/CodegenC.tpl

@@ -1057,6 +1057,8 @@ template simulationFile(SimCode simCode, String guid, String isModelExchangeFMU)
     const VAR_INFO dummyVAR_INFO = omc_dummyVarInfo;
 
     <%functionInput(simCode, modelInfo, modelNamePrefixStr)%>
+    
+    <%functionDataInput(modelInfo, modelNamePrefixStr)%>
 
     <%functionOutput(modelInfo, modelNamePrefixStr)%>
 
@@ -1095,6 +1097,7 @@ template simulationFile(SimCode simCode, String guid, String isModelExchangeFMU)
        <%symbolName(modelNamePrefixStr,"input_function")%>,
        <%symbolName(modelNamePrefixStr,"input_function_init")%>,
        <%symbolName(modelNamePrefixStr,"input_function_updateStartValues")%>,
+       <%symbolName(modelNamePrefixStr,"data_function")%>,
        <%symbolName(modelNamePrefixStr,"output_function")%>,
        <%symbolName(modelNamePrefixStr,"setc_function")%>,
        <%symbolName(modelNamePrefixStr,"function_storeDelayed")%>,
@@ -1314,6 +1317,7 @@ template populateModelInfo(ModelInfo modelInfo, String fileNamePrefix, String gu
     data->modelData->nSensitivityVars = <%listLength(vars.sensitivityVars)%>;
     data->modelData->nSensitivityParamVars = <%varInfo.numSensitivityParameters%>;
     data->modelData->nSetcVars = <%varInfo.numSetcVars%>;
+    data->modelData->ndataReconVars = <%varInfo.numDataReconVars%>;
     >>
   end match
 end populateModelInfo;
@@ -1674,6 +1678,27 @@ template functionInput(SimCode simCode, ModelInfo modelInfo, String modelNamePre
   end match
 end functionInput;
 
+template functionDataInput(ModelInfo modelInfo, String modelNamePrefix)
+  "Generates function in simulation file."
+::=
+  match modelInfo
+  case MODELINFO(vars=SIMVARS(__)) then
+    <<
+    int <%symbolName(modelNamePrefix,"data_function")%>(DATA *data, threadData_t *threadData)
+    {
+      TRACE_PUSH
+
+      <%vars.dataReconinputVars |> SIMVAR(name=name, type_=T_REAL()) hasindex i0 =>
+        '<%cref(name)%> = data->simulationInfo->datainputVars[<%i0%>];'
+        ;separator="\n"
+      %>
+      TRACE_POP
+      return 0;
+    }
+   >>
+  end match
+end functionDataInput;
+
 template functionOutput(ModelInfo modelInfo, String modelNamePrefix)
   "Generates function in simulation file."
 ::=

OMCompiler/Compiler/Template/SimCodeTV.mo

@@ -238,6 +238,7 @@ package SimCodeVar
       list<SimVar> algebraicDAEVars;
       list<SimVar> sensitivityVars;
       list<SimVar> dataReconSetcVars;
+      list<SimVar> dataReconinputVars;
     end SIMVARS;
   end SimVars;
 
@@ -705,6 +706,7 @@ package SimCode
       Integer numOptimizeFinalConstraints;
       Integer numSensitivityParameters;
       Integer numSetcVars;
+      Integer numDataReconVars;
       end VARINFO;
   end VarInfo;
 

OMCompiler/SimulationRuntime/c/dataReconciliation/dataReconciliation.cpp

@@ -772,9 +772,11 @@ inputData getInputDataFromStartAttribute(csvData Sx_result , DATA* data, threadD
 	data->callback->inputNames(data, knowns);
 	int headercount = Sx_result.headers.size();
 	/* Read data from input vars which has start attribute value set as input */
+
 	for (int h=0; h < headercount; h++)
 	{
 		tempx[h]=Sx_result.xdata[h];
+		/*
 		bool flag=false;
 		for (int in=0; in < data->modelData->nInputVars; in++)
 		{
@@ -792,7 +794,7 @@ inputData getInputDataFromStartAttribute(csvData Sx_result , DATA* data, threadD
 			logfile << "|  error   |   " << "Input Variable Not matched or not generated: "<< Sx_result.headers[h] << " , getInputDataFromStartAttribute failed()! \n";
 			logfile.close();
 			exit(1);
-		}
+		} */
 	}
 	inputData x_data ={Sx_result.rowcount,1,tempx,index};
 	free(knowns);
@@ -996,13 +998,24 @@ void checkInExpensiveMatrixInverse(ofstream & logfile)
 int RunReconciliation(DATA* data, threadData_t *threadData, inputData x, matrixData Sx, matrixData tmpjacF, matrixData tmpjacFt, double eps, int iterationcount, csvData csvinputs, matrixData xdiag, matrixData sxdiag, ofstream& logfile)
 {
 	// set the inputs first
+    /*
 	for (int i=0; i< x.rows*x.column; i++)
 	{
 		data->simulationInfo->inputVars[x.index[i]]=x.data[i];
 		//logfile << "input data:" << x.data[i]<<"\n";
+	}*/
+
+	for (int i=0; i< x.rows*x.column; i++)
+	{
+		data->simulationInfo->datainputVars[i]=x.data[i];
+		//logfile << "input data:" << x.data[i]<<"\n";
 	}
-	//data->callback->input_function_updateStartValues(data, threadData);
-	data->callback->input_function(data, threadData);
+
+    /* set the inputs via this special function generated for dataReconciliation
+     * which also sets inputs for models not involving top level inputs
+     */
+    data->callback->data_function(data, threadData);
+	//data->callback->input_function(data, threadData);
 	data->callback->functionDAE(data,threadData);
 	//data->callback->functionODE(data,threadData);
 	data->callback->setc_function(data, threadData);
@@ -1394,6 +1407,7 @@ int dataReconciliation(DATA* data, threadData_t *threadData)
 	// Start the Algorithm
 	RunReconciliation(data,threadData,x,Sx,jacF,jacFt,atof(epselon),1,Sx_data,x_diag,tmpSx_diag,logfile);
 	logfile << "|  info    |   " << "DataReconciliation Completed! \n";
+	logfile.flush();
 	logfile.close();
 	free(Sx.data);
 	free(x.data);

OMCompiler/SimulationRuntime/c/openmodelica_func.h

@@ -120,6 +120,9 @@ int (*functionLocalKnownVars)(DATA *data, threadData_t*);
 int (*input_function)(DATA*, threadData_t*);
 int (*input_function_init)(DATA*, threadData_t*);
 int (*input_function_updateStartValues)(DATA*, threadData_t*);
+/* functions for setting dataReconciliation inputs */
+int (*data_function)(DATA*, threadData_t*);
+
 int (*output_function)(DATA*, threadData_t*);
 
 /* functions for setc data_reconciliation */

OMCompiler/SimulationRuntime/c/simulation/solver/model_help.c

@@ -986,6 +986,7 @@ void initializeDataStruc(DATA *data, threadData_t *threadData)
   data->simulationInfo->inputVars = (modelica_real*) calloc(data->modelData->nInputVars, sizeof(modelica_real));
   data->simulationInfo->outputVars = (modelica_real*) calloc(data->modelData->nOutputVars, sizeof(modelica_real));
   data->simulationInfo->setcVars = (modelica_real*) calloc(data->modelData->nSetcVars, sizeof(modelica_real));
+  data->simulationInfo->datainputVars = (modelica_real*) calloc(data->modelData->ndataReconVars, sizeof(modelica_real));
 
 #if !defined(OMC_NUM_MIXED_SYSTEMS) || OMC_NUM_MIXED_SYSTEMS>0
   /* buffer for mixed systems */
@@ -1217,6 +1218,7 @@ void deInitializeDataStruc(DATA *data)
   free(data->simulationInfo->inputVars);
   free(data->simulationInfo->outputVars);
   free(data->simulationInfo->setcVars);
+  free(data->simulationInfo->datainputVars);
 
   /* free external objects buffer */
   free(data->simulationInfo->extObjs);

OMCompiler/SimulationRuntime/c/simulation_data.h

@@ -549,6 +549,7 @@ typedef struct MODEL_DATA
   long nSensitivityVars;
   long nSensitivityParamVars;
   long nSetcVars;
+  long ndataReconVars;
 }MODEL_DATA;
 
 typedef struct CLOCK_DATA {
@@ -650,6 +651,7 @@ typedef struct SIMULATION_INFO
   modelica_real* inputVars;
   modelica_real* outputVars;
   modelica_real* setcVars;
+  modelica_real* datainputVars;
 
   EXTERNAL_INPUT external_input;