---

TauNetwork.cpp

Go to the documentation of this file.

// TauNetwork.cpp: implementation of the CTauNetwork class.
//

#include "TauNetwork.h"

// Construction/Destruction

CTauNetwork::CTauNetwork()
{

}

CTauNetwork::CTauNetwork(CMixedReactionNetwork *pMixedNetwork)
{
        m_pMixedNetwork = pMixedNetwork;
        // create the fake chemical, reaction, and rate constant.  Give tau the next number
        // after the last real chemical
        m_pChemTau = new Chemical(m_pMixedNetwork->GetNumberOfChemicals(),0.0,"Tau");
        m_pRxnTauReaction = new CTauReaction(m_pChemTau);
}

CTauNetwork::~CTauNetwork()
{
        delete m_pChemTau;
        delete m_pRxnTauReaction;
}

double CTauNetwork::GetTOfTau() const
{
        return m_pChemTau->GetAmount();
}

int CTauNetwork::GetNumberOfChemicals() const
{
        // add one for the Tau "chemical"
        return m_pMixedNetwork->GetNumberOfChemicals() + 1;
}

int CTauNetwork::GetNumberOfReactions() const
{
        // add one for Tau "reaction"
        return m_pMixedNetwork->GetNumberOfReactions() + 1;
}

Chemical *CTauNetwork::GetChemical(int chemicalNumber)
{
        if(chemicalNumber != m_pChemTau->GetChemicalNumber())
        {
                // chemical is a real chemical
                return m_pMixedNetwork->GetChemical(chemicalNumber);
        }
        else
        {
                // chemical is Tau
                return m_pChemTau;
        }
}

std::vector<double> *CTauNetwork::GetReactionRates()
{
        // grab a pointer to the rates in the mixed reaction network
        std::vector<double> *rxnRates = m_pMixedNetwork->GetReactionRates();
        // get the current total stochastic rate and the current tau rate (= 1/(1-tau))
        double gammaS = m_pMixedNetwork->GetTotalStochasticReactionProbability();
        double tauRate = m_pRxnTauReaction->GetRate();
        // fill up our own vector
        reactionRates.resize(0);
        for(int i = 0; i < rxnRates->size(); i++)
        {
                reactionRates.push_back(rxnRates->at(i));
                // rescale the rate accordingly
                reactionRates[i] = reactionRates[i]*(tauRate/gammaS);
        }
        // now put tau on the rate vector, rescaled by gammaS
        reactionRates.push_back(tauRate/gammaS);
        // return the composite rate vector
        return &reactionRates;
}

std::vector<Reaction *> *CTauNetwork::GetReactions()
{
        // grab a pointer to the reactions in the mixed reaction network
        std::vector<Reaction *> *mixedRxns = m_pMixedNetwork->GetReactions();
        // fill up our own vector
        reactions.resize(0);
        for(int i = 0; i < mixedRxns->size(); i++)
        {
                reactions.push_back(mixedRxns->at(i));
        }
        // now put the tau reaction on
        reactions.push_back(m_pRxnTauReaction);
        // return the composite vector
        return &reactions;
}

std::vector<Chemical *> *CTauNetwork::GetChemicals()
{
        // grab a pointer to the chemicals in the mixed reaction network
        std::vector<Chemical *> *mixedChem = m_pMixedNetwork->GetChemicals();
        // fill up our own vector
        chemicals.resize(0);
        for(int i = 0; i < mixedChem->size(); i++)
        {
                chemicals.push_back(mixedChem->at(i));
        }
        // now put the tau chemical on
        chemicals.push_back(m_pChemTau);
        // return the composite vector
        return &chemicals;
}

---