This graph shows which files directly or indirectly include this file:

Functions
double	convertConcToNumRateInTwoCompts (double v1, unsigned int n1, double v2, unsigned int n2, double scale)

double	convertConcToNumRateUsingMesh (const Eref &e, const SrcFinfo *pools, bool doPartialConversion)

double	convertConcToNumRateUsingVol (const Eref &e, const SrcFinfo *pools, double volume, double scale, bool doPartialConversion)

ObjId	getCompt (Id id)

unsigned int	getReactantVols (const Eref &reac, const SrcFinfo *pools, vector< double > &vols)

double	lookupVolumeFromMesh (const Eref &e)

Variables
const double	CONC_UNIT_CONV

Function Documentation

double convertConcToNumRateInTwoCompts	(	double	v1,
		unsigned int	n1,
		double	v2,
		unsigned int	n2,
		double	scale
	)

Generates conversion factor for rates from concentration to mol# units. This variant is used when the reactants are in different compartments or mesh entries, and may therefore have different volumes. We already know the reactants and their affiliations. We use the first vol, v1, as the reference. The outcome of this calculation is: kf = Kf * convertConcToNumRate. The scale term is a conversion from the conc units to SI: The scale term is 1 if conc units are in SI, which is equal to moles per cubic metre, which is equal to millimolar. The scale term is 1e-3 for micromolar, uM.

Generates conversion factor for rates from concentration to mol# units. This variant is used when the reactants are in different compartments or mesh entries, and may therefore have different volumes. We already know the reactants and their affiliations.

Definition at line 187 of file lookupVolumeFromMesh.cpp.

References NA.

 {
     double conversion = 1.0;
 
     for ( unsigned int i = 1; i < n1; ++i )
         conversion *= scale * NA * v1;
     for ( unsigned int i = 0; i < n2; ++i )
         conversion *= scale * NA * v2;
 
     if ( conversion <= 0 )
             conversion = 1.0;
 
     return conversion;
 }

double convertConcToNumRateUsingMesh	(	const Eref &	e,
		const SrcFinfo *	pools,
		bool	doPartialConversion
	)

Generates conversion factor for rates from concentration to mol# units. Assumes that all reactant pools (substrate and product) are within the same mesh entry and therefore have the same volume. The outcome of this calculation is: kf = Kf * convertConcToNumRate. The Eref is an Enz or Reac. The SrcFinfo is a message to the pools. The meshIndex specifies the mesh voxel to use. The scale term is a conversion from the conc units to SI: The scale term is 1 if conc units are in SI, which is equal to moles per cubic metre, which is equal to millimolar. The scale term is 1e-3 for micromolar, uM. The doPartialConversion flag tells the function that there are other substrates not in the 'pools' list, and so it should compute the conversion for all pools, not n-1. This flag defaults to 0.

Returns conversion factor to convert rates from concentration to mol# units. Handles arbitrary combinations of volumes. Assumes that the reference volume for computing rates is the smallest volume. 26 Feb 2013: This is now changed to use the volume of the first entry. Should only be used for substrates. For products need to find the first substrate, separately, and use that to scale down the conv factor. Assumes all calculations are in SI: cubic metres and millimolar. 27 Feb 2013: This is changed to use the volume of a voxel of the the home compartment of the reac. Be warned: this can cause unexpected problems if the home compartment isn't according to convention. For example, if there is a single substrate and the home compartment is elsewhere, you will get very odd Kf:kf values. 9 Oct 2013: This is now changed to use the volume of the first substrate. Note that if the conversion is for products, then the routine has to look up the substrate list to get the first substrate. Reason is that the home compartment was often wrong in ReadKkit. Unfortunately this may yet cause problems with SBML. I don't know what conventions they use for cross-compartment reactions.

Definition at line 114 of file lookupVolumeFromMesh.cpp.

References Element::cinfo(), Eref::element(), Cinfo::findFinfo(), getReactantVols(), NA, and Finfo::name().

