ksolve/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;

        unsigned int getNumVarPools() const;

        unsigned int getNumBufPools() const;

        unsigned int getNumAllPools() const;

        unsigned int getNumProxyPools() const;

        vector< unsigned int > getPoolIdMap() 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;

        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 allocateObjMap( const vector< Id >& elist );

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

        void convertRatesToStochasticForm();

        void buildXreacs( const Eref& e, Id otherStoich );

        void filterXreacs();

        void scaleBufsAndRates( unsigned int index, double volScale );

        void comptsOnCrossReacTerms( vector< pair< Id, Id > >& xr ) const;

        void setupCrossSolverReacVols() const;
        // Zombification functions.

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

        void unZombifyModel();

        void unZombifyPools();

        void zombifyChemCompt( Id compt );

        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 );

        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();
    protected:
        bool useOneWay_;
        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_;

        vector< Id > idMap_;

        vector< Id > reacMap_;

        vector< Id > enzMap_;

        vector< Id > mmEnzMap_;
        
        vector< Id > funcMap_;

        unsigned int numVarPools_;

        unsigned int numBufPools_;
        unsigned int numFunctions_;

        unsigned int numReac_;

        int status_;

        // Off-solver stuff

        vector< Id > offSolverPools_;

        map< Id, vector< Id > > offSolverPoolMap_; 

        vector< Id > offSolverReacs_;

        vector< pair< Id, Id > > offSolverReacCompts_;

        vector< vector< Id > > subComptVec_;

        vector< vector< Id > > prdComptVec_;
};

#endif  // _STOICH_H

---