---

MixedReactionNetwork.cpp

Go to the documentation of this file.

// MixedReactionNetwork.cpp: implementation of the CMixedReactionNetwork class.
//

#include "MixedReactionNetwork.h"

// Construction/Destruction

CMixedReactionNetwork::CMixedReactionNetwork()
{

}

CMixedReactionNetwork::CMixedReactionNetwork(ReactionNetwork *pReactionNetwork, intVector stocReactionList)
{
        m_pReactionNetwork = pReactionNetwork;
        m_viStochasticList = stocReactionList;

        // make sure the stochastic reaction list is sorted - reactions
        // are indexed by number in the master list
        std::sort(m_viStochasticList.begin(),m_viStochasticList.end());

        // partition the list of reactions into noisy and non-noisy
        int listKey = 0;
        for(int i = 0; i < m_pReactionNetwork->GetNumberOfReactions(); i++)
        {
                if(i == m_viStochasticList[listKey])
                {
                        m_vpStochasticReactions.push_back(m_pReactionNetwork->GetReactions()->at(i));
                        m_dStochasticReactionRates.push_back(0.0);
                        listKey++;
                }
                else
                {
                        m_vpDeterministicReactions.push_back(m_pReactionNetwork->GetReactions()->at(i));
                        m_dDeterministicReactionRates.push_back(0.0);
                }

        }

}

CMixedReactionNetwork::~CMixedReactionNetwork()
{

}

int CMixedReactionNetwork::GetNumberOfChemicals() const
{
        return m_pReactionNetwork->GetNumberOfChemicals();
}

// returns the total number of reactions, stochastic and deterministic

int CMixedReactionNetwork::GetNumberOfReactions() const
{
        return m_pReactionNetwork->GetNumberOfReactions();
}

int CMixedReactionNetwork::GetNumberOfRateConstants() const
{
        return m_pReactionNetwork->GetNumberOfRateConstants();
}

Chemical *CMixedReactionNetwork::GetChemical(int chemicalNumber)
{
        return m_pReactionNetwork->GetChemical(chemicalNumber);
}

RateConstant *CMixedReactionNetwork::GetRateConstant(int rateConstantNumber)
{
        return m_pReactionNetwork->GetRateConstant(rateConstantNumber);
}

void CMixedReactionNetwork::ChemicalReset()
{
        for(int i = 0; i < this->GetNumberOfChemicals(); i++)
        {
                m_pReactionNetwork->GetChemical(i)->Reset();
        }
}

void CMixedReactionNetwork::RateConstantReset()
{
        for(int i = 0; i < this->GetNumberOfRateConstants(); i++)
        {
                m_pReactionNetwork->GetRateConstant(i)->Reset();
        }
}

void CMixedReactionNetwork::SetAmount(int chemicalNumber, double amount)
{
        m_pReactionNetwork->GetChemical(chemicalNumber)->SetAmount(amount);
}

vpReaction *CMixedReactionNetwork::GetReactions()
{
        return m_pReactionNetwork->GetReactions();
}

Reaction *CMixedReactionNetwork::GetReaction(int reactionNumber)
{
        return m_pReactionNetwork->GetReaction(reactionNumber);
}

vpReaction *CMixedReactionNetwork::GetStochasticReactions()
{
        return &m_vpStochasticReactions;
}

Reaction *CMixedReactionNetwork::GetStochasticReaction(int reactionNumber)
{
        return m_vpStochasticReactions[reactionNumber];
}

vpReaction *CMixedReactionNetwork::GetDeterministicReactions()
{
        return &m_vpDeterministicReactions;
}

Reaction *CMixedReactionNetwork::GetDeterministicReaction(int reactionNumber)
{
        return m_vpDeterministicReactions[reactionNumber];
}

vpChemical *CMixedReactionNetwork::GetChemicals()
{
        return m_pReactionNetwork->GetChemicals();
}

vpRateConstant *CMixedReactionNetwork::GetRateConstants()
{
        return m_pReactionNetwork->GetRateConstants();
}

int CMixedReactionNetwork::GetNumberOfStochasticReactions() const
{
        return m_vpStochasticReactions.size();
}

int CMixedReactionNetwork::GetNumberOfDeterministicReactions() const
{
        return m_vpDeterministicReactions.size();
}

dblVector *CMixedReactionNetwork::GetReactionRates()
{
        // ensure synchrony with the bulk reactions vector 
        if(reactionRates.size() != m_pReactionNetwork->GetNumberOfReactions())
        {
                // clear out the old vector
                reactionRates.erase(reactionRates.begin(),reactionRates.end());
                // fill the vector with the appropriate rates
                for(int i = 0; i < m_pReactionNetwork->GetNumberOfReactions(); i++)
                {
                        double rate = m_pReactionNetwork->GetReaction(i)->GetRate();
                        reactionRates.push_back(rate);
                }
        }
        else
        {
                for(int i = 0; i < m_pReactionNetwork->GetNumberOfReactions(); i++)
                {
                        double rate = m_pReactionNetwork->GetReaction(i)->GetRate();
                        reactionRates[i] = rate;
                }
        }
        
        // now set rates for stochastic reactions to zero
        for(int i = 0; i < m_viStochasticList.size(); i++)
        {
                reactionRates[m_viStochasticList[i]] = 0.0;
        }
        
        // return the vector of rates
        return &reactionRates;
}

dblVector *CMixedReactionNetwork::GetStochasticReactionRates()
{
        for(int i = 0; i < this->GetNumberOfStochasticReactions(); i++)
        {
                m_dStochasticReactionRates[i] = m_vpStochasticReactions[i]->GetRate();
        }
        
        // return the vector
        return &m_dStochasticReactionRates;
}

dblVector *CMixedReactionNetwork::GetDeterministicReactionRates()
{
        for(int i = 0; i < this->GetNumberOfDeterministicReactions(); i++)
        {
                m_dDeterministicReactionRates[i] = m_vpDeterministicReactions[i]->GetRate();
        }
        
        // return the vector
        return &m_dDeterministicReactionRates;
}

double CMixedReactionNetwork::GetTotalStochasticReactionProbability()
{
        double totalP = 0.0;

        for(int i = 0; i < this->GetNumberOfStochasticReactions(); i++)
        {
                totalP += this->GetStochasticReaction(i)->GetRate();
        }

        return totalP;
}

---