Referenced by ZombieEnz::vGetK1(), Reac::vGetNumKb(), ZombieReac::vGetNumKb(), Reac::vGetNumKf(), ZombieReac::vGetNumKf(), Enz::vGetNumKm(), ZombieMMenz::vGetNumKm(), MMenz::vGetNumKm(), ZombieEnz::vGetNumKm(), Reac::vReinit(), MMenz::vRemesh(), Reac::vRemesh(), Enz::vSetConcK1(), Reac::vSetConcKb(), Reac::vSetConcKf(), ZombieEnz::vSetK1(), Enz::vSetK1(), Enz::vSetKm(), MMenz::vSetKm(), ZombieReac::vSetNumKb(), Reac::vSetNumKb(), ZombieReac::vSetNumKf(), Reac::vSetNumKf(), Enz::vSetNumKm(), ZombieMMenz::vSetNumKm(), MMenz::vSetNumKm(), ZombieEnz::vSetNumKm(), and Enz::vSetRatio().

 {
     vector< double > vols;
     // unsigned int smallest = getReactantVols( e, pools, vols );
     double conv = 1.0;
     getReactantVols( e, pools, vols );
     if ( vols.size() == 0 ) { // Should this be an assertion?
         // cout << "Warning: convertConcToNumRateUsingMesh: zero reactants on " << e.id().path() << endl;
         return 1.0;
     }
     for ( unsigned int i = 0; i < vols.size(); ++i ) {
         conv *= vols[i] * NA;
     }
     if ( !doPartialConversion ) {
         if ( pools->name() == "subOut" ) {
             conv /= vols[0] * NA;
         } else {
             const Finfo* f = e.element()->cinfo()->findFinfo( "subOut" );
             assert( f );
             const SrcFinfo* toSub = dynamic_cast< const SrcFinfo* >( f );
             assert( toSub );
             vector< double > subVols;
             getReactantVols( e, toSub, subVols );
             if ( subVols.size() == 0 ) // no substrates!
                 return 1.0;
             conv /= subVols[0] * NA;
         }
         /*
         Id compt = getCompt( e.id() );
         if ( compt != Id() ) {
             Id mesh( compt.value() + 1 );
             double meshVol = Field< double >::get( mesh, "volume" );
             conv /= meshVol * NA;
         }
         */
     }
     return conv;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double convertConcToNumRateUsingVol	(	const Eref &	e,
		const SrcFinfo *	pools,
		double	volume,
		double	scale,
		bool	doPartialConversion
	)

Generates conversion factor for rates from concentration to mol# units. This variant already knows the volume, but has to figure out # of reactants. The scale term is a conversion from the conc units to SI: The scale term is 1 if conc units are in SI, which is equal to moles per cubic metre, which is equal to millimolar. The scale term is 1e-3 for micromolar, uM. The doPartialConversion flag tells the function that there are other substrates not in the 'pools' list, and so it should compute the conversion for all pools, not n-1. This flag defaults to 0.

Generates conversion factor for rates from concentration to mol# units. This variant already knows the volume, but has to figure out # of reactants.

Definition at line 160 of file lookupVolumeFromMesh.cpp.

References Eref::element(), SrcFinfo::getBindIndex(), Element::getMsgAndFunc(), and NA.

 {
     const vector< MsgFuncBinding >* mfb =
         e.element()->getMsgAndFunc( pools->getBindIndex() );
     double conversion = 1.0;
     if ( mfb && mfb->size() > 0 ) {
         if ( doPartialConversion || mfb->size() > 1 ) {
             conversion = scale * NA * volume;
             double power = doPartialConversion + mfb->size() - 1;
             if ( power > 1.0 ) {
                 conversion = pow( conversion, power );
             }
         }
         if ( conversion <= 0 )
             conversion = 1.0;
     }
 
     return conversion;
 }

Here is the call graph for this function:

ObjId getCompt ( Id id )

Returns the compartment in which the specified object is located. Traverses the tree toward the rood till it finds a compartment.

Definition at line 23 of file lookupVolumeFromMesh.cpp.

References Element::cinfo(), ObjId::element(), getCompt(), ObjId::id, Cinfo::isA(), and Neutral::parent().

Referenced by ReadKkit::assignPoolCompartments(), ReadKkit::assignReacCompartments(), findMeshOfEnz(), findParentComptOfReac(), getCompt(), Stoich::installEnzyme(), Stoich::installMMenz(), Stoich::installReaction(), isOffSolverReac(), and lookupVolumeFromMesh().

 {
     ObjId pa = Neutral::parent( id.eref() ).id;
     if ( pa == ObjId() )
         return pa;
     else if ( pa.element()->cinfo()->isA( "ChemCompt" ) )
         return pa;
     return getCompt( pa );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned int getReactantVols	(	const Eref &	reac,
		const SrcFinfo *	pools,
		vector< double > &	vols
	)

Utility function to get volumes for all reactants (substrates or products) of Reacs or Enzymes. Does NOT get volumes for the Enzyme itself.

Figures out all the volumes of the substrates or products on the specified reaction 'reac'. The SrcFinfo is for the sub or prd msg. Returns the index of the smallest vol. Passes back a vector of volumes. The meshIndex is zero. Reasoning is as follows: both in the case of well-stirred (single mesh entry) models, and in the case of spatial models with consistent mesh sizes and alignments, the mesh entry volumes are in the same ratio. Cases with more complex arrangements may also use the current vols as a starting point, but will need to add index-specific scaling factors to their reaction system.

Definition at line 58 of file lookupVolumeFromMesh.cpp.

References Element::cinfo(), Msg::e2(), Eref::element(), SrcFinfo::getBindIndex(), Msg::getMsg(), Element::getMsgAndFunc(), Cinfo::isA(), and lookupVolumeFromMesh().

Referenced by convertConcToNumRateUsingMesh().

 {
     static const unsigned int meshIndex = 0;
 
     const vector< MsgFuncBinding >* mfb =
         reac.element()->getMsgAndFunc( pools->getBindIndex() );
     unsigned int smallIndex = 0;
 
     vols.resize( 0 );
     if ( mfb ) {
         for ( unsigned int i = 0; i < mfb->size(); ++i ) {
             double v = 1;
             Element* pool = Msg::getMsg( (*mfb)[i].mid )->e2();
             if ( pool == reac.element() )
                 pool = Msg::getMsg( (*mfb)[i].mid )->e1();
             assert( pool != reac.element() );
             Eref pooler( pool, meshIndex );
             if ( pool->cinfo()->isA( "PoolBase" ) ) {
                 v = lookupVolumeFromMesh( pooler );
             } else {
                 cout << "Error: getReactantVols: pool is of unknown type\n";
                 assert( 0 );
             }
             vols.push_back( v );
             if ( v < vols[0] )
                 smallIndex = i;
         }
     }
     return smallIndex;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double lookupVolumeFromMesh ( const Eref & e )

Utility function for kinetics classes to find their volume from the attached mesh. Works for Pools and subclasses.

Utility function to find the size of a pool. We assume one-to-one match between pool indices and mesh indices: that is what they are for.

Definition at line 36 of file lookupVolumeFromMesh.cpp.

References Eref::dataIndex(), LookupField< L, A >::get(), getCompt(), and Eref::id().

Referenced by ReadKkit::buildEnz(), getReactantVols(), PoolBase::setNinit(), ZombiePool::vGetConc(), Pool::vGetConc(), ZombiePool::vGetConcInit(), ZombiePool::vGetVolume(), Pool::vGetVolume(), ZombieBufPool::vSetConc(), BufPool::vSetConc(), ZombiePool::vSetConc(), Pool::vSetConc(), ZombiePool::vSetConcInit(), and Pool::vSetConcInit().

 {
     ObjId compt = getCompt( e.id() );
     if ( compt == ObjId() )
         return 1.0;
     return LookupField< unsigned int, double >::
 			get( compt, "oneVoxelVolume", e.dataIndex() );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

const double CONC_UNIT_CONV

Used to provide the conversion factor from preferred units to SI.

Functions

Variables

Function Documentation

Variable Documentation