Edit on GitHub

RoadRunner

RoadRunner.addAssignmentRule — Method
addAssignmentRule(rr::Ptr{Nothing}, vid::String, formula::String, forceRegen::Bool)

Add an assignment rule for a variable to the current model.

RoadRunner.addCompartment — Method
addCompartment(rr, cid::String, initVolume::Float64, regen::Bool)

Add a compartment to the current model.

RoadRunner.addDelay — Method
addDelay(rr::Ptr{Nothing}, eid::String, delay::String, forceRegen::Bool)

Add delay to an existing event in the model.

RoadRunner.addDirectory — Method

addDirectory(directory::String) Add a directory in which imported files may be found, and in which to look for a '.antimony' file (which contains rules about where to look locally for imported antimony and sbml files).

RoadRunner.addEvent — Method
addEvent(rr::Ptr{Nothing}, eid::String, useValuesFromTriggerTime::Bool, trigger::String, forceRegen::Bool)

Add an event to the current model.

RoadRunner.addEventAssignment — Method
addEventAssignment(rr::Ptr{Nothing}, eid::String, vid::String, formulae::String, forceRegen::Bool)

Add an event assignment to an existing event in the model.

RoadRunner.addItem — Method
addItem(list::Ptr{RRList}, item::Ptr{RRListItem})

Create a list item to store a double value

RoadRunner.addParameter — Method
addParameter(rr::Ptr{Nothing}, pid::String, value::Float64, forceRegen::Bool)

Add a parameter to the current model.

RoadRunner.addPriority — Method
addPriority(rr::Ptr{Nothing}, eid::String, priority::String, forceRegen::Bool)

Add priority to an existing event in the model.

RoadRunner.addRateRule — Method
addRateRule(rr::Ptr{Nothing}, vid::String, formula::String, forceRegen::Bool)

Add a rate rule for a variable to the current model.

RoadRunner.addReaction — Method
addReaction(rr::Ptr{Nothing}, rid::String, reactants::Array{String}, products::Array{String}, kineticLaw::String, regen::Bool)

Add a reaction to the current model by passing its info as parameters.

RoadRunner.addSpecies — Method
addSpecies(rr::Ptr{Nothing}, sid::String, compartment::String, initialAmount::Float64, substanceUnit::String, regen::Bool)
example: addSpecies(rr, s, "Compartment", 0.1, "", true)

Add a species to the current model.

RoadRunner.addTrigger — Method
addTrigger(rr::Ptr{Nothing}, eid::String, trigger::String, forceRegen::Bool)

Add trigger to an existing event in the model.

RoadRunner.checkModule — Method

checkModule(moduleName::String) Returns 'true' if the submitted module name exists in the current active set, 'false' if not.

RoadRunner.computeSteadyStateValues — Method
computeSteadyStateValues(rr::Ptr{Nothing})

Compute the steady state of the current model. Example: RRVectorHandle values = computeSteadyStateValues (void);

RoadRunner.createRRInstanceEx — Method
createRRInstanceEx(tempFolder::String, compiler_cstr::String)

Initialize and return a new roadRunner instance.

RoadRunner.createRRList — Method
createRRList()

Create a new list. A list is a container for storing list items. List items can represent integers, double, strings and lists. To populate a list, create list items of the appropriate type and add them to the list Example, build the list [123, [3.1415926]] 1 l = createRRList(RRHandle handle); 2 item = createIntegerItem (123); 3 addItem (l, item); 4 item1 = createListItem(RRHandle handle); 5 item2 = createDoubleItem (3.1415926); 6 addItem (item1, item2); 7 addItem (l, item1); 8 9 item = getListItem (l, 0); 10 printf ("item = %d ", item->data.iValue); 11 12 printf (listToString (l)); 13 freeRRList (l);

RoadRunner.evalModel — Method
evalModel(rr::Ptr{Nothing})

Evaluate the current model, that it update all assignments and rates of change. Do not carry out an integration step.

RoadRunner.freeMatrix — Method
freeMatrix(matrix::Ptr{RRDoubleMatrix})

Free RRDoubleMatrixPtr structures.

RoadRunner.freeRRCData — Method
freeRRCData(handle::Ptr{RRCData})

Free the memory associated to a RRCData object.

RoadRunner.freetext — Method
freetext(text::Ptr{UInt8})

Free char* generated by library routines.

