RoadRunner API Reference¶

This is the API Reference page for the module: roadrunner

class roadrunner.RoadRunner¶
The main RoadRunner class. Its objects, i.e. ``rr = RoadRunner()`` perform
the libRoaRunner functions, i.e. ``rr.simulate()``.

RoadRunner.__init__(compiler='', tempDir='', supportCodeDir='')¶

All three of the libRoadRunner options default to the empty string, in this case, the default values are used.

Parameters:	compiler – if LLVM build is enabled, the compiler defaults to LLVM. tempDir – (string) typically ignored, only used by the old C RoadRunner. supportCodeDir – typically ignored, only used by the old C RoadRunner

and some more stuff.

RoadRunner.createSelection(str)¶: Creates a new SelectionRecord for the given selection string.

RoadRunner.getSteadyStateValues(*args)¶: Returns a vector of steady state values for the floating species. The order of species in the vector is indicated by the order of species Ids in a call to getFloatingSpeciesIds()

RoadRunner.getCC(variable, parameter)¶

Returns a scaled control coefficient with respect to a global parameter.

For example:

rr.getCC ('J1', 'Vmax')
rr.getCC ('S1', 'Xo')
rr.getCC ('S2', 'Km')

The first returns a flux control coefficient with respect to flux J1. The second and third return concentration control coefficients with respect to speies S1 and S2.

Parameters:	variable – The id of a dependent variable of the coefficient, for example a flux or species concentration. parameter – The id of the independent parameter, for example a kinetic constant or boundary species
Returns:	the value of the control coefficeint returned to the caller.
Return type:	double

RoadRunner.getuCC(variableId, parameterId)¶

Get unscaled control coefficient with respect to a global parameter.

Parameters:	variableId – must be either a reaction or floating species. parameterId – must be eithe a global parameter, boundary species, or conserved sum.

RoadRunner.getCompiler()¶: Return the compiler used to build the ExecutableModel.

RoadRunner.getConfigurationXML()¶

recurse through all of the child configurable objects that this class ownes and build an assemble all of thier configuration parameters into a single xml document which is returned as a string.

The value of this result depends on what child objects are presently loaded.

RoadRunner.getConservationMatrix()¶: Returns a conservation matrix $\Gamma$ which is a $c \times m$ matrix where $c$ is the number of conservation laws and $m$ the number of species.

static RoadRunner.getCopyright()¶: Returns the copyright string

RoadRunner.getEE(reactionId, parameterId, steadyState=True)¶

Retrieve a single elasticity coefficient with respect to a global parameter.

For example:

x = rr.getEE ('J1', 'Vmax')

Parameters:	variable (str) – The dependent variable of the coefficient, for example a flux or species concentration. parameter (str) – The independent parameter, for example a kinetic constant or boundary species steadyState (Boolean) – should the steady state value be computed.

RoadRunner.getuEE(reactionId, parameterId)¶: Get unscaled elasticity coefficient with respect to a global parameter or species.

RoadRunner.getEigenvalueIds()¶: returns a list of floating species ids with thier names prefixed with eigen_. For example, if the model contained the floating species S1 and S2, this would return a list containing [“eigen_S1”, “eigen_S2”].

RoadRunner.getEigenvalues(m)¶

Returns eigenvalues, first column real part, second column imaginary part.

Return type:	numpy.ndarray

static RoadRunner.getExtendedVersionInfo()¶: getVersion plus info about dependent libs versions.

RoadRunner.getFloatingSpeciesAmountIds()¶: Returns a list of the floating species Ids, but with theIids surrounded by square brackets, i.e. ‘S1’ -> ‘[S1]’

RoadRunner.getFullJacobian()¶

Compute the full Jacobian at the current operating point.

This is the Jacobian of ONLY the floating species.

RoadRunner.getFullyReorderedStoichiometryMatrix()¶: Returns the full reordered stoichiometry matrix for the currently loaded model. The rows will coresponds to the order of species in the call to getFloatinSpeciesIds(), the colunms will corresponds to the order of reactions in the call to getReactionIds().

RoadRunner.getInfo()¶

return info about the current state of the object

Return type:	str

RoadRunner.getInstanceCount()¶: Number of currently running RoadRunner instances.

RoadRunner.getInstanceID()¶: When there are multiple instances of RoadRunner, this is the instance id.

RoadRunner.getIntegrator()¶: get the integrator which is currently being used to time evolve the system.

RoadRunner.getL0Matrix()¶

