COPASI API  4.16.103
Classes | Public Member Functions | Static Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes | Friends | List of all members
CLyapWolfMethod Class Reference

#include <CLyapWolfMethod.h>

Inheritance diagram for CLyapWolfMethod:
Inheritance graph
[legend]
Collaboration diagram for CLyapWolfMethod:
Collaboration graph
[legend]

Classes

struct  Data
 

Public Member Functions

bool calculate ()
 
 CLyapWolfMethod (const CLyapWolfMethod &src, const CCopasiContainer *pParent=NULL)
 
virtual bool elevateChildren ()
 
void evalF (const C_FLOAT64 *t, const C_FLOAT64 *y, C_FLOAT64 *ydot)
 
virtual bool isValidProblem (const CCopasiProblem *pProblem)
 
virtual void start ()
 
virtual double step (const double &deltaT)
 
 ~CLyapWolfMethod ()
 
- Public Member Functions inherited from CLyapMethod
 CLyapMethod (const CLyapMethod &src, const CCopasiContainer *pParent=NULL)
 
void setProblem (CLyapProblem *problem)
 
virtual void start (const CState *initialState)
 
 ~CLyapMethod ()
 
- Public Member Functions inherited from CCopasiMethod
 CCopasiMethod (const CCopasiMethod &src, const CCopasiContainer *pParent=NULL)
 
const CCopasiMethod::SubTypegetSubType () const
 
const CCopasiTask::TypegetType () const
 
virtual void load (CReadConfig &configBuffer, CReadConfig::Mode mode=CReadConfig::SEARCH)
 
virtual void print (std::ostream *ostream) const
 
virtual void printResult (std::ostream *ostream) const
 
virtual bool setCallBack (CProcessReport *pCallBack)
 
virtual ~CCopasiMethod ()
 
- Public Member Functions inherited from CCopasiParameterGroup
bool addGroup (const std::string &name)
 
bool addParameter (const CCopasiParameter &parameter)
 
bool addParameter (const std::string &name, const CCopasiParameter::Type type)
 
template<class CType >
bool addParameter (const std::string &name, const CCopasiParameter::Type type, const CType &value)
 
void addParameter (CCopasiParameter *pParameter)
 
CCopasiParameterGroupassertGroup (const std::string &name)
 
template<class CType >
CCopasiParameterassertParameter (const std::string &name, const CCopasiParameter::Type type, const CType &defaultValue)
 
index_iterator beginIndex () const
 
name_iterator beginName () const
 
 CCopasiParameterGroup (const CCopasiParameterGroup &src, const CCopasiContainer *pParent=NULL)
 
 CCopasiParameterGroup (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &objectType="ParameterGroup")
 
void clear ()
 
index_iterator endIndex () const
 
name_iterator endName () const
 
CCopasiParameterGroupgetGroup (const std::string &name)
 
const CCopasiParameterGroupgetGroup (const std::string &name) const
 
CCopasiParameterGroupgetGroup (const size_t &index)
 
const CCopasiParameterGroupgetGroup (const size_t &index) const
 
size_t getIndex (const std::string &name) const
 
std::string getKey (const std::string &name) const
 
std::string getKey (const size_t &index) const
 
virtual const std::string & getName (const size_t &index) const
 
virtual const CObjectInterfacegetObject (const CCopasiObjectName &cn) const
 
CCopasiParametergetParameter (const std::string &name)
 
const CCopasiParametergetParameter (const std::string &name) const
 
CCopasiParametergetParameter (const size_t &index)
 
const CCopasiParametergetParameter (const size_t &index) const
 
CCopasiParameter::Type getType (const std::string &name) const
 
CCopasiParameter::Type getType (const size_t &index) const
 
std::string getUniqueParameterName (const CCopasiParameter *pParameter) const
 
const CCopasiParameter::ValuegetValue (const std::string &name) const
 
const CCopasiParameter::ValuegetValue (const size_t &index) const
 
CCopasiParameter::ValuegetValue (const std::string &name)
 
CCopasiParameter::ValuegetValue (const size_t &index)
 
CCopasiParameterGroupoperator= (const CCopasiParameterGroup &rhs)
 
bool removeParameter (const std::string &name)
 
bool removeParameter (const size_t &index)
 
template<class CType >
bool setValue (const std::string &name, const CType &value)
 
template<class CType >
bool setValue (const size_t &index, const CType &value)
 
size_t size () const
 
bool swap (const size_t &iFrom, const size_t &iTo)
 
bool swap (index_iterator &from, index_iterator &to)
 
virtual ~CCopasiParameterGroup ()
 
- Public Member Functions inherited from CCopasiParameter
 CCopasiParameter (const CCopasiParameter &src, const CCopasiContainer *pParent=NULL)
 
 CCopasiParameter (const std::string &name, const Type &type, const void *pValue=NULL, const CCopasiContainer *pParent=NULL, const std::string &objectType="Parameter")
 
virtual CCopasiObjectName getCN () const
 
virtual const std::string & getKey () const
 
virtual std::string getObjectDisplayName (bool regular=true, bool richtext=false) const
 
const CCopasiParameter::TypegetType () const
 
const ValuegetValue () const
 
ValuegetValue ()
 
virtual voidgetValuePointer () const
 
CCopasiObjectgetValueReference () const
 
bool isValidValue (const C_FLOAT64 &value) const
 
bool isValidValue (const C_INT32 &value) const
 
bool isValidValue (const unsigned C_INT32 &value) const
 
bool isValidValue (const bool &value) const
 
bool isValidValue (const std::string &value) const
 
bool isValidValue (const CCopasiObjectName &value) const
 
bool isValidValue (const std::vector< CCopasiParameter * > &value) const
 
CCopasiParameteroperator= (const CCopasiParameter &rhs)
 
template<class CType >
bool setValue (const CType &value)
 
bool setValue (const std::vector< CCopasiParameter * > &value)
 
virtual ~CCopasiParameter ()
 
- Public Member Functions inherited from CCopasiContainer
virtual bool add (CCopasiObject *pObject, const bool &adopt=true)
 
 CCopasiContainer (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &type="CN", const unsigned C_INT32 &flag=CCopasiObject::Container)
 
 CCopasiContainer (const CCopasiContainer &src, const CCopasiContainer *pParent=NULL)
 
virtual std::string getChildObjectUnits (const CCopasiObject *pObject) const
 
virtual const objectMapgetObjects () const
 
virtual std::string getUnits () const
 
virtual const CCopasiObjectgetValueObject () const
 
virtual bool remove (CCopasiObject *pObject)
 
virtual ~CCopasiContainer ()
 
- Public Member Functions inherited from CCopasiObject
void addDirectDependency (const CCopasiObject *pObject)
 
 CCopasiObject (const CCopasiObject &src, const CCopasiContainer *pParent=NULL)
 
void clearDirectDependencies ()
 
void clearRefresh ()
 
bool dependsOn (DataObjectSet candidates, const DataObjectSet &context=DataObjectSet()) const
 
void getAllDependencies (DataObjectSet &dependencies, const DataObjectSet &context) const
 
virtual const DataObjectSetgetDirectDependencies (const DataObjectSet &context=DataObjectSet()) const
 
CCopasiContainergetObjectAncestor (const std::string &type) const
 
CCopasiDataModelgetObjectDataModel ()
 
const CCopasiDataModelgetObjectDataModel () const
 
const std::string & getObjectName () const
 
CCopasiContainergetObjectParent () const
 
const std::string & getObjectType () const
 
virtual const
CObjectInterface::ObjectSet
getPrerequisites () const
 
virtual RefreshgetRefresh () const
 
UpdateMethodgetUpdateMethod () const
 
bool hasCircularDependencies (DataObjectSet &candidates, DataObjectSet &verified, const DataObjectSet &context) const
 
bool hasUpdateMethod () const
 
bool isArray () const
 
bool isContainer () const
 
bool isDataModel () const
 
bool isMatrix () const
 
bool isNameVector () const
 
bool isNonUniqueName () const
 
virtual bool isPrerequisiteForContext (const CObjectInterface *pObject, const CMath::SimulationContextFlag &context, const CObjectInterface::ObjectSet &changedObjects) const
 
bool isReference () const
 
bool isRoot () const
 
bool isSeparator () const
 
bool isStaticString () const
 
bool isValueBool () const
 
bool isValueDbl () const
 
bool isValueInt () const
 
bool isValueInt64 () const
 
bool isValueString () const
 
bool isVector () const
 
virtual bool mustBeDeleted (const DataObjectSet &deletedObjects) const
 
void removeDirectDependency (const CCopasiObject *pObject)
 
void setDirectDependencies (const DataObjectSet &directDependencies)
 
bool setObjectName (const std::string &name)
 
virtual bool setObjectParent (const CCopasiContainer *pParent)
 
void setObjectValue (const C_FLOAT64 &value)
 
void setObjectValue (const C_INT32 &value)
 
void setObjectValue (const bool &value)
 
template<class CType >
void setRefresh (CType *pType, void(CType::*method)(void))
 
template<class CType >
void setUpdateMethod (CType *pType, void(CType::*method)(const C_FLOAT64 &))
 
template<class CType >
void setUpdateMethod (CType *pType, void(CType::*method)(const C_INT32 &))
 
template<class CType >
void setUpdateMethod (CType *pType, void(CType::*method)(const bool &))
 
virtual ~CCopasiObject ()
 
- Public Member Functions inherited from CObjectInterface
 CObjectInterface ()
 
virtual ~CObjectInterface ()
 

Static Public Member Functions

static void EvalF (const C_INT *n, const C_FLOAT64 *t, const C_FLOAT64 *y, C_FLOAT64 *ydot)
 
- Static Public Member Functions inherited from CLyapMethod
static CLyapMethodcreateMethod (CCopasiMethod::SubType subType=CCopasiMethod::lyapWolf)
 
static bool isValidSubType (const CCopasiMethod::SubType &subType)
 
- Static Public Member Functions inherited from CCopasiObject
static std::vector< Refresh * > buildUpdateSequence (const DataObjectSet &objects, const DataObjectSet &uptoDateObjects, const DataObjectSet &context=DataObjectSet())
 
static void setRenameHandler (CRenameHandler *rh)
 

Private Member Functions

 CLyapWolfMethod (const CCopasiContainer *pParent=NULL)
 
void initializeParameter ()
 
void orthonormalize ()
 

Static Private Member Functions

static void add (C_FLOAT64 *dbl1, const C_FLOAT64 *dbl1End, const C_FLOAT64 &f, const C_FLOAT64 *dbl2)
 
static C_FLOAT64 norm (const C_FLOAT64 *dbl1, const C_FLOAT64 *dbl2)
 
static C_FLOAT64 product (const C_FLOAT64 *dbl1, const C_FLOAT64 *dbl1End, const C_FLOAT64 *dbl2)
 
static void scalarmult (C_FLOAT64 *dbl1, const C_FLOAT64 *dbl2, const C_FLOAT64 &f)
 

Private Attributes

CVector< C_FLOAT64mAtol
 
Data mData
 
bool mDoDivergence
 
CVector< C_FLOAT64mDWork
 
C_FLOAT64 mEndt
 
std::ostringstream mErrorMsg
 
CVector< C_INTmIWork
 
CMatrix< C_FLOAT64mJacobian
 
C_INT mJType
 
CLSODA mLSODA
 
C_INT mLsodaStatus
 
CVector< C_FLOAT64mNorms
 
unsigned C_INT32 mNumExp
 
CStatempState
 
CLyapTaskmpTask
 
bool mReducedModel
 
C_FLOAT64 mRtol
 
C_INT mState
 
C_FLOAT64 mSumDivergence
 
CVector< C_FLOAT64mSumExponents
 
size_t mSystemSize
 
C_FLOAT64 mTime
 
CVector< C_FLOAT64mVariables
 

Friends

CLyapMethodCLyapMethod::createMethod (CCopasiMethod::SubType subType)
 

Additional Inherited Members

- Public Types inherited from CCopasiMethod
enum  SubType {
  unset = 0, RandomSearch, RandomSearchMaster, SimulatedAnnealing,
  CoranaWalk, DifferentialEvolution, ScatterSearch, GeneticAlgorithm,
  EvolutionaryProgram, SteepestDescent, HybridGASA, GeneticAlgorithmSR,
  HookeJeeves, LevenbergMarquardt, NelderMead, SRES,
  Statistics, ParticleSwarm, Praxis, TruncatedNewton,
  Newton, deterministic, LSODAR, directMethod,
  stochastic, tauLeap, adaptiveSA, hybrid,
  hybridLSODA, hybridODE45, DsaLsodar, tssILDM,
  tssILDMModified, tssCSP, mcaMethodReder, scanMethod,
  lyapWolf, sensMethod, EFMAlgorithm, EFMBitPatternTreeAlgorithm,
  EFMBitPatternAlgorithm, Householder, crossSectionMethod, linearNoiseApproximation
}
 