RoadRunner.getAntimonyString — Method

getAntimonyString(moduleName::String) Returns the same output as writeAntimonyFile, but to a char* array instead of to a file.

RoadRunner.getCC — Method
getCC(rr::Ptr{Nothing}, variable::String, parameter::String)

Retrieve a single control coefficient.

RoadRunner.getCPPAPIVersion — Method
getCPPAPIVersion(rr::Ptr{Nothing})

Retrieve the current version number of the C++ API (Core RoadRunner API) library..

RoadRunner.getCellMLString — Method

getCellMLString(moduleName::String) Writes out a CellML-formatted XML file to the file indicated, retaining the same Antimony hierarchy using the CellML 'component' hieararchy.

RoadRunner.getCompSBMLString — Method

getCompSBMLString(moduleName::String) Returns the same output as writeSBMLFile, but to a char* array instead of to a file, using the 'Hierarchichal Model Composition' package.

RoadRunner.getCompartmentIds — Method
getCompartmentIds(rr::Ptr{Nothing})

Obtain the list of compartment Ids. Example: str = getCompartmentIds (RRHandle handle);

RoadRunner.getCompiler — Method
getCompiler(rr::Ptr{Nothing}))

Get the name of the compiler currently being used by roadrunner.

RoadRunner.getCompilerLocation — Method
getCompilerLocation(rr::Ptr{Nothing})

Get the path to a folder containing the compiler being used. Returns the path if successful, NULL otherwise

RoadRunner.getComplexMatrixElement — Method
getComplexMatrixElement(m::Ptr{RRComplexMatrix}, r::Int64, c::Int64)

Retrieve an element at a given row and column from a complex matrix type variable.

RoadRunner.getConservationMatrix — Method
getConservationMatrix(rr::Ptr{Nothing})

Retrieve the conservation matrix for the current model. The conservation laws as describe by row where the columns indicate the species Id.

RoadRunner.getConservedSums — Method
getConservedSums(rr::Ptr{Nothing})

Return values for conservation laws using the current initial conditions.

RoadRunner.getCurrentSBML — Method
getCurrentSBM(handle::Ptr{Nothing})

Retrieve the current state of the model in the form of an SBML string.

RoadRunner.getEE — Method
getEE(rr::Ptr{Nothing}, name::String, species::String)

Retrieve a single elasticity coefficient.

RoadRunner.getEigenVectors — Method
getEigenVectors(matrix::Ptr{RRDoubleMatrix})

Calculate the eigen-vectors of a square real matrix. This function calculates the complex (right)eigenvectors of the given real matrix. The complex matrix returned contains the eigenvectors in the columns, in the same order as LibLA_getEigenValues. The right eigenvector v(j) of A satisfies: A * v(j) = lambda(j) * v(j)

RoadRunner.getExtendedAPIInfo — Method
getExtendedAPIInfo()

Retrieve extended API info. Returns null if it fails, otherwise it returns a string with the info.

RoadRunner.getFloatingSpeciesConcentrations — Method
getFloatingSpeciesConcentrations(rr::Ptr{Nothing})

Retrieve in a vector the concentrations for all the floating species. Example: RVectorPtr values = getFloatingSpeciesConcentrations (void);

RoadRunner.getGlobalParameterValues — Method
getGlobalParameterValues(rr::Ptr{Nothing})

Retrieve the global parameter value. Example: RRVectorPtr values = getGlobalParameterValues (void);

RoadRunner.getInfo — Method
getInfo(rr::Ptr{Nothing})

Retrieve the current version number of the libSBML library.

RoadRunner.getL0Matrix — Method
getL0Matrix(rr::Ptr{Nothing})

Return the L0 Matrix. L0 is defined such that L0 Nr = N0. L0 forms part of the link matrix, L. N0 is the set of linear dependent rows from the lower portion of the reordered stoichiometry matrix.

RoadRunner.getLastError — Method
getLastError()

Retrieve the current error string. Example, str = getLastError (void);

RoadRunner.getList — Method
getList(item::Ptr{RRListItem})

Return a list from a list item if it contains a list.

RoadRunner.getListItem — Method
getListItem(list::Ptr{RRList}, index::Int64)

Return the index^th item from the list.

RoadRunner.getLogFileName — Method
getLogFileName()

Get a pointer to the string that holds the logging file name path. Example: str = getLogFileName (void)

