rrRoadRunner.h

#ifndef rrRoadRunnerH
#define rrRoadRunnerH

#include "rr-libstruct/lsMatrix.h"
#include "rrVariableType.h"
#include "rrParameterType.h"
#include "rrSelectionRecord.h"
#include "rrRoadRunnerData.h"
#include "rrConstants.h"
#include "rrRoadRunnerOptions.h"
#include "Configurable.h"

#include <string>
#include <vector>
#include <list>

namespace ls
{
class LibStructural;
}

namespace rr
{

class ModelGenerator;
class SBMLModelSimulation;
class ExecutableModel;
class Integrator;

class RR_DECLSPEC RoadRunner : public Configurable
{

public:

    RoadRunner(const std::string& compiler = "", const std::string& tempDir = "",
            const std::string& supportCodeDir = "");

    virtual ~RoadRunner();

    int getInstanceID();

    int getInstanceCount();

    static std::string getParamPromotedSBML(const std::string& sArg);

    std::string getInfo();

    class Compiler* getCompiler();

    bool setCompiler(const std::string& compiler);

    Integrator* getIntegrator();

    bool isModelLoaded();

    std::string getModelName();

    bool unLoadModel();

    bool setTempFileFolder(const std::string& folder);

    std::string getTempFolder();

    double oneStep(double currentTime, double stepSize, bool reset = true);

    const RoadRunnerData *simulate(const SimulateOptions* options = 0);

    RoadRunnerData *getSimulationResult();

    void setSimulateOptions(const SimulateOptions& settings);

    SimulateOptions& getSimulateOptions();

    std::string getSBML();

    void reset();

    void changeInitialConditions(const std::vector<double>& ic);

    ModelGenerator* getModelGenerator();

    ExecutableModel* getModel();

    bool load(const std::string& uriOrSBML,
            const LoadSBMLOptions* options = 0);

    std::vector<double> getReactionRates();

    std::vector<double> getRatesOfChange();

    std::vector<std::string> getReactionIds();

    virtual _xmlNode *createConfigNode();

    virtual void loadConfig(const _xmlDoc* doc);

    std::string getConfigurationXML();

    void setConfigurationXML(const std::string& xml);


    void correctMaxStep();

/************************ Selection Ids Species Section ***********************/
#if (1) /**********************************************************************/
/******************************************************************************/

    rr::SelectionRecord createSelection(const std::string& str);

    std::vector<rr::SelectionRecord>& getSelections();

    double getValue(const std::string& sel);

    double getValue(const SelectionRecord& record);


    void setSelections(const std::vector<std::string>& selections);

    void setSelections(const std::vector<rr::SelectionRecord>& selections);


    std::vector<double> getSelectedValues();

    void getIds(int types, std::list<std::string> &ids);

    int getSupportedIdTypes();


    bool setValue(const std::string& id, double value);

/************************ End Selection Ids Species Section *******************/
#endif /***********************************************************************/
/******************************************************************************/

    ls::DoubleMatrix getFullJacobian();

    ls::DoubleMatrix getFullReorderedJacobian();

    ls::DoubleMatrix getReducedJacobian();

    ls::DoubleMatrix getEigenvalues();

    std::vector<Complex> getEigenvaluesCpx();

    ls::DoubleMatrix* getLinkMatrix();
    ls::DoubleMatrix* getNrMatrix();
    ls::DoubleMatrix* getL0Matrix();


    ls::DoubleMatrix getConservationMatrix();
    ls::DoubleMatrix getUnscaledConcentrationControlCoefficientMatrix();
    ls::DoubleMatrix getScaledConcentrationControlCoefficientMatrix();
    ls::DoubleMatrix getUnscaledFluxControlCoefficientMatrix();
    ls::DoubleMatrix getScaledFluxControlCoefficientMatrix();
    int getNumberOfDependentSpecies();
    int getNumberOfIndependentSpecies();


    std::vector<std::string> getEigenvalueIds();

    double getUnscaledParameterElasticity(const string& reactionName,
            const string& parameterName);


    Matrix<double> getFrequencyResponse(double startFrequency,
            int numberOfDecades, int numberOfPoints,
            const string& parameterName, const string& variableName,
            bool useDB, bool useHz);

    void setConservedMoietyAnalysis(bool value);

    bool getConservedMoietyAnalysis();

    std::string getCurrentSBML();

    int getNumberOfReactions();

    double getReactionRate(const int& index);

    double getRateOfChange(const int& index);

    std::vector<std::string> getRateOfChangeIds();


    std::vector<std::string> getConservedMoietyIds();

    std::vector<double> getConservedMoietyValues();

    int getNumberOfCompartments();

