#include <CopasiPlot.h>

Inheritance diagram for CopasiPlot:

Collaboration diagram for CopasiPlot:

Public Slots
virtual void	replot ()

Signals
void	replotSignal ()

Public Member Functions
virtual bool	compile (std::vector< CCopasiContainer * > listOfContainer, const CCopasiDataModel *pDataModel)

	CopasiPlot (const CPlotSpecification plotspec, QWidget parent=NULL)

virtual void	finish ()

bool	initFromSpec (const CPlotSpecification *plotspec)

virtual void	output (const Activity &activity)

bool	saveData (const std::string &filename)

virtual void	separate (const Activity &activity)

void	setCurvesVisibility (const bool &visibility)

virtual	~CopasiPlot ()

Public Member Functions inherited from COutputInterface
virtual void	close ()

	COutputInterface ()

	COutputInterface (const COutputInterface &src)

virtual const std::set< const CCopasiObject * > &	getObjects () const

virtual void	output (const Activity &)

virtual void	separate (const Activity &)

virtual	~COutputInterface ()

Public Attributes
QwtPlotZoomer *	mpZoomer

Protected Attributes
bool	mReplotFinished

Protected Attributes inherited from COutputInterface
std::set< const CCopasiObject * >	mObjects

Private Slots
void	showCurve (QwtPlotItem *item, bool on)

Private Member Functions
void	clearBuffers ()

	CopasiPlot (QWidget *parent=NULL)

void	resizeCurveData (const size_t &activity)

void	setAxisUnits (const C_INT32 &index, const CCopasiObject *pObject)

void	updateCurves (const size_t &activity)

void	updatePlot ()

Private Attributes
std::map< std::string, C2DPlotCurve * >	mCurveMap

CVector< C2DPlotCurve * >	mCurves

std::vector< std::vector < CVector< double > * > >	mData

size_t	mDataAfter

size_t	mDataBefore

size_t	mDataDuring

std::vector< std::vector < std::pair< Activity, size_t > > >	mDataIndex

std::vector< size_t >	mDataSize

bool	mHaveAfter

bool	mHaveBefore

bool	mHaveDuring

bool	mIgnoreUpdate

QMutex	mMutex

CCopasiTimeVariable	mNextPlotTime

std::map< Activity, std::map < const CCopasiObject *, size_t > >	mObjectIndex

std::vector< std::vector< bool > >	mObjectInteger

std::vector< std::vector < const C_FLOAT64 * > >	mObjectValues

const CPlotSpecification *	mpPlotSpecification

std::vector< std::vector < const CCopasiObject * > >	mSaveCurveObjects

std::vector< const CCopasiObject * >	mSaveHistogramObjects

Static Private Attributes
static C_FLOAT64	MissingValue = std::numeric_limits<C_FLOAT64>::quiet_NaN()

Additional Inherited Members
Public Types inherited from COutputInterface
enum	Activity { BEFORE = 0x01, DURING = 0x02, AFTER = 0x04 }

Detailed Description

Definition at line 221 of file CopasiPlot.h.

Constructor & Destructor Documentation

CopasiPlot::CopasiPlot ( QWidget * parent = NULL )

private

Default constructor which may never be called.

Parameters

QWidget* parent (default: NULL)

Definition at line 762 of file CopasiPlot.cpp.

                                      :
   QwtPlot(parent),
   mCurves(0),
   mCurveMap(),
   mDataBefore(0),
   mDataDuring(0),
   mDataAfter(0),
   mHaveBefore(false),
   mHaveDuring(false),
   mHaveAfter(false),
   mpPlotSpecification(NULL),
   mNextPlotTime(),
   mIgnoreUpdate(false),
   mpZoomer(NULL),
   mReplotFinished(false)
 {}

CopasiPlot::CopasiPlot	(	const CPlotSpecification *	plotspec,
		QWidget *	parent = `NULL`
	)

Specific constructor

Parameters

const	CPlotSpecification* plotspec
QWidget*	parent (default: NULL)

Definition at line 779 of file CopasiPlot.cpp.

References ActivitySize, initFromSpec(), mData, mDataIndex, mDataSize, mObjectInteger, mObjectValues, mpZoomer, replot(), replotSignal(), and showCurve().

                                                                          :
   QwtPlot(parent),
   mCurves(0),
   mCurveMap(),
   mDataBefore(0),
   mDataDuring(0),
   mDataAfter(0),
   mHaveBefore(false),
   mHaveDuring(false),
   mHaveAfter(false),
   mpPlotSpecification(NULL),
   mNextPlotTime(),
   mIgnoreUpdate(false),
   mpZoomer(NULL),
   mReplotFinished(false)
 {
   QwtLegend *legend = new QwtLegend;
   legend->setItemMode(QwtLegend::CheckableItem);
 
   // whole legend can not be displayed at bottom on DARWIN
   // maybe a Qwt bug ?!?
 #ifdef Darwin
   insertLegend(legend, QwtPlot::TopLegend);
 #else
   insertLegend(legend, QwtPlot::BottomLegend);
 #endif
 
   // Set up the zoom facility
   mpZoomer = new ScrollZoomer(canvas());
   mpZoomer->setRubberBandPen(QColor(Qt::black));
   mpZoomer->setTrackerPen(QColor(Qt::black));
   mpZoomer->setTrackerMode(QwtPicker::AlwaysOn);
   mpZoomer->setTrackerFont(this->font());
 
   // white background better for printing...
   setCanvasBackground(Qt::white);
 
   //  setTitle(FROM_UTF8(plotspec->getTitle()));
   setCanvasLineWidth(0);
 
   canvas()->setPaintAttribute(QwtPlotCanvas::PaintPacked, true);
 
   connect(this, SIGNAL(legendChecked(QwtPlotItem *, bool)),
           SLOT(showCurve(QwtPlotItem *, bool)));
 
   // Size the vectors to be able to store information for all activities.
   mData.resize(ActivitySize);
   mObjectValues.resize(ActivitySize);
   mObjectInteger.resize(ActivitySize);
   mDataSize.resize(ActivitySize);
   mDataIndex.clear();
 
   // Initialize from the plot specification
   initFromSpec(plotspec);
   connect(this, SIGNAL(replotSignal()), this, SLOT(replot()));
 }