RoadRunner.getLogLevel — Method
getLogLevel()

Get the logging status level as a pointer to a string. The logging level can be one of the following strings "ANY", "DEBUG5", "DEBUG4", "DEBUG3", "DEBUG2", "DEBUG1", "DEBUG", "INFO", "WARNING", "ERROR" Example str = getLogLevel (void)

RoadRunner.getMatrixElement — Method
getMatrixElement(m::Ptr{RRDoubleMatrix}, r::Int64, c::Int64)

Retrieve an element at a given row and column from a matrix type variable.

RoadRunner.getNrMatrix — Method
getNrMatrix(rr::Ptr{Nothing})

Retrieve the reduced stoichiometry matrix for the current model.

RoadRunner.getNumModules — Method

getNumModules() Returns the number of modules in the current active set (the last file successfully loaded, or whichever file was returned to with 'revertTo').

RoadRunner.getNumPoints — Method
getNumPoints(rr)

Get the value of the current number of points. Example: status = getNumPoints (rrHandle, &numberOfPoints);

RoadRunner.getNumberOfReactions — Method
getNumberOfReactions(rr::Ptr{Nothing})

Obtain the number of reactions in the loaded model. Example: number = getNumberOfReactions (RRHandle handle);

RoadRunner.getRRCDataElement — Method
function getRRCDataElement(rrData::Ptr{RRCData}, r::Int64, c::Int64)

Retrieves an element at a given row and column from a RoadRunner data type variable.

RoadRunner.getRRDataColumnLabel — Method
getRRDataColumnLabel(rrData::Ptr{RRCData}, column::Int64)

Retrieves a label for a given column in a rrData type variable.

RoadRunner.getRRDataNumCols — Method
getRRDataNumCols(rrData::Ptr{RRCData})

Retrieve the number of columns in the given RoadRunner numerical data (returned from simulate(RRHandle handle))

RoadRunner.getRRDataNumRows — Method
getRRDataNumRows(rrData::Ptr{RRCData})

Retrieve the number of rows in the given RoadRunner numerical data (returned from simulate(RRHandle handle))

RoadRunner.getRateOfChange — Method
getRatesOfChange(rr::Ptr{Nothing}, index::Int64)

Retrieve the rate of change for a given floating species. Example: status = getRateOfChange (&index, *value);

RoadRunner.getRatesOfChange — Method
getRatesOfChange(rr::Ptr{Nothing})

Retrieve the vector of rates of change as determined by the current state of the model. Example: values = getRatesOfChange (RRHandle handle);

RoadRunner.getRatesOfChangeEx — Method
getRatesOfChangeEx(rr::Ptr{Nothing}, vec::Ptr{RRVector})

Retrieve the vector of rates of change given a vector of floating species concentrations. Example: values = getRatesOfChangeEx (vector);

RoadRunner.getRatesOfChangeIds — Method
getRatesOfChange(rr::Ptr{Nothing})

Retrieve the rate of change for a given floating species. Example: status = getRateOfChange (&index, *value);

RoadRunner.getReactionRate — Method
getReactionRate(rr::Ptr{Nothing}, idx::Int64)

Retrieve a give reaction rate as indicated by the index paramete.

RoadRunner.getReactionRates — Method
getReactionRates(rr::Ptr{Nothing})

Retrieve a vector of reaction rates as determined by the current state of the model.

RoadRunner.getReactionRatesEx — Method
getReactionRatesEx(rr::Ptr{Nothing}, vec::Ptr{RRVector})

Retrieve a vector of reaction rates given a vector of species concentrations.

RoadRunner.getReducedJacobian — Method
getReducedJacobian(rr::Ptr{Nothing})

Retrieve the reduced Jacobian for the current model. setComputeAndAssignConservationLaws (true) must be enabled

RoadRunner.getSBML — Method
getSBML(rr::Ptr{Nothing})

Retrieve the SBML model that was last loaded into roadRunner.

RoadRunner.getSBMLString — Method

getSBMLString(moduleName::String) Returns the same output as writeSBMLFile, but to a char* array instead of to a file.

RoadRunner.getSeed — Method
getSeed(rr::Ptr{Nothing})

Determine the current seed used by the random generator.

RoadRunner.getStringElement — Method
getStringElement(list::Ptr{RRStringArray}, index::Int64)

Returns the indexth element from the string array in the argument value.

