shell/Shell.h

Go to the documentation of this file.

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

#include "../basecode/global.h"

enum AssignmentType { SINGLE, VECTOR, REPEAT };

// These Finfo objects are exposed to other classes for convenience in test cases and other functions.
// NOTE: These should never be re-registered in an initCinfo of another class.
//extern SrcFinfo4< Id, DataId, FuncId, unsigned int >* requestGet(); // Not available
extern DestFinfo* receiveGet();
//extern SrcFinfo2< unsigned int, unsigned int >* ack(); // Not currently used.

enum NodePolicy { MooseGlobal, MooseBlockBalance, MooseSingleNode };
class NodeBalance {
    public:
        NodeBalance( unsigned int nd, NodePolicy np, unsigned int node )
                : numData( nd ), policy( np ), preferredNode( node )
        {;}

        unsigned int numData;
        NodePolicy policy;
        unsigned int preferredNode;
};

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

#ifdef  CYMOOSE
                
                    Shell* initShell();


                Id create( string type, string name, unsigned int numData, 
                        NodePolicy nodePolicy = MooseBlockBalance,
                        unsigned int preferredNode = 1 );


#endif     /* -----  CYMOOSE  ----- */
        // Field functions

                string doVersion();

                string doRevision();
        void setCwe( ObjId cwe );

        ObjId getCwe() const;

        bool isRunning() const;

        // Parser functions

        Id doCreate( string type, ObjId parent, string name, 
                unsigned int numData, 
                NodePolicy nodePolicy = MooseBlockBalance,
                unsigned int preferredNode = 1 );

        bool doDelete( ObjId oid );

        ObjId doAddMsg( const string& msgType, 
            ObjId src, const string& srcField, 
            ObjId dest, const string& destField );

        void doQuit( );

        void doStart( double runtime );

        void doNonBlockingStart( double runtime );

        void doReinit();

        void doStop();

        void doTerminate();

        void doMove( Id orig, ObjId newParent );

        Id doCopy( Id orig, ObjId newParent, string newName,
            unsigned int n, bool toGlobal, bool copyExtMsgs );

        ObjId doFind( const string& path ) const;

        void doUseClock( string path, string field, unsigned int tick );

         Id doLoadModel( const string& fname, const string& modelpath, 
            const string& solverClass = "" );

         void doSaveModel( Id model, const string& fileName, 
             bool qflag = 0 ) const;
        
         int doWriteSBML( const string& fname, const string& modelpath );
         Id doReadSBML( const string& fname, const string& modelpath, const string& solverclass=""
         );
         
        void doSyncDataHandler( Id tgt );

        void doReacDiffMesh( Id baseCompartment );

        void doSetParserIdleFlag( bool isParserIdle );

        static void clearRestructuringQ();
        // DestFinfo functions

        void start( double runTime );

        void initAck();

        void waitForAck();

        void handleAck( unsigned int ackNode, unsigned int status );

        bool isAckPending() const;

        void handleQuit();

        void handleCreate( const Eref& e,
            string type, ObjId parent, Id newElm, string name,
            NodeBalance nb, unsigned int parentMsgIndex );
        void destroy( const Eref& e, ObjId oid);

        void innerCreate( string type, ObjId parent, Id newElm, string name,
            const NodeBalance& nb, unsigned int parentMsgIndex );

        bool innerCopy( const vector< ObjId >& args, const string& newName,
            unsigned int n, bool toGlobal, bool copyExtMsgs );

        const Msg* innerAddMsg( string msgType, ObjId src, string srcField, 
            ObjId dest, string destField, unsigned int msgIndex );

        void handleAddMsg( const Eref& e, 
            string msgType,
            ObjId src, string srcField, 
            ObjId dest, string destField, 
            unsigned int msgIndex );

        bool innerMove( Id orig, ObjId newParent );

        void handleMove( const Eref& e,
            Id orig, ObjId newParent );

        void handleSync( const Eref& e, Id elm, FuncId fid);

        void handleCopy( const Eref& e,
            vector< ObjId > args, string newName, unsigned int n, 
            bool toGlobal, bool copyExtMsgs );

        bool innerUseClock( string path, string field, 
                        unsigned int tick, unsigned int msgIndex);
        void handleUseClock( const Eref& e,
            string path, string field, unsigned int tick, 
            unsigned int msgIndex );

        void addClockMsgs( const vector< ObjId >& list, 
            const string& field, unsigned int tick, unsigned int msgIndex );

        static void dropClockMsgs(
            const vector< ObjId >& list, const string& field );
        // Thread and MPI handling functions
        
        static void setHardware( 
            unsigned int numCores, unsigned int numNodes, 
            unsigned int myNode );

        static unsigned int myNode();
        static unsigned int numNodes();
        static unsigned int numCores();
        static unsigned int numProcessThreads();

        static void loadBalance();

        static void launchParser();

        static bool inBlockingParserCall();

        static bool isSingleThreaded();

        static bool keepLooping();

        static bool isParserIdle();

        static void launchThreads();

        static unsigned int reduceInt( unsigned int val );

        // Sets up clock ticks. Essentially is a call into the 
        // Clock::setupTick function, but may be needed to be called from
        // the parser so it is a Shell function too.
        void doSetClock( unsigned int tickNum, double dt );

        // Should set these up as streams so that we can build error
        // messages similar to cout.
        void warning( const string& text );
        void error( const string& text );

        static const Cinfo* initCinfo();

        // Utility functions
        static bool adopt( ObjId parent, Id child, unsigned int msgIndex );
        static bool adopt( Id parent, Id child, unsigned int msgIndex );

        static const unsigned int OkStatus;
        static const unsigned int ErrorStatus;

        // Initialization function, used only in main.cpp:init()
        void setShellElement( Element* shelle );

        static const ProcInfo* procInfo();

        const ProcInfo* getProcInfo( unsigned int index ) const;

        static bool chopString( const string& path, vector< string >& ret,
            char separator = '/' );

        static bool isNameValid( const string& name );

        static bool chopPath( const string& path, vector< string >& ret,
            vector< unsigned int >& index ); 

        // static void wildcard( const string& path, vector< Id >& list );

         static void cleanSimulation();

        void expectVector( bool flag );
        
    private:
        Element* shelle_; // It is useful for the Shell to have this.

        vector< double* > getBuf_;

        bool gettingVector_;

        unsigned int numGetVecReturns_;

        static bool isBlockedOnParser_;

        static bool keepLooping_;

        static unsigned int numCores_;

         static unsigned int numProcessThreads_;

        static unsigned int numNodes_;

        static unsigned int myNode_;

        static ProcInfo p_; 

        static vector< ProcInfo > threadProcs_;

        static unsigned int numAcks_;
        static vector< unsigned int > acked_;


        static bool doReinit_;

        static double runtime_;

        static bool isParserIdle_;

        ObjId cwe_;
};

/*
extern bool set( Eref& dest, const string& destField, const string& val );

extern bool get( const Eref& dest, const string& destField );
*/

#endif // _SHELL_H

---