Stoich.h

Go to the documentation of this file.

/**********************************************************************
** This program is part of 'MOOSE', the
** Messaging Object Oriented Simulation Environment.
**           Copyright (C) 2003-2014 Upinder S. Bhalla. and NCBS
** It is made available under the terms of the
** GNU Lesser General Public License version 2.1
** See the file COPYING.LIB for the full notice.
**********************************************************************/

#ifndef _STOICH_H
#define _STOICH_H

class Stoich
{
    public:
        Stoich();
        ~Stoich();

        // Field assignment stuff

        void setOneWay( bool v );
        bool getOneWay() const;

        // Flag that defines permission for pool values to go negative.
        void setAllowNegative( bool v );
        bool getAllowNegative() const;

        unsigned int getNumVarPools() const;

        unsigned int getNumBufPools() const;

        unsigned int getNumAllPools() const;

        unsigned int getNumProxyPools() const;

        vector< unsigned int > getPoolIdMap() const;

                Id getPoolByIndex( unsigned int index ) const;

        void setPath( const Eref& e, string path );
        string getPath( const Eref& e ) const;

        void setKsolve( Id v );
        Id getKsolve() const;

        void setDsolve( Id v );
        Id getDsolve() const;

        void setCompartment( Id v );
        Id getCompartment() const;

        unsigned int getNumRates() const;

        unsigned int getNumCoreRates() const;

        const RateTerm* rates( unsigned int i ) const;

        const vector< RateTerm* >& getRateTerms() const;

        unsigned int getNumFuncs() const;
        const FuncTerm* funcs( unsigned int i ) const;
        bool isFuncTarget( unsigned int poolIndex ) const;

        vector< int > getMatrixEntry() const;
        vector< unsigned int > getColIndex() const;
        vector< unsigned int > getRowStart() const;

        vector< Id > getProxyPools( Id i ) const;

        int getStatus() const;
        // Model traversal and building functions

        void setElist( const Eref& e, const vector< ObjId >& elist );

        void locateOffSolverReacs( Id myCompt, vector< Id >& elist );

        void resizeArrays();
        void allocateModelObject( Id id );
        void allocateModel( const vector< Id >& elist );

        void buildPoolLookup();
        void buildRateTermLookup();
        void buildFuncLookup();

        void convertRatesToStochasticForm();

        void scaleBufsAndRates( unsigned int index, double volScale );

        // Zombification functions.

        void zombifyModel( const Eref& e, const vector< Id >& elist );

        void unZombifyModel();

        void unZombifyPools();

        void zombifyChemCompt( Id compt );

        Id zombifyPoolFuncWithScaling( Id pool );

        unsigned int convertIdToReacIndex( Id id ) const;
        unsigned int convertIdToPoolIndex( Id id ) const;
        unsigned int convertIdToFuncIndex( Id id ) const;

        ZeroOrder* makeHalfReaction(
                        double rate, const vector< Id >& reactants );

        /*
         * This takes the specified Reac and its substrate and product
         * list, and installs them into the Stoich. It also builds up the
         * vectors to store which compartment each substrate/product
         * belongs to, needed for cross-reaction computations.
         * This is the high-level interface function.
         */
        void installReaction( Id reacId,
                const vector< Id >& subs, const vector< Id >& prds );
        /*
         * This takes the specified subs and prds belonging
         * to the specified Reac, and builds them into the Stoich.
         * It is a low-level function used internally.
         */
        unsigned int innerInstallReaction( Id reacId,
                const vector< Id >& subs, const vector< Id >& prds );

        void installMMenz( Id enzId, const vector< Id >& enzMolId,
            const vector< Id >& subs, const vector< Id >& prds );
        void installMMenz( MMEnzymeBase* meb, unsigned int rateIndex,
            const vector< Id >& subs, const vector< Id >& prds );

        /*
         * This takes the specified Reac and its substrate and product
         * list, and installs them into the Stoich. This is the high-level
         * interface function.
         */
        void installEnzyme( Id enzId, Id enzMolId, Id cplxId,
                const vector< Id >& subs, const vector< Id >& prds );
        void installEnzyme( ZeroOrder* r1, ZeroOrder* r2, ZeroOrder* r3,
            Id enzId, Id enzMolId, const vector< Id >& prds );