RoadRunner.getTempFolder — Method
getTempFolder(rr::Ptr{Nothing})

Retrieve the current temporary folder path. When RoadRunner is run in C generation mode it uses a temporary folder to store the generate C source code. This method can be used to get the current value for the temporary folder path.

RoadRunner.getTimeEnd — Method
getTimeEnd(rr::Ptr{Nothing})

Get the value of the current time end. Example: status = getTimeEnd (rrHandle, &timeEnd);

RoadRunner.getValue — Method
getValue(rr::Ptr{Nothing}, symbolId::String)

Get the value for a given symbol, use getAvailableTimeCourseSymbols(void) for a list of symbols. Example status = getValue (rrHandle, "S1", &value);

RoadRunner.getVersion — Method
getVersion()

Get the version number. Return the roadrunner version number in the form or 102030 if the number is 1.2.3 return the individual version numbers as XXYYZZ where XX is the major version, YY the minor and ZZ the revision, eg 10000, or 10100, 20000 etc

RoadRunner.getVersionEx — Method
getVersionEx()

return something like "1.0.0; compiled with clang "3.3 (tags/RELEASE_33/final)" on date Dec 8 2013, 17:24:57'

RoadRunner.getWarnings — Method

getWarnings() When translating some other format to Antimony, elements that are unable to be translated are saved as warnings, retrievable with this function (returns NULL if no warnings present).

RoadRunner.getZEigenVectors — Method
getZEigenVectors(matrix::Ptr{RRComplexMatrix})

Calculate the eigen-vectors of a square nonsymmetrix complex matrix. This function calculates the complex (right)eigenvectors of the given real matrix. The complex matrix returned contains the eigenvectors in the columns, in the same order as getZEigenValues. The right eigenvector v(j) of A satisfies: A * v(j) = lambda(j) * v(j)

RoadRunner.getlibSBMLVersion — Method
getlibSBMLVersion(rr::Ptr{Nothing})

Retrieve info about current state of roadrunner, e.g. loaded model, conservationAnalysis etc.

RoadRunner.getuCC — Method
getuCC(rr::Ptr{Nothing}, variable::String, parameter::String)

Retrieve a single unscaled control coefficient.

RoadRunner.getuEE — Method
getuEE(rr::Ptr{Nothing}, name::String, species::String)

Retrieve a single unscaled elasticity coefficient.

RoadRunner.gillespie — Method
gillespie(rr::Ptr{Nothing})

Carry out a time-course simulation using the Gillespie algorithm with variable step size. setTimeStart, setTimeEnd, etc are used to set the simulation characteristics.

RoadRunner.gillespieEx — Method
gillespieEx(rr::Ptr{Nothing}, timeStart::Float64, timeEnd::Float64)

Carry out a time-course simulation using the Gillespie algorithm with variable step size. setTimeStart, setTimeEnd, etc are used to set the simulation characteristics.

RoadRunner.gillespieMeanOnGrid — Method
gillespieMeanOnGrid(rr::Ptr{Nothing}, numberOfSimulations::Int64)

Carry out a series of time-course simulations using the Gillespie algorithm with fixed step size, then return the average of the simulations. setTimeStart, setTimeEnd, setNumPoints, etc are used to set the simulation characteristics.

RoadRunner.gillespieMeanOnGridEx — Method
gillespieMeanOnGridEx(rr::Ptr{Nothing}, timeStart::Float64, timeEnd::Float64, numberOfPoints::Int64, numberOfSimulations::Int64)

Carry out a series of time-course simulations using the Gillespie algorithm with fixed step size, then return the average of the simulations. Based on the given arguments, time start, time end, and number of points. Example: 1 RRCDataPtr m; 2 double timeStart = 0.0; 3 double timeEnd = 25; 4 int numberOfPoints = 200; 5 int numberOfSimulations = 10; 6 m = gillespieMeanOnGridEx (rrHandle, timeStart, timeEnd, numberOfPoints, numberOfSimulations);

RoadRunner.gillespieMeanSDOnGrid — Method
gillespieMeanSDOnGrid(rr::Ptr{Nothing}, numberOfSimulations::Int64)

Carry out a series of time-course simulations using the Gillespie algorithm with fixed step size, then return the average and standard deviation of the simulations. setTimeStart, setTimeEnd, setNumPoints, etc are used to set the simulation characteristics.

