---

ForcingData.cpp

Go to the documentation of this file.

// ForcingData.cpp: implementation of the CForcingData class.
//

#include "ForcingData.h"

// Construction/Destruction

CForcingData::CForcingData()
{

}

CForcingData::~CForcingData()
{
        for(int i = 0; i < m_vpForcingVector.size(); i++)
        {
                delete m_vpForcingVector[i];
        }
}

// Forcing data is read in from a file, with the format
//              time            Chemical Name           value           
// Data does not have to be ordered in any way; entries
// in the above format should be input with no separating whitespace
// ForcingData is very similar to ChemicalTimeSeriesData, except with 
// less functionality since it doesn't need to do as many things.


void CForcingData::AttachNewForcingData(ReactionNetwork *reactionNetwork, std::string fileName)
{
        int whereAmI;
        int nChem = reactionNetwork->GetNumberOfChemicals();

        // used for reading in the data
        char lineBuf[1000];
        double time;
        double value;
        char name[100];

        // open the file for reading
        ifstream dataFile(fileName.c_str());
        assert(dataFile);
        
        // put the force data line by line into the linebuffer and then parse it
        while(dataFile.getline(lineBuf,sizeof(lineBuf)))
        {
                // '%' is a comment character
                if(lineBuf[0] == '%') {continue;}
                std::istringstream dataStream(lineBuf);
                dataStream >> time >> name >> value;
                
                // find the number the network has assigned to this chemical
                std::string nameString(name);
                for(whereAmI = 0; whereAmI < nChem; whereAmI++)
                {       
                        bool isEqual = ( nameString == (reactionNetwork->GetChemical(whereAmI)->GetName()) );
                        if(isEqual) {break;}    
                }
                // create a force point and put it on the vector
                m_vpForcingVector.push_back(new CForceVectorPoint(time,value,whereAmI));
        }
        // sort the vector
        SortForcingVector();
                
        return;
}

void CForcingData::SortForcingVector()
{
        // use STL sort with the correct comparator
        CForceVectorPoint::CForceVectorPointComparator comparator;
        std::sort(m_vpForcingVector.begin(),m_vpForcingVector.end(),comparator);
}

// GetNextForcingTime(t) returns the next time after t at which there
// is a forcing point recorded. 

double CForcingData::GetNextForcingTime(double time)
{
        // STL algorithm
        // define an iterator for the timeVector
        std::vector<CForceVectorPoint *>::iterator it;
        // the comparator is defined in terms of CForceVectorPoint *, so
        // that's the value we need (it's a dummy in terms of everything
        // except time)
        CForceVectorPoint *fp = new CForceVectorPoint(time,0.0,0);
        // comparator
        CForceVectorPoint::CForceVectorPointComparator comparator;
        // get the iterator
        it = std::lower_bound(m_vpForcingVector.begin(),m_vpForcingVector.end(),fp,comparator); 
        // iterator points to a data point; if it's at the end the comparison
        // time is off-the-end of the vector
        if( it != m_vpForcingVector.end() )
        {
                return (*it)->GetTime();
        }
        else
        {
                // throwing an exception is just temporary
                throw std::runtime_error("There are no more forcings recorded.");
        }
        
        // cleanup
        delete fp;
        //delete it; commented out for linux
}

// The function GetLatestForcingTime() gets the time at which the last
// forcing point is recorded.  This function assumes the vector of 
// forcings is already sorted according to time.

double CForcingData::GetLatestForcingTime()
{
        double latestTime = (m_vpForcingVector[m_vpForcingVector.size() - 1])->GetTime();
        return latestTime;
}

---