inline void SpatiocyteNextReactionProcess::calculateOrder()
{
ReactionProcess::calculateOrder();
for(VariableReferenceVector::iterator
i(theVariableReferenceVector.begin());
i != theVariableReferenceVector.end(); ++i)
{
VariableReference aVariableReference(*i);
long int aCoefficient(aVariableReference.getCoefficient());
// here assume aCoefficient != 0
if(aCoefficient == 0)
{
THROW_EXCEPTION(InitializationFailed,
"[" + getFullID().asString() +
"]: Zero stoichiometry is not allowed.");
}
}
// set theGetPropensityMethodPtr
if(getOrder() == 0) // no substrate
{
theGetPropensityMethodPtr = RealMethodProxy::create<
&SpatiocyteNextReactionProcess::getPropensity_ZerothOrder>();
}
else if(getOrder() == 1) // one substrate, first order.
{
theGetPropensityMethodPtr = RealMethodProxy::create<
&SpatiocyteNextReactionProcess::getPropensity_FirstOrder>();
}
else if(getOrder() == 2)
{
//Two unique substrate species, second order
//A + B -> products:
if(getZeroVariableReferenceOffset() == 2)
{
theGetPropensityMethodPtr = RealMethodProxy::
create<&SpatiocyteNextReactionProcess::
getPropensity_SecondOrder_TwoSubstrates>();
}
//One substrate species, second order
//A + A -> products:
else
{
theGetPropensityMethodPtr = RealMethodProxy::
create<&SpatiocyteNextReactionProcess::
getPropensity_SecondOrder_OneSubstrate>();
}
}
else
{
// change code (2011/02/03)
THROW_EXCEPTION( UnexpectedError,
"never get here (" + std::string( __PRETTY_FUNCTION__ )
+ ")" );
// NEVER_GET_HERE;
}
}
void MassActionProcess::fire()
{
if(theSpace == 0)
{
Species* aSpecies(NULL);
for(VariableReferenceVector::iterator
i(theVariableReferenceVector.begin());
i != theVariableReferenceVector.end(); ++i)
{
Variable* aVariable((*i).getVariable());
aSpecies = theSpatiocyteStepper->getSpecies(aVariable);
if(aSpecies != NULL)
{
break;
}
}
if(aSpecies->getIsVolume())
{
theSpace = aSpecies->getCompartment()->actualVolume;
cout << "Mass Action Volume:" << theSpace << endl;
}
else
{
theSpace = aSpecies->getCompartment()->actualArea;
cout << "Mass Action Area:" << theSpace << endl;
}
}
double velocity(k);
velocity *= theSpace;
for(VariableReferenceVector::iterator
s(theVariableReferenceVector.begin());
s != theZeroVariableReferenceIterator; ++s)
{
VariableReference aVariableReference(*s);
long int aCoefficient(aVariableReference.getCoefficient());
do
{
++aCoefficient;
velocity *= aVariableReference.getVariable()->getValue()/theSpace;
}
while(aCoefficient != 0);
}
setFlux(velocity);
}
void GillespieProcess::fire()
{
Real velocity( getk() * N_A );
velocity *= getSuperSystem()->getSize();
for( VariableReferenceVector::const_iterator
s( theVariableReferenceVector.begin() );
s != theZeroVariableReferenceIterator; ++s )
{
VariableReference aVariableReference( *s );
Integer aCoefficient( aVariableReference.getCoefficient() );
do
{
++aCoefficient;
velocity *= aVariableReference.getVariable()->getMolarConc();
}
while( aCoefficient != 0 );
}
setActivity( velocity );
}
virtual void fire()
{
Real velocity( k * N_A );
velocity *= getSuperSystem()->getSize();
for( VariableReferenceVector::const_iterator
s( theVariableReferenceVector.begin() );
s != theZeroVariableReferenceIterator; ++s )
{
VariableReference aVariableReference( *s );
Integer aCoefficient( aVariableReference.getCoefficient() );
do {
++aCoefficient;
velocity *= aVariableReference.getMolarConc();
} while( aCoefficient != 0 );
}
setFlux(velocity);
}
void Stepper::updateVariableVector()
{
typedef std::map< Variable*, VariableReference, std::less< Variable* > >
PtrVariableReferenceMap;
typedef Process::VariableReferenceVector VariableReferenceVector;
PtrVariableReferenceMap aPtrVariableReferenceMap;
for( ProcessVector::const_iterator i( theProcessVector.begin());
i != theProcessVector.end() ; ++i )
{
VariableReferenceVector const& aVariableReferenceVector(
(*i)->getVariableReferenceVector() );
// for all the VariableReferences
for( VariableReferenceVector::const_iterator j(
aVariableReferenceVector.begin() );
j != aVariableReferenceVector.end(); ++j )
{
VariableReference const& aNewVariableReference( *j );
Variable* aVariablePtr( aNewVariableReference.getVariable() );
PtrVariableReferenceMap::iterator
anIterator( aPtrVariableReferenceMap.find( aVariablePtr ) );
if( anIterator == aPtrVariableReferenceMap.end() )
{
aPtrVariableReferenceMap.insert(
PtrVariableReferenceMap::value_type(
aVariablePtr, aNewVariableReference ) );
}
else
{
VariableReference& aVariableReference( anIterator->second );
aVariableReference.setIsAccessor(
aVariableReference.isAccessor()
|| aNewVariableReference.isAccessor() );
aVariableReference.setCoefficient(
abs( aVariableReference.getCoefficient() )
+ abs( aNewVariableReference.getCoefficient() ) );
}
}
}
VariableReferenceVector aVariableReferenceVector;
aVariableReferenceVector.reserve( aPtrVariableReferenceMap.size() );
// I want select2nd... but use a for loop for portability.
for( PtrVariableReferenceMap::const_iterator
i( aPtrVariableReferenceMap.begin() );
i != aPtrVariableReferenceMap.end() ; ++i )
{
aVariableReferenceVector.push_back( i->second );
}
VariableReferenceVector::iterator aReadOnlyVariableReferenceIterator =
std::partition( aVariableReferenceVector.begin(),
aVariableReferenceVector.end(),
std::mem_fun_ref( &VariableReference::isMutator ) );
VariableReferenceVector::iterator aReadWriteVariableReferenceIterator =
std::partition( aVariableReferenceVector.begin(),
aReadOnlyVariableReferenceIterator,
std::not1(
std::mem_fun_ref( &VariableReference::isAccessor )
) );
theVariableVector.clear();
theVariableVector.reserve( aVariableReferenceVector.size() );
std::transform( aVariableReferenceVector.begin(),
aVariableReferenceVector.end(),
std::back_inserter( theVariableVector ),
std::mem_fun_ref( &VariableReference::getVariable ) );
theReadWriteVariableOffset = aReadWriteVariableReferenceIterator
- aVariableReferenceVector.begin();
theReadOnlyVariableOffset = aReadOnlyVariableReferenceIterator
- aVariableReferenceVector.begin();
VariableVector::iterator aReadWriteVariableIterator =
theVariableVector.begin() + theReadWriteVariableOffset;
VariableVector::iterator aReadOnlyVariableIterator =
theVariableVector.begin() + theReadOnlyVariableOffset;
// For each part of the vector, sort by memory address.
// This is an optimization.
std::sort( theVariableVector.begin(), aReadWriteVariableIterator );
std::sort( aReadWriteVariableIterator, aReadOnlyVariableIterator );
std::sort( aReadOnlyVariableIterator, theVariableVector.end() );
}