RoadRunner.gillespieMeanSDOnGridEx — Method
gillespieMeanSDOnGridEx(rr::Ptr{Nothing}, timeStart::Float64, timeEnd::Float64, numberOfPoints::Int64, numberOfSimulations::Int64)

Carry out a series of time-course simulations using the Gillespie algorithm with fixed step size, then return the average and standard deviation of the simulations. Based on the given arguments, time start, time end, number of points, and number of simulations. Example: 1 RRCDataPtr m; 2 double timeStart = 0.0; 3 double timeEnd = 25; 4 int numberOfPoints = 200; 5 int numberOfSimulations = 10; 6 m = gillespieMeanSDOnGridEx (rrHandle, timeStart, timeEnd, numberOfPoints, numberOfSimulations);

RoadRunner.gillespieOnGrid — Method
gillespieOnGrid(rr::Ptr{Nothing})

Carry out a time-course simulation using the Gillespie algorithm based on the given arguments, time start, time end and number of points. Example: 1 RRCDataPtr m; 2 double timeStart = 0.0; 3 double timeEnd = 25; 4 m = gillespieEx (rrHandle, timeStart, timeEnd);

RoadRunner.gillespieOnGridEx — Method
gillespieOnGridEx(rr::Ptr{Nothing}, timeStart::Float64, timeEnd::Float64, numberOfPoints::Int64)

Carry out a time-course simulation using the Gillespie algorithm with fixed step size based on the given arguments, time start, time end, and number of points. Example: 1 RRCDataPtr m; 2 double timeStart = 0.0; 3 double timeEnd = 25; 4 int numberOfPoints = 200; 5 m = gillespieOnGridEx (rrHandle, timeStart, timeEnd, numberOfPoints);

RoadRunner.hasError — Method
hasError()

Check if there is an error string to retrieve. Example: status = hasError (void)

RoadRunner.isListItem — Method
isListItem(item::Ptr{RRListItem}, itemType)

Returns true or false if the list item is the given itemType.

RoadRunner.isListItemList — Method
isListItemList(item::Ptr{RRListItem})

Return true or false if the list item is a list itself.

RoadRunner.isListItemString — Method
isListItemString(item::Ptr{RRListItem})

Return true or false if the list item is a character array.

RoadRunner.loadFile — Method

loadFile(filename::String) Load a file of any format libAntimony knows about (potentially Antimony, SBML, or CellML).

RoadRunner.loadSBML — Method
loadSBML(rr::Ptr{Nothing}, sbml::String)

Load a model from an SBML string.

RoadRunner.loadSBMLEx — Method
loadSBMLEx(rr::Ptr{Nothing}, sbml::String, forceRecompile::Bool)

Load a model from an SBML string.

RoadRunner.loadSBMLFromFileE — Method
loadSBMLFromFile(rr::Nothing, fileName::String, forceRecompile::Bool)

Load a model from a SBML file, force recompilation.

RoadRunner.loadString — Method

loadString(model::String) Load a string of any format libAntimony knows about (potentially Antimony, SBML, or CellML).

RoadRunner.loada — Method
loada(antString::String)

Take an antimony string and return a roadrunner instance

RoadRunner.oneStep — Method
oneStep(rr::Ptr{Nothing}, currentTime::Float64, stepSize::Float64)

Carry out a one step integration of the model. Example: status = OneStep (rrHandle, currentTime, timeStep, newTimeStep);

RoadRunner.printAllDataFor — Method

printAllDataFor(moduleName::String) An example function that will print to stdout all the information in the given module.

RoadRunner.removeEvent — Method
removeEvent(rr::Ptr{Nothing}, eid::String, forceRegen::Bool)

Remove an event from the current model.

RoadRunner.removeEventAssignments — Method
removeEventAssignments(rr::Ptr{Nothing}, eid::String, vid::String, forceRegen::Bool)

Add all event assignments for a variable from an existing event in the model.

RoadRunner.removeParameter — Method
removeParameter(rr::Ptr{Nothing}, pid::String, forceRegen::Bool)

Remove a parameter from the current model.

RoadRunner.removeReaction — Method
removeReaction(rr::Ptr{Nothing}, rid::String, regen::Bool)

Remove a reaction from the current model.

RoadRunner.removeRules — Method
removeRules(rr::Ptr{Nothing}, vid::String, forceRegen::Bool)