    void setCompartmentByIndex(const int& index, const double& value);

    double getCompartmentByIndex(const int& index);

    std::vector<std::string> getCompartmentIds();

    int getNumberOfBoundarySpecies();

    void setBoundarySpeciesByIndex(const int& index, const double& value);

    double getBoundarySpeciesByIndex(const int& index);

    std::vector<double> getBoundarySpeciesConcentrations();

    void setBoundarySpeciesConcentrations(const std::vector<double>& values);

    std::vector<std::string> getBoundarySpeciesIds();

    int getNumberOfFloatingSpecies();

    double getFloatingSpeciesByIndex(int index);

    void setFloatingSpeciesByIndex(int index, double value);

    std::vector<double> getFloatingSpeciesConcentrations();

    std::vector<double> getFloatingSpeciesInitialConcentrations();

    void setFloatingSpeciesConcentrations(const std::vector<double>& values);

    void setFloatingSpeciesInitialConcentrationByIndex(const int& index,
            const double& value);

    void setFloatingSpeciesInitialConcentrations(const std::vector<double>& values);

    std::vector<std::string> getFloatingSpeciesIds();

    std::vector<std::string> getFloatingSpeciesInitialConditionIds();

    int getNumberOfGlobalParameters();

    void setGlobalParameterByIndex(const int index, const double value);

    double getGlobalParameterByIndex(const int& index);

    std::vector<double> getGlobalParameterValues();

    std::vector<std::string> getGlobalParameterIds();

    void evalModel();

    static std::string getExtendedVersionInfo();


    double getuCC(const std::string& variableName, const std::string& parameterName);

    double getCC(const std::string& variableName, const std::string& parameterName);

    double getuEE(const std::string& reactionName, const std::string& parameterName);

    double getuEE(const std::string& reactionName, const std::string& parameterName,
            bool computeSteadystate);

    double getEE(const std::string& reactionName, const std::string& parameterName);

    double getEE(const std::string& reactionName, const std::string& parameterName,
            bool computeSteadyState);

    ls::DoubleMatrix getUnscaledElasticityMatrix();

    ls::DoubleMatrix getScaledElasticityMatrix();

    double getScaledFloatingSpeciesElasticity(const std::string& reactionName,
            const std::string& speciesName);

    double getUnscaledSpeciesElasticity(int reactionId, int speciesIndex);


    /******************************* Steady State Section *************************/
    #if (1) /**********************************************************************/
    /******************************************************************************/

    double steadyState();

    std::vector<rr::SelectionRecord>& getSteadyStateSelections();

    void setSteadyStateSelections(const std::vector<std::string>&
            steadyStateSelections);

    void setSteadyStateSelections(const std::vector<rr::SelectionRecord>&
            steadyStateSelections);

    std::vector<double> getSteadyStateValues();

    /******************************* End Steady State Section *********************/
    #endif /***********************************************************************/
    /******************************************************************************/

private:
    static int mInstanceCount;
    int mInstanceID;
    bool mUseKinsol;
    const double mDiffStepSize;

    const double mSteadyStateThreshold;
    ls::DoubleMatrix mRawRoadRunnerData;
    RoadRunnerData mRoadRunnerData;

    std::string mCurrentSBMLFileName;

    class CvodeInterface *mCVode;
    std::vector<SelectionRecord> mSelectionList;

    ModelGenerator *mModelGenerator;

    bool mComputeAndAssignConservationLaws;

    std::vector<SelectionRecord> mSteadyStateSelection;

    ExecutableModel* mModel;

    std::string mCurrentSBML;

    LibStructural* mLS;

    SimulateOptions mSettings;


    int createDefaultSteadyStateSelectionList();
    int createDefaultTimeCourseSelectionList();

    void addNthOutputToResult(ls::DoubleMatrix& results, int nRow,
            double dCurrentTime);
    bool populateResult();


    double getNthSelectedOutput(const int& index, const double& dCurrentTime);

    double getVariableValue(const VariableType::VariableType variableType,
            const int variableIndex);



    std::string createModelName(const std::string& mCurrentSBMLFileName);

    LibStructural* getLibStruct();

    bool initializeModel();

    bool createDefaultSelectionLists();

    int createTimeCourseSelectionList();

    void setParameterValue(const ParameterType::ParameterType parameterType,
            const int parameterIndex, const double value);

    double getParameterValue(const ParameterType::ParameterType parameterType,
            const int parameterIndex);

    void changeParameter(ParameterType::ParameterType parameterType,
            int reactionIndex, int parameterIndex, double originalValue,
            double increment);


    std::vector<SelectionRecord> getSelectionList();

    std::string configurationXML;


    friend class aFinalizer;
};

}

#endif