- Public Types inherited from CCopasiParameterGroup
typedef parameterGroup::iterator index_iterator
 
typedef
CCopasiContainer::objectMap::iterator 
name_iterator
 
typedef std::vector
< CCopasiParameter * > 
parameterGroup
 
- Public Types inherited from CCopasiParameter
enum  Type {
  DOUBLE = 0, UDOUBLE, INT, UINT,
  BOOL, GROUP, STRING, CN,
  KEY, FILE, EXPRESSION, INVALID
}
 
- Public Types inherited from CCopasiContainer
typedef std::multimap
< std::string, CCopasiObject * > 
objectMap
 
- Public Types inherited from CCopasiObject
typedef std::set< const
CCopasiObject * > 
DataObjectSet
 
typedef std::vector< Refresh * > DataUpdateSequence
 
- Public Types inherited from CObjectInterface
typedef std::set< const
CObjectInterface * > 
ObjectSet
 
typedef std::vector
< CObjectInterface * > 
UpdateSequence
 
- Static Public Attributes inherited from CLyapMethod
static const CLyapValidSubTypes ValidSubTypes
 
- Static Public Attributes inherited from CCopasiMethod
static const std::string SubTypeName []
 
static const char * XMLSubType []
 
- Static Public Attributes inherited from CCopasiParameter
static const std::string TypeName []
 
static const char * XMLType []
 
- Static Public Attributes inherited from CCopasiContainer
static const std::vector
< CCopasiContainer * > 
EmptyList
 
- Protected Types inherited from CCopasiObject
enum  Flag {
  Container = 0x1, Vector = 0x2, Matrix = 0x4, NameVector = 0x8,
  Reference = 0x10, ValueBool = 0x20, ValueInt = 0x40, ValueInt64 = 0x80,
  ValueDbl = 0x100, NonUniqueName = 0x200, StaticString = 0x400, ValueString = 0x800,
  Separator = 0x1000, ModelEntity = 0x2000, Array = 0x4000, DataModel = 0x8000,
  Root = 0x10000, Gui = 0x20000
}
 
- Protected Member Functions inherited from CLyapMethod
 CLyapMethod (const CCopasiMethod::SubType &subType, const CCopasiContainer *pParent=NULL)
 
- Protected Member Functions inherited from CCopasiMethod
 CCopasiMethod (const CCopasiTask::Type &taskType, const SubType &subType, const CCopasiContainer *pParent=NULL)
 
- Protected Member Functions inherited from CCopasiParameterGroup
 CCopasiParameterGroup ()
 
- Protected Member Functions inherited from CCopasiContainer
template<class CType >
CCopasiObjectaddMatrixReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)
 
template<class CType >
CCopasiObjectaddObjectReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)
 
template<class CType >
CCopasiObjectaddVectorReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)
 
void initObjects ()
 
- Protected Member Functions inherited from CCopasiObject
 CCopasiObject ()
 
 CCopasiObject (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &type="CN", const unsigned C_INT32 &flag=0)
 
- Protected Attributes inherited from CLyapMethod
CLyapProblemmpProblem
 
- Protected Attributes inherited from CCopasiMethod
CProcessReportmpCallBack
 
- Protected Attributes inherited from CCopasiParameter
std::string mKey
 
CCopasiObjectmpValueReference
 
size_t mSize
 
Value mValue
 
- Protected Attributes inherited from CCopasiContainer
objectMap mObjects
 
- Static Protected Attributes inherited from CCopasiObject
static CRenameHandlersmpRenameHandler = NULL
 

Detailed Description

Definition at line 36 of file CLyapWolfMethod.h.

Constructor & Destructor Documentation

CLyapWolfMethod::CLyapWolfMethod ( const CCopasiContainer pParent = NULL)
private

Default constructor.

Parameters
constCCopasiContainer * pParent (default: NULL)

Definition at line 29 of file CLyapWolfMethod.cpp.

References CLyapWolfMethod::Data::dim, initializeParameter(), mData, and CLyapWolfMethod::Data::pMethod.

29  :
31  mpState(NULL)
32 {
33  assert((void *) &mData == (void *) &mData.dim);
34 
35  mData.pMethod = this;
37 }
CLyapWolfMethod * pMethod
CLyapWolfMethod::CLyapWolfMethod ( const CLyapWolfMethod src,
const CCopasiContainer pParent = NULL 
)

Copy constructor.

Parameters
const CLsodaMethod &src
constCCopasiContainer * pParent (default: NULL)

Definition at line 39 of file CLyapWolfMethod.cpp.

References CLyapWolfMethod::Data::dim, initializeParameter(), mData, and CLyapWolfMethod::Data::pMethod.

40  :
41  CLyapMethod(src, pParent),
42  mpState(NULL)
43 {
44  assert((void *) &mData == (void *) &mData.dim);
45 
46  mData.pMethod = this;
48 }
CLyapWolfMethod * pMethod
CLyapWolfMethod::~CLyapWolfMethod ( )

Destructor.

Definition at line 50 of file CLyapWolfMethod.cpp.

References mpState, and pdelete.

51 {
53 }
#define pdelete(p)
Definition: copasi.h:215

Member Function Documentation

void CLyapWolfMethod::add ( C_FLOAT64 dbl1,
const C_FLOAT64 dbl1End,
const C_FLOAT64 f,
const C_FLOAT64 dbl2 
)
staticprivate

Definition at line 494 of file CLyapWolfMethod.cpp.

Referenced by orthonormalize().

496 {
497  //calculate v1 = v1 + f * v2
498  for (; dbl1 != dbl1End; ++dbl1, ++dbl2)
499  *dbl1 += f * *dbl2;
500 }
bool CLyapWolfMethod::calculate ( void  )
virtual

handles the complete calculation

Implements CLyapMethod.

Definition at line 326 of file CLyapWolfMethod.cpp.

