#include <ZombieFunction.h>

Inheritance diagram for ZombieFunction:

Collaboration diagram for ZombieFunction:

Public Member Functions
void	innerSetExpr (const Eref &e, string val)

void	process (const Eref &e, ProcPtr p)

void	reinit (const Eref &e, ProcPtr p)

void	setSolver (Id solver, Id orig)

	ZombieFunction ()

	~ZombieFunction ()

Public Member Functions inherited from Function
unsigned int	addVar ()

	Function ()

	Function (const Function &rhs)

double	getConst (string name) const

double	getDerivative () const

bool	getDoEvalAtReinit () const

string	getExpr (const Eref &e) const

string	getIndependent () const

unsigned int	getMode () const

unsigned int	getNumVar () const

double	getRate () const

bool	getUseTrigger () const

double	getValue () const

Variable *	getVar (unsigned int ii)

vector< string >	getVars () const

vector< double >	getY () const

Function &	operator= (const Function rhs)

void	process (const Eref &e, ProcPtr p)

void	reinit (const Eref &e, ProcPtr p)

void	setConst (string name, double value)

void	setDoEvalAtReinit (bool doEvalAtReinit)

void	setExpr (const Eref &e, string expr)

void	setIndependent (string index)

void	setMode (unsigned int mode)

void	setNumVar (unsigned int num)

void	setUseTrigger (bool useTrigger)

void	setVar (unsigned int index, double value)

void	setVarValues (vector< string > vars, vector< double > vals)

	~Function ()

Static Public Member Functions
static const Cinfo *	initCinfo ()

static void	zombify (Element orig, const Cinfo zClass, Id ksolve, Id dsolve)

Static Public Member Functions inherited from Function
static const Cinfo *	initCinfo ()

Additional Inherited Members
Static Public Attributes inherited from Function
static const int	VARMAX

Protected Member Functions inherited from Function
void	_clearBuffer ()

void	_showError (mu::Parser::exception_type &e) const

Protected Attributes inherited from Function
map< string, double * >	_constbuf

bool	_doEvalAtReinit

string	_independent

double	_lastValue

unsigned int	_mode

unsigned int	_numVar

mu::Parser	_parser

vector< double * >	_pullbuf

double	_rate

char *	_stoich

double	_t

bool	_useTrigger

bool	_valid

double	_value

vector< Variable * >	_varbuf

Detailed Description

Definition at line 13 of file ZombieFunction.h.

Constructor & Destructor Documentation

ZombieFunction::ZombieFunction ( )

Definition at line 107 of file ZombieFunction.cpp.

108 {;}

ZombieFunction::~ZombieFunction ( )

Definition at line 110 of file ZombieFunction.cpp.

111 {;}

Member Function Documentation

const Cinfo * ZombieFunction::initCinfo ( )

static

Definition at line 29 of file ZombieFunction.cpp.

References Function::initCinfo(), process(), reinit(), and zombieFunctionCinfo.