Returns the L0 matrix for the current model. The L0 matrix is an (m-r) by r matrix that expresses the dependent reaction rates in terms of the indepdent rates. m is the number of floating species and r is the rank of the stoichiometry matrix.

Return type:	numpy.ndarray

RoadRunner.getLinkMatrix()¶

Returns the full link matrix, L for the current model. The Link matrix is an m by r matrix where m is the number of floating species and r the rank of the stichiometric matrix, N.

Return type:	numpy.ndarray

RoadRunner.getNrMatrix()¶

Returns the reduced stoichiometry matrix, $N_R$ , which wil have only r rows where r is the rank of the full stoichiometry matrix. The matrix will be reordered such that the rows of $N_R$ are independent.

Return type:	numpy.ndarray

static RoadRunner.getParamPromotedSBML(*args)¶

Takes an sbml document (in textual form) and changes all of the local parameters to be global parameters.

Parameters:	sbml (str) – the contents of an sbml document
Return type:	str

RoadRunner.getReducedJacobian()¶

Returns the reduced Jacobian for the independent species. This matrix will be non-singular for models that include moiety-concerved cycles.

Return type:	numpy.ndarray

RoadRunner.getReorderedStoichiometryMatrix()¶

Returns the reordered stoichiometry matrix where the tops rows represent the independent species of which there will be rank (N) and the bottom rows the dependent species.

Return type:	numpy.ndarray

RoadRunner.getCurrentSBML()¶

Returns the current state of the model in the form of an sbml string.

That is the SBML will reflect the current state of the model and not the orginal SBML that was loaded into roadRunner.

Return type:	str

RoadRunner.getSBML()¶

Returns the original sbml model that was loaded into roadrunner.

Return type:	str

RoadRunner.getScaledConcentrationControlCoefficientMatrix()¶

Returns the m by n matrix of scaled conentration control coefficients where m is the number of floating species and n the number of reactiohs.

Return type:	numpy.ndarray

RoadRunner.getScaledFloatingSpeciesElasticity(reactionId, speciesId)¶

Returns the scaled elasticity for a given reaction and given species.

Parameters:	reactionId (str) – the sbml id of a reaction. speciesId (str) – the sbml id of a species.
Return type:	double

RoadRunner.getScaledFluxControlCoefficientMatrix()¶

Returns the n by n matrix of scaled flux control coefficients where n is the number of reactions.

Return type:	numpy.ndarray

RoadRunner.getScaledElasticityMatrix()¶

Returns the scaled elasticity matrix at the current operating point.

Return type:	numpy.ndarray

RoadRunner.getValue(sel)¶

Returns the value for a given selection.

Parameters:	sel (str or SelectionRecord) – a selection that is either a string or a SelectionRecord that was obtained from createSelection

RoadRunner.getSelectedValues()¶

returns the values selected with SimulateOptions for the current model time / timestep

Return type:	numpy.ndarray

RoadRunner.getSimulationResult()¶

get the simulation result in case one forgot to hold on to the simulate return value.

Return type:	numpy.ndarray

RoadRunner.selections¶

RoadRunner.createSelection(sel)

Create a new selection based on a selection string

Return type:	roadrunner.SelectionRecord

RoadRunner.getUnscaledConcentrationControlCoefficientMatrix()¶: Returns the unscaled concentration control coefficent matrix.

RoadRunner.getUnscaledElasticityMatrix()¶: Returns the unscaled species elasticity matrix at the current operating point.

RoadRunner.getUnscaledFluxControlCoefficientMatrix()¶: Returns the unscaled flux control coefficient matrix.

RoadRunner.getUnscaledSpeciesElasticity(reactionIndx, speciesIndx)¶

Get a single species elasticity value. IMPORTANT: Assumes that the reaction rates have been precomputed at the operating point !!

Parameters:	reactionIndx (int) – index of reactionl speciesIndx (int) – index of species.

static RoadRunner.__version__()¶: Returns the current version of the roadRunner library.

static RoadRunner.getlibSBMLVersion()¶: Returns theversion of the libSBML library that is currently being used.

RoadRunner.isModelLoaded()¶: Return True if model was loaded; False otherwise

RoadRunner.load(uriOrDocument)¶

Loads an sbml document, given a string for file path, uri, or contents.

This method also accepts http uri for remote files, however this feature is currently limited to the Mac version, plan on enabling http loading of SBML documents on Windows and Linux shortly.

Some examples of loading files on Mac or Linux:

>>> r.load("myfile.xml")                               # load a file from the current dirctory
>>> r.load("/Users/Fred/myfile.xml")                   # absolute path
>>> r.load("http://sbml.org/example_system.xml")       # remote file

Or on Windows:

>>> r.load("myfile.xml")                                  # load a file from the current dirctory
>>> r.load("file://localhost/c:/Users/Fred/myfile.xml")   # using a uri

One may also load the contents of a document::

>>> myfile = open("myfile.xml, "r")
>>> contents = file.read()
>>> r.load(contents)

In future version, we will also support loading directly from a libSBML Dcoument object.

Parameters:	uriOrDocument – A string which may be a local path, URI or contents of an SBML document.

RoadRunner.model None¶: Get the currently loaded model. The model object contains the enite state of the SBML model.

RoadRunner.oneStep(startTime, stepSize)¶

Carry out a one step integration of the model. The method takes two arguments, the current time and the step size to us in the integration. The method returns the new time which will be currentTime + StepSize:

newTime = rr.oneStep (10, 0.5)

RoadRunner.reset()¶: This method resets all the floating species concentrations to their initial values.

RoadRunner.setConfigurationXML(*args)¶

given a xml document, which should have been returned from getConfigurationXML, this method recurses though all the child configurable elements and sets thier configuration to the values specified in the document.

Parameters:	xml (str) – the contents of an xml document.

RoadRunner.conservedMoietyAnalysis¶

Enables / Disables conserved moiety analysis (boolean).

If this is enabled, the sbml document (either current, or one about to be loaded) is converted using the ConservedMoietyConverter. All of the linearly dependent species are replaced with assignment rules and a new set of conserved moeity parameters are introduced.

RoadRunner.simulate(*args)¶

Simulate the current SBML model.

There are a number of ways to call simulate.

With no arguments. In this case, the current set of SimulateOptions will be used for the simulation. The current set may be changed either directly via setSimulateOptions() or with one of the two alternate ways of calling simulate.

2: With single SimulateOptions argument. In this case, all of the settings: in the given options are copied and will be used for the current and future simulations.
3: With the three positions arguments, timeStart, timeEnd, steps. In this case: these three values are copied and will be used for the current and future simulations.

The options given in the 2nd and 3rd forms will remain in effect until changed. So, if one calls:

rr.simulate (0, 3, 100)

The start time of 0, end time of 3 and steps of 100 will remain in effect, so that if this is followed by a call to:

rr.simulate()

This simulation will use the previous values.

Returns:	a numpy array with each selected output timeseries being a column vector, and the 0’th column is the simulation time.
Return type:	numpy.ndarray

RoadRunner.simulateOptions None¶: Get the SimulateOptions object where simulation options may be set.

roadrunner.RoadRunner_getCopyright()¶: Returns the copyright string

roadrunner.RoadRunner_getExtendedVersionInfo()¶: getVersion plus info about dependent libs versions.

roadrunner.RoadRunner_getParamPromotedSBML(*args)¶

Takes an sbml document (in textual form) and changes all of the local parameters to be global parameters.

Parameters:	sbml (str) – the contents of an sbml document
Return type:	str

RoadRunner.evalModel()¶

Evaluates the current model, that is it updates the rates of change and any assignments in the model. It does not carry out an integration step.

Returns:	Returns true if successful

RoadRunner.steadyStateSelections¶

A list of SelectionRecords which determine what values are used for a steady state calculation. This list may be set by assigning a list of valid selection symbols:

r.steadyStateSelections = \['S1', '\[S2]', 'P1']

RoadRunner.steadyState()¶

Attempt to evaluate the steady state for the model. The method returns a value that indicates how close the solution is to the steady state. The smaller the value the better. Values less than 1E-6 usually indicate a steady state has been found. If necessary the method can be called a second time to improve the solution.

Returns:	the sum of squares of the steady state solution.
Return type:	double

RoadRunner.getSteadyStateValues()

Performs a steady state calculation (evolves the system to a steady state), then calculates and returns the set of values specifed by the steady state selections.

Returns:	a numpy array corresponding to the values specified by steadyStateSelections
Return type:	numpy.ndarray

class roadrunner.SimulateOptions(*args)¶

RoadRunner simulation options.

This is the full set of options that determines how RoadRunner performs a simulation of an sbml model.

This is a superset of the values stored in a sbml test suite settings file, the documentation of the fields which correspond to an sbml test suite settings was taken from http://sbml.org

This object can be read from a sbml test suite options file by using a file name in the constructor.

Parameters:	sbmlSettingFilePath – (optional) if this is given, the settings are read from this settings file, if not, the default values are set.

SimulateOptions.absolute¶: A number representing the absolute difference permitted for the integrator tolerence.

SimulateOptions.amounts¶: A list of the variable whose output in the results file is in amount (not concentration) units. This list of variables must be a subset of the names listed in variables.

SimulateOptions.concentrations¶: A list of the variable whose output in the results file is in concentration (not amount) units. This list of variables must be a subset of the names listed in variables.

SimulateOptions.duration¶: The duration of the simulation run, in the model’s units of time. Note, setting the duration automatically sets the end time and visa versa.

SimulateOptions.end¶: The simulation end time. Note, setting the end time automatically sets the duration accoringly and visa versa.

SimulateOptions.flags¶: can be set to ResetModel so that the model is reset to its intial state when the simulation is run.

SimulateOptions.relative¶: A float-point number representing the relative difference permitted. Defaults 0.0001

SimulateOptions.resetModel¶: Causes the model to be reset to the original conditions specified in the sbml when the simulation is run.

SimulateOptions.start¶: The start time of the simulation time-series data. Often this is 0, but not necessarily.

SimulateOptions.steps¶: The number of steps at which the output is sampled. The samples are evenly spaced. When a simulation system calculates the data points to record, it will typically divide the duration by the number of time steps. Thus, for X steps, the output will have X+1 data rows.

SimulateOptions.stiff¶: Use the stiff integrator.

SimulateOptions.variables¶

The variables (in addition to time) whose values will be saved in the result. These are SBML model id’s. Order is significant, as this determines the order of the columns in the result matrix.

Important: if a symbol in this list refers to a species in the model, then that symbol should also be listed in either the amount or concentration lists below. If a species symbol is listed in variables, but is not listed in either amounts or concentrations, then it defaults to an amount value.

The ordering of the symbols in variabls is what determines the output ordering. The order of symbols in either amounts or concetrations do not effect the output ordering.

NOTE:If a listed variable has two underscores in it (‘__’), that variable is actually present only in a submodel of the main model, from the Hierarchical Model Composition package, in the format submodelID__variableID. If the model is flattened, the variable will appear automatically.

class roadrunner.ExecutableModel(*args, **kwargs)¶

ExecutableModel.getNumFloatingSpecies()¶: Returns the number of floating species in the model.

ExecutableModel.getFloatingSpeciesIds()¶: Return a list of floating species sbml ids.

ExecutableModel.getFloatingSpeciesAmountRates([index])¶

Return a vector of floating species amount rates.

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to return.
Returns:	an array of the rates of change of the floating species amounts.
Return type:	numpy.ndarray

ExecutableModel.getFloatingSpeciesAmounts([index])¶

Get the list of floating species amounts. If no arguments are given, this returns all floating species amounts.

Parameters:	index – an optional array of desired floating species indices. i.e. if this model has 4 floating species and we want the amounts for the last and first, we would use [3,0] for the index array.

get all the amounts:

>>> e.getFloatingSpeciesAmounts()
[15,2,3,20]

get amounts 3 and 0:

>>> getFloatingSpeciesAmounts([3,0])
[10,15]

ExecutableModel.getFloatingSpeciesConcentrations([index])¶

Returns a vector of floating species concentrations. The order of species is given by the order of Ids returned by getFloatingSpeciesIds()

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to return.
Returns:	an array of floating species concentrations.
Return type:	numpy.ndarray

ExecutableModel.evalInitialConditions()¶

ExecutableModel.getBoundarySpeciesAmounts([index])¶

Returns a vector of boundary species amounts. The order of species is given by the order of Ids returned by getBoundarySpeciesIds()

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to return.
Returns:	an array of the boundary species amounts.
Return type:	numpy.ndarray.

given by the order of Ids returned by getBoundarySpeciesIds()

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to return.
Returns:	an array of the boundary species amounts.
Return type:	numpy.ndarray.

ExecutableModel.getBoundarySpeciesConcentrations([index])¶

Returns a vector of boundary species concentrations. The order of species is given by the order of Ids returned by getBoundarySpeciesIds()

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to return.
Returns:	an array of the boundary species concentrations.
Return type:	numpy.ndarray.

given by the order of Ids returned by getBoundarySpeciesIds()

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to return.
Returns:	an array of the boundary species concentrations.
Return type:	numpy.ndarray.

ExecutableModel.getBoundarySpeciesIds()¶

Returns a vector of boundary species Ids.

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to return.
Returns:	a list of boundary species ids.

ExecutableModel.getCompartmentIds([index])¶

Returns a vector of compartment identifier symbols.

Parameters:	index (None or numpy.ndarray) – A array of compartment indices indicating which comparment ids to return.
Returns:	a list of compartment ids.

ExecutableModel.getCompartmentVolumes([index])¶

Returns a vector of compartment volumes. The order of volumes is given by the order of Ids returned by getCompartmentIds()

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to return.
Returns:	an array of compartment volumes.
Return type:	numpy.ndarray.

ExecutableModel.getGlobalParameterValues([index])¶

Return a vector of global parameter values. The order of species is given by the order of Ids returned by getGlobalParameterIds()

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to return.
Returns:	an array of global parameter values.
Return type:	numpy.ndarray.

ExecutableModel.getInfo()¶

ExecutableModel.getModelName()¶: Get the model name specified in the SBML.

ExecutableModel.getNumBoundarySpecies()¶: Returns the number of boundary species in the model.

ExecutableModel.getNumCompartments()¶

Returns the number of compartments in the model.

Return type:	int

ExecutableModel.getNumDependentSpecies()¶: Returns the number of dependent floating species in the model.

ExecutableModel.getNumGlobalParameters()¶: Returns the number of global parameters in the model.

ExecutableModel.getNumIndependentSpecies()¶: Returns the number of independent floating species in the model.

ExecutableModel.getNumReactions()¶: Returns the number of reactions in the model.

ExecutableModel.getNumRules()¶: Returns the number of rules in the SBML model.

ExecutableModel.getReactionIds()¶

Returns a vector of reaction Ids.

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to return.
Returns:	a list of reaction ids.

ExecutableModel.getReactionRates([index])¶

Returns a vector of reaction rates for the current state of the model. The order of reaction rates is given by the order of Ids returned by getReactionIds()

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to return.
Returns:	an array of reaction rates.
Return type:	numpy.ndarray

ExecutableModel.getTime()¶: Not sure what this does

ExecutableModel.reset()¶: Reset the floating species concentration to their initial conditions.

ExecutableModel.setBoundarySpeciesConcentrations([index], values)¶

Use this to set the entire set of boundary species concentrations in one call. The order of species is given by the order of Ids returned by getBoundarySpeciesIds()

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to set, or if no index array is given, the first param should be an array of all the values to set. values (numpy.ndarray) – the values to set.

ExecutableModel.setCompartmentVolumes([index], values)¶

Sets a vector of compartment volumes.

If the index vector is not give, then the values vector treated as a vector of all compartment volumes to set. If index is given, then values should have the same length as index.

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to set, or if no index array is given, the first param should be an array of all the values to set. values (numpy.ndarray) – the values to set.

ExecutableModel.setFloatingSpeciesAmounts([index], values)¶

Use this to set the entire set of floating species amounts in one call. The order of species is given by the order of Ids returned by getFloatingSpeciesIds()

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to set, or if no index array is given, the first param should be an array of all the values to set. values (numpy.ndarray) – the values to set.

ExecutableModel.setFloatingSpeciesConcentrations([index], values)¶

Use this to set the entire set of floating species concentrations in one call. The order of species is given by the order of Ids returned by getFloatingSpeciesIds()

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to set, or if no index array is given, the first param should be an array of all the values to set. values (numpy.ndarray) – the values to set.

ExecutableModel.setGlobalParameterValues([index], values)¶

Use this to set the entire set of global parameters in one call. The order of parameters is given by the order of Ids returned by getGlobalParameterIds()

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to set, or if no index array is given, the first param should be an array of all the values to set. values (numpy.ndarray) – the values to set.

ExecutableModel.setTime(time)¶

Set the model time variable. NOt sure what this does.

Parameters:	time – time the time value to set.
Returns:	None

ExecutableModel.getStoichiometry(speciesIndex, reactionIndex)¶

Returns the stochiometric coefficient for the given species index and reaction index.

Frequently one does not need the full stochiometrix matrix, particularly if the system is large and only a single coefficent is needed.

Parameters:	speciesIndex – a floating species index from `getFloatingSpeciesIds()` reactionIndex – a reaction index from `getReactionIds()`

ExecutableModel.getStoichiometryMatrix()¶

Returns the current stoichiomentry matrix, a $n \times m$ matrix where $n$ is the number of species which take place in reactions (floating species) and $m$ is the number of reactions.

this is a line with “quotes”

When the LLVM back end is used (default) this always returns the current state of the stochiometric coeffecients, so if any of these are determined by any rule, this will return the currect value.

Returns:	an n by m numpy ndarray of the stoichiometrix coeffecients.
Return type:	numpy.ndarray

ExecutableModel.getNumConservedMoieties()¶

Returns the number of conserved moieties in the model.

Return type:	int

ExecutableModel.getConservedMoietyIds([index])¶

Returns a vector of conserved moiety identifier symbols.

Parameters:	index (None or numpy.ndarray) – A array of compartment indices indicating which comparment ids to return.
Returns:	a list of compartment ids.

ExecutableModel.getConservedMoietyValues([index])¶

Returns a vector of conserved moiety volumes. The order of values is given by the order of Ids returned by getConservedMoietyIds()

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to return.
Returns:	an array of conserved moiety values.
Return type:	numpy.ndarray.

ExecutableModel.setConservedMoietyValues([index], values)¶

Sets a vector of conserved moiety values.

Note This method currently only updates the conserved moeity values, it does not update the initial species condition from which the values were calculated.

If the index vector is not given, then the values vector treated as a vector of all values to set. If index is given, then values should have the same length as index.

Parameters:	index (numpy.ndarray) – (optional) an index array indicating which items to set, or if no index array is given, the first param should be an array of all the values to set. values (numpy.ndarray) – the values to set.

class roadrunner.SelectionRecord(str)¶

RoadRunner provides a range of flexible ways of selecting values from a simulation. These values can not only be calculated directly via RoadRunner.getSelectionValue, but any of these selections can be used as columns in the simulate result matrix.

The SectionRecord.selectionType should be one of the constants listed here.

Most selection types only require the first symbol id, p1 to be set, however certain ones such as [???] require both p1 and p2.

SelectionRecord.TIME¶

SelectionRecord.CONCENTRATION¶

SelectionRecord.AMOUNT¶: species must have either a CONCENTRATION or AMOUNT modifer to distinguish it.

SelectionRecord.RATE¶

SelectionRecord.BOUNDARY¶

SelectionRecord.FLOATING¶

SelectionRecord.REACTION¶

SelectionRecord.INITIAL¶

SelectionRecord.CURRENT¶

SelectionRecord.UNSCALED¶

SelectionRecord.ELASTICITY¶

SelectionRecord.CONTROL¶

SelectionRecord.EIGENVALUE¶

SelectionRecord.ELEMENT¶

SelectionRecord.STOICHIOMETRY¶

SelectionRecord.UNKNOWN¶

SelectionRecord.DEPENDENT¶

SelectionRecord.INDEPENDENT¶

SelectionRecord.CONSREVED_MOIETY¶

SelectionRecord.UNKNOWN_CONCENTRATION¶

SelectionRecord.COMPARTMENT¶

SelectionRecord.GLOBAL_PARAMETER¶

SelectionRecord.FLOATING_AMOUNT¶

SelectionRecord.BOUNDARY_AMOUNT¶

SelectionRecord.BOUNDARY_CONCENTRATION¶

SelectionRecord.FLOATING_CONCENTRATION¶

SelectionRecord.FLOATING_AMOUNT_RATE¶

SelectionRecord.FLOATING_CONCENTRATION_RATE¶

SelectionRecord.REACTION_RATE¶

SelectionRecord.INITIAL_FLOATING_AMOUNT¶

SelectionRecord.INITIAL_FLOATING_CONCENTRATION¶

SelectionRecord.UNSCALED_ELASTICITY¶

SelectionRecord.UNSCALED_CONTROL¶

SelectionRecord.UNKNOWN_ELEMENT¶

SelectionRecord.ALL¶

SelectionRecord.ALL_INDEPENDENT¶

SelectionRecord.ALL_DEPENDENT¶

SelectionRecord.ALL_INDEPENDENT_AMOUNT¶

SelectionRecord.ALL_DEPENDENT_AMOUNT¶

SelectionRecord.ALL_INDEPENDENT_CONCENTRATION¶

SelectionRecord.ALL_DEPENDENT_CONCENTRATION¶

SelectionRecord.index int¶

SelectionRecord.p1 str¶

SelectionRecord.p2 str¶

SelectionRecord.selectionType int¶

RoadRunner API Reference¶

Previous topic

This Page

Navigation

RoadRunner API Reference¶

Previous topic

This Page

Quick search

Navigation