CopasiPlot::~CopasiPlot ( )

virtual

Destructor

Definition at line 1388 of file CopasiPlot.cpp.

References clearBuffers().

 {
   clearBuffers();
 }

Member Function Documentation

void CopasiPlot::clearBuffers ( )

private

Clear all allocate buffers and set reset values

Definition at line 1675 of file CopasiPlot.cpp.

References ActivitySize, mData, mDataAfter, mDataBefore, mDataDuring, mDataIndex, mDataSize, mHaveAfter, mHaveBefore, mHaveDuring, mObjectIndex, mObjectInteger, COutputInterface::mObjects, mObjectValues, mSaveCurveObjects, and mSaveHistogramObjects.

Referenced by compile(), and ~CopasiPlot().

 {
   mObjects.clear();
 
   size_t Activity;
   size_t i, imax;
 
   for (Activity = 0; Activity < ActivitySize; Activity++)
     {
       std::vector< CVector< double > * > & data = mData[Activity];
 
       // Delete each QMemArray
       for (i = 0, imax = data.size(); i < imax; i++)
         if (data[i] != NULL) delete data[i];
 
       data.clear();
 
       mObjectValues[Activity].clear();
       mObjectInteger[Activity].clear();
       mDataSize[Activity] = 0;
     }
 
   mDataIndex.clear();
   mObjectIndex.clear();
 
   mSaveCurveObjects.clear();
   mSaveHistogramObjects.clear();
 
   mDataBefore = 0;
   mDataDuring = 0;
   mDataAfter = 0;
 
   mHaveBefore = false;
   mHaveDuring = false;
   mHaveAfter = false;
 }

bool CopasiPlot::compile	(	std::vector< CCopasiContainer * >	listOfContainer,
		const CCopasiDataModel *	pDataModel
	)

virtual

compile the object list from name vector

Parameters

std::vector<	CCopasiContainer * > listOfContainer
const	CCopasiDataModel* pDataModel

Returns: bool success

Reimplemented from COutputInterface.

Definition at line 1035 of file CopasiPlot.cpp.

References ActivitySize, COutputInterface::AFTER, CVectorCore< CType >::array(), CPlotItem::bandedGraph, COutputInterface::BEFORE, C_FLOAT64, clearBuffers(), CPlotItem::curve2d, COutputInterface::DURING, fatalError, CPlotItem::getActivity(), CPlotItem::getChannels(), CCopasiTimeVariable::getCurrentWallTime(), CPlotSpecification::getItems(), CPlotItem::getNumChannels(), CPlotItem::getType(), CCopasiObject::getValuePointer(), CPlotItem::histoItem1d, CCopasiObject::isValueDbl(), CCopasiObject::isValueInt(), MCCopasiTask, mCurves, mData, mDataIndex, mHaveAfter, mHaveBefore, mHaveDuring, MissingValue, mNextPlotTime, mObjectIndex, mObjectInteger, COutputInterface::mObjects, mObjectValues, mpPlotSpecification, mReplotFinished, mSaveCurveObjects, mSaveHistogramObjects, CCopasiDataModel::ObjectFromName(), setAxisUnits(), CVectorCore< CType >::size(), CCopasiVector< T >::size(), and CCopasiMessage::WARNING.