Referenced by zombify().

 {
         // Field Definitions: mostly inherited from Function
 
         // MsgDest Definitions: All inherited from Function
         // SrcFinfo Definitions: All inherited from Function
         // SharedMsg Definitions: Override Function
     static DestFinfo process( "process",
               "Handles process call, updates internal time stamp.",
               new ProcOpFunc< ZombieFunction >( &ZombieFunction::process) );
     static DestFinfo reinit( "reinit",
              "Handles reinit call.",
              new ProcOpFunc< ZombieFunction >( &ZombieFunction::reinit ) );
     static Finfo* processShared[] =
             {
                 &process, &reinit
             };
 
     static SharedFinfo proc( "proc",
              "This is a shared message to receive Process messages "
              "from the scheduler objects."
              "The first entry in the shared msg is a MsgDest "
              "for the Process operation. It has a single argument, "
              "ProcInfo, which holds lots of information about current "
              "time, thread, dt and so on. The second entry is a MsgDest "
              "for the Reinit operation. It also uses ProcInfo. ",
              processShared, sizeof( processShared ) / sizeof( Finfo* )
              );
 
     // Note that here the isOneZombie_ flag on the Dinfo constructor is
     // true. This means that the duplicate and copy operations only make
     // one copy, regardless of how big the array of zombie pools.
     // The assumption is that each Id has a single pool, which can be
     // present in many voxels.
     static Finfo *functionFinfos[] =
             {
                 &proc,
             };
 
     static string doc[] =
             {
                 "Name", "ZombieFunction",
                 "Author", "Upi Bhalla",
                 "Description",
                 "ZombieFunction: Takes over Function, which is a general "
                 "purpose function calculator using real numbers."
             };
 
     static Dinfo< ZombieFunction > dinfo;
     static Cinfo zombieFunctionCinfo (
         "ZombieFunction",
         Function::initCinfo(),
         functionFinfos,
         sizeof(functionFinfos) / sizeof(Finfo*),
         &dinfo,
         doc,
        sizeof(doc)/sizeof(string)
     );
 
     return &zombieFunctionCinfo;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ZombieFunction::innerSetExpr	(	const Eref &	e,
		string	val
	)

virtual

Reimplemented from Function.

Definition at line 128 of file ZombieFunction.cpp.

References Function::_stoich, Function::innerSetExpr(), and Stoich::setFunctionExpr().

 {
     Function::innerSetExpr( e, v );
     if ( _stoich ) {
         Stoich* s = reinterpret_cast< Stoich* >( _stoich );
         s->setFunctionExpr( e, v );
     } else {
         // I had this warning here but it is triggered needlessly when we
         // do an assignment of the Zombie function. So removed.
         // cout << "Warning: ZombieFunction::setExpr: Stoich not set.\n";
     }
 }

Here is the call graph for this function:

void ZombieFunction::process	(	const Eref &	e,
		ProcPtr	p
	)

Definition at line 116 of file ZombieFunction.cpp.

References Function::_t, and ProcInfo::currTime.

Referenced by initCinfo().

 {
     _t = p->currTime;
 }

Here is the caller graph for this function:

void ZombieFunction::reinit	(	const Eref &	e,
		ProcPtr	p
	)

Definition at line 121 of file ZombieFunction.cpp.

Referenced by initCinfo().

122 {;}

Here is the caller graph for this function:

void ZombieFunction::setSolver	(	Id	solver,
		Id	orig
	)

Definition at line 145 of file ZombieFunction.cpp.

References Function::_stoich, Element::cinfo(), ObjId::data(), Id::element(), Field< A >::get(), Cinfo::isA(), Cinfo::name(), and Id::path().

Referenced by zombify().

 {
     if ( ksolve.element()->cinfo()->isA( "Ksolve" ) ||
                     ksolve.element()->cinfo()->isA( "Gsolve" ) ) {
         Id sid = Field< Id >::get( ksolve, "stoich" );
         _stoich = ObjId( sid, 0 ).data();
         if ( _stoich == 0 )
             cout << "Warning:ZombieFunction::setSolver: Empty Stoich on Ksolve" << ksolve.path() << endl;
     } else if ( ksolve == Id() ) {
             _stoich = 0;
     } else {
             cout << "Warning:ZombieFunction::setSolver: solver class " <<
                     ksolve.element()->cinfo()->name() <<
                     " not known.\nShould be Ksolve or Gsolve\n";
             _stoich = 0;
     }
 
     /*
     if ( dsolve.element()->cinfo()->isA( "Dsolve" ) ) {
             dsolve_= ObjId( dsolve, 0 ).data();
     } else if ( dsolve == Id() ) {
             dsolve_ = 0;
     } else {
             cout << "Warning:ZombieFunction::vSetSolver: solver class " <<
                     dsolve.element()->cinfo()->name() <<
                     " not known.\nShould be Dsolve\n";
             dsolve_ = 0;
     }
     */
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void ZombieFunction::zombify	(	Element *	orig,
		const Cinfo *	zClass,
		Id	ksolve,
		Id	dsolve
	)

static

Definition at line 176 of file ZombieFunction.cpp.

References Element::cinfo(), Eref::data(), initCinfo(), Element::numLocalData(), setSolver(), and Element::zombieSwap().

Referenced by Stoich::unZombifyModel(), Stoich::zombifyModel(), and Stoich::zombifyPoolFuncWithScaling().

 {
     //cout << "ZombieFunction::zombify: " << orig->id().path() << endl;
     if ( orig->cinfo() == zClass )
             return;
     // unsigned int start = orig->localDataStart();
     unsigned int num = orig->numLocalData();
     if ( num == 0 )
         return;
     if ( num > 1 )
         cout << "ZombieFunction::zombify: Warning: ZombieFunction doesn't\n"
                 "handle volumes yet. Proceeding without this.\n";
 
     Function* f = reinterpret_cast< Function *>( Eref( orig, 0 ).data() );
     Function temp = *f;
     orig->zombieSwap( zClass );
     if ( zClass == ZombieFunction::initCinfo() ) { // call SetSolver
         ZombieFunction* zf = reinterpret_cast< ZombieFunction *>(
                         Eref( orig, 0 ).data() );
         *zf = *static_cast< ZombieFunction* >(&temp);
         zf->setSolver( ksolve, dsolve );
     } else {
         Function* nf =
                     reinterpret_cast< Function *>(Eref( orig, 0 ).data());
         *nf = temp;
     }
 
     /*
     // We can swap the class because the class data is identical, just
     // the moose expr and process handlers are different.
     if ( orig->cinfo() == ZombieFunction::initCinfo() ) { // unzombify
         orig->replaceCinfo( Function::initCinfo() );
     } else { // zombify
         orig->replaceCinfo( ZombieFunction::initCinfo() );
         ZombieFunction* zf = reinterpret_cast< ZombieFunction *>(
                         Eref( orig, 0 ).data() );
         zf->setSolver( ksolve, dsolve );
     }
     */
 }

Here is the call graph for this function:

Here is the caller graph for this function:

The documentation for this class was generated from the following files:

moose-core/ksolve/ZombieFunction.h
moose-core/ksolve/ZombieFunction.cpp

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation