/home/msneddon/eclipse/galileoSR1_cpp/workspace/NFsim/src/NFfunction/NFfunction.hh

Go to the documentation of this file.

#ifndef NFFUNCTION_HH_
#define NFFUNCTION_HH_


#include "muParser/muParser.h"
#include "../NFcore/NFcore.hh"


using namespace std;


namespace NFcore {

        class System;
        class ReactionClass;
        class Observable;


        class FuncFactory {
                public:

                        static mu::Parser * create(string function, vector <string> & variableNames, vector <double *> & variablePtrs);


                        static mu::Parser * create();

                        static double Eval(mu::Parser *p);

                        static void test();

        };




        class GlobalFunction {

                public:
                        GlobalFunction(string name,
                                        string funcExpression,
                                        vector <string> &varRefNames,
                                        vector <string> &varRefTypes,
                                        vector <string> &paramNames,
                                        System *s);

                        ~GlobalFunction();

                        void prepareForSimulation(System *s);

                        void updateParameters(System *s);



                        string getNiceName() const {return name+"()";};

                        string getName() const {return name;};

                        void printDetails();
                        void printDetails(System *s);


                        void attatchRxn(ReactionClass *r);


                        int getNumOfVarRefs() const { return (int) n_varRefs; };
                        string getVarRefName(int varRefIndex) const {
                                return varRefNames[varRefIndex];
                        }
                        string getVarRefType(int varRefIndex) const {
                                return varRefTypes[varRefIndex];
                        }

                        mu::Parser *p;

                protected:

                        string name;
                        string funcExpression;

                        unsigned int n_varRefs;
                        string *varRefNames;
                        string *varRefTypes;

                        unsigned int n_params;
                        string *paramNames;
        };



        class FunctionReference
        {

                public:
                        FunctionReference(string name, string expression, string referencedFuncName) {
                                this->name = name;
                                this->expression=expression;
                                this->referencedFuncName=referencedFuncName;
                        };
                        ~FunctionReference() {};

                        string name;
                        string expression;
                        string referencedFuncName;

        };




        class StateCounter {
                public:
                        StateCounter(string name, MoleculeType *mt, string stateName);
                        ~StateCounter();

                        void add(Molecule *m);
                        void reset() { value=0; };
                        int getValue() const { return (int)value; };


                        string name;
                        MoleculeType *mt;
                        int stateIndex;
                        double value;
        };









        class LocalFunction {

                public:

                        LocalFunction(System *s,
                                                                string name,
                                                                string originalExpression,
                                                                string parsedExpression,
                                                                vector <string> &args,
                                                                vector <string> &varRefNames,
                                                                vector <string> &varObservableNames,
                                                                vector <Observable *> & varObservables,
                                                                vector <int> &varRefScope,
                                                                vector <string> paramNames);
                        ~LocalFunction();


                        string getName() const;
                        string getNiceName() const;
                        string getExpression() const;
                        string getParsedExpression() const;


                        void printDetails(System *s);

                        void prepareForSimulation(System *s);


                        double getValue(Molecule *m, int scope);
                        double evaluateOn(Molecule *m, int scope);


                        void addTypeIMoleculeDependency(MoleculeType *mt);
                        void updateParameters(System *s);

                        static const int SPECIES = 0;
                        static const int MOLECULE = 1;

                        mu::Parser *p;
                protected:


                        string name;
                        string nicename;
                        string originalExpression;
                        string parsedExpression;

                        unsigned int n_args;
                        string *argNames;


                        unsigned int n_params;
                        string *paramNames;

                        unsigned int n_varRefs;
                        string *varRefNames;
                        string *varObservableNames;
                        int *varRefScope;
                        Observable **varLocalObservables;


                        static list <Molecule *> molList;
                        static list <Molecule *>::iterator molIter;

                        //Here we store back pointers into both type I and type II molecules
                        //Remember that type I molecules must store the value of this function
                        //locally so that it can be used in DOR reactions.  Type II molecules
                        //do not have the local value explicitly, but local functions should still
                        //know 'of' them in case of future speedups that might use this information

                        //@todo : change these to arrays from vectors!!!

                        vector <MoleculeType *> typeI_mol;
                        vector <int> typeI_localFunctionIndex;
                        int n_typeIImolecules;
                        MoleculeType ** typeII_mol;
                        //vector <MoleculeType *> typeII_mol;
                        vector <int> typeII_localFunctionIndex;


        };



        class CompositeFunction {
                        public:
                                CompositeFunction(System *s,
                                                string name,
                                                string expression,
                                                vector <string> &functions,
                                                vector <string> & argNames,
                                                vector <string> &paramNames);
                                ~CompositeFunction();


                                string getName() const {return name;};

                                void updateParameters(System *s);

                                void finalizeInitialization(System *s);

                                void prepareForSimulation(System *s);


                                void setGlobalObservableDependency(ReactionClass *r, System *s);

                                double evaluateOn(Molecule **molList, int *scope, int *curReactantCounts, int n_reactants);

                                void printDetails(System *s);

                                int getNumOfArgs() const;
                                string getArgName(int aIndex) const;

                                void addTypeIMoleculeDependency(MoleculeType *mt);


                        protected:

                                string name;
                                string originalExpression;
                                string parsedExpression;


                                unsigned int n_allFuncs;
                                string * allFuncNames;


                                unsigned int n_args;
                                string * argNames;

                                unsigned int n_params;
                                string *paramNames;

                                //here are the referenced global functions
                                int n_gfs;
                                string * gfNames;
                                GlobalFunction ** gfs;
                                double * gfValues;

                                //stores list of all local functions
                                int n_lfs;
                                string * lfNames;
                                LocalFunction ** lfs;


                                int n_reactantCounts;
                                double * reactantCount;

                                //stores list of all local functions and how they are referenced
                                int n_refLfs;
                                int *refLfInds;
                                string *refLfRefNames;
                                int *refLfScopes;
                                double * refLfValues;

                                mu::Parser *p;
                };





}














#endif /*NFFUNCTION_HH_*/

---