        void installDummyEnzyme( Id enzId, Id enzMolId);

        void installAndUnschedFunc( Id func, Id pool, double volScale );

        void installAndUnschedFuncRate( Id func, Id pool );

        void installAndUnschedFuncReac( Id func, Id reac );


        unsigned int getSpecies( unsigned int poolIndex ) const;

        void setSpecies( unsigned int poolIndex, unsigned int s );

        void setReacKf( const Eref& e, double v ) const;

        void setReacKb( const Eref& e, double v ) const;

        void setMMenzKm( const Eref& e, double v ) const;
        double getMMenzNumKm( const Eref& e ) const;

        void setMMenzKcat( const Eref& e, double v ) const;
        double getMMenzKcat( const Eref& e ) const;

        void setEnzK1( const Eref& e, double v ) const;
        double getEnzNumK1( const Eref& e ) const;

        void setEnzK2( const Eref& e, double v ) const;
        double getEnzK2( const Eref& e ) const;

        void setEnzK3( const Eref& e, double v ) const;
        double getEnzK3( const Eref& e ) const;

        double getR1( const Eref& e ) const;
        double getR1offset1( const Eref& e ) const;
        double getR1offset2( const Eref& e ) const;

        double getR2( const Eref& e ) const;

        void setFunctionExpr( const Eref& e, string expr );

        void updateRatesAfterRemesh();

        void print() const;

        void printRates() const;
        // Utility funcs for numeric calculations

        void updateReacVelocities( const double* s, vector< double >& vel,
                       unsigned int volIndex ) const;

        void updateFuncs( double* s, double t ) const;

        /*
        void updateJunctionRates( const double* s,
               const vector< unsigned int >& reacTerms, double* yprime );
               */

        const KinSparseMatrix& getStoichiometryMatrix() const;
        // Access functions for cross-node reactions.
        const vector< Id >& getOffSolverPools() const;

        vector< Id > getOffSolverCompts() const;

        const vector< Id >& offSolverPoolMap( Id compt ) const;

        static const unsigned int PoolIsNotOnSolver;
        static const Cinfo* initCinfo();
    private:
        bool useOneWay_;

        bool allowNegative_;

        string path_;

        Id ksolve_;

        Id dsolve_;

        Id compartment_;

        ZombiePoolInterface* kinterface_;
        ZombiePoolInterface* dinterface_;

        vector< unsigned int > species_;

        vector< RateTerm* > rates_;

        unsigned int numVoxels_;

        vector< FuncTerm* > funcs_;

        KinSparseMatrix N_;

        // vector< unsigned int > objMap_;
        // unsigned int objMapStart_;
        //
        // Here we have the vectors of the different kinds of objects
        // managed by the Stoich

        vector< Id > varPoolVec_;

        vector< Id > bufPoolVec_;

        vector< Id > offSolverPoolVec_;

        vector< Id > reacVec_;
        vector< Id > offSolverReacVec_;

        vector< Id > enzVec_;
        vector< Id > offSolverEnzVec_;

        vector< Id > mmEnzVec_;
        vector< Id > offSolverMMenzVec_;

        vector< Id > poolFuncVec_;

        vector< unsigned int > funcTarget_;

        vector< Id > incrementFuncVec_;

        vector< Id > reacFuncVec_;

        // Here we have maps to look up objects from their ids.
        map< Id, unsigned int > poolLookup_;
        map< Id, unsigned int > rateTermLookup_;
        map< Id, unsigned int > funcLookup_;

        // unsigned int numVarPools_;

        // unsigned int numBufPools_;

        int status_;

        // Off-solver stuff

        map< Id, vector< Id > > offSolverPoolMap_;

        vector< pair< Id, Id > > offSolverReacCompts_;
        vector< pair< Id, Id > > offSolverEnzCompts_;
        vector< pair< Id, Id > > offSolverMMenzCompts_;

        vector< vector< Id > > subComptVec_;

        vector< vector< Id > > prdComptVec_;
};

#endif  // _STOICH_H