COPASI API  4.16.103
CSteadyStateTask.cpp
Go to the documentation of this file.
1 // Copyright (C) 2010 - 2014 by Pedro Mendes, Virginia Tech Intellectual
2 // Properties, Inc., University of Heidelberg, and The University
3 // of Manchester.
4 // All rights reserved.
5 
6 // Copyright (C) 2008 - 2009 by Pedro Mendes, Virginia Tech Intellectual
7 // Properties, Inc., EML Research, gGmbH, University of Heidelberg,
8 // and The University of Manchester.
9 // All rights reserved.
10 
11 // Copyright (C) 2002 - 2007 by Pedro Mendes, Virginia Tech Intellectual
12 // Properties, Inc. and EML Research, gGmbH.
13 // All rights reserved.
14 
15 /**
16  * CSteadyStateTask class.
17  *
18  * This class implements a steady state task which is comprised of a
19  * of a problem and a method. Additionally calls to the reporting
20  * methods are done when initialized.
21  *
22  * Created for COPASI by Stefan Hoops 2002
23  */
24 
25 #include "copasi.h"
26 
27 #include "CSteadyStateTask.h"
28 #include "CSteadyStateProblem.h"
29 #include "CSteadyStateMethod.h"
30 #include "model/CModel.h"
31 #include "model/CState.h"
33 #include "report/CKeyFactory.h"
34 #include "report/CReport.h"
35 
36 #include <sstream>
37 
38 #define XXXX_Reporting
39 
41  CCopasiTask(CCopasiTask::steadyState, pParent),
42  mpSteadyState(NULL),
43  mJacobian(),
44  mJacobianX(),
45  mpJacobianAnn(NULL),
46  mpJacobianXAnn(NULL),
47  mEigenValues("Eigenvalues of Jacobian", this),
48  mEigenValuesX("Eigenvalues of reduced system Jacobian", this)
49 {
50  mpProblem = new CSteadyStateProblem(this);
51 
53  this->add(mpMethod, true);
54 
55  initObjects();
56 }
57 
59  const CCopasiContainer * pParent):
60  CCopasiTask(src, pParent),
61  mpSteadyState(src.mpSteadyState),
62  mJacobian(src.mJacobian),
63  mJacobianX(src.mJacobianX),
64  mpJacobianAnn(NULL),
65  mpJacobianXAnn(NULL),
66  mEigenValues(src.mEigenValues, this),
67  mEigenValuesX(src.mEigenValuesX, this)
68 {
69  mpProblem =
71 
73  this->add(mpMethod, true);
74 
75  initObjects();
76 }
77 
79 {
81 }
82 
83 // virtual
85 {
87 
89 }
90 
92 {}
93 
95 {
96  mpJacobianAnn = new CArrayAnnotation("Jacobian (complete system)", this,
100  mpJacobianAnn->setDimensionDescription(0, "Variables of the system, including dependent species");
101  mpJacobianAnn->setDimensionDescription(1, "Variables of the system, including dependent species");
102 
103  mpJacobianXAnn = new CArrayAnnotation("Jacobian (reduced system)", this,
107  mpJacobianXAnn->setDimensionDescription(0, "Independent variables of the system");
108  mpJacobianXAnn->setDimensionDescription(1, "Independent variables of the system");
109 
110  mpEigenvaluesJacobianAnn = new CArrayAnnotation("Eigenvalues of Jacobian", this,
115  mpEigenvaluesJacobianAnn->setDimensionDescription(1, "Real/Imaginary part");
116 
117  mpEigenvaluesJacobianXAnn = new CArrayAnnotation("Eigenvalues of reduced system Jacobian", this,
119 // mpEigenvaluesJacobianXAnn->setMode(CArrayAnnotation::VECTOR);
123  mpEigenvaluesJacobianXAnn->setDimensionDescription(1, "Real/Imaginary part");
124 }
125 
126 void CSteadyStateTask::print(std::ostream * ostream) const {(*ostream) << (*this);}
127 
129 {
130  configBuffer.getVariable("SteadyState", "bool", &mScheduled,
132 
133  ((CSteadyStateProblem *) mpProblem)->load(configBuffer);
134 
135  ((CSteadyStateMethod *) mpMethod)->load(configBuffer);
136 }
137 
139 {return mpSteadyState;}
140 
142 {return mJacobian;}
144 {return mJacobianX;}
145 
147 {
148  return mpJacobianAnn;
149 }
150 
152 {
153  return mpJacobianXAnn;
154 }
155 
157 {
158  return mEigenValues;
159 }
161 {
162  return mEigenValuesX;
163 }
164 
166 {
167  if (!mpProblem->getModel()) return false;
168 
169  const CStateTemplate & stateTemplate = mpProblem->getModel()->getStateTemplate();
170 
171  // init Jacobians
172  size_t sizeX = stateTemplate.getNumIndependent();
173  mJacobianX.resize(sizeX, sizeX);
174  size_t size = sizeX + stateTemplate.getNumDependent();
175  mJacobian.resize(size, size);
176 
177  // Jacobian Annotations
178 
180  CModelEntity *const* ppEntities = stateTemplate.getEntities();
181  const size_t * pUserOrder = stateTemplate.getUserOrder().array();
182  const size_t * pUserOrderEnd = pUserOrder + stateTemplate.getUserOrder().size();
183 
184  pUserOrder++; // We skip the time which is the first.
185 
186  size_t i, imax = size;
187 
188  for (i = 0; i < imax && pUserOrder != pUserOrderEnd; pUserOrder++)
189  {
190  const CModelEntity::Status & Status = ppEntities[*pUserOrder]->getStatus();
191 
192  if (Status == CModelEntity::ODE ||
193  (Status == CModelEntity::REACTIONS && ppEntities[*pUserOrder]->isUsed()))
194  {
195  mpJacobianAnn->setAnnotationCN(0 , i, ppEntities[*pUserOrder]->getCN());
196  mpJacobianAnn->setAnnotationCN(1 , i, ppEntities[*pUserOrder]->getCN());
197 
198  i++;
199  }
200  }
201 
203 
204  ppEntities = stateTemplate.beginIndependent();
205  imax = sizeX;
206 
207  for (i = 0; i < imax; ++i, ++ppEntities)
208  {
209  mpJacobianXAnn->setAnnotationCN(0 , i, (*ppEntities)->getCN());
210  mpJacobianXAnn->setAnnotationCN(1 , i, (*ppEntities)->getCN());
211  }
212 
213  // initial dimension of Eigenvalues of Jacobian
214  mEigenvaluesMatrix.resize(size, 2);
215  mEigenvaluesXMatrix.resize(sizeX, 2);
216 
217  return true;
218 }
219 
221  COutputHandler * pOutputHandler,
222  std::ostream * pOstream)
223 {
224  assert(mpProblem && mpMethod);
225 
226  if (!mpMethod->isValidProblem(mpProblem)) return false;
227 
228  bool success = true;
229 
230  if (!updateMatrices())
231  return false;
232 
233  success &= CCopasiTask::initialize(of, pOutputHandler, pOstream);
234 
237 
239 
240 #ifdef xxxx
241  // init Jacobians
242  size_t sizeX = mpSteadyState->getNumIndependent();
243  mJacobianX.resize(sizeX, sizeX);
244  size_t size = sizeX + mpSteadyState->getNumDependent();
245  mJacobian.resize(size, size);
246 
247  //jacobian annotations
248  CStateTemplate & StateTemplate = mpProblem->getModel()->getStateTemplate();
249 
251  CModelEntity **ppEntities = StateTemplate.getEntities();
252  const size_t * pUserOrder = StateTemplate.getUserOrder().array();
253  const size_t * pUserOrderEnd = pUserOrder + StateTemplate.getUserOrder().size();
254 
255  pUserOrder++; // We skip the time which is the first.
256 
257  size_t i, imax = size;
258 
259  for (i = 0; i < imax && pUserOrder != pUserOrderEnd; pUserOrder++)
260  {
261  const CModelEntity::Status & Status = ppEntities[*pUserOrder]->getStatus();
262 
263  if (Status == CModelEntity::ODE ||
264  (Status == CModelEntity::REACTIONS && ppEntities[*pUserOrder]->isUsed()))
265  {
266  mpJacobianAnn->setAnnotationCN(0 , i, ppEntities[*pUserOrder]->getCN());
267  mpJacobianAnn->setAnnotationCN(1 , i, ppEntities[*pUserOrder]->getCN());
268 
269  i++;
270  }
271  }
272 
274 
275  ppEntities = StateTemplate.beginIndependent();
276  imax = sizeX;
277 
278  for (i = 0; i < imax; ++i, ++ppEntities)
279  {
280  mpJacobianXAnn->setAnnotationCN(0 , i, (*ppEntities)->getCN());
281  mpJacobianXAnn->setAnnotationCN(1 , i, (*ppEntities)->getCN());
282  }
283 
284 #endif
285 
286  CSteadyStateProblem* pProblem =
287  dynamic_cast<CSteadyStateProblem *>(mpProblem);
288  assert(pProblem);
289 
290  success &= pProblem->initialize();
291 
292  CSteadyStateMethod* pMethod =
293  dynamic_cast<CSteadyStateMethod *>(mpMethod);
294  assert(pMethod);
295 
296  success &= pMethod->initialize(pProblem);
297 
298  return success;
299 }
300 
301 bool CSteadyStateTask::process(const bool & useInitialValues)
302 {
303  if (useInitialValues)
304  {
306  }
307 
309 
310  // A steady-state makes only sense in an autonomous model,
311  // i.e., the time of the steady-state must not be changed
312  // during simulation.
313  C_FLOAT64 InitialTime = mpSteadyState->getTime();
314 
315  CSteadyStateMethod* pMethod =
316  dynamic_cast<CSteadyStateMethod *>(mpMethod);
317  assert(pMethod);
318 
319  CSteadyStateProblem* pProblem =
320  dynamic_cast<CSteadyStateProblem *>(mpProblem);
321  assert(pMethod);
322 
324 
325  //call the method
326  mResult = pMethod->process(mpSteadyState,
327  mJacobianX,
328  mpCallBack);
329 
331  restore();
332 
333  //update jacobian
334  if (mpSteadyState->isValid())
335  {
336  if (pProblem->isJacobianRequested() ||
337  pProblem->isStabilityAnalysisRequested())
338  {
339  pMethod->doJacobian(mJacobian, mJacobianX);
340  }
341 
342  //mpProblem->getModel()->setState(mpSteadyState);
343  //mpProblem->getModel()->updateRates();
344 
345  //calculate eigenvalues
346  if (pProblem->isStabilityAnalysisRequested())
347  {
350 
353  }
354  }
355 
356  // Reset the time.
357  mpSteadyState->setTime(InitialTime);
358 
359  C_FLOAT64 * pTo;
360  size_t i;
361 
362  // construct Eigenvalues of Jacobian
363  CVector< C_FLOAT64 > vectorEigen_R = mEigenValues.getR();
364  CVector< C_FLOAT64 > vectorEigen_I = mEigenValues.getI();
365 
366 #ifdef DEBUG_UI
367  C_INT32 size = vectorEigen_R.size() + vectorEigen_I.size();
368 
369  std::cout << "vectorEigen_R.size() = " << vectorEigen_R.size() << " + vectorEigen_I.size() = " << vectorEigen_I.size() << " == " << size << std::endl;
370  std::cout << "size = " << mEigenvaluesXMatrix.size() << std::endl;
371 #endif
372  assert(vectorEigen_R.size() == vectorEigen_I.size());
373 
374  pTo = mEigenvaluesMatrix.array();
375 
376  for (i = 0; i < vectorEigen_R.size(); ++i)
377  {
378  *pTo = vectorEigen_R[i]; ++pTo;
379  *pTo = vectorEigen_I[i]; ++pTo;
380  }
381 
382 #ifdef DEBUG_UI
383  std::cout << mEigenvaluesMatrix << std::endl;
384 #endif
385 
386  // construct Eigenvalues of Jacobian of reduced system
387  CVector< C_FLOAT64 > vectorEigenX_R = mEigenValuesX.getR();
388  CVector< C_FLOAT64 > vectorEigenX_I = mEigenValuesX.getI();
389 
390 #ifdef DEBUG_UI
391  C_INT32 sizeX = vectorEigenX_R.size() + vectorEigenX_I.size();
392 
393  std::cout << "vectorEigenX_R.size() = " << vectorEigenX_R.size() << " + vectorEigenX_I.size() = " << vectorEigenX_I.size() << " == " << sizeX << std::endl;
394  std::cout << "size = " << mEigenvaluesXMatrix.size() << std::endl;
395 #endif
396 
397  assert(vectorEigenX_R.size() == vectorEigenX_I.size());
398 
399  pTo = mEigenvaluesXMatrix.array();
400 
401  for (i = 0; i < vectorEigenX_R.size(); ++i)
402  {
403  *pTo = vectorEigenX_R[i]; ++pTo;
404  *pTo = vectorEigenX_I[i]; ++pTo;
405  }
406 
407 #ifdef DEBUG_UI
408  std::cout << mEigenvaluesXMatrix << std::endl;
409 #endif
410 
412 
414 }
415 
417 {
418  CModel * pModel = mpProblem->getModel();
419  pModel->setInitialState(pModel->getState());
420 }
421 
423 {
424  bool success = CCopasiTask::restore();
425 
426  if (mUpdateModel)
427  {
428  CModel * pModel = mpProblem->getModel();
429 
430  pModel->setState(*mpSteadyState);
431  pModel->updateSimulatedValues(true);
432  pModel->setInitialState(pModel->getState());
433  pModel->updateInitialValues();
434  }
435 
436  return success;
437 }
438 
439 std::ostream &operator<<(std::ostream &os, const CSteadyStateTask &A)
440 {
441  switch (A.getResult())
442  {
444  os << "A steady state with given resolution was found." << std::endl;
445  break;
446 
448  os << "No steady state with given resolution was found!" << std::endl;
449  os << "(below are the last unsuccessful trial values)" << std::endl;
450  break;
451 
453  os << "An equilibrium steady state (zero fluxes) was found." << std::endl;
454  break;
455 
457  os << "An invalid steady state (negative concentrations) was found." << std::endl;
458  }
459 
460  os << std::endl;
461 
462  // Update all necessary values.
463  CState * pState = const_cast<CState *>(A.getState());
464 
465  if (!pState) return os;
466 
467  CModel * pModel = A.mpProblem->getModel();
468 
469  if (!pModel) return os;
470 
471  pModel->setState(*pState);
472  pModel->updateSimulatedValues(true);
473  pModel->updateNonSimulatedValues();
474 
475  // Metabolite Info: Name, Concentration, Concentration Rate, Particle Number, Particle Rate, Transition Time
476  const CCopasiVector<CMetab> & Metabolites = pModel->getMetabolites();
477  const CMetab * pMetab;
478 
479  size_t i, imax = Metabolites.size();
480 
481  os << "Species" << "\t";
482  os << "Concentration";
483 
484  std::string Units = pModel->getConcentrationUnitsDisplayString();
485 
486  if (Units != "")
487  os << " (" << Units << ")";
488 
489  os << "\t";
490 
491  os << "Concentration Rate";
492  Units = pModel->getConcentrationRateUnitsDisplayString();
493 
494  if (Units != "")
495  os << " (" << Units << ")";
496 
497  os << "\t";
498 
499  os << "Particle Number" << "\t";
500 
501  os << "Particle Number Rate";
502  Units = pModel->getFrequencyUnitsDisplayString();
503 
504  if (Units != "")
505  os << " (" << Units << ")";
506 
507  os << "\t";
508 
509  os << "Transition Time";
510  Units = pModel->getTimeUnitsDisplayString();
511 
512  if (Units != "")
513  os << " (" << Units << ")";
514 
515  os << std::endl;
516 
517  for (i = 0; i < imax; ++i)
518  {
519  pMetab = Metabolites[i];
520  os << CMetabNameInterface::getDisplayName(pModel, *pMetab, false) << "\t";
521  os << pMetab->getConcentration() << "\t";
522  os << pMetab->getConcentrationRate() << "\t";
523  os << pMetab->getValue() << "\t";
524  os << pMetab->getRate() << "\t";
525  os << pMetab->getTransitionTime() << std::endl;
526  }
527 
528  os << std::endl;
529 
530  // Reaction Info: Name, Flux, Particle Flux
531  const CCopasiVector<CReaction>& Reactions = pModel->getReactions();
532  const CReaction * pReaction;
533 
534  imax = Reactions.size();
535 
536  os << "Reaction" << "\t";
537 
538  os << "Flux";
539  Units = pModel->getQuantityRateUnitsDisplayString();
540 
541  if (Units != "")
542  os << " (" << Units << ")";
543 
544  os << "\t";
545 
546  os << "Particle Flux";
547  Units = pModel->getFrequencyUnitsDisplayString();;
548 
549  if (Units != "")
550  os << " (" << Units << ")";
551 
552  os << std::endl;
553 
554  for (i = 0; i < imax; ++i)
555  {
556  pReaction = Reactions[i];
557  os << pReaction->getObjectName() << "\t";
558  os << pReaction->getFlux() << "\t";
559  os << pReaction->getParticleFlux() << std::endl;
560  }
561 
562  os << std::endl;
563 
564  if (static_cast<CSteadyStateProblem *>(A.mpProblem)->isJacobianRequested())
565  {
566  os << *A.mpJacobianAnn << std::endl;
567 
568  if (static_cast<CSteadyStateProblem *>(A.mpProblem)->isStabilityAnalysisRequested())
569  {
570  os << "Eigenvalues\treal\timaginary" << std::endl;
571  imax = A.mEigenValues.getR().size();
572 
573  for (i = 0; i < imax; i++)
574  os << "\t" << A.mEigenValues.getR()[i] << "\t" << A.mEigenValues.getI()[i] << std::endl;
575 
576  os << std::endl;
577  }
578 
579  os << *A.mpJacobianXAnn << std::endl;
580 
581  if (static_cast<CSteadyStateProblem *>(A.mpProblem)->isStabilityAnalysisRequested())
582  {
583  os << "Eigenvalues\treal\timaginary" << std::endl;
584  imax = A.mEigenValuesX.getR().size();
585 
586  for (i = 0; i < imax; i++)
587  os << "\t" << A.mEigenValuesX.getR()[i] << "\t" << A.mEigenValuesX.getI()[i] << std::endl;
588 
589  os << std::endl;
590  }
591  }
592 
593  if (static_cast<CSteadyStateProblem *>(A.mpProblem)->isStabilityAnalysisRequested())
594  {
595  os << "Stability Analysis of the Reduced System" << std::endl;
596  os << A.mEigenValuesX << std::endl;
597  }
598 
599  return os;
600 }
CSteadyStateMethod::ReturnCode mResult
const CSteadyStateMethod::ReturnCode & getResult() const
const CArrayAnnotation * getJacobianAnnotated() const
CCopasiMethod * mpMethod
Definition: CCopasiTask.h:239
#define pdelete(p)
Definition: copasi.h:215
void calcEigenValues(const CMatrix< C_FLOAT64 > &matrix)
Definition: CEigen.cpp:243
virtual bool process(const bool &useInitialValues)
std::string getTimeUnitsDisplayString() const
Definition: CModel.cpp:4531
const C_FLOAT64 & getParticleFlux() const
Definition: CReaction.cpp:201
const C_FLOAT64 & getRate() const
virtual CCopasiObjectName getCN() const
const CCopasiVector< CMetab > & getMetabolites() const
Definition: CModel.cpp:1051
std::string getConcentrationRateUnitsDisplayString() const
Definition: CModel.cpp:4607
const std::string & getObjectName() const
size_t getNumIndependent() const
Definition: CState.cpp:222
std::string getFrequencyUnitsDisplayString() const
Definition: CModel.cpp:4539
Definition: CEigen.h:36
virtual size_t size() const
virtual bool initialize(const OutputFlag &of, COutputHandler *pOutputHandler, std::ostream *pOstream)
void updateNonSimulatedValues(void)
Definition: CModel.cpp:1892
bool mScheduled
Definition: CCopasiTask.h:217
virtual CCopasiMethod * createMethod(const int &type) const
void setInitialState(const CState &state)
Definition: CModel.cpp:1774
void updateSimulatedValues(const bool &updateMoieties)
Definition: CModel.cpp:1851
CProcessReport * mpCallBack
Definition: CCopasiTask.h:249
std::string getQuantityRateUnitsDisplayString() const
Definition: CModel.cpp:4657
void setAnnotationCN(size_t d, size_t i, const std::string cn)
Definition: CState.h:305
CMatrix< C_FLOAT64 > mJacobianX
bool isStabilityAnalysisRequested() const
virtual void output(const COutputInterface::Activity &activity)
const CState * getState() const
void setDescription(const std::string &s)
CArrayAnnotation * mpJacobianAnn
const CCopasiMethod::SubType & getSubType() const
const CArrayAnnotation * getJacobianXAnnotated() const
const C_FLOAT64 & getFlux() const
Definition: CReaction.cpp:192
#define C_INT32
Definition: copasi.h:90
static std::string getDisplayName(const CModel *model, const std::string &key, const bool &quoted)
Definition: CMetab.h:178
void applyInitialValues()
Definition: CModel.cpp:1236
const CVector< C_FLOAT64 > & getI() const
Definition: CEigen.cpp:687
const CEigen & getEigenValues() const
void setTime(const C_FLOAT64 &time)
Definition: CState.cpp:326
virtual bool isValidProblem(const CCopasiProblem *pProblem)
CCopasiProblem * mpProblem
Definition: CCopasiTask.h:234
CArrayAnnotation * mpJacobianXAnn
size_t getNumDependent() const
Definition: CState.cpp:344
size_t getNumDependentReactionMetabs() const
Definition: CModel.cpp:1133
void setState(const CState &state)
Definition: CModel.cpp:1785
std::ostream & operator<<(std::ostream &os, const CSteadyStateTask &A)
virtual ~CSteadyStateTask()
virtual bool updateMatrices()
CSteadyStateTask(const CCopasiContainer *pParent=NULL)
void stabilityAnalysis(const C_FLOAT64 &resolution)
Definition: CEigen.cpp:454
size_t getNumIndependent() const
Definition: CState.cpp:342
const CMatrix< C_FLOAT64 > & getJacobianReduced() const
CModelEntity ** beginIndependent()
Definition: CState.cpp:208
bool mUpdateModel
Definition: CCopasiTask.h:223
virtual bool initialize(const CSteadyStateProblem *pProblem)
const CVector< C_FLOAT64 > & getR() const
Definition: CEigen.cpp:690
virtual void resize(size_t rows, size_t cols, const bool &copy=false)
Definition: CMatrix.h:151
static CSteadyStateMethod * createMethod(CCopasiMethod::SubType subType=CCopasiMethod::Newton)
bool isValid() const
Definition: CState.cpp:351
size_t size() const
Definition: CVector.h:100
void setMode(size_t d, Mode m)
std::string getConcentrationUnitsDisplayString() const
Definition: CModel.cpp:4587
void setDimensionDescription(size_t d, const std::string &s)
const C_FLOAT64 & getValue() const
const C_FLOAT64 & getTime() const
Definition: CState.cpp:325
const CEigen & getEigenValuesReduced() const
size_t getNumDependent() const
Definition: CState.cpp:224
#define C_FLOAT64
Definition: copasi.h:92
const CState & getInitialState() const
Definition: CModel.cpp:1768
virtual bool initialize(const OutputFlag &of, COutputHandler *pOutputHandler, std::ostream *pOstream)
CType * array()
Definition: CVector.h:139
const CStateTemplate & getStateTemplate() const
Definition: CModel.cpp:1172
virtual size_t size() const
Definition: CMatrix.h:132
CCopasiVectorNS< CReaction > & getReactions()
Definition: CModel.cpp:1039
CSteadyStateMethod::ReturnCode process(CState *pState, CMatrix< C_FLOAT64 > &jacobianX, CProcessReport *handler)
virtual bool add(CCopasiObject *pObject, const bool &adopt=true)
bool updateInitialValues()
Definition: CModel.cpp:1461
const C_FLOAT64 & getConcentration() const
Definition: CMetab.cpp:218
C_FLOAT64 getStabilityResolution()
Definition: CModel.h:50
void doJacobian(CMatrix< C_FLOAT64 > &jacobian, CMatrix< C_FLOAT64 > &jacobianX)
C_INT32 getVariable(const std::string &name, const std::string &type, void *pout, CReadConfig::Mode mode=CReadConfig::NEXT)
Definition: CReadConfig.cpp:81
bool isJacobianRequested() const
const CState & getState() const
Definition: CModel.cpp:1771
virtual bool restore()
const CModelEntity::Status & getStatus() const
CMatrix< C_FLOAT64 > mEigenvaluesXMatrix
const CVector< size_t > & getUserOrder() const
Definition: CState.cpp:201
const C_FLOAT64 & getTransitionTime() const
Definition: CMetab.cpp:229
C_FLOAT64 getConcentrationRate() const
Definition: CMetab.cpp:870
void load(CReadConfig &configBuffer)
virtual bool restore()
const CMatrix< C_FLOAT64 > & getJacobian() const
CMatrix< C_FLOAT64 > mJacobian
CArrayAnnotation * mpEigenvaluesJacobianXAnn
virtual CType * array()
Definition: CMatrix.h:337
CModel * getModel() const
virtual void print(std::ostream *ostream) const
CModelEntity ** getEntities()
Definition: CState.cpp:204
CMatrix< C_FLOAT64 > mEigenvaluesMatrix
CArrayAnnotation * mpEigenvaluesJacobianAnn