Remove all rules for a variable from the current model, including assignment and rate rules.

RoadRunner.removeSpecies — Method
removeSpecies(rr::Ptr{Nothing}, sid::String, regen::Bool)

Remove a species from the current model.

RoadRunner.reset — Method
resetRR(rr::Ptr{Nothing})

Reset all variables of the model to their current initial values. Does not change the parameters.

RoadRunner.resetAll — Method
resetAll(rr::Ptr{Nothing})

Reset all variables of the model to their current initial values, and resets all parameters to their original values.

RoadRunner.resetToOrigin — Method
resetToOriginRR(rr::Ptr{Nothing})

Reset the model to the state in which it was first loaded, including initial conditions, variables, and parameters.

RoadRunner.revertTo — Method

revertTo(Index) Change the 'active' set of modules to the ones from the given index (as received from 'load<file/string>').

RoadRunner.setBoundary — Method
setBoundary(rr::Ptr{Nothing}, sid::String, boundaryCondition::Bool, forceRegen::Bool)
RoadRunner.setBoundarySpeciesConcentrations — Method
setBoundarySpeciesConcentrations(rr::Ptr{Nothing}, vec::Ptr{RRVector})

Set the boundary species concentration to the vector vec. Example: 1 myVector = createVector (getNumberOfBoundarySpecies(RRHandle handle)); 2 setVectorElement (myVector, 0, 1.2); 3 setVectorElement (myVector, 1, 5.7); 4 setVectorElement (myVector, 2, 3.4); 5 setBoundarySpeciesConcentrations(myVector);

RoadRunner.setCodeGenerationMode — Method
setCodeGenerationMode(rr::Ptr{Nothing}, mode::Int64)

Set the runtime generation option [Not yet implemented]. RoadRunner can either execute a model by generating, compiling and linking self-generated C code or it can employ an internal interpreter to evaluate the model equations. The later method is useful when the OS forbids the compiling of externally generated code.

RoadRunner.setCompiler — Method
setCompiler(rr::Ptr{Nothing}, fName::String)

Set the path and filename to the compiler to be used by roadrunner.

RoadRunner.setCompilerLocation — Method
setCompilerLocation(rr::Ptr{Nothing}, folder::String)

Set the path to a folder containing the compiler being used. Returns true if successful

RoadRunner.setComplexMatrixElement — Method
setComplexMatrixElement(m::Ptr{RRComplexMatrix}, r::Int64, c::Int64, value::Float64)

Set an element at a given row and column with a given value in a complex matrix type variable.

RoadRunner.setCurrentIntegrator — Method
setCurrentIntegrator(rr::Ptr{Nothing}, nameOfIntegrator::String)

Specify the current integrator to be used for simulation. This method instantiates a new integrator of the given type (e.g. cvode, gillespie) if one does not currently exist. Otherwise, the existing integrator of this type is used.

RoadRunner.setCurrentSteadyStateSolver — Method
setCurrentSteadyStateSolver(rr::Ptr{Nothing}, nameOfSteadyStateSolver::String)

Specify the current steady state solver to be used for simulation. This method instantiates a new steady state solver of the given type (e.g. cvode, gillespie) if one does not currently exist. Otherwise, the existing steady state solver of this type is used.

RoadRunner.setFloatingSpeciesConcentrations — Method
setFloatingSpeciesConcentrations(rr::Ptr{Nothing}, vec::Ptr{RRVector})

Set the floating species concentration to the vector vec. Example: 1 myVector = createVector (getNumberOfFloatingSpecies(RRHandle handle)); 2 setVectorElement (myVector, 0, 1.2); 3 setVectorElement (myVector, 1, 5.7); 4 setVectorElement (myVector, 2, 3.4); 5 setFloatingSpeciesConcentrations(myVector);

RoadRunner.setFloatingSpeciesInitialConcentrations — Method
setFloatingSpeciesInitialConcentrations(rr::Ptr{Nothing}, vec::Ptr{RRVector})

Set the initial floating species concentrations. Example: status = setFloatingSpeciesInitialConcentrations (vec);

RoadRunner.setInstallFolder — Method
getInstallFolder(folder::String)

Set the internal string containing the folder in where the RoadRunner C API is installed.

RoadRunner.setKineticLaw — Method
setKineticLaw(rr::Ptr{Nothing}, rid::String, kineticLaw::String, forceRegen::Bool)