Referenced by PlotWindow::compile().

 {
   clearBuffers();
 
   size_t i, imax;
   size_t j, jmax;
 
   std::pair< std::set< const CCopasiObject * >::iterator, bool > Inserted;
   std::pair< Activity, size_t > DataIndex;
   std::vector< std::set < const CCopasiObject * > > ActivityObjects;
 
   ActivityObjects.resize(ActivitySize);
 
   // Loop over all curves.
   imax = mpPlotSpecification->getItems().size();
   mDataIndex.resize(imax);
 
   std::vector< std::vector < const CCopasiObject * > >::iterator itX;
   assert(pDataModel != NULL);
 
   for (i = 0; i < imax; ++i)
     {
       CPlotItem * pItem = mpPlotSpecification->getItems()[i];
       Activity ItemActivity = pItem->getActivity();
       DataIndex.first = ItemActivity;
 
       // Loop over all channels
       jmax = pItem->getNumChannels();
       mDataIndex[i].resize(jmax);
 
       for (j = 0; j < jmax; ++j)
         {
           const CCopasiObject* pObj =
             pDataModel->ObjectFromName(listOfContainer, pItem->getChannels()[j]);
 
           if (pObj)
             mObjects.insert(pObj);
           else
             CCopasiMessage(CCopasiMessage::WARNING, MCCopasiTask + 6,
                            pItem->getChannels()[j].c_str());
 
           // Remember the actual order for saving the data.
           // Note, we are currently only dealing with 2D curves and histograms.
           // In addition the data is not normalized. The same data column may appear
           // multiple times, e.g. as X value and as Y value for another curve.
           if (j == 0)
             {
               // We have an X value
               for (itX = mSaveCurveObjects.begin(); itX != mSaveCurveObjects.end(); ++itX)
                 if (*itX->begin() == pObj) break;
 
               if (itX == mSaveCurveObjects.end())
                 {
                   std::vector < const CCopasiObject * > NewX;
                   NewX.push_back(pObj);
 
                   mSaveCurveObjects.push_back(NewX);
                   itX = mSaveCurveObjects.end() - 1;
 
                   setAxisUnits(xBottom, pObj);
                 }
 
               if (pItem->getType() == CPlotItem::histoItem1d)
                 mSaveHistogramObjects.push_back(pObj);
             }
           else
             {
               itX->push_back(pObj);
               setAxisUnits(yLeft, pObj);
             }
 
           Inserted = ActivityObjects[ItemActivity].insert(pObj);
 
           if (Inserted.second)
             {
               if (ItemActivity & COutputInterface::BEFORE) mHaveBefore = true;
 
               if (ItemActivity & COutputInterface::DURING) mHaveDuring = true;
 
               if (ItemActivity & COutputInterface::AFTER) mHaveAfter = true;
 
               // The insert was successful
               DataIndex.second = ActivityObjects[ItemActivity].size() - 1;
 
               // Allocate the data buffer
               mData[ItemActivity].push_back(new CVector<double>(1000));
 
               // Store the pointer to the current object value. (Only if it has a double or integer value
               // and the value pointer actually exists. If not, use a dummy value.)
               void * tmp;
 
               if ((pObj && (pObj->isValueInt() || pObj->isValueDbl())) && (tmp = pObj->getValuePointer()))
                 {
                   mObjectValues[ItemActivity].push_back((C_FLOAT64 *) tmp); //pObj->getValuePointer());
                   mObjectInteger[ItemActivity].push_back(pObj->isValueInt());
                 }
               else
                 {
                   mObjectValues[ItemActivity].push_back(&MissingValue);
                   mObjectInteger[ItemActivity].push_back(false);
                 }
 
               // Store [curve][channel] to data index
               mDataIndex[i][j] = DataIndex;
 
               // Store the [Activity][object] to data index.
               mObjectIndex[ItemActivity][pObj] = DataIndex.second;
             }
           else
             {
               // The object already existed we only need to
               // store [curve][channel] to data index.
               DataIndex.second = mObjectIndex[ItemActivity][pObj];
               mDataIndex[i][j] = DataIndex;
             }
         }
     }
 
   // We need to set the curve data here!
   size_t k = 0;
   C2DPlotCurve ** itCurves = mCurves.array();
   C2DPlotCurve ** endCurves = itCurves + mCurves.size();
 
   for (; itCurves != endCurves; ++itCurves, ++k)
     {
       std::vector< CVector< double > * > & data = mData[(*itCurves)->getActivity()];
 
       switch ((*itCurves)->getType())
         {
           case CPlotItem::curve2d:
             (*itCurves)->setData(C2DCurveData(*data[mDataIndex[k][0].second],
                                               *data[mDataIndex[k][1].second],
                                               0));
             break;
 
           case CPlotItem::bandedGraph:
             (*itCurves)->setData(CBandedGraphData(*data[mDataIndex[k][0].second],
                                                   *data[mDataIndex[k][1].second],
                                                   *data[mDataIndex[k][2].second],
                                                   0));
             break;
 
           case CPlotItem::histoItem1d:
             (*itCurves)->setData(CHistoCurveData(*data[mDataIndex[k][0].second],
                                                  0,
                                                  mCurves[k]->getIncrement()));
 
             break;
 
           default:
             fatalError();
             break;
         }
     }
 
   mNextPlotTime = CCopasiTimeVariable::getCurrentWallTime();
   mReplotFinished = true;
 
   return true;
 }

void CopasiPlot::finish ( )

virtual

Finish the output

Reimplemented from COutputInterface.

Definition at line 1270 of file CopasiPlot.cpp.

References mNextPlotTime, mpZoomer, and replot().

Referenced by PlotWindow::finish().

 {
   // We need to force a replot, i.e., the next mNextPlotTime should be in the past.
   mNextPlotTime = 0;
   replot();
 
   if (mpZoomer)
     {
       mpZoomer->setEnabled(true);
       mpZoomer->setZoomBase();
     }
 }

bool CopasiPlot::initFromSpec ( const CPlotSpecification * plotspec )

Initialize the the plot from the specification

Parameters

const CPlotSpecification* plotspec

Definition at line 836 of file CopasiPlot.cpp.

References CVectorCore< CType >::array(), CPlotItem::bandedGraph, CCopasiVector< T >::begin(), C_FLOAT64, C_INT32, CPlotItem::curve2d, CCopasiVector< T >::end(), FROM_UTF8, CQPlotColors::getColor(), CPlotSpecification::getItems(), CPlotItem::getTitle(), C2DPlotCurve::getType(), CPlotItem::histoItem1d, CPlotSpecification::isLogX(), CPlotSpecification::isLogY(), mCurveMap, mCurves, mIgnoreUpdate, mMutex, mpPlotSpecification, mpZoomer, pdelete, CVector< CType >::resize(), C2DPlotCurve::setIncrement(), showCurve(), and CCopasiVector< T >::size().