References CVectorCore< CType >::array(), CState::beginIndependent(), C_FLOAT64, CCopasiProblem::getModel(), CCopasiObject::getObjectParent(), CLyapProblem::getTransientTime(), CCopasiParameter::getValue(), CLyapTask::mAverageDivergence, mDoDivergence, CLyapTask::methodCallback(), CLyapTask::mExponents, CLyapTask::mIntervalDivergence, CLyapTask::mLocalExponents, mLsodaStatus, mNorms, mNumExp, CLyapMethod::mpProblem, mpState, mpTask, mReducedModel, mSumDivergence, mSumExponents, mSystemSize, mTime, mVariables, orthonormalize(), CCopasiParameter::Value::pUDOUBLE, CModel::setState(), CState::setTime(), CVectorCore< CType >::size(), start(), step(), and CModel::updateSimulatedValues().

327 {
328  //get the pointer to the parent task. It's needed for output
329  mpTask = dynamic_cast<CLyapTask*>(getObjectParent());
330  assert(mpTask);
331 
332  //initialize LSODA
333  start();
334 
335  C_FLOAT64 stepSize = *getValue("Orthonormalization Interval").pUDOUBLE;
336  C_FLOAT64 transientTime = mpProblem->getTransientTime() + mTime;
337  C_FLOAT64 endTime = mTime + *getValue("Overall time").pUDOUBLE;
338  C_FLOAT64 startTime = mTime;
339 
340  bool flagProceed = true;
341  C_FLOAT64 handlerFactor = 100.0 / (endTime - startTime);
342 
343  //** do the transient **
344  C_FLOAT64 CompareTime = transientTime - 100.0 * fabs(transientTime) * std::numeric_limits< C_FLOAT64 >::epsilon();
345 
346  if (mTime < CompareTime)
347  {
348  do
349  {
350  step(transientTime - mTime);
351 
352  if (mTime > CompareTime) break;
353 
354  /* Here we will do conditional event processing */
355 
356  /* Currently this is correct since no events are processed. */
357  //CCopasiMessage(CCopasiMessage::EXCEPTION, MCTrajectoryMethod + 12);
358 
359  flagProceed &= mpTask->methodCallback((mTime - startTime) * handlerFactor, true);
360  }
361  while (flagProceed);
362 
363  //mpLyapProblem->getModel()->setState(*mpCurrentState);
364  //mpLyapProblem->getModel()->updateSimulatedValues();
365  }
366  else
367  {
368  }
369 
370  //copy working array to state
373 
374  //copy state to model and do output
377  mpTask->methodCallback((mTime - startTime) * handlerFactor, false);
378  //********
379 
380  orthonormalize();
381 
382  if (mDoDivergence)
383  *(mVariables.array() + mVariables.size() - 1) = 0; //divergence
384 
385  mLsodaStatus = 1; //the state has changed, we need to restart lsoda
386 
387  size_t i;
388 
389  C_FLOAT64 realStepSize;
390 
391  do
392  {
393  realStepSize = step(stepSize);
394 
395  orthonormalize();
396  mLsodaStatus = 1; //the state has changed, we need to restart lsoda
397 
398  //process results of orthonormalisation
399  for (i = 0; i < mNumExp; ++i)
400  {
401  mpTask->mLocalExponents[i] = log(mNorms[i]);
403  mpTask->mLocalExponents[i] = mpTask->mLocalExponents[i] / realStepSize;
404  mpTask->mExponents[i] = mSumExponents[i] / (mTime - transientTime);
405  }
406 
407  //process result of divergence integration
408  if (mDoDivergence)
409  {
411  mpTask->mIntervalDivergence = *(mVariables.array() + mVariables.size() - 1) / realStepSize;
412  *(mVariables.array() + mVariables.size() - 1) = 0;
413  mpTask->mAverageDivergence = mSumDivergence / (mTime - transientTime);
414  }
415 
416  //copy working array to state
419  //copy state to model and do output
422  flagProceed &= mpTask->methodCallback((mTime - startTime) * handlerFactor, false);
423  }
424  while ((mTime < endTime) && flagProceed);
425 
426  return flagProceed;
427 }
CVector< C_FLOAT64 > mLocalExponents
Definition: CLyapTask.h:58
void updateSimulatedValues(const bool &updateMoieties)
Definition: CModel.cpp:1851
bool methodCallback(const C_FLOAT64 &percentage, bool onlyProgress)
Definition: CLyapTask.cpp:260
CVector< C_FLOAT64 > mNorms
CLyapProblem * mpProblem
Definition: CLyapMethod.h:74
C_FLOAT64 mSumDivergence
void setTime(const C_FLOAT64 &time)
Definition: CState.cpp:326
virtual void start()
virtual double step(const double &deltaT)
void setState(const CState &state)
Definition: CModel.cpp:1785
const C_FLOAT64 & getTransientTime() const
C_FLOAT64 mIntervalDivergence
Definition: CLyapTask.h:67
unsigned C_INT32 mNumExp
const Value & getValue() const
CVector< C_FLOAT64 > mVariables
CVector< C_FLOAT64 > mExponents
Definition: CLyapTask.h:59
size_t size() const
Definition: CVector.h:100
#define C_FLOAT64
Definition: copasi.h:92
CType * array()
Definition: CVector.h:139
CLyapTask * mpTask
C_FLOAT64 mAverageDivergence
Definition: CLyapTask.h:72
CModel * getModel() const
CCopasiContainer * getObjectParent() const
C_FLOAT64 * beginIndependent()
Definition: CState.cpp:328
CVector< C_FLOAT64 > mSumExponents
bool CLyapWolfMethod::elevateChildren ( )
virtual

This methods must be called to elevate subgroups to derived objects. The default implementation does nothing.

Returns
bool success

Reimplemented from CCopasiParameterGroup.

Definition at line 89 of file CLyapWolfMethod.cpp.

References initializeParameter().

90 {
92  return true;
93 }
void CLyapWolfMethod::EvalF ( const C_INT n,
const C_FLOAT64 t,
const C_FLOAT64 y,
C_FLOAT64 ydot 
)
static

Calculate the default absolute tolerance

Parameters
constCModel * pModel
Returns
C_FLOAT64 defaultAtol

Definition at line 239 of file CLyapWolfMethod.cpp.

References evalF(), and CLyapWolfMethod::Data::pMethod.

Referenced by step().

240 {static_cast<Data *>((void *) n)->pMethod->evalF(t, y, ydot);}
void CLyapWolfMethod::evalF ( const C_FLOAT64 t,
const C_FLOAT64 y,
C_FLOAT64 ydot 
)

This evaluates the derivatives for the complete model

Definition at line 242 of file CLyapWolfMethod.cpp.