Set the kinetic law for an existing reaction in the current model.

RoadRunner.setLogLevel — Method
setLogLevel(lvl::String)

Set the logging status level The logging level is determined by the following strings. "ANY", "DEBUG5", "DEBUG4", "DEBUG3", "DEBUG2", "DEBUG1", "DEBUG", "INFO", "WARNING", "ERROR" Example: setLogLevel ("DEBUG4")

RoadRunner.setMatrixElement — Method
setMatrixElement(m::Ptr{RRDoubleMatrix}, r::Int64, c::Int64, value::Float64)

Set an element at a given row and column with a given value in a matrix type variable.

RoadRunner.setNumPoints — Method
setNumPoints(rr::Ptr{Nothing}, nrPoints::Int64)

Set the number of points to generate in a time course simulation.

RoadRunner.setSeed — Method
setSeed(rr::Ptr{Nothing}, result::Int64)

Determine the current seed used by the random generator.

RoadRunner.setSteadyStateSelectionList — Method
setSteadyStateSelectionList(rr::Ptr{Nothing}, list::String)

Set the selection list of the steady state analysis.Use getAvailableTimeCourseSymbols(void) to retrieve the list of all possible symbols. Example: setSteadyStateSelectionList ("S1, J1, J2") or setSteadyStateSelectionList ("S1 J1 J2")

RoadRunner.setSupportCodeFolder — Method
setSupportCodeFolder(rr::Ptr{Nothing}, folder::String)

Set the path to a folder containing support code for model generation.

RoadRunner.setTempFolder — Method
setTempFolder(rr::Ptr{Nothing}, folder::String)

Set the path to the temporary folder where the C code will be stored. When RoadRunner is run in C generation mode it uses a temporary folder to store the generated C source code. This method can be used to set the temporary folder path if necessary.

RoadRunner.setTimeCourseSelectionList — Method
setTimeCourseSelectionList(rr::Ptr{Nothing}, list::String)

Set the selection list for output from simulate(void) or simulateEx(void). Use getAvailableTimeCourseSymbols(void) to retrieve the list of all possible symbols. Example: setTimeCourseSelectionList ("Time, S1, J1, J2"); or setTimeCourseSelectionList ("Time S1 J1 J2")

RoadRunner.setTimeEnd — Method
setTimeEnd(rr::Ptr{Nothing}, timeEnd::Number)

Set the time end for a time course simulation.

RoadRunner.setTimeStart — Method
setTimeStart(rr::Ptr{Nothing}, timeStart::Number)

Set the time start for a time course simulation.

RoadRunner.setValue — Method
setValue(rr::Ptr{Nothing}, symbolId::String, value::Float64)

Set the value for a given symbol, use getAvailableTimeCourseSymbols(void) for a list of symbols. Example: status = setValue (rrHandle, "S1", 0.5);

RoadRunner.setVectorElement — Method
setVectorElement(vector::Ptr{RRVector}, index::Int64, value::Float64)

Set a particular element in a vector.

RoadRunner.simulateEx — Method
simulateEx(rr::Ptr{Nothing}, startTime::Number, endTime::Number, setNumPoints::Int)

Carry out a time-course simulation based on the given arguments, time start, time end and number of points.

RoadRunner.steadyState — Method
steadyState(rr::Ptr{Nothing})

Compute the steady state of the current model. Example: status = steadyState (rrHandle, &closenessToSteadyState);

RoadRunner.writeAntimonyFile — Method

writeAntimonyFile(filename::String, moduleName::String) Writes out an antimony-formatted file containing the given module.

RoadRunner.writeCellMLFile — Method

writeCellMLFile(filename::String, moduleName::String) Writes out a CellML-formatted XML file to the file indicated, retaining the same Antimony hierarchy using the CellML 'component' hieararchy.

RoadRunner.writeCompSBMLFile — Method

writeCompSBMLFile(filename::String, moduleName::String) Writes out a SBML-formatted XML file to the file indicated, using the 'Hierarchichal Model Composition' package

RoadRunner.writeRRData — Method
writeRRData(rr::Ptr{Nothing}, fileNameAndPath::String)

Writes RoadRunner data to file.

RoadRunner.writeSBMLFile — Method

writeSBMLFile(filename::String, moduleName::String) Writes out a SBML-formatted XML file to the file indicated.