Referenced by CopasiPlot(), and PlotWindow::initFromSpec().

 {
   mIgnoreUpdate = true;
   mpPlotSpecification = plotspec;
 
   if (mpZoomer) mpZoomer->setEnabled(false);
 
   // size_t k, kmax = mpPlotSpecification->getItems().size();
 
   setTitle(FROM_UTF8(mpPlotSpecification->getTitle()));
 
   mCurves.resize(mpPlotSpecification->getItems().size());
   mCurves = NULL;
 
   std::map< std::string, C2DPlotCurve * >::iterator found;
 
   CCopasiVector< CPlotItem >::const_iterator itPlotItem = mpPlotSpecification->getItems().begin();
   CCopasiVector< CPlotItem >::const_iterator endPlotItem = mpPlotSpecification->getItems().end();
 
   CVector< bool > Visible(mpPlotSpecification->getItems().size());
   Visible = true;
   bool * pVisible = Visible.array();
 
   for (; itPlotItem != endPlotItem; ++itPlotItem, ++pVisible)
     {
       // Qwt does not like it to reuse the curve as this may lead to access
       // violation. We therefore delete the curves but remember their visibility.
       if ((found = mCurveMap.find((*itPlotItem)->CCopasiParameter::getKey())) != mCurveMap.end())
         {
           *pVisible = found->second->isVisible();
         }
     }
 
   // Remove unused curves if definition has changed
   std::map< std::string, C2DPlotCurve * >::iterator it = mCurveMap.begin();
   std::map< std::string, C2DPlotCurve * >::iterator end = mCurveMap.end();
 
   for (; it != end; ++it)
     pdelete(it->second);
 
   mCurveMap.clear();
 
   itPlotItem = mpPlotSpecification->getItems().begin();
   pVisible = Visible.array();
   C2DPlotCurve ** ppCurve = mCurves.array();
   unsigned long int k = 0;
   bool needLeft = false;
   bool needRight = false;
 
   for (; itPlotItem != endPlotItem; ++itPlotItem, ++pVisible, ++ppCurve, ++k)
     {
       // set up the curve
       C2DPlotCurve * pCurve = new C2DPlotCurve(&mMutex,
           (*itPlotItem)->getType(),
           (*itPlotItem)->getActivity(),
           FROM_UTF8((*itPlotItem)->getTitle()));
       *ppCurve = pCurve;
 
       mCurveMap[(*itPlotItem)->CCopasiParameter::getKey()] = pCurve;
 
       //color handling should be similar for different curve types
       QColor color;
 
       if (pCurve->getType() == CPlotItem::curve2d
           || pCurve->getType() == CPlotItem::histoItem1d
           || pCurve->getType() == CPlotItem::bandedGraph)
         {
           std::string colorstr = *(*itPlotItem)->getValue("Color").pSTRING;
           color = CQPlotColors::getColor(colorstr, k);
         }
 
       pCurve->setPen(color);
       pCurve->attach(this);
 
       showCurve(pCurve, *pVisible);
 
       if (pCurve->getType() == CPlotItem::curve2d
           || pCurve->getType() == CPlotItem::bandedGraph)
         {
           needLeft = true;
           pCurve->setRenderHint(QwtPlotItem::RenderAntialiased);
 
           unsigned C_INT32 linetype = *(*itPlotItem)->getValue("Line type").pUINT;
 
           if (linetype == 0      //line
               || linetype == 3)  //line+symbols
             {
               pCurve->setStyle(QwtPlotCurve::Lines);
               unsigned C_INT32 linesubtype = *(*itPlotItem)->getValue("Line subtype").pUINT;
               C_FLOAT64 width = *(*itPlotItem)->getValue("Line width").pUDOUBLE;
 
               switch (linesubtype) //symbol type
                 {
                   case 1:
                     pCurve->setPen(QPen(QBrush(color), width, Qt::DotLine, Qt::FlatCap));
                     break;
 
                   case 2:
                     pCurve->setPen(QPen(QBrush(color), width, Qt::DashLine));
                     break;
 
                   case 3:
                     pCurve->setPen(QPen(QBrush(color), width, Qt::DashDotLine));
                     break;
 
                   case 4:
                     pCurve->setPen(QPen(QBrush(color), width, Qt::DashDotDotLine));
                     break;
 
                   case 0:
                   default:
                     pCurve->setPen(QPen(QBrush(color), width, Qt::SolidLine));
                     break;
                 }
             }
 
           if (linetype == 1) //points
             {
               C_FLOAT64 width = *(*itPlotItem)->getValue("Line width").pUDOUBLE;
               pCurve->setPen(QPen(color, width, Qt::SolidLine, Qt::RoundCap));
               pCurve->setStyle(QwtPlotCurve::Dots);
             }
 
           if (linetype == 2) //only symbols
             {
               pCurve->setStyle(QwtPlotCurve::NoCurve);
             }
 
           if (linetype == 2      //symbols
               || linetype == 3)  //line+symbols
             {
               unsigned C_INT32 symbolsubtype = *(*itPlotItem)->getValue("Symbol subtype").pUINT;
 
               switch (symbolsubtype) //symbol type
                 {
                   case 1:
                     pCurve->setSymbol(QwtSymbol(QwtSymbol::Cross, QBrush(), QPen(QBrush(color), 2), QSize(7, 7)));
                     break;
 
                   case 2:
                     pCurve->setSymbol(QwtSymbol(QwtSymbol::Ellipse, QBrush(), QPen(QBrush(color), 1), QSize(8, 8)));
                     break;
 
                   case 0:
                   default:
                     pCurve->setSymbol(QwtSymbol(QwtSymbol::Cross, QBrush(color), QPen(QBrush(color), 1), QSize(5, 5)));
                     break;
                 }
             }
         } //2d curves and banded graphs
 
       if (pCurve->getType() == CPlotItem::bandedGraph)
         {
           //set fill color
           QColor c = color;
           c.setAlpha(64);
           pCurve->setBrush(c);
         }
 
       if (pCurve->getType() == CPlotItem::histoItem1d)
         {
           pCurve->setIncrement(*(*itPlotItem)->getValue("increment").pDOUBLE);
 
           pCurve->setStyle(QwtPlotCurve::Steps);
           pCurve->setYAxis(QwtPlot::yRight);
           pCurve->setCurveAttribute(QwtPlotCurve::Inverted);
 
           needRight = true;
         }
     }
 
   if (plotspec->isLogX())
     setAxisScaleEngine(xBottom, new QwtLog10ScaleEngine());
   else
     setAxisScaleEngine(xBottom, new QwtLinearScaleEngine());
 
   setAxisAutoScale(xBottom);
 
   if (plotspec->isLogY())
     setAxisScaleEngine(yLeft, new QwtLog10ScaleEngine());
   else
     setAxisScaleEngine(yLeft, new QwtLinearScaleEngine());
 
   setAxisAutoScale(yLeft);
 
   enableAxis(yLeft, needLeft);
 
   if (needRight)
     {
       setAxisScaleEngine(yRight, new QwtLinearScaleEngine());
       setAxisTitle(yRight, "Percent %");
       enableAxis(yRight);
     }
 
   mIgnoreUpdate = false;
 
   return true; //TODO really check!
 }