References CVectorCore< CType >::array(), CMatrix< CType >::array(), CState::beginIndependent(), C_FLOAT64, CModel::calculateDerivatives(), CModel::calculateDerivativesX(), CModel::calculateJacobianX(), CCopasiProblem::getModel(), mDoDivergence, mJacobian, mNumExp, CLyapMethod::mpProblem, mpState, mReducedModel, mSystemSize, mVariables, CModel::setState(), CState::setTime(), and CModel::updateSimulatedValues().

Referenced by EvalF().

243 {
244  assert(y == mVariables.array());
245 
246  //set time in model
247  mpState->setTime(*t);
248 
249  //copy working array to state
251 
252  //copy state to model
253  CModel * pModel = mpProblem->getModel();
254  pModel->setState(*mpState);
256 
257  //the model
258  if (mReducedModel)
259  pModel->calculateDerivativesX(ydot);
260  else
261  pModel->calculateDerivatives(ydot);
262 
263  //the linearized model
264 
265  //get jacobian
266  pModel->calculateJacobianX(mJacobian, 1e-6, 1e-12);
267 
268  //empty dummy entries... to be removed later
269  //C_FLOAT64 *dbl, *dblEnd = ydot + mData.dim;
270  //for (dbl = ydot + mSystemSize; dbl != dblEnd; ++dbl)
271  // *dbl = 0;
272 
273  // char T = 'N';
274  // C_INT M = mSystemSize;
275  // C_INT N = mSystemSize;
276  // C_INT K = 1;
277  // //C_INT LD = mUnscaledElasticities.numCols();
278  //
279  // C_FLOAT64 Alpha = 1.0;
280  // C_FLOAT64 Beta = 0.0;
281  //
282  // dgemm_(&T, &T, &K, &N, &M, &Alpha,
283  // const_cast<C_FLOAT64*>(y) + mSystemSize, &K,
284  // mJacobian.array(), &M,
285  // &Beta,
286  // ydot + mSystemSize, &M);
287 
288  C_FLOAT64 *dbl1;
289  const C_FLOAT64 *dbl2, *dbl3, *dbl1end, *dbl3end;
290 
291  dbl1 = ydot + mSystemSize;
292 
293  size_t i;
294 
295  for (i = 1; i <= mNumExp; ++i)
296  {
297  //dbl1 += mSystemSize;
298  dbl1end = dbl1 + mSystemSize;
299  dbl2 = mJacobian.array();
300 
301  for (; dbl1 != dbl1end; ++dbl1)
302  {
303  *dbl1 = 0.0;
304 
305  dbl3 = y + i * mSystemSize;
306  dbl3end = dbl3 + mSystemSize;
307 
308  for (; dbl3 != dbl3end; ++dbl3, ++dbl2)
309  *dbl1 += *dbl2 * *dbl3;
310  }
311  }
312 
313  if (!mDoDivergence) return;
314 
315  //divergence; trace of jacobian
316  *dbl1 = 0;
317  dbl2 = mJacobian.array();
318 
319  for (i = 0; i < mSystemSize; ++i, dbl2 += (mSystemSize + 1))
320  * dbl1 += *dbl2;
321 
322  return;
323 }
void updateSimulatedValues(const bool &updateMoieties)
Definition: CModel.cpp:1851
void calculateJacobianX(CMatrix< C_FLOAT64 > &jacobianX, const C_FLOAT64 &derivationFactor, const C_FLOAT64 &resolution)
Definition: CModel.cpp:2082
CLyapProblem * mpProblem
Definition: CLyapMethod.h:74
void setTime(const C_FLOAT64 &time)
Definition: CState.cpp:326
void setState(const CState &state)
Definition: CModel.cpp:1785
unsigned C_INT32 mNumExp
CVector< C_FLOAT64 > mVariables
CMatrix< C_FLOAT64 > mJacobian
void calculateDerivativesX(C_FLOAT64 *derivativesX)
Definition: CModel.cpp:1941
#define C_FLOAT64
Definition: copasi.h:92
CType * array()
Definition: CVector.h:139
void calculateDerivatives(C_FLOAT64 *derivatives)
Definition: CModel.cpp:1903
Definition: CModel.h:50
virtual CType * array()
Definition: CMatrix.h:337
CModel * getModel() const
C_FLOAT64 * beginIndependent()
Definition: CState.cpp:328
void CLyapWolfMethod::initializeParameter ( )
private

Intialize the method parameter

Definition at line 55 of file CLyapWolfMethod.cpp.

References CCopasiParameterGroup::assertParameter(), C_FLOAT64, C_INT32, CCopasiParameterGroup::getParameter(), CCopasiParameter::getValue(), CCopasiParameter::Value::pBOOL, CCopasiParameter::Value::pUDOUBLE, CCopasiParameterGroup::removeParameter(), CCopasiParameterGroup::setValue(), CCopasiParameter::UDOUBLE, and CCopasiParameter::UINT.

Referenced by CLyapWolfMethod(), and elevateChildren().

56 {
57  assertParameter("Orthonormalization Interval", CCopasiParameter::UDOUBLE, (C_FLOAT64) 1.0);
58  assertParameter("Overall time", CCopasiParameter::UDOUBLE, (C_FLOAT64) 1000.0);
59  assertParameter("Relative Tolerance", CCopasiParameter::UDOUBLE, (C_FLOAT64) 1.0e-6);
60  assertParameter("Absolute Tolerance", CCopasiParameter::UDOUBLE, (C_FLOAT64) 1.0e-12);
61  assertParameter("Max Internal Steps", CCopasiParameter::UINT, (unsigned C_INT32) 10000);
62 
63  // Check whether we have an (obsolete) parameter "Use Default Absolute Tolerance"
64  CCopasiParameter *pParm;
65 
66  if ((pParm = getParameter("Use Default Absolute Tolerance")) != NULL)
67  {
68  C_FLOAT64 NewValue;
69 
70  if (*pParm->getValue().pBOOL)
71  {
72  // The default
73  NewValue = 1.e-12;
74  }
75  else
76  {
77  NewValue = *getValue("Absolute Tolerance").pUDOUBLE;
78  }
79 
80  setValue("Absolute Tolerance", NewValue);
81  removeParameter("Use Default Absolute Tolerance");
82  }
83 
84  // These parameters are no longer supported.
85  removeParameter("Adams Max Order");
86  removeParameter("BDF Max Order");
87 }
#define C_INT32
Definition: copasi.h:90
bool removeParameter(const std::string &name)
const Value & getValue() const
bool setValue(const std::string &name, const CType &value)
CCopasiParameter * getParameter(const std::string &name)
#define C_FLOAT64
Definition: copasi.h:92
CCopasiParameter * assertParameter(const std::string &name, const CCopasiParameter::Type type, const CType &defaultValue)
bool CLyapWolfMethod::isValidProblem ( const CCopasiProblem pProblem)
virtual

