COPASI API  4.16.103
CReaction.h
Go to the documentation of this file.
1 // Copyright (C) 2010 - 2013 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) 2001 - 2007 by Pedro Mendes, Virginia Tech Intellectual
12 // Properties, Inc. and EML Research, gGmbH.
13 // All rights reserved.
14 
15 /**
16  * CReaction class.
17  * Derived from Gepasi's cstep.cpp. (C) Pedro Mendes 1995-2000.
18  *
19  * Converted for COPASI by Stefan Hoops 2001
20  */
21 
22 #ifndef COPASI_CReaction
23 #define COPASI_CReaction
24 
25 #include <string>
26 #include <vector>
27 
29 #include "copasi/model/CMetab.h"
30 #include "copasi/model/CChemEq.h"
33 
39 
40 class CReadConfig;
41 class SBase;
42 class CFunctionDB;
43 
44 class CReaction : public CCopasiContainer, public CAnnotation
45 {
46 public:
47  /**
48  * Default constructor
49  * @param const std::string & name (default: "NoName")
50  * @param const CCopasiContainer * pParent (default: NULL)
51  */
52  CReaction(const std::string & name = "NoName",
53  const CCopasiContainer * pParent = NULL);
54 
55  /**
56  * Copy constructor
57  * @param "const CReaction &" src
58  * @param const CCopasiContainer * pParent (default: NULL)
59  */
60  CReaction(const CReaction & src,
61  const CCopasiContainer * pParent = NULL);
62 
63 private:
64  CReaction & operator= (const CReaction &);
65 
66 public:
67  /**
68  * Destructor
69  */
70  virtual ~CReaction();
71 
72  /**
73  * Retrieve the units of the child object.
74  * @return std::string units
75  */
76  virtual std::string getChildObjectUnits(const CCopasiObject * pObject) const;
77 
78  /**
79  * Delete
80  */
81  void cleanup();
82 
83  /**
84  * Overload display name. Special treatment for reaction to
85  * provide a shorter display
86  */
87  virtual std::string getObjectDisplayName(bool regular = true, bool richtext = false) const;
88 
89  /**
90  * Loads an object with data coming from a CReadConfig object.
91  * (CReadConfig object reads an input stream)
92  * @param pconfigbuffer reference to a CReadConfig object.
93  * @return mFail
94  * @see mFail
95  */
96  C_INT32 load(CReadConfig & configbuffer);
97 
98  /**
99  * Sets the parent of the metabolite;
100  * @param const CCopasiContainer * pParent
101  * @return bool success
102  */
103  virtual bool setObjectParent(const CCopasiContainer * pParent);
104 
105  /**
106  * Retrieve the list of deleted numeric child objects;
107  * @return std::set< const CCopasiObject * > deletedObjects
108  */
109  virtual std::set< const CCopasiObject * > getDeletedObjects() const;
110 
111  /**
112  * Check whether an object must be deleted because its prerequisites can
113  * no longer be fulfilled due to the given deleted objects
114  * @param const DataObjectSet & deletedObjects
115  * @return bool mustBeDeleted
116  */
117  virtual bool mustBeDeleted(const DataObjectSet & deletedObjects) const;
118 
119  /**
120  * Retrieves the key of the reaction
121  * @return std::string key
122  */
123  virtual const std::string & getKey() const;
124 
125  /**
126  * Retrieves the chemical equation of the reaction
127  * @return const CChemEq & chemEq
128  */
129  const CChemEq & getChemEq() const;
130 
131  /**
132  * Retrieves the chemical equation of the reaction
133  * @return CChemEq & chemEq
134  */
135  CChemEq & getChemEq();
136 
137  /**
138  * Retrieves the rate function of the reaction
139  * @return "CBaseFunction &"
140  */
141  const CFunction * getFunction() const;
142 
143  /**
144  * Retrieves the flux of the reaction
145  * @return const C_FLOAT64 & flux
146  */
147  const C_FLOAT64 & getFlux() const;
148 
149  /**
150  * Retrieves the scaled flux of the reaction
151  * @return const C_FLOAT64 & scaledFlux
152  */
153  const C_FLOAT64 & getParticleFlux() const;
154 
155  /**
156  * Retrieves whether the reaction is reversible
157  * @return bool
158  */
159  bool isReversible() const;
160 
161  /**
162  * Add a substrate to the reaction
163  * @param std::string & metabKey
164  * @param const C_FLOAT64 & multiplicity (Default 1.0)
165  * @return bool success
166  */
167  bool addSubstrate(const std::string & metabKey,
168  const C_FLOAT64 & multiplicity = 1.0);
169 
170  /**
171  * Add a product to the reaction
172  * @param std::string & metabKey
173  * @param const C_FLOAT64 & multiplicity (Default 1.0)
174  * @return bool success
175  */
176  bool addProduct(const std::string & metabKey,
177  const C_FLOAT64 & multiplicity = 1.0);
178 
179  /**
180  * Add a modifier to the reaction
181  * @param std::string & metabKey
182  * @param const C_FLOAT64 & multiplicity (Default 1.0)
183  * @return bool success
184  */
185  bool addModifier(const std::string & metabKey,
186  const C_FLOAT64 & multiplicity = 1.0);
187 
188  /**
189  * Sets the rate function of the reaction
190  * @param const string & functionName
191  * @return bool success
192  */
193  bool setFunction(const std::string & functionName);
194 
195  /**
196  * Sets the rate function of the reaction
197  * @param CFunction * pFunction
198  * @return bool success
199  */
200  bool setFunction(CFunction * pFunction);
201 
202  //****************************************************************************************
203 
204  /**
205  * Retrieve the index of the given parameter name in the function call. If pType is not
206  * NULL the type of the parameter is returned
207  * @param const std::string & parameterName
208  * @param CFunctionParameter::DataType * pType (default: NULL)
209  * @return size_t index;
210  */
211  size_t getParameterIndex(const std::string & parameterName, CFunctionParameter::DataType * pType = NULL) const;
212 
213  /**
214  * Sets a parameter value
215  * if updateStatus==true the status is also updated to make sure
216  * the value is actually used (instead of a global value that may
217  * have been used before).
218  * if updateStatus==false only the value of the local parameter is
219  * set, even if it is not used
220  * @param const std::string & parameterName
221  * @param const C_FLOAT64 & value
222  * @param const bool & updateStatus (default: true(
223  */
224  void setParameterValue(const std::string & parameterName,
225  const C_FLOAT64 & value,
226  const bool & updateStatus = true);
227 
228  /**
229  * Retrieves a parameter value
230  */
231  const C_FLOAT64 & getParameterValue(const std::string & parameterName) const;
232 
233  /**
234  * Sets a parameter mapping for the indexed parameter.
235  * @param const size_t & index
236  * @param const std::string & key
237  */
238  void setParameterMapping(const size_t & index, const std::string & key);
239 
240  /**
241  * Add a parameter mapping for the indexed parameter.
242  * @param const size_t & index
243  * @param const std::string & key
244  */
245  void addParameterMapping(const size_t & index, const std::string & key);
246 
247  /**
248  * Sets a parameter mapping for the named parameter.
249  * @param const std::string & parameterName
250  * @param const std::string & key
251  * @return bool success
252  */
253  bool setParameterMapping(const std::string & parameterName, const std::string & key);
254 
255  /**
256  * Add a parameter mapping for the named parameter.
257  * @param const std::string & parameterName
258  * @param const std::string & key
259  */
260  void addParameterMapping(const std::string & parameterName, const std::string & key);
261 
262  /**
263  * Set the mapping for the name parameter which must be of type vector
264  * @param const std::string & parameterName
265  * @param const std::vector<std::string> & keys
266  */
267  void setParameterMappingVector(const std::string & parameterName,
268  const std::vector<std::string> & keys);
269 
270  /**
271  * Clear the parameter mapping for the named parameter.
272  * @param const size_t & index
273  */
274  void clearParameterMapping(const std::string & parameterName);
275 
276  /**
277  * Clear the parameter mapping for the indexed parameter.
278  * @param const size_t & index
279  */
280  void clearParameterMapping(const size_t & index);
281 
282  /**
283  * Retrieve the mappings of kinetic function parameters.
284  */
285  const std::vector< std::vector<std::string> > & getParameterMappings() const
286  {return mMetabKeyMap;}
287 
288  std::vector< std::vector<std::string> > & getParameterMappings()
289  {return mMetabKeyMap;}
290 
291  const std::vector<std::string> & getParameterMapping(const size_t & index) const;
292 
293  const std::vector<std::string> & getParameterMapping(const std::string & parameterName) const;
294 
295  /**
296  * Gets the list of kinetic parameter objects of the reaction/function
297  */
298  const CCopasiParameterGroup & getParameters() const;
299 
300  /**
301  * Gets the list of kinetic parameter objects of the reaction/function
302  */
304 
305  /**
306  * Check whether the indexed parameter is a local parameter.
307  * @param const size_t & index
308  * @return bool isLocal
309  */
310  bool isLocalParameter(const size_t & index) const;
311 
312  /**
313  * Check whether the named parameter is a local parameter.
314  * @param const std::string & parameterName
315  * @return bool isLocal
316  */
317  bool isLocalParameter(const std::string & parameterName) const;
318 
319  /**
320  * We are hiding local reaction parameter which are covered by global quantities.
321  * @param const CCopasiObjectName & cn
322  * @return const CObjectInterface * pObject
323  */
324  virtual const CObjectInterface * getObject(const CCopasiObjectName & cn) const;
325 
326  /**
327  * Gets the description of what parameters the function expects.
328  */
330 
331  /**
332  * Sets whether the reaction is reversible
333  * @param bool reversible
334  */
335  void setReversible(bool reversible);
336 
337  /**
338  * Compile the reaction, i.e., links the metabolites and parameters with the
339  * rate function. The connection of the reaction and the function parameter mapping
340  * to the actual metabolites is established (before compile() the chemical equation
341  * and the reaction only hold the names of the metabolites).
342  * @param "CCopasiVectorNS < CCompartment > &" compartments
343  */
344  void compile();
345 
346  /**
347  * Calculate the kinetic function and returns the flux
348  * @return const C_FLOAT64 & Flux
349  */
350  const C_FLOAT64 & calculateFlux();
351 
352  /**
353  * Calculates the kinetic function and returns the particle flux
354  * @return const C_FLOAT64 & ParticleFlux
355  */
357 
358  /**
359  * Retrieve object referencing the particle flux
360  * @return CCopasiObject * particleFluxReference
361  */
363 
364  /**
365  * Retrieve const object referencing the particle flux
366  * @return CCopasiObject * particleFluxReference
367  */
368  const CCopasiObject * getParticleFluxReference() const;
369 
370  /**
371  * Retrieve object referencing the flux
372  * @return CCopasiObject * fluxReference
373  */
375 
376  /**
377  * Retrieve const object referencing the flux
378  * @return CCopasiObject * fluxReference
379  */
380  const CCopasiObject * getFluxReference() const;
381 
382  /**
383  * Retrieve object referencing the propensity
384  * @return CCopasiObject * propensityReference
385  */
387 
388  /**
389  * Retrieve object referencing the propensity
390  * @return CCopasiObject * propensityReference
391  */
392  const CCopasiObject * getPropensityReference() const;
393 
394  /**
395  * Retrieve the call parameter given to the kinetic function.
396  * @return const CCallParameters< C_FLOAT64 > & callParameters
397  */
399 
400 private:
401  /**
402  * Calculate the kinetic function
403  */
404  void calculate();
405 
406 public:
407  /**
408  * Calculate partial derivative of the flux
409  * @param C_FLOAT64 * pXi
410  * @param const C_FLOAT64 & derivationFactor
411  * @param const C_FLOAT64 & resolution (unscaled resolution)
412  * @return C_FLOAT64 partial
413  */
415  const C_FLOAT64 & derivationFactor,
416  const C_FLOAT64 & resolution);
417 
418  /**
419  * Retrieves the number of compartments the reaction is acting in.
420  * @return "size_t" the compartment number
421  */
422  size_t getCompartmentNumber() const;
423 
424  /**
425  * Retrieve the largest compartment that the reaction touches.
426  * This is time dependent it can only be called after update initial values
427  * has been called. Note for an empty reaction a NULL pointer is returned.
428  * @return const CCompartment * pCompartment
429  */
430  const CCompartment * getLargestCompartment() const;
431 
432  /**
433  * Converts an expression tree into a CFunction object
434  * and sets the mapping for the reaction.
435  */
437  std::map<CCopasiObject*, SBase*> & copasi2sbmlmap,
438  CFunctionDB* pFunctionDB);
439 
440  /**
441  * Converts the function tree into the corresponding expression tree.
442  * All variable nodes are replaced by object nodes.
443  */
445 
446  /**
447  * Sets the SBMLId.
448  */
449  void setSBMLId(const std::string& id);
450 
451  /**
452  * Returns a reference to the SBML Id.
453  */
454  const std::string& getSBMLId() const;
455 
456  /**
457  * Friend declaration for ostream operator
458  * @param std::ostream & os
459  * @param const CReaction & d
460  * @return std::ostream & os
461  */
462  friend std::ostream & operator<<(std::ostream & os, const CReaction & d);
463 
464  void printDebug() const;
465 
466  /**
467  * Set whether the reaction is to be treated as fast
468  * @param const bool & fast
469  */
470  void setFast(const bool & fast);
471 
472  /**
473  * Check whether the reaction needs to be treated as fast
474  * @ return const bool & fast
475  */
476  const bool & isFast() const;
477 
478 private:
479 
480  /**
481  * Loads a reaction from a Gepasi file
482  */
483  C_INT32 loadOld(CReadConfig & configbuffer);
484 
485  /**
486  * Used for loading Gepasi files. Loads the mapping for one role
487  */
488  bool loadOneRole(CReadConfig & configbuffer,
490  const std::string & prefix);
491 
492  /**
493  * Sets the scaling factor of the for the fluxes
494  */
495  void setScalingFactor();
496 
497  void initObjects();
498 
499  /**
500  * creates the mParamters List of CParameter objects.
501  * mMap needs to be initialized before.
502  */
503  void initializeParameters();
504 
505  /**
506  * Initializes the mMetabNameMap vectors to the right size.
507  */
509 
510  /**
511  * Replaces all object nodes in an expression tree by variable nodes.
512  * The usage term of the variable nodes is recorded in terms
513  * of CFunctionParameters that are stored in the replacementMap.
514  * On failure a NULL pointer is returned.
515  */
517  std::map<std::string, std::pair<CCopasiObject*, CFunctionParameter*> >& replacementMap,
518  std::map<CCopasiObject*, SBase*>& copasi2sbmlmap);
519 
520  /**
521  * Converts a single object node to a variable node.
522  * The usage term of the variable nodes is recorded in terms
523  * of CFunctionParameters that are stored in the replacementMap.
524  * On failure a NULL pointer is returned.
525  */
527  std::map<std::string, std::pair<CCopasiObject*, CFunctionParameter*> >& replacementMap,
528  std::map<CCopasiObject*, SBase*>& copasi2sbmlmap);
529 
530  /**
531  * Replaces all variable nodes in a function tree by object nodes.
532  * On failure a NULL pointer is returned.
533  */
535 
536  /**
537  * Converts a single variable node to an object node.
538  * On failure a NULL pointer is returned.
539  */
541 
542  /**
543  * Escapes double quotes and backslashes in a string and puts strings with
544  * tabs and spaces in double quotes.
545  */
546  std::string escapeId(const std::string& id);
547 
548  // Attributes
549 private:
550  /**
551  * The default scaling factor of a reaction which is 1.
552  */
554 
555  /**
556  * The chemical equation
557  */
559 
560  /**
561  * A pointer to the rate function of the reaction
562  */
564 
565  /**
566  * The flux of the reaction, as amount of substance/time
567  */
570 
571  /**
572  * The scaled flux of the reaction, as particle number/time
573  */
576 
577  /**
578  * The propensity of the reaction
579  */
582 
583  /**
584  * A pointer to the scaling factor for the flux to calculate the particle number
585  * changes. For a single compartment reaction this is the volume of
586  * the compartment
587  */
589 
590  /**
591  * The unit conversion factor
592  */
594 
595  /**
596  * This describes the mapping of the species and parameters to the function parameters.
597  * Here are the pointers to the actual objects and values.
598  */
600 
601  /**
602  * This describes the mapping of the species to the function parameters. Here the
603  * keys of the metabolites (as in the chemical equation) are stored.
604  */
605  std::vector< std::vector< std::string > > mMetabKeyMap;
606 
607  /**
608  * This is a list of parameter objects.
609  */
611 
612  /**
613  * The id of the corresponding reaction in an SBML file.
614  * This value is either set upon importing an SBML file,
615  * or when the object is first exported to an SBML file.
616  */
617  std::string mSBMLId;
618 
619  /**
620  * This flag indicates whether the reaction is treated as fast. The interpretation of fast
621  * is up to to the integration algorithm.
622  */
623  bool mFast;
624 };
625 
626 #endif // COPASI_CReaction
void initObjects()
Definition: CReaction.cpp:945
CCopasiParameterGroup mParameters
Definition: CReaction.h:610
void calculate()
Definition: CReaction.cpp:840
void setReversible(bool reversible)
Definition: CReaction.cpp:247
CCopasiObjectReference< C_FLOAT64 > * mpFluxReference
Definition: CReaction.h:569
void cleanup()
Definition: CReaction.cpp:135
CCopasiObject * getParticleFluxReference()
Definition: CReaction.cpp:207
CCopasiObjectReference< C_FLOAT64 > * mpPropensityReference
Definition: CReaction.h:581
CFunction * setFunctionFromExpressionTree(const CExpression &tree, std::map< CCopasiObject *, SBase * > &copasi2sbmlmap, CFunctionDB *pFunctionDB)
Definition: CReaction.cpp:1343
C_INT32 loadOld(CReadConfig &configbuffer)
Definition: CReaction.cpp:767
const C_FLOAT64 & getParticleFlux() const
Definition: CReaction.cpp:201
CFunction * mpFunction
Definition: CReaction.h:563
bool addSubstrate(const std::string &metabKey, const C_FLOAT64 &multiplicity=1.0)
Definition: CReaction.cpp:232
virtual std::string getChildObjectUnits(const CCopasiObject *pObject) const
Definition: CReaction.cpp:116
virtual const std::string & getKey() const
Definition: CReaction.cpp:190
virtual ~CReaction()
Definition: CReaction.cpp:108
void setParameterValue(const std::string &parameterName, const C_FLOAT64 &value, const bool &updateStatus=true)
Definition: CReaction.cpp:303
friend std::ostream & operator<<(std::ostream &os, const CReaction &d)
Definition: CReaction.cpp:1029
virtual std::string getObjectDisplayName(bool regular=true, bool richtext=false) const
Definition: CReaction.cpp:1688
const CCallParameters< C_FLOAT64 > & getCallParameters() const
Definition: CReaction.cpp:216
bool addProduct(const std::string &metabKey, const C_FLOAT64 &multiplicity=1.0)
Definition: CReaction.cpp:236
C_FLOAT64 mParticleFlux
Definition: CReaction.h:574
bool isLocalParameter(const size_t &index) const
Definition: CReaction.cpp:449
C_FLOAT64 calculatePartialDerivative(C_FLOAT64 *pXi, const C_FLOAT64 &derivationFactor, const C_FLOAT64 &resolution)
Definition: CReaction.cpp:847
CEvaluationNode * objects2variables(const CEvaluationNode *expression, std::map< std::string, std::pair< CCopasiObject *, CFunctionParameter * > > &replacementMap, std::map< CCopasiObject *, SBase * > &copasi2sbmlmap)
Definition: CReaction.cpp:1285
void clearParameterMapping(const std::string &parameterName)
Definition: CReaction.cpp:407
const C_FLOAT64 & calculateFlux()
Definition: CReaction.cpp:826
const C_FLOAT64 & getFlux() const
Definition: CReaction.cpp:192
#define C_INT32
Definition: copasi.h:90
CCopasiObject * getPropensityReference()
Definition: CReaction.cpp:210
virtual const CObjectInterface * getObject(const CCopasiObjectName &cn) const
Definition: CReaction.cpp:479
void setParameterMappingVector(const std::string &parameterName, const std::vector< std::string > &keys)
Definition: CReaction.cpp:390
virtual std::set< const CCopasiObject * > getDeletedObjects() const
Definition: CReaction.cpp:959
CEvaluationNodeVariable * object2variable(const CEvaluationNodeObject *objectNode, std::map< std::string, std::pair< CCopasiObject *, CFunctionParameter * > > &replacementMap, std::map< CCopasiObject *, SBase * > &copasi2sbmlmap)
Definition: CReaction.cpp:1076
const C_FLOAT64 * mUnitScalingFactor
Definition: CReaction.h:593
const std::string & getSBMLId() const
Definition: CReaction.cpp:1654
CChemEq mChemEq
Definition: CReaction.h:558
void compile()
Definition: CReaction.cpp:583
void setScalingFactor()
Definition: CReaction.cpp:879
const CFunction * getFunction() const
Definition: CReaction.cpp:252
CEvaluationNode * variables2objects(CEvaluationNode *expression)
Definition: CReaction.cpp:1440
virtual bool mustBeDeleted(const DataObjectSet &deletedObjects) const
Definition: CReaction.cpp:981
const CFunctionParameters & getFunctionParameters() const
Definition: CReaction.cpp:576
CReaction(const std::string &name="NoName", const CCopasiContainer *pParent=NULL)
Definition: CReaction.cpp:51
void printDebug() const
Definition: CReaction.cpp:1700
size_t getParameterIndex(const std::string &parameterName, CFunctionParameter::DataType *pType=NULL) const
Definition: CReaction.cpp:292
bool addModifier(const std::string &metabKey, const C_FLOAT64 &multiplicity=1.0)
Definition: CReaction.cpp:240
CFunctionParameterMap mMap
Definition: CReaction.h:599
bool setFunction(const std::string &functionName)
Definition: CReaction.cpp:255
void setSBMLId(const std::string &id)
Definition: CReaction.cpp:1649
C_INT32 load(CReadConfig &configbuffer)
Definition: CReaction.cpp:148
std::vector< std::vector< std::string > > & getParameterMappings()
Definition: CReaction.h:288
const C_FLOAT64 & calculateParticleFlux()
Definition: CReaction.cpp:832
bool isReversible() const
Definition: CReaction.cpp:229
const bool & isFast() const
Definition: CReaction.cpp:1712
C_FLOAT64 mPropensity
Definition: CReaction.h:580
const C_FLOAT64 * mScalingFactor
Definition: CReaction.h:588
C_FLOAT64 mFlux
Definition: CReaction.h:568
#define C_FLOAT64
Definition: copasi.h:92
const CCopasiParameterGroup & getParameters() const
Definition: CReaction.cpp:333
const CCompartment * getLargestCompartment() const
Definition: CReaction.cpp:876
void setParameterMapping(const size_t &index, const std::string &key)
Definition: CReaction.cpp:339
size_t getCompartmentNumber() const
Definition: CReaction.cpp:873
bool loadOneRole(CReadConfig &configbuffer, CFunctionParameter::Role role, C_INT32 n, const std::string &prefix)
Definition: CReaction.cpp:668
The class for handling a chemical kinetic function.
Definition: CFunction.h:29
bool mFast
Definition: CReaction.h:623
void setFast(const bool &fast)
Definition: CReaction.cpp:1703
std::string escapeId(const std::string &id)
Definition: CReaction.cpp:1659
CEvaluationNodeObject * variable2object(CEvaluationNodeVariable *pVariableNode)
Definition: CReaction.cpp:1614
virtual bool setObjectParent(const CCopasiContainer *pParent)
Definition: CReaction.cpp:141
std::vector< std::vector< std::string > > mMetabKeyMap
Definition: CReaction.h:605
CEvaluationNode * getExpressionTree()
Definition: CReaction.cpp:1644
const std::vector< std::vector< std::string > > & getParameterMappings() const
Definition: CReaction.h:285
static C_FLOAT64 mDefaultScalingFactor
Definition: CReaction.h:553
CReaction & operator=(const CReaction &)
void initializeParameters()
Definition: CReaction.cpp:509
std::set< const CCopasiObject * > DataObjectSet
CCopasiObjectReference< C_FLOAT64 > * mpParticleFluxReference
Definition: CReaction.h:575
const CChemEq & getChemEq() const
Definition: CReaction.cpp:223
const C_FLOAT64 & getParameterValue(const std::string &parameterName) const
Definition: CReaction.cpp:326
std::string mSBMLId
Definition: CReaction.h:617
void addParameterMapping(const size_t &index, const std::string &key)
Definition: CReaction.cpp:348
void initializeMetaboliteKeyMap()
Definition: CReaction.cpp:558
const std::vector< std::string > & getParameterMapping(const size_t &index) const
Definition: CReaction.cpp:432
CCopasiObject * getFluxReference()
Definition: CReaction.cpp:198