void CopasiPlot::output ( const Activity & activity )

virtual

Perform an output event for the current activity

Parameters

const Activity & activity

Definition at line 1197 of file CopasiPlot.cpp.

References ActivitySize, COutputInterface::AFTER, COutputInterface::BEFORE, C_INT32, COutputInterface::DURING, mData, mDataAfter, mDataBefore, mDataDuring, mDataSize, mHaveAfter, mHaveBefore, mHaveDuring, mObjectInteger, mObjectValues, resizeCurveData(), and updatePlot().

Referenced by PlotWindow::output().

 {
   size_t i, imax;
   C_INT32 ItemActivity;
 
   if (mHaveBefore && (activity == COutputInterface::BEFORE)) mDataBefore++;
   else if (mHaveDuring && (activity == COutputInterface::DURING)) mDataDuring++;
   else if (mHaveAfter && (activity == COutputInterface::AFTER)) mDataAfter++;
 
   for (ItemActivity = 0; ItemActivity < ActivitySize; ItemActivity++)
     if ((ItemActivity & activity) && mData[ItemActivity].size())
       {
         std::vector< CVector< double > * > & data = mData[ItemActivity];
         size_t & ndata = mDataSize[ItemActivity];
 
         if ((imax = data.size()) != 0)
           {
             if (ndata >= data[0]->size())
               {
                 resizeCurveData(ItemActivity);
               }
 
             //the data that needs to be stored internally:
             for (i = 0; i < imax; ++i)
               if (mObjectInteger[ItemActivity][i])
                 (*data[i])[ndata] = *(C_INT32 *)mObjectValues[ItemActivity][i];
               else
                 (*data[i])[ndata] = *mObjectValues[ItemActivity][i];
 
             ++ndata;
           }
       }
 
   updatePlot();
 }

void CopasiPlot::replot ( )

virtualslot

Definition at line 1726 of file CopasiPlot.cpp.

References C_INVALID_INDEX, CCopasiTimeVariable::getCurrentWallTime(), CCopasiTimeVariable::getMicroSeconds(), mMutex, mNextPlotTime, mReplotFinished, and updateCurves().

Referenced by CopasiPlot(), finish(), setCurvesVisibility(), showCurve(), PlotWindow::toggleLogX(), and PlotWindow::toggleLogY().

 {
   if (mNextPlotTime < CCopasiTimeVariable::getCurrentWallTime())
     {
       CCopasiTimeVariable Delta = CCopasiTimeVariable::getCurrentWallTime();
 
       {
         QMutexLocker Locker(&mMutex);
         updateCurves(C_INVALID_INDEX);
       }
 
       QwtPlot::replot();
 
       Delta = CCopasiTimeVariable::getCurrentWallTime() - Delta;
       mNextPlotTime = CCopasiTimeVariable::getCurrentWallTime() + 3 * Delta.getMicroSeconds();
     }
 
   mReplotFinished = true;
 }

void CopasiPlot::replotSignal ( )

signal

Referenced by CopasiPlot(), and updatePlot().

void CopasiPlot::resizeCurveData ( const size_t & activity )

private

Resize the curve data

Definition at line 1306 of file CopasiPlot.cpp.

References CVectorCore< CType >::array(), CPlotItem::bandedGraph, CPlotItem::curve2d, fatalError, CPlotItem::histoItem1d, mCurves, mData, mDataIndex, pdelete, and CVectorCore< CType >::size().

Referenced by output(), and separate().

 {
   std::vector< CVector< double > * > & data = mData[activity];
   std::vector< CVector< double > * >::iterator it = data.begin();
 
   std::vector< CVector< double > * > OldData = data;
   std::vector< CVector< double > * >::iterator itOld = OldData.begin();
   std::vector< CVector< double > * >::iterator endOld = OldData.end();
 
   size_t oldSize = (*it)->size();
   size_t newSize = 2 * (*it)->size();
 
   // We must not deallocate the old data since this will create a window of time
   // were the GUI thread may access the old location before it is notified.
   for (; itOld != endOld; ++itOld, ++it)
     {
       *it = new CVector< double >(newSize);
       memcpy((*it)->array(), (*itOld)->array(), oldSize * sizeof(double));
     }
 
   // Tell the curves that the location of the data has changed
   // otherwise repaint events could crash
   size_t k = 0;
   C2DPlotCurve ** itCurves = mCurves.array();
   C2DPlotCurve ** endCurves = itCurves + mCurves.size();
 
   for (; itCurves != endCurves; ++itCurves, ++k)
     {
       if ((size_t)(*itCurves)->getActivity() == activity)
         {
           std::vector< CVector< double > * > & data = mData[activity];
 
           switch ((*itCurves)->getType())
             {
               case CPlotItem::curve2d:
                 (*itCurves)->reallocatedData(data[mDataIndex[k][0].second],
                                              data[mDataIndex[k][1].second]);
                 break;
 
               case CPlotItem::bandedGraph:
                 (*itCurves)->reallocatedData(data[mDataIndex[k][0].second],
                                              data[mDataIndex[k][1].second],
                                              data[mDataIndex[k][2].second]);
                 break;
 
               case CPlotItem::histoItem1d:
                 (*itCurves)->reallocatedData(data[mDataIndex[k][0].second],
                                              NULL);
                 break;
 
               default:
                 fatalError();
                 break;
             }
         }
     }
 
   // It is now save to delete the old data since the GUI thread has been notified.
   for (itOld = OldData.begin(); itOld != endOld; ++itOld)
     {
       pdelete(*itOld);
     }
 }