Check if the method is suitable for this problem

Returns
bool suitability of the method

Reimplemented from CLyapMethod.

Definition at line 503 of file CLyapWolfMethod.cpp.

References C_FLOAT64, CCopasiMessage::EXCEPTION, CLyapProblem::getTransientTime(), CCopasiParameter::getValue(), CLyapMethod::isValidProblem(), MCLyap, and CCopasiParameter::Value::pUDOUBLE.

504 {
505  if (!CLyapMethod::isValidProblem(pProblem)) return false;
506 
507  const CLyapProblem * pLP = dynamic_cast<const CLyapProblem *>(pProblem);
508  assert(pLP);
509 
510  C_FLOAT64 stepSize = *getValue("Orthonormalization Interval").pUDOUBLE;
511  C_FLOAT64 transientTime = pLP->getTransientTime();
512  C_FLOAT64 endTime = *getValue("Overall time").pUDOUBLE;
513 
514  if (transientTime >= endTime)
515  {
516  //
518  return false;
519  }
520 
521  if (stepSize > (endTime - transientTime))
522  {
523  //
525  return false;
526  }
527 
528  return true;
529 }
#define MCLyap
const C_FLOAT64 & getTransientTime() const
const Value & getValue() const
virtual bool isValidProblem(const CCopasiProblem *pProblem)
#define C_FLOAT64
Definition: copasi.h:92
C_FLOAT64 CLyapWolfMethod::norm ( const C_FLOAT64 dbl1,
const C_FLOAT64 dbl2 
)
staticprivate

Definition at line 463 of file CLyapWolfMethod.cpp.

References C_FLOAT64.

Referenced by orthonormalize().

464 {
465  C_FLOAT64 sum = 0;
466 
467  for (; dbl1 != dbl2; ++dbl1)
468  sum += *dbl1 * *dbl1;
469 
470  return sqrt(sum);
471 }
#define C_FLOAT64
Definition: copasi.h:92
void CLyapWolfMethod::orthonormalize ( )
private

Definition at line 429 of file CLyapWolfMethod.cpp.

References add(), CVectorCore< CType >::array(), C_FLOAT64, mNorms, mNumExp, mSystemSize, mVariables, norm(), product(), and scalarmult().

Referenced by calculate(), and start().

430 {
431  if (mNumExp < 1) return;
432 
433  //TODO generalize
434  C_FLOAT64 *dbl, *dblEnd;
435 
436  dbl = mVariables.array() + mSystemSize;
437  dblEnd = dbl + mSystemSize;
438  mNorms[0] = norm(dbl, dblEnd);
439  scalarmult(dbl, dblEnd, 1 / mNorms[0]);
440 
441  size_t i, j;
442 
443  for (i = 1; i < mNumExp; ++i)
444  {
445  dbl += mSystemSize;
446  dblEnd = dbl + mSystemSize;
447 
448  //orthogonalisation
449  for (j = 0; j < i; ++j)
450  {
451  add(dbl, dblEnd,
452  -product(dbl, dblEnd, mVariables.array() + (j + 1)*mSystemSize),
453  mVariables.array() + (j + 1)*mSystemSize);
454  }
455 
456  //normalisation
457  mNorms[i] = norm(dbl, dblEnd);
458  scalarmult(dbl, dblEnd, 1 / mNorms[i]);
459  }
460 }
static C_FLOAT64 norm(const C_FLOAT64 *dbl1, const C_FLOAT64 *dbl2)
static C_FLOAT64 product(const C_FLOAT64 *dbl1, const C_FLOAT64 *dbl1End, const C_FLOAT64 *dbl2)
static void add(C_FLOAT64 *dbl1, const C_FLOAT64 *dbl1End, const C_FLOAT64 &f, const C_FLOAT64 *dbl2)
CVector< C_FLOAT64 > mNorms
unsigned C_INT32 mNumExp
static void scalarmult(C_FLOAT64 *dbl1, const C_FLOAT64 *dbl2, const C_FLOAT64 &f)
CVector< C_FLOAT64 > mVariables
#define C_FLOAT64
Definition: copasi.h:92
CType * array()
Definition: CVector.h:139
C_FLOAT64 CLyapWolfMethod::product ( const C_FLOAT64 dbl1,
const C_FLOAT64 dbl1End,
const C_FLOAT64 dbl2 
)
staticprivate

Definition at line 482 of file CLyapWolfMethod.cpp.

References C_FLOAT64.

Referenced by orthonormalize().

484 {
485  C_FLOAT64 sum = 0;
486 
487  for (; dbl1 != dbl1End; ++dbl1, ++dbl2)
488  sum += *dbl1 * *dbl2;
489 
490  return sum;
491 }
#define C_FLOAT64
Definition: copasi.h:92
void CLyapWolfMethod::scalarmult ( C_FLOAT64 dbl1,
const C_FLOAT64 dbl2,
const C_FLOAT64 f 
)
staticprivate

Definition at line 474 of file CLyapWolfMethod.cpp.

Referenced by orthonormalize().

476 {
477  for (; dbl1 != dbl2; ++dbl1)
478  *dbl1 *= f;
479 }
void CLyapWolfMethod::start ( )
virtual

This instructs the method to prepare for integration starting with the initialState given.

Parameters
const CState *initialState

Definition at line 140 of file CLyapWolfMethod.cpp.

References CVectorCore< CType >::array(), CState::beginIndependent(), C_FLOAT64, C_INT, CLyapWolfMethod::Data::dim, CLyapProblem::divergenceRequested(), CLyapProblem::getExponentNumber(), CCopasiProblem::getModel(), CModel::getNumDependentReactionMetabs(), CState::getNumIndependent(), CModel::getState(), CState::getTime(), CCopasiParameter::getValue(), CModel::initializeAtolVector(), mAtol, CLyapTask::mAverageDivergence, mData, mDoDivergence, mDWork, mErrorMsg, CLyapTask::mExponents, CLyapTask::mIntervalDivergence, mIWork, mJacobian, mJType, CLyapTask::mLocalExponents, mLSODA, mLsodaStatus, mNorms, mNumExp, CLyapMethod::mpProblem, mpState, mpTask, mReducedModel, mRtol, mState, mSumDivergence, mSumExponents, mSystemSize, mTime, mVariables, orthonormalize(), pdelete, CCopasiParameter::Value::pUDOUBLE, CCopasiParameter::Value::pUINT, CMatrix< CType >::resize(), CVector< CType >::resize(), and CInternalSolver::setOstream().

