Dsolve.h

Go to the documentation of this file.

/**********************************************************************
** This program is part of 'MOOSE', the
** Messaging Object Oriented Simulation Environment.
**           Copyright (C) 2003-2013 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 _DSOLVE_H
#define _DSOLVE_H

class Dsolve: public ZombiePoolInterface
{
    public:
        Dsolve();
        ~Dsolve();

        // Field assignment stuff
        unsigned int getNumVarPools() const;

        void setStoich( Id id );
        Id getStoich() const;
        void setCompartment( Id id );
        // Defined in base class. Id getCompartment() const;
        void setDsolve( Id id ); 

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

        unsigned int getNumVoxels() const;
        void setNumAllVoxels( unsigned int numVoxels );

        vector< double > getNvec( unsigned int pool ) const;
        void setNvec( unsigned int pool, vector< double > vec );

        double getDiffVol1( unsigned int voxel ) const;
        void setDiffVol1( unsigned int voxel, double vol );
        double getDiffVol2( unsigned int voxel ) const;
        void setDiffVol2( unsigned int voxel, double vol );
        double getDiffScale( unsigned int voxel ) const;
        void setDiffScale( unsigned int voxel, double scale );

        // Dest Finfos
        void process( const Eref& e, ProcPtr p );
        void reinit( const Eref& e, ProcPtr p );

        void updateJunctions( double dt );

        void buildNeuroMeshJunctions( const Eref& e, Id spineD, Id psdD );

        void buildMeshJunctions( const Eref& e, Id other );

        static void innerBuildMeshJunctions( Id self, Id other, 
                        bool isMembraneBound );

        static void mapDiffPoolsBetweenDsolves( DiffJunction& jn, 
                        Id self, Id other);

        static void mapXfersBetweenDsolves(
                        vector< unsigned int >& srcPools, 
                        vector< unsigned int >& destPools,
                        Id src, Id dest );
        static void mapChansBetweenDsolves( DiffJunction& jn, 
                        Id self, Id other);

        void calcJunction( const DiffJunction& jn, double dt );
        // Inherited virtual funcs from ZombiePoolInterface
        double getNinit( const Eref& e ) const;
        void setNinit( const Eref& e, double value );
        double getN( const Eref& e ) const;
        void setN( const Eref& e, double value );
        double getDiffConst( const Eref& e ) const;
        void setDiffConst( const Eref& e, double value );
        void setMotorConst( const Eref& e, double value );

        void setNumPools( unsigned int num );
        unsigned int getNumPools() const;
        unsigned int getNumLocalVoxels() const;
        VoxelPoolsBase* pools( unsigned int i );
        double volume( unsigned int i ) const;

        void getBlock( vector< double >& values ) const;
        void setBlock( const vector< double >& values );
        void setPrev();

        // This one isn't used in Dsolve, but is defined as a dummy.
        void setupCrossSolverReacs(
                    const map< Id, vector< Id > >& xr, Id otherStoich );
        void setupCrossSolverReacVols(
            const vector< vector< Id > >& subCompts,
            const vector< vector< Id > >& prdCompts );
        void filterCrossRateTerms( const vector< pair< Id, Id > >& xrt );

        // Do any updates following a volume or rate constant change.
        void updateRateTerms( unsigned int index );
        // Model traversal and building functions
        unsigned int convertIdToPoolIndex( Id id ) const;
        unsigned int convertIdToPoolIndex( const Eref& e ) const;
        unsigned int getPoolIndex( const Eref& e ) const;

        void makePoolMapFromElist( const vector< ObjId >& elist,
                        vector< Id >& temp );

        void build( double dt );
        void rebuildPools();
        void calcJnDiff( const DiffJunction& jn, Dsolve* other, double dt );
        void calcJnXfer( const DiffJunction& jn, 
                        const vector< unsigned int >& srcXfer, 
                        const vector< unsigned int >& destXfer, 
                        Dsolve* srcDsolve, Dsolve* destDsolve );
        void calcJnChan( const DiffJunction& jn, Dsolve* other, double dt );
        void calcOtherJnChan( const DiffJunction& jn, Dsolve* other, 
                        double dt );
        void fillConcChans( const vector< ObjId >& chans );

        void print() const;

        static const Cinfo* initCinfo();
    private:

        string path_;

        double dt_;

        unsigned int numTotPools_;
        unsigned int numLocalPools_;
        unsigned int poolStartIndex_;
        unsigned int numVoxels_;

        vector< DiffPoolVec > pools_;
        vector< ConcChanInfo > channels_;

        unsigned int poolMapStart_;

        vector< unsigned int > poolMap_;

        vector< DiffJunction > junctions_;
};


#endif  // _DSOLVE_H