bool CopasiPlot::saveData ( const std::string & filename )

Save tab delimited data to file

Parameters

const std::string & filename

Returns: bool success

Definition at line 1393 of file CopasiPlot.cpp.

References ActivitySize, COutputInterface::AFTER, CVectorCore< CType >::array(), COutputInterface::BEFORE, C_INT32, COutputInterface::DURING, CLocaleString::fromUtf8(), CPlotItem::histoItem1d, mCurves, mData, mDataAfter, mDataBefore, mDataDuring, mDataSize, MissingValue, mObjectIndex, COutputInterface::mObjects, mSaveCurveObjects, mSaveHistogramObjects, CVectorCore< CType >::size(), CHistoCurveData::size(), CHistoCurveData::x(), and CHistoCurveData::y().

Referenced by PlotWindow::slotSaveData().

 {
   // No objects.
   if (!mObjects.size()) return true;
 
   // Find out whether we have any data.
   C_INT32 ItemActivity;
 
   for (ItemActivity = 0; ItemActivity < ActivitySize; ItemActivity++)
     if (mDataSize[ItemActivity] != 0) break;
 
   // No data
   if (ItemActivity == ActivitySize) return true;
 
   std::ofstream fs(CLocaleString::fromUtf8(filename).c_str());
 
   if (!fs.good()) return false;
 
   // Write the table header
   fs << "# ";
 
   std::vector< std::vector < const CCopasiObject * > >::const_iterator itX;
   std::vector< std::vector < const CCopasiObject * > >::const_iterator endX =
     mSaveCurveObjects.end();
 
   std::vector < const CCopasiObject * >::const_iterator it;
   std::vector < const CCopasiObject * >::const_iterator end;
 
   for (itX = mSaveCurveObjects.begin(); itX != endX; ++itX)
     for (it = itX->begin(), end = itX->end(); it != end; ++it)
       if (*it != NULL)
         fs << (*it)->getObjectDisplayName() << "\t";
       else
         fs << "Not found\t";
 
   fs << "\n";
 
   size_t i, imax = mObjects.size();
   std::vector< CVector< double > * > Data;
   Data.resize(imax);
 
   std::vector< CVector< double > * >::const_iterator itData;
   std::vector< CVector< double > * >::const_iterator endData = Data.end();
 
   std::vector< size_t > Offset;
   std::vector< size_t >::const_iterator itOffset;
 
   Offset.resize(imax);
 
   std::map< Activity, std::map< const CCopasiObject *, size_t > >::iterator itActivity;
   std::map< const CCopasiObject *, size_t >::iterator itObject;
 
   if (mDataBefore)
     {
       for (itX = mSaveCurveObjects.begin(), i = 0; itX != endX; ++itX)
         for (it = itX->begin(), end = itX->end(); it != end; ++it, ++i)
           {
             if ((itActivity = mObjectIndex.find(COutputInterface::BEFORE)) != mObjectIndex.end() &&
                 (itObject = itActivity->second.find(*it)) != itActivity->second.end())
               {
                 Data[i] = mData[COutputInterface::BEFORE][itObject->second];
                 continue;
               }
 
             if ((itActivity = mObjectIndex.find((COutputInterface::Activity)(COutputInterface::BEFORE | COutputInterface::DURING))) != mObjectIndex.end() &&
                 (itObject = itActivity->second.find(*it)) != itActivity->second.end())
               {
                 Data[i] = mData[COutputInterface::BEFORE | COutputInterface::DURING][itObject->second];
                 continue;
               }
 
             if ((itActivity = mObjectIndex.find((COutputInterface::Activity)(COutputInterface::BEFORE | COutputInterface::AFTER))) != mObjectIndex.end() &&
                 (itObject = itActivity->second.find(*it)) != itActivity->second.end())
               {
                 Data[i] = mData[COutputInterface::BEFORE | COutputInterface::AFTER][itObject->second];
                 continue;
               }
 
             if ((itActivity = mObjectIndex.find((COutputInterface::Activity)(COutputInterface::BEFORE | COutputInterface::DURING | COutputInterface::AFTER))) != mObjectIndex.end() &&
                 (itObject = itActivity->second.find(*it)) != itActivity->second.end())
               {
                 Data[i] = mData[COutputInterface::BEFORE | COutputInterface::DURING | COutputInterface::AFTER][itObject->second];
                 continue;
               }
 
             Data[i] = NULL;
           }
 
       for (i = 0; i < mDataBefore; i++)
         {
           for (itData = Data.begin(); itData != endData; ++itData)
             {
               if (*itData) fs << (**itData)[i];
               else fs << MissingValue;
 
               fs << "\t";
             }
 
           fs << std::endl;
         }
     }
 
   if (mDataDuring)
     {
       for (itX = mSaveCurveObjects.begin(), i = 0; itX != endX; ++itX)
         for (it = itX->begin(), end = itX->end(); it != end; ++it, ++i)
           {
             if ((itActivity = mObjectIndex.find(COutputInterface::DURING)) != mObjectIndex.end() &&
                 (itObject = itActivity->second.find(*it)) != itActivity->second.end())
               {
                 Data[i] = mData[COutputInterface::DURING][itObject->second];
                 Offset[i] = 0;
                 continue;
               }
 
             if ((itActivity = mObjectIndex.find((COutputInterface::Activity)(COutputInterface::BEFORE | COutputInterface::DURING))) != mObjectIndex.end() &&
                 (itObject = itActivity->second.find(*it)) != itActivity->second.end())
               {
                 Data[i] = mData[COutputInterface::BEFORE | COutputInterface::DURING][itObject->second];
                 Offset[i] = mDataBefore;
                 continue;
               }
 
             if ((itActivity = mObjectIndex.find((COutputInterface::Activity)(COutputInterface::DURING | COutputInterface::AFTER))) != mObjectIndex.end() &&
                 (itObject = itActivity->second.find(*it)) != itActivity->second.end())
               {
                 Data[i] = mData[COutputInterface::DURING | COutputInterface::AFTER][itObject->second];
                 Offset[i] = 0;
                 continue;
               }
 
             if ((itActivity = mObjectIndex.find((COutputInterface::Activity)(COutputInterface::BEFORE | COutputInterface::DURING | COutputInterface::AFTER))) != mObjectIndex.end() &&
                 (itObject = itActivity->second.find(*it)) != itActivity->second.end())
               {
                 Data[i] = mData[COutputInterface::BEFORE | COutputInterface::DURING | COutputInterface::AFTER][itObject->second];
                 Offset[i] = mDataBefore;
                 continue;
               }
 
             Data[i] = NULL;
           }
 
       for (i = 0; i < mDataDuring; i++)
         {
           for (itData = Data.begin(), itOffset = Offset.begin(); itData != endData; ++itData)
             {
               if (*itData) fs << (**itData)[i + *itOffset];
               else fs << MissingValue;
 
               fs << "\t";
             }
 
           fs << std::endl;
         }
     }
 
   if (mDataAfter)
     {
       for (itX = mSaveCurveObjects.begin(), i = 0; itX != endX; ++itX)
         for (it = itX->begin(), end = itX->end(); it != end; ++it, ++i)
           {
             if ((itActivity = mObjectIndex.find(COutputInterface::AFTER)) != mObjectIndex.end() &&
                 (itObject = itActivity->second.find(*it)) != itActivity->second.end())
               {
                 Data[i] = mData[COutputInterface::AFTER][itObject->second];
                 Offset[i] = 0;
                 continue;
               }
 
             if ((itActivity = mObjectIndex.find((COutputInterface::Activity)(COutputInterface::BEFORE | COutputInterface::AFTER))) != mObjectIndex.end() &&
                 (itObject = itActivity->second.find(*it)) != itActivity->second.end())
               {
                 Data[i] = mData[COutputInterface::BEFORE | COutputInterface::AFTER][itObject->second];
                 Offset[i] = mDataBefore;
                 continue;
               }
 
             if ((itActivity = mObjectIndex.find((COutputInterface::Activity)(COutputInterface::DURING | COutputInterface::AFTER))) != mObjectIndex.end() &&
                 (itObject = itActivity->second.find(*it)) != itActivity->second.end())
               {
                 Data[i] = mData[COutputInterface::DURING | COutputInterface::AFTER][itObject->second];
                 Offset[i] = mDataDuring;
                 continue;
               }
 
             if ((itActivity = mObjectIndex.find((COutputInterface::Activity)(COutputInterface::BEFORE | COutputInterface::DURING | COutputInterface::AFTER))) != mObjectIndex.end() &&
                 (itObject = itActivity->second.find(*it)) != itActivity->second.end())
               {
                 Data[i] = mData[COutputInterface::BEFORE | COutputInterface::DURING | COutputInterface::AFTER][itObject->second];
                 Offset[i] = mDataBefore + mDataDuring;
                 continue;
               }
 
             Data[i] = NULL;
           }
 
       for (i = 0; i < mDataAfter; i++)
         {
           for (itData = Data.begin(), itOffset = Offset.begin(); itData != endData; ++itData)
             {
               if (*itData) fs << (**itData)[i + *itOffset];
               else fs << MissingValue;
 
               fs << "\t";
             }
 
           fs << std::endl;
         }
     }
 
   bool FirstHistogram = true;
   size_t HistogramIndex = 0;
 
   C2DPlotCurve ** itCurves = mCurves.array();
   C2DPlotCurve ** endCurves = itCurves + mCurves.size();
 
   for (; itCurves != endCurves; ++itCurves)
     {
       if ((*itCurves)->getType() == CPlotItem::histoItem1d)
         {
           if (FirstHistogram)
             {
               fs << "\n# The histograms: \n";
               FirstHistogram = false;
             }
 
           if (mSaveHistogramObjects[HistogramIndex] != NULL)
             fs << mSaveHistogramObjects[HistogramIndex]->getObjectDisplayName();
           else
             fs << "Not found";
 
           fs << std::endl;
 
           CHistoCurveData * pData = static_cast< CHistoCurveData * >(&(*itCurves)->data());
           size_t i, imax = pData->size();
 
           for (i = 0; i < imax; ++i)
             {
               fs << pData->x(i) << "\t" << pData->y(i) << "\n";
             }
         }
     }
 
   fs.close();
 
   if (!fs.good()) return false;
 
   return true;
 }