Referenced by calculate().

141 {
142  /* Reset lsoda */
143  mLsodaStatus = 1;
144  mState = 1;
145  mJType = 2;
146  mErrorMsg.str("");
148 
149  /* Release previous state and make the initialState the current */
150  pdelete(mpState);
152 
153  //mY = mpState->beginIndependent();
154  mTime = mpState->getTime();
155 
156  mReducedModel = true; /* *getValue("Integrate Reduced Model").pBOOL;*/
157 
158  if (mReducedModel)
160  else
162 
165 
166  //calculate the number of variables for lsoda integration
167  if (mDoDivergence)
168  mData.dim = (C_INT)(mSystemSize * (1 + mNumExp) + 1);
169  else
170  mData.dim = (C_INT)(mSystemSize * (1 + mNumExp));
171 
172  //reserve space for exponents. The vectors in the task are resized by the task because they
173  //need to have a minimum size defined in the task
174  //pTask->mLocalExponents.resize(mNumExp);
177  //pTask->mExponents.resize(mNumExp);
178 
179  //initialize the vector on which lsoda will work
182 
183  //generate base vectors. Just define some arbitrary starting vectors that are not too specific and orthonormalize
184  // first fill the array with 0.1
185  C_FLOAT64 *dbl, *dblEnd = mVariables.array() + mData.dim;
186 
187  for (dbl = mVariables.array() + mSystemSize; dbl != dblEnd; ++dbl)
188  *dbl = 0.01;
189 
190  //now add 1.0
191  if (mNumExp > 0)
192  for (dbl = mVariables.array() + mSystemSize; dbl < dblEnd; dbl += (mSystemSize + 1))
193  * dbl = 1.0;
194 
195  orthonormalize();
196 
197  //reserve space for jacobian
199 
200  size_t i, imax = mNumExp;
201 
202  for (i = 0; i < imax; ++i)
203  {
204  mpTask->mLocalExponents[i] = 0;
205  mSumExponents[i] = 0;
206  mpTask->mExponents[i] = 0;
207  }
208 
210  mSumDivergence = 0;
212 
213  /* Configure lsoda */
214  mRtol = * getValue("Relative Tolerance").pUDOUBLE;
215 
216  C_FLOAT64 * pTolerance = getValue("Absolute Tolerance").pUDOUBLE;
218 
220 
221  for (i = 0; i < mSystemSize; ++i)
222  mAtol[i] = tmpAtol[i];
223 
224  for (i = mSystemSize; (int)i < mData.dim; ++i)
225  mAtol[i] = 1e-20;
226 
227  mDWork.resize(22 + mData.dim * std::max<C_INT>(16, mData.dim + 9));
228  mDWork[4] = mDWork[5] = mDWork[6] = mDWork[7] = mDWork[8] = mDWork[9] = 0.0;
229  mIWork.resize(20 + mData.dim);
230  mIWork[4] = mIWork[6] = mIWork[9] = 0;
231 
232  mIWork[5] = * getValue("Max Internal Steps").pUINT;
233  mIWork[7] = 12;
234  mIWork[8] = 5;
235 
236  return;
237 }
#define C_INT
Definition: copasi.h:115
#define pdelete(p)
Definition: copasi.h:215
CVector< C_FLOAT64 > mLocalExponents
Definition: CLyapTask.h:58
CVector< C_FLOAT64 > mAtol
void setOstream(std::ostream &os)
Definition: CState.h:305
CVector< C_FLOAT64 > mNorms
void resize(size_t size, const bool &copy=false)
Definition: CVector.h:301
CLyapProblem * mpProblem
Definition: CLyapMethod.h:74
C_FLOAT64 mSumDivergence
CVector< C_INT > mIWork
size_t getNumDependentReactionMetabs() const
Definition: CModel.cpp:1133
C_FLOAT64 mIntervalDivergence
Definition: CLyapTask.h:67
unsigned C_INT32 mNumExp
const Value & getValue() const
std::ostringstream mErrorMsg
CVector< C_FLOAT64 > mVariables
unsigned C_INT32 * pUINT
size_t getNumIndependent() const
Definition: CState.cpp:342
CVector< C_FLOAT64 > mExponents
Definition: CLyapTask.h:59
const unsigned C_INT32 & getExponentNumber() const
CVector< C_FLOAT64 > mDWork
virtual void resize(size_t rows, size_t cols, const bool &copy=false)
Definition: CMatrix.h:151
CMatrix< C_FLOAT64 > mJacobian
const C_FLOAT64 & getTime() const
Definition: CState.cpp:325
#define C_FLOAT64
Definition: copasi.h:92
CType * array()
Definition: CVector.h:139
bool divergenceRequested() const
CLyapTask * mpTask
CVector< C_FLOAT64 > initializeAtolVector(const C_FLOAT64 &baseTolerance, const bool &reducedModel) const
Definition: CModel.cpp:4368
C_FLOAT64 mAverageDivergence
Definition: CLyapTask.h:72
const CState & getState() const
Definition: CModel.cpp:1771
CModel * getModel() const
C_FLOAT64 * beginIndependent()
Definition: CState.cpp:328
CVector< C_FLOAT64 > mSumExponents
double CLyapWolfMethod::step ( const double &  deltaT)
virtual

This instructs the method to calculate a time step of deltaT starting with the current state, i.e., the result of the previous step. The new state (after deltaT) is expected in the current state. The return value is the actual timestep taken.

Parameters
const double &deltaT

Reimplemented from CLyapMethod.

Definition at line 95 of file CLyapWolfMethod.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, C_INT, CLyapWolfMethod::Data::dim, EvalF(), CCopasiMessage::EXCEPTION, mAtol, MCTrajectoryMethod, mData, mDWork, mErrorMsg, mIWork, mJType, mLSODA, mLsodaStatus, mpState, mRtol, mState, mTime, mVariables, CState::setTime(), and CVectorCore< CType >::size().

Referenced by calculate().