void CopasiPlot::separate ( const Activity & activity )

virtual

Introduce an additional separator into the output

Parameters

const Activity & activity

Definition at line 1233 of file CopasiPlot.cpp.

References ActivitySize, COutputInterface::AFTER, COutputInterface::BEFORE, C_INT32, COutputInterface::DURING, mData, mDataAfter, mDataBefore, mDataDuring, mDataSize, mHaveAfter, mHaveBefore, mHaveDuring, MissingValue, resizeCurveData(), and updatePlot().

Referenced by PlotWindow::separate().

 {
   size_t i, imax;
   C_INT32 ItemActivity;
 
   if (mHaveBefore && (activity == COutputInterface::BEFORE)) mDataBefore++;
 
   if (mHaveDuring && (activity == COutputInterface::DURING)) mDataDuring++;
 
   if (mHaveAfter && (activity == COutputInterface::AFTER)) mDataAfter++;
 
   for (ItemActivity = 0; ItemActivity < ActivitySize; ItemActivity++)
     if ((ItemActivity & activity) && mData[ItemActivity].size())
       {
         std::vector< CVector< double > * > & data = mData[ItemActivity];
         size_t & ndata = mDataSize[ItemActivity];
 
         if ((imax = data.size()) != 0)
           {
             if (ndata >= data[0]->size())
               {
                 resizeCurveData(ItemActivity);
               }
 
             //the data that needs to be stored internally:
             for (i = 0; i < imax; ++i)
               (*data[i])[ndata] = MissingValue;
 
             ++ndata;
           }
       }
 
   updatePlot();
 
   return;
 }

void CopasiPlot::setAxisUnits	(	const C_INT32 &	index,
		const CCopasiObject *	pObject
	)

private

Set the units of the indexed axis based on the type of the object.

Parameters

const	C_INT32 & index
const	CCopasiObject * pObject

Definition at line 1712 of file CopasiPlot.cpp.

References FROM_UTF8, and CCopasiObject::getUnits().

Referenced by compile().

 {
   if (pObject == NULL) return;
 
   std::string Units = pObject->getUnits();
 
   if (Units != "")
     setAxisTitle(index, FROM_UTF8(Units));
 
   return;
 }

void CopasiPlot::setCurvesVisibility ( const bool & visibility )

Shows or hide all curves depending on whether visibility is false or true

Parameters

const bool & visibility

Definition at line 1656 of file CopasiPlot.cpp.

References mCurveMap, mIgnoreUpdate, and replot().

Referenced by PlotWindow::slotDeselectAll(), and PlotWindow::slotSelectAll().

 {
   std::map< std::string, C2DPlotCurve * >::iterator it = mCurveMap.begin();
   std::map< std::string, C2DPlotCurve * >::iterator end = mCurveMap.end();
 
   for (; it != end; ++it)
     {
       it->second->setVisible(visibility);
       it->second->setItemAttribute(QwtPlotItem::AutoScale, visibility);
       QWidget *w = legend()->find(it->second);
 
       if (w && w->inherits("QwtLegendItem"))
         static_cast< QwtLegendItem * >(w)->setChecked(visibility);
     }
 
   if (!mIgnoreUpdate)
     replot();
 }

void CopasiPlot::showCurve	(	QwtPlotItem *	item,
		bool	on
	)

privateslot

Slot used to turn curves on and of through the legend buttons.

Parameters

QwtPlotItem	*item
bool	on

Definition at line 1643 of file CopasiPlot.cpp.

References mIgnoreUpdate, and replot().

Referenced by CopasiPlot(), and initFromSpec().

 {
   item->setVisible(on);
   item->setItemAttribute(QwtPlotItem::AutoScale, on);
   QWidget *w = legend()->find(item);
 
   if (w && w->inherits("QwtLegendItem"))
     static_cast< QwtLegendItem * >(w)->setChecked(on);
 
   if (!mIgnoreUpdate)
     replot();
 }

void CopasiPlot::updateCurves ( const size_t & activity )

private

Tell the curves where the data is located. It must be called after reallocating the memory for the curve data.

Definition at line 1283 of file CopasiPlot.cpp.

References ActivitySize, CVectorCore< CType >::array(), C_INT32, C_INVALID_INDEX, mCurves, mDataSize, and CVectorCore< CType >::size().

Referenced by replot().

 {
   if (activity == C_INVALID_INDEX)
     {
       C_INT32 ItemActivity;
 
       for (ItemActivity = 0; ItemActivity < ActivitySize; ItemActivity++)
         updateCurves(ItemActivity);
 
       return;
     }
 
   size_t k = 0;
   C2DPlotCurve ** itCurves = mCurves.array();
   C2DPlotCurve ** endCurves = itCurves + mCurves.size();
 
   for (; itCurves != endCurves; ++itCurves, ++k)
     if ((size_t)(*itCurves)->getActivity() == activity)
       {
         (*itCurves)->setDataSize(mDataSize[activity]);
       }
 }

void CopasiPlot::updatePlot ( )

private

Redraw the plot

Definition at line 1370 of file CopasiPlot.cpp.

References mReplotFinished, and replotSignal().

Referenced by output(), and separate().

 {
   if (mReplotFinished)
     {
       mReplotFinished = false;
       emit replotSignal();
     }
 }

Member Data Documentation

std::map< std::string, C2DPlotCurve * > CopasiPlot::mCurveMap

private

A map between a specification identified by its key and a curve

Definition at line 391 of file CopasiPlot.h.

Referenced by initFromSpec(), and setCurvesVisibility().

CVector< C2DPlotCurve * > CopasiPlot::mCurves

private

The list of curves

Definition at line 386 of file CopasiPlot.h.

Referenced by compile(), initFromSpec(), resizeCurveData(), saveData(), and updateCurves().

std::vector< std::vector< CVector< double > * > > CopasiPlot::mData

private

Vector that contains pointers to vectors of data in the selected columns.

Definition at line 344 of file CopasiPlot.h.

Referenced by clearBuffers(), compile(), CopasiPlot(), output(), resizeCurveData(), saveData(), and separate().

size_t CopasiPlot::mDataAfter

private

Count of data lines recorded during activity AFTER.

Definition at line 416 of file CopasiPlot.h.

Referenced by clearBuffers(), output(), saveData(), and separate().

size_t CopasiPlot::mDataBefore

private

Vector of the activity of each item (curve) Map of curve to the index to the corresponding histogram. Count of data lines recorded during activity BEFORE.

Definition at line 406 of file CopasiPlot.h.

Referenced by clearBuffers(), output(), saveData(), and separate().

size_t CopasiPlot::mDataDuring

private

Count of data lines recorded during activity DURING.

Definition at line 411 of file CopasiPlot.h.

Referenced by clearBuffers(), output(), saveData(), and separate().