96 {
97  if (!mData.dim) //just do nothing if there are no variables
98  {
99  mTime = mTime + deltaT;
101 
102  return deltaT;
103  }
104 
105  C_FLOAT64 startTime = mTime;
106  C_FLOAT64 EndTime = mTime + deltaT;
107  C_INT one = 1;
108  C_INT two = 2;
109  C_INT DSize = (C_INT) mDWork.size();
110  C_INT ISize = (C_INT) mIWork.size();
111 
112  mLSODA(&EvalF , // 1. evaluate F
113  &mData.dim , // 2. number of variables
114  mVariables.array(), // 3. the array of current concentrations
115  &mTime , // 4. the current time
116  &EndTime , // 5. the final time
117  &two , // 6. vector absolute error, scalar relative error
118  &mRtol , // 7. relative tolerance array
119  mAtol.array() , // 8. absolute tolerance array
120  &mState , // 9. output by overshoot & interpolation
121  &mLsodaStatus , // 10. the state control variable
122  &one , // 11. futher options (one)
123  mDWork.array() , // 12. the double work array
124  &DSize , // 13. the double work array size
125  mIWork.array() , // 14. the int work array
126  &ISize , // 15. the int work array size
127  NULL , // 16. evaluate J (not given)
128  &mJType); // 17. the type of Jacobian calculate (2)
129 
130  if (mLsodaStatus == -1) mLsodaStatus = 2;
131 
132  if ((mLsodaStatus != 1) && (mLsodaStatus != 2) && (mLsodaStatus != -1))
133  {
135  }
136 
137  return mTime - startTime;
138 }
#define C_INT
Definition: copasi.h:115
static void EvalF(const C_INT *n, const C_FLOAT64 *t, const C_FLOAT64 *y, C_FLOAT64 *ydot)
CVector< C_FLOAT64 > mAtol
void setTime(const C_FLOAT64 &time)
Definition: CState.cpp:326
CVector< C_INT > mIWork
#define MCTrajectoryMethod
std::ostringstream mErrorMsg
CVector< C_FLOAT64 > mVariables
CVector< C_FLOAT64 > mDWork
size_t size() const
Definition: CVector.h:100
#define C_FLOAT64
Definition: copasi.h:92
CType * array()
Definition: CVector.h:139

Friends And Related Function Documentation

Member Data Documentation

CVector<C_FLOAT64> CLyapWolfMethod::mAtol
private

Absolute tolerance.

Definition at line 124 of file CLyapWolfMethod.h.

Referenced by start(), and step().

Data CLyapWolfMethod::mData
private

mData.dim is the dimension of the ODE system. mData.pMethod contains CLsodaMethod * this to be used in the static method EvalF

Definition at line 65 of file CLyapWolfMethod.h.

Referenced by CLyapWolfMethod(), start(), and step().

bool CLyapWolfMethod::mDoDivergence
private

Definition at line 77 of file CLyapWolfMethod.h.

Referenced by calculate(), evalF(), and start().

CVector< C_FLOAT64 > CLyapWolfMethod::mDWork
private

Definition at line 133 of file CLyapWolfMethod.h.

Referenced by start(), and step().

C_FLOAT64 CLyapWolfMethod::mEndt
private

Requested end time.

Definition at line 99 of file CLyapWolfMethod.h.

std::ostringstream CLyapWolfMethod::mErrorMsg
private

Definition at line 129 of file CLyapWolfMethod.h.

Referenced by start(), and step().

CVector< C_INT > CLyapWolfMethod::mIWork
private

Definition at line 134 of file CLyapWolfMethod.h.

Referenced by start(), and step().

CMatrix<C_FLOAT64> CLyapWolfMethod::mJacobian
private

Definition at line 79 of file CLyapWolfMethod.h.

Referenced by evalF(), and start().

C_INT CLyapWolfMethod::mJType
private

Definition at line 141 of file CLyapWolfMethod.h.

Referenced by start(), and step().

CLSODA CLyapWolfMethod::mLSODA
private

Definition at line 131 of file CLyapWolfMethod.h.

Referenced by start(), and step().

C_INT CLyapWolfMethod::mLsodaStatus
private

LSODA state.

Definition at line 104 of file CLyapWolfMethod.h.

Referenced by calculate(), start(), and step().

CVector<C_FLOAT64> CLyapWolfMethod::mNorms
private

Definition at line 84 of file CLyapWolfMethod.h.

Referenced by calculate(), orthonormalize(), and start().

unsigned C_INT32 CLyapWolfMethod::mNumExp
private

Number of exponents to calculate

Definition at line 75 of file CLyapWolfMethod.h.

Referenced by calculate(), evalF(), orthonormalize(), and start().

CState* CLyapWolfMethod::mpState
private

A pointer to the current state in complete model view.

Definition at line 59 of file CLyapWolfMethod.h.

Referenced by calculate(), evalF(), start(), step(), and ~CLyapWolfMethod().

CLyapTask* CLyapWolfMethod::mpTask
private

Definition at line 143 of file CLyapWolfMethod.h.

Referenced by calculate(), and start().

bool CLyapWolfMethod::mReducedModel
private

Definition at line 109 of file CLyapWolfMethod.h.

Referenced by calculate(), evalF(), and start().

C_FLOAT64 CLyapWolfMethod::mRtol
private

Relative tolerance.

Definition at line 114 of file CLyapWolfMethod.h.

Referenced by start(), and step().

C_INT CLyapWolfMethod::mState
private

Definition at line 132 of file CLyapWolfMethod.h.

Referenced by start(), and step().

C_FLOAT64 CLyapWolfMethod::mSumDivergence
private

integrated divergence

Definition at line 89 of file CLyapWolfMethod.h.

Referenced by calculate(), and start().

CVector<C_FLOAT64> CLyapWolfMethod::mSumExponents
private

Definition at line 82 of file CLyapWolfMethod.h.

Referenced by calculate(), and start().

size_t CLyapWolfMethod::mSystemSize
private

Number of variables in the model

Definition at line 70 of file CLyapWolfMethod.h.

Referenced by calculate(), evalF(), orthonormalize(), and start().

C_FLOAT64 CLyapWolfMethod::mTime
private

Current time.

Definition at line 94 of file CLyapWolfMethod.h.

Referenced by calculate(), start(), and step().

CVector< C_FLOAT64 > CLyapWolfMethod::mVariables
private

the vector that contains the extended system

Definition at line 139 of file CLyapWolfMethod.h.

Referenced by calculate(), evalF(), orthonormalize(), start(), and step().


The documentation for this class was generated from the following files: