#include <CExperiment.h>

Inheritance diagram for CExperiment:

Collaboration diagram for CExperiment:

Public Types
enum	Type { ignore = 0, independent, dependent, time }

enum	WeightMethod { MEAN = 0, MEAN_SQUARE, SD, VALUE_SCALING }

Public Types inherited from CCopasiParameterGroup
typedef parameterGroup::iterator	index_iterator

typedef CCopasiContainer::objectMap::iterator	name_iterator

typedef std::vector < CCopasiParameter * >	parameterGroup

Public Types inherited from CCopasiParameter
enum	Type { DOUBLE = 0, UDOUBLE, INT, UINT, BOOL, GROUP, STRING, CN, KEY, FILE, EXPRESSION, INVALID }

Public Types inherited from CCopasiContainer
typedef std::multimap < std::string, CCopasiObject * >	objectMap

Public Types inherited from CCopasiObject
typedef std::set< const CCopasiObject * >	DataObjectSet

typedef std::vector< Refresh * >	DataUpdateSequence

Public Types inherited from CObjectInterface
typedef std::set< const CObjectInterface * >	ObjectSet

typedef std::vector < CObjectInterface * >	UpdateSequence

Public Member Functions
bool	calculateStatistics ()

bool	calculateWeights ()

	CExperiment (const CCopasiContainer *pParent, const std::string &name="Experiment")

	CExperiment (const CExperiment &src, const CCopasiContainer *pParent=NULL)

	CExperiment (const CCopasiParameterGroup &group, const CCopasiContainer *pParent=NULL)

bool	compile (const std::vector< CCopasiContainer * > listOfContainer=CCopasiContainer::EmptyList)

virtual bool	elevateChildren ()

size_t	extendedTimeSeriesSize () const

void	fixBuild55 ()

const std::vector< std::string > &	getColumnNames () const

size_t	getColumnValidValueCount (CCopasiObject *const &pObject) const

C_FLOAT64	getDefaultScale (const CCopasiObject *const &pObject) const

const CMatrix< C_FLOAT64 > &	getDependentData () const

const std::map< CCopasiObject *, size_t > &	getDependentObjects () const

const C_FLOAT64 &	getErrorMean () const

const C_FLOAT64 &	getErrorMeanSD () const

C_FLOAT64	getErrorMeanSD (CCopasiObject *const &pObject, const C_FLOAT64 &errorMean) const

C_FLOAT64	getErrorSum (CCopasiObject *const &pObject) const

const CCopasiTask::Type &	getExperimentType () const

const std::string &	getFileName () const

const unsigned C_INT32 &	getFirstRow () const

const CCopasiVector < CFittingPoint > &	getFittingPoints () const

const unsigned C_INT32 &	getHeaderRow () const

const CMatrix< C_FLOAT64 > &	getIndependentData () const

const std::set< const CCopasiObject * > &	getIndependentObjects () const

const unsigned C_INT32 &	getLastRow () const

bool	getNormalizeWeightsPerExperiment () const

const unsigned C_INT32 &	getNumColumns () const

size_t	getNumDataRows () const

const C_FLOAT64 &	getObjectiveValue () const

C_FLOAT64	getObjectiveValue (CCopasiObject *const &pObject) const

CExperimentObjectMap &	getObjectMap ()

const C_FLOAT64 &	getRMS () const

C_FLOAT64	getRMS (CCopasiObject *const &pObject) const

const std::string &	getSeparator () const

const CVector< C_FLOAT64 > &	getTimeData () const

const WeightMethod &	getWeightMethod () const

size_t	guessColumnNumber () const

void	initExtendedTimeSeries (size_t s)

const bool &	isRowOriented () const

CExperiment &	operator= (const CExperiment &rhs)

virtual void	printResult (std::ostream *ostream) const

bool	read (std::istream &in, size_t &currentLine)

bool	readColumnNames ()

bool	restoreModelIndependentData ()

bool	setExperimentType (const CCopasiTask::Type &type)

bool	setFileName (const std::string &fileName)

bool	setFirstRow (const unsigned C_INT32 &firstRow)

bool	setHeaderRow (const unsigned C_INT32 &headerRow)

bool	setIsRowOriented (const bool &isRowOriented)

bool	setLastRow (const unsigned C_INT32 &lastRow)

void	setNormalizeWeightsPerExperiment (bool flag)

bool	setNumColumns (const unsigned C_INT32 &cols)

bool	setSeparator (const std::string &seperator)

bool	setWeightMethod (const WeightMethod &weightMethod)

void	storeExtendedTimeSeriesData (C_FLOAT64 time)

C_FLOAT64	sumOfSquares (const size_t &index, C_FLOAT64 *&residuals) const

C_FLOAT64	sumOfSquaresStore (const size_t &index, C_FLOAT64 *&dependentValues)

void	updateFittedPoints ()

void	updateFittedPointValues (const size_t &index, bool includeSimulation)

void	updateFittedPointValuesFromExtendedTimeSeries (const size_t &index)

bool	updateModelWithIndependentData (const size_t &index)

virtual	~CExperiment ()

Public Member Functions inherited from CCopasiParameterGroup
bool	addGroup (const std::string &name)

bool	addParameter (const CCopasiParameter &parameter)

bool	addParameter (const std::string &name, const CCopasiParameter::Type type)

template<class CType >
bool	addParameter (const std::string &name, const CCopasiParameter::Type type, const CType &value)

void	addParameter (CCopasiParameter *pParameter)

CCopasiParameterGroup *	assertGroup (const std::string &name)

template<class CType >
CCopasiParameter *	assertParameter (const std::string &name, const CCopasiParameter::Type type, const CType &defaultValue)

index_iterator	beginIndex () const

name_iterator	beginName () const

	CCopasiParameterGroup (const CCopasiParameterGroup &src, const CCopasiContainer *pParent=NULL)

	CCopasiParameterGroup (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &objectType="ParameterGroup")

void	clear ()

index_iterator	endIndex () const

name_iterator	endName () const

CCopasiParameterGroup *	getGroup (const std::string &name)

const CCopasiParameterGroup *	getGroup (const std::string &name) const

CCopasiParameterGroup *	getGroup (const size_t &index)

const CCopasiParameterGroup *	getGroup (const size_t &index) const

size_t	getIndex (const std::string &name) const

std::string	getKey (const std::string &name) const

std::string	getKey (const size_t &index) const

virtual const std::string &	getName (const size_t &index) const

virtual const CObjectInterface *	getObject (const CCopasiObjectName &cn) const

CCopasiParameter *	getParameter (const std::string &name)

const CCopasiParameter *	getParameter (const std::string &name) const

CCopasiParameter *	getParameter (const size_t &index)

const CCopasiParameter *	getParameter (const size_t &index) const

CCopasiParameter::Type	getType (const std::string &name) const

CCopasiParameter::Type	getType (const size_t &index) const

std::string	getUniqueParameterName (const CCopasiParameter *pParameter) const

const CCopasiParameter::Value &	getValue (const std::string &name) const

const CCopasiParameter::Value &	getValue (const size_t &index) const

CCopasiParameter::Value &	getValue (const std::string &name)

CCopasiParameter::Value &	getValue (const size_t &index)

CCopasiParameterGroup &	operator= (const CCopasiParameterGroup &rhs)

virtual void	print (std::ostream *ostream) const

bool	removeParameter (const std::string &name)

bool	removeParameter (const size_t &index)

template<class CType >
bool	setValue (const std::string &name, const CType &value)

template<class CType >
bool	setValue (const size_t &index, const CType &value)

size_t	size () const

bool	swap (const size_t &iFrom, const size_t &iTo)

bool	swap (index_iterator &from, index_iterator &to)

virtual	~CCopasiParameterGroup ()

Public Member Functions inherited from CCopasiParameter
	CCopasiParameter (const CCopasiParameter &src, const CCopasiContainer *pParent=NULL)

	CCopasiParameter (const std::string &name, const Type &type, const void pValue=NULL, const CCopasiContainer pParent=NULL, const std::string &objectType="Parameter")

virtual CCopasiObjectName	getCN () const

virtual const std::string &	getKey () const

virtual std::string	getObjectDisplayName (bool regular=true, bool richtext=false) const

const CCopasiParameter::Type &	getType () const

const Value &	getValue () const

Value &	getValue ()

virtual void *	getValuePointer () const

CCopasiObject *	getValueReference () const

bool	isValidValue (const C_FLOAT64 &value) const

bool	isValidValue (const C_INT32 &value) const

bool	isValidValue (const unsigned C_INT32 &value) const

bool	isValidValue (const bool &value) const

bool	isValidValue (const std::string &value) const

bool	isValidValue (const CCopasiObjectName &value) const

bool	isValidValue (const std::vector< CCopasiParameter * > &value) const

CCopasiParameter &	operator= (const CCopasiParameter &rhs)

template<class CType >
bool	setValue (const CType &value)

bool	setValue (const std::vector< CCopasiParameter * > &value)

virtual	~CCopasiParameter ()

Public Member Functions inherited from CCopasiContainer
virtual bool	add (CCopasiObject *pObject, const bool &adopt=true)

	CCopasiContainer (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &type="CN", const unsigned C_INT32 &flag=CCopasiObject::Container)

	CCopasiContainer (const CCopasiContainer &src, const CCopasiContainer *pParent=NULL)

virtual std::string	getChildObjectUnits (const CCopasiObject *pObject) const

virtual const objectMap &	getObjects () const

virtual std::string	getUnits () const

virtual const CCopasiObject *	getValueObject () const

virtual bool	remove (CCopasiObject *pObject)

virtual	~CCopasiContainer ()

Public Member Functions inherited from CCopasiObject
void	addDirectDependency (const CCopasiObject *pObject)

	CCopasiObject (const CCopasiObject &src, const CCopasiContainer *pParent=NULL)

void	clearDirectDependencies ()

void	clearRefresh ()

bool	dependsOn (DataObjectSet candidates, const DataObjectSet &context=DataObjectSet()) const

void	getAllDependencies (DataObjectSet &dependencies, const DataObjectSet &context) const

virtual const DataObjectSet &	getDirectDependencies (const DataObjectSet &context=DataObjectSet()) const

CCopasiContainer *	getObjectAncestor (const std::string &type) const

CCopasiDataModel *	getObjectDataModel ()

const CCopasiDataModel *	getObjectDataModel () const

const std::string &	getObjectName () const

CCopasiContainer *	getObjectParent () const

const std::string &	getObjectType () const

virtual const CObjectInterface::ObjectSet &	getPrerequisites () const

virtual Refresh *	getRefresh () const

UpdateMethod *	getUpdateMethod () const

bool	hasCircularDependencies (DataObjectSet &candidates, DataObjectSet &verified, const DataObjectSet &context) const

bool	hasUpdateMethod () const

bool	isArray () const

bool	isContainer () const

bool	isDataModel () const

bool	isMatrix () const

bool	isNameVector () const

bool	isNonUniqueName () const

virtual bool	isPrerequisiteForContext (const CObjectInterface *pObject, const CMath::SimulationContextFlag &context, const CObjectInterface::ObjectSet &changedObjects) const

bool	isReference () const

bool	isRoot () const

bool	isSeparator () const

bool	isStaticString () const

bool	isValueBool () const

bool	isValueDbl () const

bool	isValueInt () const

bool	isValueInt64 () const

bool	isValueString () const

bool	isVector () const

virtual bool	mustBeDeleted (const DataObjectSet &deletedObjects) const

void	removeDirectDependency (const CCopasiObject *pObject)

void	setDirectDependencies (const DataObjectSet &directDependencies)

bool	setObjectName (const std::string &name)

virtual bool	setObjectParent (const CCopasiContainer *pParent)

void	setObjectValue (const C_FLOAT64 &value)

void	setObjectValue (const C_INT32 &value)

void	setObjectValue (const bool &value)

template<class CType >
void	setRefresh (CType pType, void(CType::method)(void))

template<class CType >
void	setUpdateMethod (CType pType, void(CType::method)(const C_FLOAT64 &))

template<class CType >
void	setUpdateMethod (CType pType, void(CType::method)(const C_INT32 &))

template<class CType >
void	setUpdateMethod (CType pType, void(CType::method)(const bool &))

virtual	~CCopasiObject ()

Public Member Functions inherited from CObjectInterface
	CObjectInterface ()

virtual	~CObjectInterface ()

Static Public Member Functions
static bool	compare (const CExperiment lhs, const CExperiment rhs)

Static Public Member Functions inherited from CCopasiObject
static std::vector< Refresh * >	buildUpdateSequence (const DataObjectSet &objects, const DataObjectSet &uptoDateObjects, const DataObjectSet &context=DataObjectSet())

static void	setRenameHandler (CRenameHandler *rh)

Static Public Attributes
static const std::string	TypeName []

static const std::string	WeightMethodName []

static const char *	WeightMethodType []

static const char *	XMLType []

Static Public Attributes inherited from CCopasiParameter
static const std::string	TypeName []

static const char *	XMLType []

Static Public Attributes inherited from CCopasiContainer
static const std::vector < CCopasiContainer * >	EmptyList

Private Member Functions
void	initializeParameter ()

void	initializeScalingMatrix ()

Private Attributes
std::vector< std::string >	mColumnName

CVector< C_FLOAT64 >	mColumnObjectiveValue

CVector< C_FLOAT64 >	mColumnRMS

CVector< C_FLOAT64 >	mColumnScale

CVector< size_t >	mColumnValidValueCount

CMatrix< C_FLOAT64 >	mDataDependent

CMatrix< C_FLOAT64 >	mDataIndependent

CVector< C_FLOAT64 >	mDataTime

CVector< C_FLOAT64 >	mDefaultColumnScale

std::map< CCopasiObject *, size_t >	mDependentObjects

CVector< C_FLOAT64 * >	mDependentValues

CVector< C_FLOAT64 >	mExtendedTimeSeries

size_t	mExtendedTimeSeriesSize

CCopasiVector< CFittingPoint >	mFittingPoints

std::set< const CCopasiObject * >	mIndependentObjects

CVector< UpdateMethod * >	mIndependentUpdateMethods

CVector< C_FLOAT64 >	mIndependentValues

C_FLOAT64	mMean

CVector< C_FLOAT64 >	mMeans

C_FLOAT64	mMeanSD

bool	mMissingData

size_t	mNumDataRows

C_FLOAT64	mObjectiveValue

C_FLOAT64 *	mpDataDependentCalculated

std::string *	mpFileName

unsigned C_INT32 *	mpFirstRow

unsigned C_INT32 *	mpHeaderRow

unsigned C_INT32 *	mpLastRow

bool *	mpNormalizeWeightsPerExperiment

unsigned C_INT32 *	mpNumColumns

CExperimentObjectMap *	mpObjectMap

bool *	mpRowOriented

std::string *	mpSeparator

CCopasiTask::Type *	mpTaskType

WeightMethod *	mpWeightMethod

std::vector< Refresh * >	mRefreshMethods

C_FLOAT64	mRMS

CVector< C_FLOAT64 >	mRowObjectiveValue

CVector< C_FLOAT64 >	mRowRMS

CMatrix< C_FLOAT64 >	mScale

C_FLOAT64 *	mStorageIt

Friends
bool	operator== (const CExperiment &lhs, const CExperiment &rhs)

Additional Inherited Members
Protected Types inherited from CCopasiObject
enum	Flag { Container = 0x1, Vector = 0x2, Matrix = 0x4, NameVector = 0x8, Reference = 0x10, ValueBool = 0x20, ValueInt = 0x40, ValueInt64 = 0x80, ValueDbl = 0x100, NonUniqueName = 0x200, StaticString = 0x400, ValueString = 0x800, Separator = 0x1000, ModelEntity = 0x2000, Array = 0x4000, DataModel = 0x8000, Root = 0x10000, Gui = 0x20000 }

Protected Member Functions inherited from CCopasiParameterGroup
	CCopasiParameterGroup ()

Protected Member Functions inherited from CCopasiContainer
template<class CType >
CCopasiObject *	addMatrixReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)

template<class CType >
CCopasiObject *	addObjectReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)

template<class CType >
CCopasiObject *	addVectorReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)

void	initObjects ()

Protected Member Functions inherited from CCopasiObject
	CCopasiObject ()

	CCopasiObject (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &type="CN", const unsigned C_INT32 &flag=0)

Protected Attributes inherited from CCopasiParameter
std::string	mKey

CCopasiObject *	mpValueReference

size_t	mSize

Value	mValue

Protected Attributes inherited from CCopasiContainer
objectMap	mObjects

Static Protected Attributes inherited from CCopasiObject
static CRenameHandler *	smpRenameHandler = NULL

Detailed Description

Definition at line 61 of file CExperiment.h.

Member Enumeration Documentation

enum CExperiment::Type

Enumeration of the types of columns known to COPASI.

Enumerator
ignore
independent
dependent
time

Definition at line 67 of file CExperiment.h.

   {
     ignore = 0,
     independent,
     dependent,
     time
   };

enum CExperiment::WeightMethod

Enumeration of methods to calculate the weight.

Enumerator
MEAN
MEAN_SQUARE
SD
VALUE_SCALING

Definition at line 89 of file CExperiment.h.

   {
     MEAN = 0,
     MEAN_SQUARE,
     SD,
     VALUE_SCALING
   };

Constructor & Destructor Documentation

CExperiment::CExperiment	(	const CCopasiContainer *	pParent,
		const std::string &	name = `"Experiment"`
	)

Default constructor

Parameters

const	CCopasiContainer * pParent
const	std::string & name (default: Experiment)

Definition at line 76 of file CExperiment.cpp.

References CVectorCore< CType >::array(), initializeParameter(), mExtendedTimeSeries, and mStorageIt.

                                                 :
   CCopasiParameterGroup(name, pParent),
   mpFileName(NULL),
   mpFirstRow(NULL),
   mpLastRow(NULL),
   mpTaskType(NULL),
   mpNormalizeWeightsPerExperiment(NULL),
   mpSeparator(NULL),
   mpWeightMethod(NULL),
   mpRowOriented(NULL),
   mpHeaderRow(NULL),
   mpNumColumns(NULL),
   mColumnName(),
   mpObjectMap(NULL),
   mDataTime(0),
   mDataIndependent(0, 0),
   mDataDependent(0, 0),
   mScale(0, 0),
   mMissingData(false),
   mMeans(0),
   mColumnScale(0),
   mDefaultColumnScale(0),
   mDependentValues(0),
   mIndependentUpdateMethods(0),
   mRefreshMethods(),
   mIndependentObjects(),
   mIndependentValues(0),
   mNumDataRows(0),
   mpDataDependentCalculated(NULL),
   mMean(0),
   mMeanSD(0),
   mObjectiveValue(0),
   mRMS(0),
   mRowObjectiveValue(0),
   mRowRMS(0),
   mColumnObjectiveValue(0),
   mColumnRMS(0),
   mColumnValidValueCount(0),
   mDependentObjects(),
   mFittingPoints("Fitted Points", this),
   mExtendedTimeSeries(0),
   mStorageIt(NULL),
   mExtendedTimeSeriesSize(0)
 {
   mStorageIt = mExtendedTimeSeries.array();
 
   initializeParameter();
 }

CExperiment::CExperiment	(	const CExperiment &	src,
		const CCopasiContainer *	pParent = `NULL`
	)

Copy constructor

Parameters

const	CExperiment & src
const	CCopasiContainer * pParent (default: src data model)

Definition at line 126 of file CExperiment.cpp.

References CVectorCore< CType >::array(), initializeParameter(), mExtendedTimeSeries, and mStorageIt.

                                                           :
   CCopasiParameterGroup(src, static_cast< const CCopasiContainer * >((pParent != NULL) ? pParent : src.getObjectDataModel())),
   mpFileName(NULL),
   mpFirstRow(NULL),
   mpLastRow(NULL),
   mpTaskType(NULL),
   mpNormalizeWeightsPerExperiment(NULL),
   mpSeparator(NULL),
   mpWeightMethod(NULL),
   mpRowOriented(NULL),
   mpHeaderRow(NULL),
   mpNumColumns(NULL),
   mColumnName(src.mColumnName),
   mpObjectMap(NULL),
   mDataTime(src.mDataTime),
   mDataIndependent(src.mDataIndependent),
   mDataDependent(src.mDataDependent),
   mScale(src.mScale),
   mMissingData(src.mMissingData),
   mMeans(src.mMeans),
   mColumnScale(src.mColumnScale),
   mDefaultColumnScale(src.mDefaultColumnScale),
   mDependentValues(src.mDependentValues),
   mIndependentUpdateMethods(src.mIndependentUpdateMethods),
   mRefreshMethods(src.mRefreshMethods),
   mIndependentObjects(src.mIndependentObjects),
   mIndependentValues(src.mIndependentValues),
   mNumDataRows(src.mNumDataRows),
   mpDataDependentCalculated(src.mpDataDependentCalculated),
   mMean(src.mMean),
   mMeanSD(src.mMeanSD),
   mObjectiveValue(0),
   mRMS(src.mRMS),
   mRowObjectiveValue(src.mRowObjectiveValue),
   mRowRMS(src.mRowRMS),
   mColumnObjectiveValue(src.mColumnObjectiveValue),
   mColumnRMS(src.mColumnRMS),
   mColumnValidValueCount(src.mColumnValidValueCount),
   mDependentObjects(src.mDependentObjects),
   mFittingPoints(src.mFittingPoints, this),
   mExtendedTimeSeries(src.mExtendedTimeSeries),
   mStorageIt(src.mStorageIt),
   mExtendedTimeSeriesSize(src.mExtendedTimeSeriesSize)
 
 {
   mStorageIt = mExtendedTimeSeries.array() + (src.mStorageIt - src.mExtendedTimeSeries.array());
 
   initializeParameter();
 }

CExperiment::CExperiment	(	const CCopasiParameterGroup &	group,
		const CCopasiContainer *	pParent = `NULL`
	)

Specific constructor used for reading COPASI files

Parameters

const	CCopasiParameterGroup & group
const	CCopasiContainer * pParent (default: group data model)

Definition at line 177 of file CExperiment.cpp.

References CVectorCore< CType >::array(), initializeParameter(), mExtendedTimeSeries, and mStorageIt.

                                                           :
   CCopasiParameterGroup(group, static_cast< const CCopasiContainer * >((pParent != NULL) ? pParent : group.getObjectDataModel())),
   mpFileName(NULL),
   mpFirstRow(NULL),
   mpLastRow(NULL),
   mpTaskType(NULL),
   mpNormalizeWeightsPerExperiment(NULL),
   mpSeparator(NULL),
   mpWeightMethod(NULL),
   mpRowOriented(NULL),
   mpHeaderRow(NULL),
   mpNumColumns(NULL),
   mColumnName(),
   mpObjectMap(NULL),
   mDataTime(0),
   mDataIndependent(0, 0),
   mDataDependent(0, 0),
   mScale(0, 0),
   mMissingData(false),
   mMeans(0),
   mColumnScale(0),
   mDefaultColumnScale(0),
   mDependentValues(0),
   mIndependentUpdateMethods(0),
   mRefreshMethods(),
   mIndependentObjects(),
   mIndependentValues(0),
   mNumDataRows(0),
   mpDataDependentCalculated(NULL),
   mMean(0),
   mMeanSD(0),
   mObjectiveValue(0),
   mRMS(0),
   mRowObjectiveValue(0),
   mRowRMS(0),
   mColumnObjectiveValue(0),
   mColumnRMS(0),
   mColumnValidValueCount(0),
   mDependentObjects(),
   mFittingPoints("Fitted Points", this),
   mExtendedTimeSeries(0),
   mStorageIt(NULL),
   mExtendedTimeSeriesSize(0)
 {
   mStorageIt = mExtendedTimeSeries.array();
 
   initializeParameter();
 }

CExperiment::~CExperiment ( )

virtual

Destructor

Definition at line 227 of file CExperiment.cpp.

227 {}

Member Function Documentation

bool CExperiment::calculateStatistics ( )

Calculate statistics by comparing the stored calculated values with the measurements.

Returns: bool success

Definition at line 601 of file CExperiment.cpp.

References CMatrix< CType >::array(), C_FLOAT64, CCopasiDataModel::getModel(), CCopasiObject::getObjectDataModel(), CModel::getTime(), max, mColumnObjectiveValue, mColumnRMS, mColumnValidValueCount, mDataDependent, mMean, mMeanSD, mObjectiveValue, mpDataDependentCalculated, mpTaskType, mRMS, mRowObjectiveValue, mRowRMS, mScale, CMatrix< CType >::numCols(), CMatrix< CType >::numRows(), CVector< CType >::resize(), and CCopasiTask::timeCourse.

 {
   C_FLOAT64 * pTime = NULL;
   C_FLOAT64 SavedTime = 0.0;
 
   if (*mpTaskType == CCopasiTask::timeCourse)
     {
       pTime = const_cast<C_FLOAT64 *>(&getObjectDataModel()->getModel()->getTime());
       SavedTime = *pTime;
     }
 
   size_t numRows = mDataDependent.numRows();
   size_t numCols = mDataDependent.numCols();
 
   // Overall statistic;
   mMean = 0.0;
   mMeanSD = 0.0;
   mObjectiveValue = 0.0;
   mRMS = 0.0;
   size_t ValidValueCount = 0;
 
   // per row statistic;
   mRowObjectiveValue.resize(numRows);
   mRowObjectiveValue = 0.0;
   mRowRMS.resize(numRows);
   mRowRMS = 0.0;
   CVector< size_t > RowCount;
   RowCount.resize(numRows);
   RowCount = 0;
 
   // per column statistic;
   mColumnObjectiveValue.resize(numCols);
   mColumnObjectiveValue = 0.0;
   mColumnRMS.resize(numCols);
   mColumnRMS = 0.0;
   mColumnValidValueCount.resize(numCols);
   mColumnValidValueCount = 0;
 
   size_t i, j;
   C_FLOAT64 Residual;
 
   if (mpDataDependentCalculated == NULL)
     return false;
 
   C_FLOAT64 * pDataDependentCalculated = mpDataDependentCalculated;
   C_FLOAT64 * pDataDependent = mDataDependent.array();
   C_FLOAT64 * pScale = mScale.array();
 
   for (i = 0; i < numRows; i++)
     {
       for (j = 0; j < numCols; j++, pDataDependentCalculated++, pDataDependent++, pScale++)
         {
 
 #ifdef COPASI_PARAMETERFITTING_RESIDUAL_SCALING
           Residual = (*pDataDependentCalculated - *pDataDependent) * std::max(1.0, *pDataDependentCalculated);
 #else
           Residual = (*pDataDependentCalculated - *pDataDependent) * *pScale;
 #endif
 
           if (isnan(Residual)) continue;
 
           mMean += Residual;
 
           Residual = Residual * Residual;
 
           mObjectiveValue += Residual;
           ValidValueCount++;
 
           mRowObjectiveValue[i] += Residual;
           RowCount[i]++;
 
           mColumnObjectiveValue[j] += Residual;
           mColumnValidValueCount[j]++;
         }
     }
 
   if (ValidValueCount)
     {
       mMean /= ValidValueCount;
       mRMS = sqrt(mObjectiveValue / ValidValueCount);
     }
   else
     {
       mMean = std::numeric_limits<C_FLOAT64>::quiet_NaN();
       mRMS = std::numeric_limits<C_FLOAT64>::quiet_NaN();
     }
 
   for (i = 0; i < numRows; i++)
     {
       if (RowCount[i])
         mRowRMS[i] = sqrt(mRowObjectiveValue[i] / RowCount[i]);
       else
         mRowRMS[i] = std::numeric_limits<C_FLOAT64>::quiet_NaN();
     }
 
   for (j = 0; j < numCols; j++)
     {
       if (mColumnValidValueCount[j])
         mColumnRMS[j] = sqrt(mColumnObjectiveValue[j] / mColumnValidValueCount[j]);
       else
         mColumnRMS[j] = std::numeric_limits<C_FLOAT64>::quiet_NaN();
     }
 
   pDataDependentCalculated = mpDataDependentCalculated;
   pDataDependent = mDataDependent.array();
   pScale = mScale.array();
 
   for (i = 0; i < numRows; i++)
     {
       for (j = 0; j < numCols; j++, pDataDependentCalculated++, pDataDependent++, pScale++)
         {
 
 #ifdef COPASI_PARAMETERFITTING_RESIDUAL_SCALING
           Residual = mMean - (*pDataDependentCalculated - *pDataDependent) / std::max(1.0, *pDataDependentCalculated);
 #else
           Residual = mMean - (*pDataDependentCalculated - *pDataDependent) * *pScale;
 #endif
 
           if (isnan(Residual)) continue;
 
           mMeanSD += Residual * Residual;
         }
     }
 
   if (ValidValueCount)
     mMeanSD = sqrt(mMeanSD / ValidValueCount);
   else
     mMeanSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
 
   if (*mpTaskType == CCopasiTask::timeCourse) *pTime = SavedTime;
 
   return true;
 }

bool CExperiment::calculateWeights ( )

Calculate/set the weights used in the sum of squares.

Returns: bool success

Definition at line 1051 of file CExperiment.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, max, mColumnValidValueCount, mDataDependent, mDefaultColumnScale, MEAN, MEAN_SQUARE, mMeans, mMissingData, mNumDataRows, mpNormalizeWeightsPerExperiment, mpWeightMethod, SD, CVectorCore< CType >::size(), and VALUE_SCALING.

Referenced by read(), CQExperimentData::slotCheckNormalizeWeightsPerExperiment(), and CQExperimentData::slotWeightMethod().

 {
   // We need to calculate the means and the weights
   C_FLOAT64 MinWeight = std::numeric_limits< C_FLOAT64 >::max();
 
   size_t DependentCount = mMeans.size();
   CVector< C_FLOAT64 > MeanSquares(DependentCount);
   CVector< C_FLOAT64 > ColumnEpsilons(DependentCount);
   C_FLOAT64 * pColumnEpsilon;
   size_t i, j;
 
   mMeans = 0.0;
   MeanSquares = 0.0;
   ColumnEpsilons = std::numeric_limits< C_FLOAT64 >::infinity();
 
   mColumnValidValueCount = 0;
   mMissingData = false;
 
   // Calculate the means
   for (i = 0; i < mNumDataRows; i++)
     for (j = 0, pColumnEpsilon = ColumnEpsilons.array(); j < DependentCount; j++, pColumnEpsilon++)
       {
         C_FLOAT64 & Data = mDataDependent[i][j];
 
         if (!isnan(Data))
           {
             mColumnValidValueCount[j]++;
             mMeans[j] += Data;
             MeanSquares[j] += Data * Data;
 
             if (Data != 0.0 && fabs(Data) < *pColumnEpsilon)
               {
                 *pColumnEpsilon = fabs(Data);
               }
           }
         else
           mMissingData = true;
       }
 
   // calculate the means;
   for (j = 0, pColumnEpsilon = ColumnEpsilons.array(); j < DependentCount; j++, pColumnEpsilon++)
     {
       if (*pColumnEpsilon == std::numeric_limits< C_FLOAT64 >::infinity())
         {
           // TODO CRITICAL We need to create a preference for this.
           *pColumnEpsilon = 1e8 * std::numeric_limits< C_FLOAT64 >::epsilon();
         }
 
       if (mColumnValidValueCount[j])
         {
           mMeans[j] /= mColumnValidValueCount[j];
           MeanSquares[j] /= mColumnValidValueCount[j];
         }
       else
         {
           // :TODO: We need to create an error message here to instruct the user
           // :TODO: to mark this column as ignored as it contains no data.
           mMeans[j] = std::numeric_limits<C_FLOAT64>::quiet_NaN();
           MeanSquares[j] = std::numeric_limits<C_FLOAT64>::quiet_NaN();
         }
     }
 
   for (i = 0; i < DependentCount; i++)
     {
       C_FLOAT64 & DefaultColumScale = mDefaultColumnScale[i];
 
       switch (*mpWeightMethod)
         {
           case SD:
             DefaultColumScale = MeanSquares[i] - mMeans[i] * mMeans[i];
             break;
 
           case MEAN:
             DefaultColumScale = mMeans[i] * mMeans[i];
             break;
 
           case MEAN_SQUARE:
             DefaultColumScale = MeanSquares[i];
             break;
 
           case VALUE_SCALING:
             DefaultColumScale = ColumnEpsilons[i] * ColumnEpsilons[i] * 1e-12;
             break;
         }
 
       if (DefaultColumScale < MinWeight) MinWeight = DefaultColumScale;
     }
 
   if (!*mpNormalizeWeightsPerExperiment)
     {
       MinWeight = 1.0;
     }
 
   if (*mpWeightMethod != VALUE_SCALING)
     {
       // We have to calculate the default weights
       for (i = 0; i < DependentCount; i++)
         mDefaultColumnScale[i] =
           (MinWeight + sqrt(std::numeric_limits< C_FLOAT64 >::epsilon()))
           / (mDefaultColumnScale[i] + sqrt(std::numeric_limits< C_FLOAT64 >::epsilon()));
     }
 
   return true;
 }

bool CExperiment::compare	(	const CExperiment *	lhs,
		const CExperiment *	rhs
	)

static

Comparison used to evaluate the order of the experiment based on the filename and starting line number.

Parameters

const	CExperiment * lhs;
const	CExperiment * rhs;

Returns: bool isLess

Definition at line 1386 of file CExperiment.cpp.

References mpFileName, and mpFirstRow.

Referenced by CExperimentSet::sort().

 {
   return (*lhs->mpFileName < *rhs->mpFileName ||
           (*lhs->mpFileName == *rhs->mpFileName &&
            *lhs->mpFirstRow < *rhs->mpFirstRow));
 }

bool CExperiment::compile ( const std::vector< CCopasiContainer * > listOfContainer = CCopasiContainer::EmptyList )

Compile the experiment. This function must be called before any evaluations can be performed.

Parameters

const std::vector< CCopasiContainer * > listOfContainer

Returns: bool success

Definition at line 735 of file CExperiment.cpp.

References CCopasiObject::buildUpdateSequence(), C_FLOAT64, C_INVALID_INDEX, CExperimentObjectMap::compile(), dependent, CCopasiMessage::ERROR, CCopasiObjectName::escape(), CExperimentObjectMap::getLastColumn(), CExperimentObjectMap::getLastNotIgnoredColumn(), CExperimentObjectMap::getMappedObjects(), CCopasiObject::getObjectDataModel(), CCopasiParameter::getObjectDisplayName(), CCopasiObject::getObjectName(), CExperimentObjectMap::getRole(), CExperimentObjectMap::getScale(), CModel::getUptoDateObjects(), CCopasiContainer::getValueObject(), CCopasiParameter::getValuePointer(), ignore, independent, initializeScalingMatrix(), CCopasiObject::isValueDbl(), MCFitting, mColumnObjectiveValue, mColumnRMS, mColumnScale, mColumnValidValueCount, mDataDependent, mDataIndependent, mDependentObjects, mDependentValues, mIndependentObjects, mIndependentUpdateMethods, mIndependentValues, mMean, mMeanSD, mObjectiveValue, mpNumColumns, mpObjectMap, mpTaskType, mRefreshMethods, mRMS, mRowObjectiveValue, mRowRMS, CMatrix< CType >::numCols(), CMatrix< CType >::numRows(), CCopasiDataModel::ObjectFromName(), CVector< CType >::resize(), time, and CCopasiTask::timeCourse.

Referenced by CQExperimentData::slotCheckNormalizeWeightsPerExperiment(), CQExperimentData::slotExperimentChanged(), CQExperimentData::slotWeightMethod(), and CQExperimentData::updateScales().

 {
   bool success = true;
 
   if (!mpObjectMap->compile(listOfContainer))
     success = false;
 
   size_t LastMappedColumn = mpObjectMap->getLastColumn();
   const CVector< CCopasiObject * > & Objects = mpObjectMap->getMappedObjects();
 
   size_t i, imax = mpObjectMap->getLastNotIgnoredColumn();
 
   if (*mpNumColumns < imax)
     *mpNumColumns = imax;
 
   //if (*mpNumColumns <= imax)
   //  {
   //    CCopasiMessage(CCopasiMessage::ERROR, MCFitting + 4, imax + 1, *mpNumColumns + 1);
   //    return false; // More column types specified than we have data columns
   //  }
 
   if (LastMappedColumn < imax || LastMappedColumn == C_INVALID_INDEX)
     {
       CCopasiMessage(CCopasiMessage::ERROR, MCFitting + 5, imax + 1);
       return false; // More column types specified than we have mapped columns
     }
 
   size_t IndependentCount = mDataIndependent.numCols();
   size_t DependentCount = mDataDependent.numCols();
 
   mDependentValues.resize(DependentCount);
   mIndependentUpdateMethods.resize(IndependentCount);
   mIndependentValues.resize(IndependentCount);
   mIndependentObjects.clear();
   mDependentObjects.clear();
   std::set< const CCopasiObject * > Dependencies;
 
   IndependentCount = 0;
   DependentCount = 0;
 
   bool TimeFound = false;
 
   for (i = 0; i <= imax; i++)
     switch (mpObjectMap->getRole(i))
       {
         case ignore:
           break;
 
         case independent:
 
           if (!Objects[i]) // Object not found
             {
               CCopasiMessage(CCopasiMessage::ERROR, MCFitting + 5, i + 1);
               return false;
             }
 
           if (!Objects[i]->isValueDbl())
             {
               CCopasiMessage(CCopasiMessage::ERROR, MCFitting + 6, Objects[i]->getObjectDisplayName().c_str(), i + 1);
               return false;
             }
 
           mIndependentObjects.insert(Objects[i]);
           mIndependentUpdateMethods[IndependentCount] =
             Objects[i]->getUpdateMethod();
           mIndependentValues[IndependentCount] =
             *(C_FLOAT64 *)Objects[i]->getValuePointer();
           // :TODO: do we have to check if getValuePointer() return a valid pointer?
 
           IndependentCount++;
           break;
 
         case dependent:
 
           if (!Objects[i]) // Object not found
             {
               CCopasiMessage(CCopasiMessage::ERROR, MCFitting + 5, i + 1);
               return false;
             }
 
           if (!Objects[i]->isValueDbl())
             {
               CCopasiMessage(CCopasiMessage::ERROR, MCFitting + 6, Objects[i]->getObjectDisplayName().c_str(), i + 1);
               return false;
             }
 
           mDependentValues[DependentCount] =
             (C_FLOAT64 *) Objects[i]->getValuePointer();
           // :TODO: do we have to check if getValuePointer() return a valid pointer?
           mDependentObjects[Objects[i]] = DependentCount;
           mColumnScale[DependentCount] = mpObjectMap->getScale(i);
           Dependencies.insert(Objects[i]->getValueObject());
 
           DependentCount++;
           break;
 
         case time:
           TimeFound = true;
           break;
       }
 
   /* We need to check whether a column is mapped to time */
   if (!TimeFound && *mpTaskType == CCopasiTask::timeCourse)
     success = false;
 
   // Allocation and initialization of statistical information
   size_t numRows = mDataDependent.numRows();
   size_t numCols = mDataDependent.numCols();
 
   // Overall statistic;
   mMean = std::numeric_limits<C_FLOAT64>::quiet_NaN();
   mMeanSD = std::numeric_limits<C_FLOAT64>::quiet_NaN();
   mObjectiveValue = std::numeric_limits<C_FLOAT64>::quiet_NaN();
   mRMS = std::numeric_limits<C_FLOAT64>::quiet_NaN();
 
   // per row statistic;
   mRowObjectiveValue.resize(numRows);
   mRowObjectiveValue = std::numeric_limits<C_FLOAT64>::quiet_NaN();
   mRowRMS.resize(numRows);
   mRowRMS = std::numeric_limits<C_FLOAT64>::quiet_NaN();
 
   // per column statistic;
   mColumnObjectiveValue.resize(numCols);
   mColumnObjectiveValue = std::numeric_limits<C_FLOAT64>::quiet_NaN();
   mColumnRMS.resize(numCols);
   mColumnRMS = std::numeric_limits<C_FLOAT64>::quiet_NaN();
   mColumnValidValueCount.resize(numCols);
   mColumnValidValueCount = std::numeric_limits<size_t>::quiet_NaN();
 
   CModel * pModel =
     dynamic_cast< CModel * >(getObjectDataModel()->ObjectFromName(listOfContainer, CCopasiObjectName("Model=" + CCopasiObjectName::escape(getObjectDataModel()->getModel()->getObjectName()))));
 
   mRefreshMethods = CCopasiObject::buildUpdateSequence(Dependencies, pModel->getUptoDateObjects());
 
   initializeScalingMatrix();
 
   return success;
 }

bool CExperiment::elevateChildren ( )

virtual

This methods must be called to elevate subgroups to derived objects. The default implementation does nothing.

Returns: bool success

Reimplemented from CCopasiParameterGroup.

Definition at line 300 of file CExperiment.cpp.

References CCopasiParameterGroup::clear(), CCopasiParameterGroup::getGroup(), CExperimentObjectMap::getObjectCN(), CCopasiParameterGroup::getValue(), mpObjectMap, mpWeightMethod, CCopasiParameter::Value::pUINT, CCopasiParameterGroup::removeParameter(), SD, CExperimentObjectMap::setNumCols(), CExperimentObjectMap::setObjectCN(), CExperimentObjectMap::setRole(), CCopasiParameterGroup::size(), StringPrint(), and updateFittedPoints().

Referenced by initializeParameter(), and operator=().

 {
   mpObjectMap =
     elevate<CExperimentObjectMap, CCopasiParameterGroup>(getGroup("Object Map"));
 
   if (!mpObjectMap) return false;
 
   CCopasiParameterGroup *pGroup = getGroup("Column Role");
 
   if (pGroup) // We have an old data format
     {
       size_t i, imax = pGroup->size();
       CExperimentObjectMap Roles;
       Roles.setNumCols(imax);
 
       for (i = 0; i < imax; i++)
         {
           Roles.setRole(i, *(Type *) pGroup->getValue(StringPrint("%d", i)).pUINT);
           Roles.setObjectCN(i, mpObjectMap->getObjectCN(i));
         }
 
       mpObjectMap->clear();
       *mpObjectMap = Roles;
       mpObjectMap =
         elevate<CExperimentObjectMap, CCopasiParameterGroup>(getGroup("Object Map"));
 
       removeParameter("Column Role");
 
       *mpWeightMethod = SD;
     }
 
   updateFittedPoints();
 
   return true;
 }

size_t CExperiment::extendedTimeSeriesSize ( ) const

Definition at line 596 of file CExperiment.cpp.

References mExtendedTimeSeriesSize.

Referenced by updateFittedPointValuesFromExtendedTimeSeries().

 {
   return mExtendedTimeSeriesSize;
 }

void CExperiment::fixBuild55 ( )

Fix files written with Version 4.10.55, which wrote the square root of user defined weights for the parameter fitting task

Definition at line 1711 of file CExperiment.cpp.

References CExperimentObjectMap::fixBuild55(), and mpObjectMap.

 {
   mpObjectMap->fixBuild55();
 }

const std::vector< std::string > & CExperiment::getColumnNames ( ) const

Retrieve the column names

Returns: const std::vector< std::string > & columnNames;

Definition at line 1214 of file CExperiment.cpp.

References mColumnName.

Referenced by CQExperimentData::loadTable().

1215 {return mColumnName;}

CExperiment::mColumnName

std::vector< std::string > mColumnName

Definition: CExperiment.h:610

size_t CExperiment::getColumnValidValueCount ( CCopasiObject *const & pObject ) const

Retrieve the data point count for the object.

Parameters

CCopasiObject * const & pObject

Returns: size_t count

Definition at line 1665 of file CExperiment.cpp.

References mColumnValidValueCount, and mDependentObjects.

 {
   std::map< CCopasiObject *, size_t>::const_iterator it
   = mDependentObjects.find(pObject);
 
   if (it != mDependentObjects.end())
     return mColumnValidValueCount[it->second];
   else
     return 0;
 }

C_FLOAT64 CExperiment::getDefaultScale ( const CCopasiObject *const & pObject ) const

Retrieve the default scaling factor for the object.

Parameters

CCopasiObject *const& pObject

Returns: C_FLOAT64 defaultScale

Definition at line 1573 of file CExperiment.cpp.

References mDefaultColumnScale, and mDependentObjects.

Referenced by CExperimentObjectMap::CDataColumn::getDefaultScale().

 {
   std::map< CCopasiObject *, size_t>::const_iterator it
   = mDependentObjects.find(const_cast<CCopasiObject*>(pObject));
 
   if (it == mDependentObjects.end())
     return std::numeric_limits<C_FLOAT64>::quiet_NaN();
 
   return mDefaultColumnScale[it->second];
 }

const CMatrix< C_FLOAT64 > & CExperiment::getDependentData ( ) const

Retrieve the dependent data of the experiment.

Returns: const CMatrix< C_FLOAT64 > & dependentData

Definition at line 1276 of file CExperiment.cpp.

References mDataDependent.

Referenced by CExperimentSet::getDependentData(), and initExtendedTimeSeries().

1277 {return mDataDependent;}

CExperiment::mDataDependent

CMatrix< C_FLOAT64 > mDataDependent

Definition: CExperiment.h:630

const std::map< CCopasiObject *, size_t > & CExperiment::getDependentObjects ( ) const

Retrieve the list of dependent data objects

Returns: const std::map< CCopasiObject *, size_t > & dependentObjects

Definition at line 1156 of file CExperiment.cpp.

References mDependentObjects.

1157 {return mDependentObjects;}

CExperiment::mDependentObjects

std::map< CCopasiObject *, size_t > mDependentObjects

Definition: CExperiment.h:680

const C_FLOAT64 & CExperiment::getErrorMean ( ) const

Retrieve the mean of the error

Parameters

const C_FLOAT64 & errorMean

Definition at line 1556 of file CExperiment.cpp.

References mMean.

Referenced by CQFittingResult::enterProtected().

1557 {return mMean;}

CExperiment::mMean

C_FLOAT64 mMean

Definition: CExperiment.h:665

const C_FLOAT64 & CExperiment::getErrorMeanSD ( ) const

Retrieve the std. deviation of the error

Parameters

const C_FLOAT64 & errorMeanSD

Definition at line 1559 of file CExperiment.cpp.

References mMeanSD.

Referenced by CQFittingResult::enterProtected().

1560 {return mMeanSD;}

CExperiment::mMeanSD

C_FLOAT64 mMeanSD

Definition: CExperiment.h:666

C_FLOAT64 CExperiment::getErrorMeanSD	(	CCopasiObject *const &	pObject,
		const C_FLOAT64 &	errorMean
	)		const

Retrieve the error mean std. deviations for the object. More specifically this is the sum of the squared deviations of the residuals from the provided errorMean. The sum is over all data points for the object.

Parameters

CCopasiObject	*const& pObject
C_FLOAT64	errorMean

Returns: C_FLOAT64 errorMeanSD

Definition at line 1627 of file CExperiment.cpp.

References CMatrix< CType >::array(), C_FLOAT64, max, mDataDependent, mDependentObjects, mpDataDependentCalculated, mScale, CMatrix< CType >::numCols(), and CMatrix< CType >::numRows().

 {
   std::map< CCopasiObject *, size_t>::const_iterator it
   = mDependentObjects.find(pObject);
 
   if (it == mDependentObjects.end() ||
       mpDataDependentCalculated == NULL)
     return std::numeric_limits<C_FLOAT64>::quiet_NaN();
 
   C_FLOAT64 MeanSD = 0;
   C_FLOAT64 Residual;
   size_t numRows = mDataDependent.numRows();
   size_t numCols = mDataDependent.numCols();
 
   const C_FLOAT64 *pDataDependentCalculated = mpDataDependentCalculated + it->second;
   const C_FLOAT64 *pEnd = pDataDependentCalculated + numRows * numCols;
   const C_FLOAT64 *pDataDependent = mDataDependent.array() + it->second;
   const C_FLOAT64 *pScale = mScale.array() + it->second;
 
   for (; pDataDependentCalculated != pEnd;
        pDataDependentCalculated += numCols, pDataDependent += numCols)
     {
 
 #ifdef COPASI_PARAMETERFITTING_RESIDUAL_SCALING
       Residual = errorMean - (*pDataDependentCalculated - *pDataDependent) / std::max(1.0, *pDataDependentCalculated);
 #else
       Residual = errorMean - (*pDataDependentCalculated - *pDataDependent) * *pScale;
 #endif
 
       if (isnan(Residual)) continue;
 
       MeanSD += Residual * Residual;
     }
 
   return MeanSD;
 }

C_FLOAT64 CExperiment::getErrorSum ( CCopasiObject *const & pObject ) const

Retrieve the sum of errors (scaled residuals) for the object.

Parameters

CCopasiObject *const& pObject

Returns: C_FLOAT64 errorSum

Definition at line 1595 of file CExperiment.cpp.

References CMatrix< CType >::array(), C_FLOAT64, mColumnScale, mDataDependent, mDependentObjects, mpDataDependentCalculated, CMatrix< CType >::numCols(), and CMatrix< CType >::numRows().

 {
   std::map< CCopasiObject *, size_t>::const_iterator it
   = mDependentObjects.find(pObject);
 
   if (it == mDependentObjects.end() ||
       mpDataDependentCalculated == NULL)
     return std::numeric_limits<C_FLOAT64>::quiet_NaN();
 
   C_FLOAT64 Mean = 0;
   C_FLOAT64 Residual;
   size_t numRows = mDataDependent.numRows();
   size_t numCols = mDataDependent.numCols();
 
   const C_FLOAT64 *pDataDependentCalculated = mpDataDependentCalculated + it->second;
   const C_FLOAT64 *pEnd = pDataDependentCalculated + numRows * numCols;
   const C_FLOAT64 *pDataDependent = mDataDependent.array() + it->second;
   const C_FLOAT64 & Weight = sqrt(mColumnScale[it->second]);
 
   for (; pDataDependentCalculated != pEnd;
        pDataDependentCalculated += numCols, pDataDependent += numCols)
     {
       Residual = Weight * (*pDataDependentCalculated - *pDataDependent);
 
       if (isnan(Residual)) continue;
 
       Mean += Residual;
     }
 
   return Mean;
 }

const CCopasiTask::Type & CExperiment::getExperimentType ( ) const

Retrieve the experiment type

Returns: const CCopasiTask::Type & experimentType

Definition at line 1237 of file CExperiment.cpp.

References mpTaskType.

Referenced by CFitProblem::calculate(), CFitProblem::calculateCrossValidation(), COutputAssistant::createDefaultOutput(), CExperimentSet::getExperimentType(), CQExperimentData::isLikePreviousExperiment(), and CQExperimentData::loadExperiment().

1238 {return *mpTaskType;}

CExperiment::mpTaskType

CCopasiTask::Type * mpTaskType

Definition: CExperiment.h:575

const std::string & CExperiment::getFileName ( ) const

Retrieve the file name

Returns: const std::string & fileName

Definition at line 1279 of file CExperiment.cpp.

References CDirEntry::fileName(), CCopasiObject::getObjectDataModel(), CDirEntry::isRelativePath(), CDirEntry::makePathAbsolute(), and mpFileName.

Referenced by guessColumnNumber(), printResult(), readColumnNames(), CQExperimentData::slotCheckNormalizeWeightsPerExperiment(), CQExperimentData::slotExperimentChanged(), CQExperimentData::slotFileDelete(), CQExperimentData::slotWeightMethod(), CExperimentFileInfo::sync(), and CQExperimentData::updateScales().

 {
   std::string * pFileName = const_cast<CExperiment *>(this)->mpFileName;
 
   if (CDirEntry::isRelativePath(*pFileName) &&
       !CDirEntry::makePathAbsolute(*pFileName,
                                    getObjectDataModel()->getFileName()))
     *pFileName = CDirEntry::fileName(*pFileName);
 
   return *mpFileName;
 }

const unsigned C_INT32 & CExperiment::getFirstRow ( ) const

Retrieve the first row

Returns: const unsigned C_INT32 & firstRow

Definition at line 1303 of file CExperiment.cpp.

References mpFirstRow.

Referenced by CQExperimentData::loadExperiment(), and CQExperimentData::slotCheckFrom().

1304 {return *mpFirstRow;}

CExperiment::mpFirstRow

unsigned C_INT32 * mpFirstRow

Definition: CExperiment.h:565

const CCopasiVector< CFittingPoint > & CExperiment::getFittingPoints ( ) const

Retrieve the list of fitting points

Returns: const CCopasiVector< CFittingPoint > & fittingPoints

Definition at line 1300 of file CExperiment.cpp.

References mFittingPoints.

Referenced by COutputAssistant::createDefaultOutput().

1301 {return mFittingPoints;}

CExperiment::mFittingPoints

CCopasiVector< CFittingPoint > mFittingPoints

Definition: CExperiment.h:682

const unsigned C_INT32 & CExperiment::getHeaderRow ( ) const

Retrieve the header row

Returns: const unsigned C_INT32 & headerRow

Definition at line 1327 of file CExperiment.cpp.

References mpHeaderRow.

Referenced by CQExperimentData::isLikePreviousExperiment(), and CQExperimentData::loadExperiment().

1328 {return *mpHeaderRow;}

CExperiment::mpHeaderRow

unsigned C_INT32 * mpHeaderRow

Definition: CExperiment.h:600

const CMatrix< C_FLOAT64 > & CExperiment::getIndependentData ( ) const

Retrieve the independent data of the experiment.

Returns: const CMatrix< C_FLOAT64 > & independentData

Definition at line 1273 of file CExperiment.cpp.

References mDataIndependent.

Referenced by CExperimentSet::getIndependentData().

1274 {return mDataIndependent;}

CExperiment::mDataIndependent

CMatrix< C_FLOAT64 > mDataIndependent

Definition: CExperiment.h:625

const std::set< const CCopasiObject * > & CExperiment::getIndependentObjects ( ) const

Retrieve the list of independent objects

Returns: const std::set< const CCopasiObject * > & independentObjects

Definition at line 1676 of file CExperiment.cpp.

References mIndependentObjects.

Referenced by CFitProblem::initialize().

 {
   return mIndependentObjects;
 }

const unsigned C_INT32 & CExperiment::getLastRow ( ) const

Retrieve the last row

Returns: const unsigned C_INT32 & lastRow

Definition at line 1315 of file CExperiment.cpp.

References mpLastRow.

Referenced by CQExperimentData::loadExperiment(), CQExperimentData::slotCheckFrom(), and CQExperimentDataValidator::validate().

1316 {return *mpLastRow;}

CExperiment::mpLastRow

unsigned C_INT32 * mpLastRow

Definition: CExperiment.h:570

bool CExperiment::getNormalizeWeightsPerExperiment ( ) const

Definition at line 1262 of file CExperiment.cpp.

References mpNormalizeWeightsPerExperiment.

Referenced by CQExperimentData::isLikePreviousExperiment(), and CQExperimentData::loadExperiment().

 {
   if (mpNormalizeWeightsPerExperiment)
     return *mpNormalizeWeightsPerExperiment;
   else
     return true;
 }

const unsigned C_INT32 & CExperiment::getNumColumns ( ) const

Retrieve the number of columns

Returns: const unsigned C_INT32 & numColumns

Definition at line 1338 of file CExperiment.cpp.

References mpNumColumns.

1339 {return *mpNumColumns;}

CExperiment::mpNumColumns

unsigned C_INT32 * mpNumColumns

Definition: CExperiment.h:605

size_t CExperiment::getNumDataRows ( ) const

Retrieve the number of data rows

Returns: const size_t numDataRows

Definition at line 1347 of file CExperiment.cpp.

References mNumDataRows.

Referenced by CFitProblem::calculate(), and CFitProblem::calculateCrossValidation().

1348 {return mNumDataRows;}

CExperiment::mNumDataRows

size_t mNumDataRows

Definition: CExperiment.h:658

const C_FLOAT64 & CExperiment::getObjectiveValue ( ) const

Retrieve the value of the objective function

Parameters

const C_FLOAT64 & errorMean

Definition at line 1550 of file CExperiment.cpp.

References mObjectiveValue.

Referenced by CQFittingResult::enterProtected().

1551 {return mObjectiveValue;}

CExperiment::mObjectiveValue

C_FLOAT64 mObjectiveValue

Definition: CExperiment.h:667

C_FLOAT64 CExperiment::getObjectiveValue ( CCopasiObject *const & pObject ) const

Retrieve the objective value for the object.

Parameters

CCopasiObject *const& pObject

Returns: C_FLOAT64 objectiveValue

Definition at line 1562 of file CExperiment.cpp.

References mColumnObjectiveValue, and mDependentObjects.

 {
   std::map< CCopasiObject *, size_t >::const_iterator it
   = mDependentObjects.find(pObject);
 
   if (it != mDependentObjects.end())
     return mColumnObjectiveValue[it->second];
   else
     return std::numeric_limits<C_FLOAT64>::quiet_NaN();
 }

CExperimentObjectMap & CExperiment::getObjectMap ( )

Retrieve the object map

Returns: CExperimentObjectMap & mpObjectMap

Definition at line 1297 of file CExperiment.cpp.

References mpObjectMap.

Referenced by CQExperimentData::isLikePreviousExperiment(), CQExperimentData::loadTable(), CQExperimentData::saveTable(), CQExperimentData::slotExprimentType(), and CQExperimentData::updateScales().

1298 {return * mpObjectMap;}

CExperiment::mpObjectMap

CExperimentObjectMap * mpObjectMap

Definition: CExperiment.h:615

const C_FLOAT64 & CExperiment::getRMS ( ) const

Retrieve the RMS

Parameters

const C_FLOAT64 & RMS

Definition at line 1553 of file CExperiment.cpp.

References mRMS.

Referenced by CQFittingResult::enterProtected().

1554 {return mRMS;}

CExperiment::mRMS

C_FLOAT64 mRMS

Definition: CExperiment.h:668

C_FLOAT64 CExperiment::getRMS ( CCopasiObject *const & pObject ) const

Retrieve the RMS for the object.

Parameters

CCopasiObject *const& pObject

Returns: C_FLOAT64 RMS

Definition at line 1584 of file CExperiment.cpp.

References mColumnRMS, and mDependentObjects.

 {
   std::map< CCopasiObject *, size_t>::const_iterator it
   = mDependentObjects.find(pObject);
 
   if (it != mDependentObjects.end())
     return mColumnRMS[it->second];
   else
     return std::numeric_limits<C_FLOAT64>::quiet_NaN();
 }

const std::string & CExperiment::getSeparator ( ) const

Retrieve the separator

Returns: const std::string & separator

Definition at line 1350 of file CExperiment.cpp.

References mpSeparator.

Referenced by CQExperimentData::isLikePreviousExperiment(), and CQExperimentData::loadExperiment().

1351 {return *mpSeparator;}

CExperiment::mpSeparator

std::string * mpSeparator

Definition: CExperiment.h:585

const CVector< C_FLOAT64 > & CExperiment::getTimeData ( ) const

Retrieve the time data of the experiment.

Returns: const CVector< C_FLOAT64 > & timeData

Definition at line 1270 of file CExperiment.cpp.

References mDataTime.

Referenced by CFitProblem::calculate(), and CFitProblem::calculateCrossValidation().

1271 {return mDataTime;}

CExperiment::mDataTime

CVector< C_FLOAT64 > mDataTime

Definition: CExperiment.h:620

const CExperiment::WeightMethod & CExperiment::getWeightMethod ( ) const

Retrieve the method used for calculating the default weights.

Returns: const WeightMethod & weightMethod

Definition at line 1359 of file CExperiment.cpp.

References mpWeightMethod.

Referenced by CQExperimentData::isLikePreviousExperiment(), CQExperimentData::loadExperiment(), CQExperimentData::slotCheckTo(), and CQExperimentData::slotWeightMethod().

1360 {return *mpWeightMethod;}

CExperiment::mpWeightMethod

WeightMethod * mpWeightMethod

Definition: CExperiment.h:590

size_t CExperiment::guessColumnNumber ( ) const

Try to guess the number of columns

Returns: size_t numColumns

Definition at line 1190 of file CExperiment.cpp.

References CLocaleString::fromUtf8(), getFileName(), CTableRow::guessColumnNumber(), mpFirstRow, mpLastRow, mpSeparator, and skipLine().

Referenced by CQExperimentData::slotExperimentAdd(), and CQExperimentData::slotSeparator().

 {
   size_t tmp, count = 0;
 
   std::ifstream in;
   in.open(CLocaleString::fromUtf8(getFileName()).c_str(), std::ios::binary);
 
   if (in.fail()) return false;
 
   // Forwind to first row.
   size_t i;
 
   for (i = 1; i < *mpFirstRow && !in.fail(); i++)
     skipLine(in);
 
   CTableRow Row(0, (*mpSeparator)[0]);
 
   for (i--; i < *mpLastRow; i++)
     if ((tmp = Row.guessColumnNumber(in, false)) > count)
       count = tmp;
 
   return count;
 }

void CExperiment::initExtendedTimeSeries ( size_t s )

Initialize the storage of an extended time series for plotting. This clears the storage, resizes it to the given size and sets the iterator to the start of the storage. The size given is the number of time points, not the number of data

Definition at line 569 of file CExperiment.cpp.

References CVectorCore< CType >::array(), getDependentData(), mExtendedTimeSeries, mExtendedTimeSeriesSize, mStorageIt, and CVector< CType >::resize().

Referenced by CFitProblem::calculate(), and CFitProblem::calculateCrossValidation().

 {
   mExtendedTimeSeriesSize = s;
   mExtendedTimeSeries.resize(s * (this->getDependentData().numCols() + 1)); //+1 for time
   mStorageIt = mExtendedTimeSeries.array();
 }

void CExperiment::initializeParameter ( )

private

Allocates all group parameters and assures that they are properly initialized.

Definition at line 256 of file CExperiment.cpp.

References CKeyFactory::add(), CCopasiParameterGroup::assertGroup(), CCopasiParameterGroup::assertParameter(), CCopasiParameter::BOOL, C_INT32, elevateChildren(), CCopasiParameter::FILE, CCopasiRootContainer::getKeyFactory(), CCopasiParameterGroup::getParameter(), CCopasiParameter::getValue(), InvalidIndex, CCopasiParameter::KEY, MEAN_SQUARE, CCopasiParameter::mKey, mpFileName, mpFirstRow, mpHeaderRow, mpLastRow, mpNormalizeWeightsPerExperiment, mpNumColumns, mpRowOriented, mpSeparator, mpTaskType, mpWeightMethod, CCopasiParameter::Value::pBOOL, CCopasiParameter::Value::pFILE, CCopasiParameter::Value::pSTRING, CCopasiParameter::Value::pUINT, CKeyFactory::remove(), CCopasiParameterGroup::removeParameter(), CCopasiParameter::setValue(), CCopasiParameter::STRING, CCopasiParameter::UINT, and CCopasiTask::unset.

Referenced by CExperiment().

 {
   CCopasiRootContainer::getKeyFactory()->remove(mKey);
   mKey = CCopasiRootContainer::getKeyFactory()->add("Experiment", this);
 
   assertParameter("Key", CCopasiParameter::KEY, mKey)->setValue(mKey);
 
   mpFileName =
     assertParameter("File Name", CCopasiParameter::FILE, std::string(""))->getValue().pFILE;
   mpFirstRow =
     assertParameter("First Row", CCopasiParameter::UINT, (unsigned C_INT32) InvalidIndex)->getValue().pUINT;
   mpLastRow =
     assertParameter("Last Row", CCopasiParameter::UINT, (unsigned C_INT32) InvalidIndex)->getValue().pUINT;
   mpTaskType = (CCopasiTask::Type *)
                assertParameter("Experiment Type", CCopasiParameter::UINT, (unsigned C_INT32) CCopasiTask::unset)->getValue().pUINT;
 
   mpNormalizeWeightsPerExperiment =
     assertParameter("Normalize Weights per Experiment", CCopasiParameter::BOOL, true)->getValue().pBOOL;
 
   mpSeparator =
     assertParameter("Separator", CCopasiParameter::STRING, std::string("\t"))->getValue().pSTRING;
   mpWeightMethod = (WeightMethod *)
                    assertParameter("Weight Method", CCopasiParameter::UINT, (unsigned C_INT32) MEAN_SQUARE)->getValue().pUINT;
   mpRowOriented =
     assertParameter("Data is Row Oriented", CCopasiParameter::BOOL, (bool) true)->getValue().pBOOL;
   mpHeaderRow =
     assertParameter("Row containing Names", CCopasiParameter::UINT, (unsigned C_INT32) InvalidIndex)->getValue().pUINT;
   mpNumColumns =
     assertParameter("Number of Columns", CCopasiParameter::UINT, (unsigned C_INT32) 0)->getValue().pUINT;
 
   assertGroup("Object Map");
 
   // Old files have a typo in the name of the separator parameter.
   CCopasiParameter * pParameter = getParameter("Seperator");
 
   if (pParameter != NULL)
     {
       *mpSeparator =  *pParameter->getValue().pSTRING;
       removeParameter("Seperator");
     }
 
   elevateChildren();
 }

void CExperiment::initializeScalingMatrix ( )

private

Initialize the scaling matrix

Definition at line 1681 of file CExperiment.cpp.

References CVectorCore< CType >::array(), CMatrix< CType >::array(), C_FLOAT64, max, mColumnScale, mDataDependent, mpWeightMethod, mScale, CMatrix< CType >::numCols(), CMatrix< CType >::numRows(), CMatrix< CType >::resize(), CVectorCore< CType >::size(), CMatrix< CType >::size(), and VALUE_SCALING.

Referenced by compile().

 {
   mScale.resize(mDataDependent.numRows(), mDataDependent.numCols());
 
   // We need to initialize the scaling factors for the residuals
   C_FLOAT64 * pData = mDataDependent.array();
   C_FLOAT64 * pScale = mScale.array();
   C_FLOAT64 * pScaleEnd = pScale + mScale.size();
 
   C_FLOAT64 * pColumnScale = mColumnScale.array();
   C_FLOAT64 * pColumnScaleEnd = pColumnScale + mColumnScale.size();
 
   for (; pScale < pScaleEnd;)
     {
       for (pColumnScale = mColumnScale.array(); pColumnScale < pColumnScaleEnd; ++pColumnScale, ++pScale, ++pData)
         {
           switch (*mpWeightMethod)
             {
               case VALUE_SCALING:
                 *pScale = 1.0 / std::max(fabs(*pData), *pColumnScale);
                 break;
 
               default:
                 *pScale = sqrt(*pColumnScale);
                 break;
             }
         }
     }
 }

const bool & CExperiment::isRowOriented ( ) const

Check whter the data is row oriented.

Returns: const bool & isRowOriented

Definition at line 1377 of file CExperiment.cpp.

References mpRowOriented.

Referenced by setIsRowOriented().

1378 {return *mpRowOriented;}

CExperiment::mpRowOriented

bool * mpRowOriented

Definition: CExperiment.h:595

CExperiment & CExperiment::operator= ( const CExperiment & rhs )

Assignment operator

Parameters

const CExperiment & rhs

Returns: CExperiment & lhs

Definition at line 229 of file CExperiment.cpp.

References CCopasiParameterGroup::clear(), elevateChildren(), CCopasiParameter::getValue(), mpFileName, mpFirstRow, mpHeaderRow, mpLastRow, mpNormalizeWeightsPerExperiment, mpNumColumns, mpRowOriented, mpSeparator, mpTaskType, mpWeightMethod, CCopasiParameter::Value::pBOOL, CCopasiParameter::Value::pFILE, CCopasiParameter::Value::pKEY, CCopasiParameter::Value::pSTRING, CCopasiParameter::Value::pUINT, and CCopasiParameterGroup::setValue().

 {
   std::string Key = *getValue("Key").pKEY;
 
   clear();
 
   *static_cast<CCopasiParameterGroup *>(this) =
     *static_cast<const CCopasiParameterGroup *>(&rhs);
 
   setValue("Key", Key);
 
   mpFileName = getValue("File Name").pFILE;
   mpFirstRow = getValue("First Row").pUINT;
   mpLastRow = getValue("Last Row").pUINT;
   mpTaskType = (CCopasiTask::Type *) getValue("Experiment Type").pUINT;
   mpNormalizeWeightsPerExperiment = getValue("Normalize Weights per Experiment").pBOOL;
   mpSeparator = getValue("Separator").pSTRING;
   mpWeightMethod = (WeightMethod *) getValue("Weight Method").pUINT;
   mpRowOriented = getValue("Data is Row Oriented").pBOOL;
   mpHeaderRow = getValue("Row containing Names").pUINT;
   mpNumColumns = getValue("Number of Columns").pUINT;
 
   elevateChildren();
 
   return *this;
 }

void CExperiment::printResult ( std::ostream * ostream ) const

virtual

This is the output method for the statistics for the experiment. This method is called from CFitProblem::printResult.

Parameters

std::ostream * ostream

Definition at line 1409 of file CExperiment.cpp.

References C_FLOAT64, dependent, getFileName(), CExperimentObjectMap::getLastNotIgnoredColumn(), CExperimentObjectMap::getMappedObjects(), CCopasiParameter::getObjectDisplayName(), CCopasiObject::getObjectName(), CExperimentObjectMap::getRole(), mColumnObjectiveValue, mColumnRMS, mColumnScale, mDataDependent, mDataTime, mMean, mNumDataRows, mObjectiveValue, mpDataDependentCalculated, mpObjectMap, mpTaskType, mRMS, mRowObjectiveValue, mRowRMS, mScale, CMatrix< CType >::numCols(), CVectorCore< CType >::size(), and CCopasiTask::timeCourse.

Referenced by CFitProblem::printResult().

 {
   std::ostream & os = *ostream;
 
   os << "File Name:\t" << getFileName() << std::endl;
   os << "Experiment:\t" << getObjectName() << std::endl;
 
   os << "Mean:\t" << mMean << std::endl;
   os << "Objective Value:\t" << mObjectiveValue << std::endl;
   os << "Root Mean Square:\t" << mRMS << std::endl;
 
   size_t i, imax = mNumDataRows;
   size_t j, jmax = mDataDependent.numCols();
   size_t k, kmax = mpObjectMap->getLastNotIgnoredColumn() + 1;
 
   const CVector<CCopasiObject *> & Objects =
     mpObjectMap->getMappedObjects();
 
   os << "Row\t";
 
   if (*mpTaskType == CCopasiTask::timeCourse)
     os << "Time\t";
 
   for (k = 0; k < kmax; k++)
     if (mpObjectMap->getRole(k) == CExperiment::dependent)
       {
         std::string Name;
 
         if (k < Objects.size() && Objects[k] != NULL)
           Name = Objects[k]->getObjectDisplayName();
         else
           Name = "unknown";
 
         os << Name << "(Data)\t";
         os << Name << "(Fit)\t";
         os << Name << "(Weighted Error)\t";
       }
 
   os << "Objective Value\tRoot Mean Square" << std::endl << std::endl;
 
   C_FLOAT64 * pDataDependentCalculated = mpDataDependentCalculated;
 
   if (pDataDependentCalculated)
     for (i = 0; i < imax; i++)
       {
         os << i + 1 << ".\t";
 
         if (*mpTaskType == CCopasiTask::timeCourse)
           os << mDataTime[i] << "\t";
 
         for (j = 0; j < jmax; j++, pDataDependentCalculated++)
           {
             os << mDataDependent(i, j) << "\t";
             os << *pDataDependentCalculated << "\t";
             os << mScale(i, j) *(*pDataDependentCalculated - mDataDependent(i, j)) << "\t";
           }
 
         os << mRowObjectiveValue[i] << "\t" << mRowRMS[i] << std::endl;
       }
   else
     for (i = 0; i < imax; i++)
       {
         os << i + 1 << ".\t";
 
         if (*mpTaskType == CCopasiTask::timeCourse)
           os << mDataTime[i] << "\t";
 
         for (j = 0; j < jmax; j++)
           {
             os << mDataDependent(i, j) << "\tNaN\tNaN\t";
           }
 
         if (i < mRowObjectiveValue.size())
           {
             os << mRowObjectiveValue[i] << "\t";
           }
         else
           {
             os << "NaN\t";
           }
 
         if (i < mRowRMS.size())
           {
             os << mRowRMS[i];
           }
         else
           {
             os << "NaN";
           }
 
         os << std::endl;
       }
 
   os << "Objective Value";
 
   if (*mpTaskType == CCopasiTask::timeCourse)
     os << "\t";
 
   for (j = 0; j < jmax; j++)
     {
       if (j < mColumnObjectiveValue.size())
         os << "\t\t\t" << mColumnObjectiveValue[j];
       else
         os << "\t\t\tNaN";
     }
 
   os << std::endl;
 
   os << "Root Mean Square";
 
   if (*mpTaskType == CCopasiTask::timeCourse)
     os << "\t";
 
   for (j = 0; j < jmax; j++)
     {
       if (j < mColumnRMS.size())
         os << "\t\t\t" << mColumnRMS[j];
       else
         os << "\t\t\tNaN";
     }
 
   os << std::endl;
 
   os << "Weight";
 
   if (*mpTaskType == CCopasiTask::timeCourse)
     os << "\t";
 
   for (j = 0; j < jmax; j++)
     {
       if (j < mColumnScale.size())
         os << "\t\t\t" << mColumnScale[j];
       else
         os << "\t\t\tNaN";
     }
 
   os << std::endl;
 
   return;
 }

bool CExperiment::read	(	std::istream &	in,
		size_t &	currentLine
	)

Reads the experiment data form a the given stream

Parameters

std::istream	& in
size_t	& currentLine

Returns: bool success

Definition at line 874 of file CExperiment.cpp.

References CVectorCore< CType >::applyPivot(), CMatrix< CType >::applyPivot(), CVectorCore< CType >::array(), C_INVALID_INDEX, calculateWeights(), dependent, CCopasiMessage::ERROR, CTableRow::getCells(), CCopasiParameterGroup::getName(), CCopasiObject::getObjectName(), CExperimentObjectMap::getRole(), ignore, independent, MCFitting, mColumnName, mColumnScale, mColumnValidValueCount, mDataDependent, mDataIndependent, mDataTime, mDefaultColumnScale, mMeans, mNumDataRows, mpDataDependentCalculated, mpFileName, mpFirstRow, mpHeaderRow, mpLastRow, mpNumColumns, mpObjectMap, mpSeparator, mpTaskType, CMatrix< CType >::resize(), CVector< CType >::resize(), CVectorCore< CType >::size(), CCopasiParameterGroup::size(), skipLine(), sortWithPivot(), time, and CCopasiTask::timeCourse.

Referenced by CQExperimentData::slotCheckNormalizeWeightsPerExperiment(), CQExperimentData::slotExperimentChanged(), CQExperimentData::slotWeightMethod(), and CQExperimentData::updateScales().

 {
   // Allocate for reading
   size_t i, imax = mpObjectMap->size();
 
   if (*mpNumColumns < imax)
     *mpNumColumns = imax;
   //if (*mpNumColumns < imax)
   //  {
   //    CCopasiMessage(CCopasiMessage::ERROR, MCFitting + 4, imax, *mpNumColumns);
   //    return false; // More column types specified than we have data columns
   //  }
 
   size_t IndependentCount = 0;
   size_t DependentCount = 0;
   size_t TimeCount = 0;
   size_t IgnoreCount = 0;
 
   for (i = 0; i < imax; i++)
     switch (mpObjectMap->getRole(i))
       {
         case ignore:
           IgnoreCount++;
           break;
 
         case independent:
           IndependentCount++;
           break;
 
         case dependent:
           DependentCount++;
           break;
 
         case time:
           TimeCount++;
           break;
       }
 
   mNumDataRows = *mpLastRow - *mpFirstRow +
                  ((*mpHeaderRow < *mpFirstRow || *mpLastRow < *mpHeaderRow) ? 1 : 0);
 
   mDataTime.resize(TimeCount ? mNumDataRows : 0);
   mDataIndependent.resize(mNumDataRows, IndependentCount);
   mDataDependent.resize(mNumDataRows, DependentCount);
   mpDataDependentCalculated = NULL;
   mColumnName.resize(IndependentCount + DependentCount + TimeCount);
 
   // resize the vectors for the statistics
   mMeans.resize(DependentCount);
   mColumnScale.resize(DependentCount);
   mDefaultColumnScale.resize(DependentCount);
   mColumnValidValueCount.resize(DependentCount);
 
   if (!TimeCount && *mpTaskType == CCopasiTask::timeCourse)
     {
       CCopasiMessage(CCopasiMessage::ERROR, MCFitting + 3, getObjectName().c_str());
       return false;
     }
 
   if (DependentCount == 0)
     {
       CCopasiMessage(CCopasiMessage::ERROR, MCFitting + 10, getObjectName().c_str());
       return false;
     }
 
   if (mNumDataRows == 0)
     {
       CCopasiMessage(CCopasiMessage::ERROR, MCFitting + 9, getObjectName().c_str());
       return false;
     }
 
   CTableRow Row(*mpNumColumns, (*mpSeparator)[0]);
   const std::vector< CTableCell > & Cells = Row.getCells();
 
   size_t j;
 
   if (currentLine > *mpFirstRow) return false; // We are past our first line
 
   // forwind to our first line
   for (j = currentLine; j < *mpFirstRow && !in.fail(); j++)
     {
       skipLine(in);
       currentLine++;
     }
 
   for (j = 0; j < mNumDataRows && !in.fail(); j++, currentLine++)
     {
       in >> Row;
 
       if (currentLine == *mpHeaderRow)
         {
           j--;
 
           size_t Column = 0;
 
           for (i = 0; i < *mpNumColumns; i++)
             if (mpObjectMap->getRole(i) != ignore)
               mColumnName[Column++] = Cells[i].getName();
 
           continue;
         }
 
       IndependentCount = 0;
       DependentCount = 0;
 
       for (i = 0; i < imax; i++)
         {
           switch (mpObjectMap->getRole(i))
             {
               case ignore:
                 break;
 
               case independent:
 
                 if (!Cells[i].isValue())
                   {
                     CCopasiMessage(CCopasiMessage::ERROR, MCFitting + 11,
                                    getObjectName().c_str(), currentLine, i + 1);
                     return false;
                   }
 
                 mDataIndependent[j][IndependentCount++] =
                   Cells[i].getValue();
                 break;
 
               case dependent:
                 mDataDependent[j][DependentCount++] =
                   Cells[i].getValue();
                 break;
 
               case time:
 
                 if (!Cells[i].isValue())
                   {
                     CCopasiMessage(CCopasiMessage::ERROR, MCFitting + 11,
                                    getObjectName().c_str(), currentLine, i + 1);
                     return false;
                   }
 
                 mDataTime[j] = Cells[i].getValue();
                 break;
             }
         }
     }
 
   if ((in.fail() && !in.eof()))
     {
       CCopasiMessage(CCopasiMessage::ERROR, MCFitting + 8, mpFileName->c_str());
       return false;
     }
 
   if (j != mNumDataRows)
     {
       CCopasiMessage(CCopasiMessage::ERROR, MCFitting + 7, mNumDataRows, j - 1);
       return false;
     }
 
   // If it is a time course this is the place to assert that it is sorted.
   if (*mpTaskType == CCopasiTask::timeCourse)
     {
       CVector<size_t> Pivot;
       sortWithPivot(mDataTime.array(), mDataTime.array() + mDataTime.size(), CompareDoubleWithNaN(), Pivot);
 
       mDataTime.applyPivot(Pivot);
       mDataIndependent.applyPivot(Pivot);
       mDataDependent.applyPivot(Pivot);
 
       for (mNumDataRows--; mNumDataRows != C_INVALID_INDEX; mNumDataRows--)
         if (!isnan(mDataTime[mNumDataRows])) break;
 
       mNumDataRows++;
     }
 
   return calculateWeights();
 }

bool CExperiment::readColumnNames ( )

Reads the header row for the experiment data

Returns: bool success

Definition at line 1159 of file CExperiment.cpp.

References CLocaleString::fromUtf8(), CTableRow::getCells(), getFileName(), CCopasiParameterGroup::getName(), InvalidIndex, mColumnName, mpHeaderRow, mpNumColumns, mpSeparator, and skipLine().

Referenced by CQExperimentData::loadTable(), and CQExperimentData::slotSeparator().

 {
   mColumnName.resize(*mpNumColumns);
 
   if (*mpHeaderRow == InvalidIndex) return false;
 
   // Open the file
   std::ifstream in;
   in.open(CLocaleString::fromUtf8(getFileName()).c_str(), std::ios::binary);
 
   if (in.fail()) return false;
 
   // Forwind to header row.
   size_t i;
 
   for (i = 1; i < *mpHeaderRow && !in.fail(); i++)
     skipLine(in);
 
   // Read row
   CTableRow Row(*mpNumColumns, (*mpSeparator)[0]);
   const std::vector< CTableCell > & Cells = Row.getCells();
   in >> Row;
 
   if (in.fail() && !in.eof()) return false;
 
   for (i = 0; i < *mpNumColumns; i++)
     mColumnName[i] = Cells[i].getName();
 
   return true;
 }

bool CExperiment::restoreModelIndependentData ( )

Restore the model with the independent data from before the experiment

Returns: bool success

Definition at line 1227 of file CExperiment.cpp.

References mIndependentUpdateMethods, mIndependentValues, and CVectorCore< CType >::size().

Referenced by CFitProblem::calculate(), and CFitProblem::calculateCrossValidation().

 {
   size_t i, imax = mIndependentUpdateMethods.size();
 
   for (i = 0; i < imax; i++)
     (*mIndependentUpdateMethods[i])(mIndependentValues[i]);
 
   return true;
 }

bool CExperiment::setExperimentType ( const CCopasiTask::Type & type )

set the experiment type

Parameters

const CCopasiTask::Type & experimentType

Returns: bool success

Definition at line 1240 of file CExperiment.cpp.

References mpTaskType, CCopasiTask::steadyState, and CCopasiTask::timeCourse.

Referenced by CQExperimentData::saveExperiment(), and CQExperimentData::slotExprimentType().

 {
   switch (type)
     {
       case CCopasiTask::steadyState:
       case CCopasiTask::timeCourse:
         *mpTaskType = type;
         return true;
         break;
 
       default:
         break;
     }
 
   return false;
 }

bool CExperiment::setFileName ( const std::string & fileName )

Set the file name

Parameters

const std::string & fileName

Returns: bool success

Definition at line 1291 of file CExperiment.cpp.

References mpFileName.

Referenced by CQExperimentData::slotExperimentAdd().

 {
   *mpFileName = fileName;
   return true;
 }

bool CExperiment::setFirstRow ( const unsigned C_INT32 & firstRow )

Set the first row containing data

Parameters

const unsigned C_INT32 & firstRow

Returns: bool success

Definition at line 1306 of file CExperiment.cpp.

References mpFirstRow, mpHeaderRow, and mpLastRow.

Referenced by CQExperimentData::saveExperiment(), CQExperimentData::slotExperimentAdd(), and CQExperimentDataValidator::validate().

 {
   if (first > *mpLastRow ||
       (first == *mpLastRow && first == *mpHeaderRow)) return false;
 
   *mpFirstRow = first;
   return true;
 }

bool CExperiment::setHeaderRow ( const unsigned C_INT32 & headerRow )

Set the header row containing data

Parameters

const unsigned C_INT32 & headerRow

Returns: bool success

Definition at line 1330 of file CExperiment.cpp.

References mpFirstRow, mpHeaderRow, and mpLastRow.

Referenced by CQExperimentData::saveExperiment(), CQExperimentData::slotExperimentAdd(), and CQExperimentDataValidator::validate().

 {
   if (header == *mpFirstRow && header == *mpLastRow) return false;
 
   *mpHeaderRow = header;
   return true;
 }

bool CExperiment::setIsRowOriented ( const bool & isRowOriented )

Set whether the data is row oriented. This only impacts reading the data from a stream

Parameters

const bool & isRowOriented

Returns: bool success

Definition at line 1380 of file CExperiment.cpp.

References isRowOriented(), and mpRowOriented.

 {
   *mpRowOriented = isRowOriented;
   return true;
 }

bool CExperiment::setLastRow ( const unsigned C_INT32 & lastRow )

Set the last row containing data

Parameters

const unsigned C_INT32 & lastRow

Returns: bool success

Definition at line 1318 of file CExperiment.cpp.

References mpFirstRow, mpHeaderRow, and mpLastRow.

Referenced by CQExperimentData::saveExperiment(), CQExperimentData::slotExperimentAdd(), and CQExperimentDataValidator::validate().

 {
   if (*mpFirstRow > last ||
       (*mpFirstRow == last && last == *mpHeaderRow)) return false;
 
   *mpLastRow = last;
   return true;
 }

void CExperiment::setNormalizeWeightsPerExperiment ( bool flag )

Definition at line 1257 of file CExperiment.cpp.

References mpNormalizeWeightsPerExperiment.

Referenced by CQExperimentData::saveExperiment(), CQExperimentData::slotCheckNormalizeWeightsPerExperiment(), and CQExperimentData::slotExperimentAdd().

 {
   *mpNormalizeWeightsPerExperiment = flag;
 }

bool CExperiment::setNumColumns ( const unsigned C_INT32 & cols )

Set the number of columns in a stream

Parameters

const unsigned C_INT32 & cols

Returns: bool success

Definition at line 1341 of file CExperiment.cpp.

References mpNumColumns.

Referenced by CQExperimentData::slotExperimentAdd(), and CQExperimentData::slotSeparator().

 {
   *mpNumColumns = cols;
   return true;
 }

bool CExperiment::setSeparator ( const std::string & seperator )

Set the seperator used when reading a stream

Parameters

const std::string & separator

Returns: bool success

Definition at line 1353 of file CExperiment.cpp.

References mpSeparator.

Referenced by CQExperimentData::saveExperiment(), and CQExperimentData::slotSeparator().

 {
   *mpSeparator = separator;
   return true;
 }

bool CExperiment::setWeightMethod ( const WeightMethod & weightMethod )

Set the weight calculation method and resets manual adjusted weights

Parameters

const WeightMethod & weightMethod

Returns: bool success

Definition at line 1362 of file CExperiment.cpp.

References mpObjectMap, mpWeightMethod, and CExperimentObjectMap::setScale().

Referenced by CQExperimentData::saveExperiment(), and CQExperimentData::slotWeightMethod().

 {
   if (*mpWeightMethod == weightMethod) return true;
 
   // Reset to default weights
   *mpWeightMethod = weightMethod;
   std::vector< CCopasiParameter * >::iterator it = mpObjectMap->CCopasiParameter::getValue().pGROUP->begin();
   std::vector< CCopasiParameter * >::iterator end = mpObjectMap->CCopasiParameter::getValue().pGROUP->end();
 
   for (; it != end; ++ it)
     static_cast< CExperimentObjectMap::CDataColumn * >(*it)->setScale(std::numeric_limits<C_FLOAT64>::quiet_NaN());
 
   return true;
 }

void CExperiment::storeExtendedTimeSeriesData ( C_FLOAT64 time )

Add one dataset to the extended time series. The time and the simulated dependent values are stored and the iterator is increased

Definition at line 576 of file CExperiment.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, mDataDependent, mDependentValues, mRefreshMethods, mStorageIt, CMatrix< CType >::numCols(), and time.

Referenced by CFitProblem::calculate(), and CFitProblem::calculateCrossValidation().

 {
   //first store time
   *mStorageIt = time; ++mStorageIt;
 
   //do all necessary refreshs
   std::vector< Refresh * >::const_iterator it = mRefreshMethods.begin();
   std::vector< Refresh * >::const_iterator end = mRefreshMethods.end();
 
   for (; it != end; ++it)
     (**it)();
 
   //store the calculated data
   C_FLOAT64 * const * ppDependentValues = mDependentValues.array();
   size_t  i, imax = mDataDependent.numCols();
 
   for (i = 0; i < imax; ++i, ++ppDependentValues, ++mStorageIt)
     *mStorageIt = **ppDependentValues;
 }

C_FLOAT64 CExperiment::sumOfSquares	(	const size_t &	index,
		C_FLOAT64 *&	residuals
	)		const

Calculate the sum of squares for the indexed row of the experiment. If residuals is not NULL residuals will contain the differences between the calculated and the experiment values.

Parameters

const	size_t & index
C_FLOAT64	*& residuals (may be NULL)

Returns: C_FLOAT64 sumOfSquares

Definition at line 426 of file CExperiment.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, max, mDataDependent, mDependentValues, mMissingData, mRefreshMethods, mScale, and CMatrix< CType >::numCols().

Referenced by CFitProblem::calculate(), and CFitProblem::calculateCrossValidation().

 {
   C_FLOAT64 Residual;
   C_FLOAT64 s = 0.0;
 
   C_FLOAT64 const * pDataDependent = mDataDependent[index];
   C_FLOAT64 const * pEnd = pDataDependent + mDataDependent.numCols();
   C_FLOAT64 * const * ppDependentValues = mDependentValues.array();
   C_FLOAT64 const * pScale = mScale[index];
 
   std::vector< Refresh * >::const_iterator it = mRefreshMethods.begin();
   std::vector< Refresh * >::const_iterator end = mRefreshMethods.end();
 
   for (; it != end; ++it)
     (**it)();
 
   if (mMissingData)
     {
       if (residuals)
         for (; pDataDependent != pEnd;
              pDataDependent++, ppDependentValues++, pScale++, residuals++)
           {
             if (isnan(*pDataDependent))
               {
                 // We ignore missing data, i.e., the residual is 0.
                 *residuals = 0.0;
                 continue;
               }
 
 #ifdef COPASI_PARAMETERFITTING_RESIDUAL_SCALING
             *residuals = (*pDataDependent - **ppDependentValues) / std::max(1.0, **ppDependentValues);
 #else
             *residuals = (*pDataDependent - **ppDependentValues) * *pScale;
 #endif
 
             s += *residuals * *residuals;
           }
       else
         for (; pDataDependent != pEnd;
              pDataDependent++, ppDependentValues++, pScale++)
           {
             if (isnan(*pDataDependent)) continue;
 
 #ifdef COPASI_PARAMETERFITTING_RESIDUAL_SCALING
             Residual = (*pDataDependent - **ppDependentValues) / std::max(1.0, **ppDependentValues);
 #else
             Residual = (*pDataDependent - **ppDependentValues) * *pScale;
 #endif
 
             s += Residual * Residual;
           }
     }
   else
     {
       if (residuals)
         for (; pDataDependent != pEnd;
              pDataDependent++, ppDependentValues++, pScale++, residuals++)
           {
 #ifdef COPASI_PARAMETERFITTING_RESIDUAL_SCALING
             *residuals = (*pDataDependent - **ppDependentValues) / std::max(1.0, **ppDependentValues);
 #else
             *residuals = (*pDataDependent - **ppDependentValues) * *pScale;
 #endif
 
             s += *residuals * *residuals;
           }
       else
         for (; pDataDependent != pEnd;
              pDataDependent++, ppDependentValues++, pScale++)
           {
 
 #ifdef COPASI_PARAMETERFITTING_RESIDUAL_SCALING
             Residual = (*pDataDependent - **ppDependentValues) / std::max(1.0, **ppDependentValues);
 #else
             Residual = (*pDataDependent - **ppDependentValues) * *pScale;
 #endif
 
             s += Residual * Residual;
           }
     }
 
   return s;
 }

C_FLOAT64 CExperiment::sumOfSquaresStore	(	const size_t &	index,
		C_FLOAT64 *&	dependentValues
	)

Calculate the sum of squares for the indexed row of the experiment. On return dependentValues contains the calculated values. If residuals is not NULL residuals will contain the differences between the calculated and the experiment values.

Parameters

const	size_t & index
C_FLOAT64	*& dependentValues (must not be NULL)

Returns: C_FLOAT64 sumOfSquares

Definition at line 511 of file CExperiment.cpp.

References CVectorCore< CType >::array(), C_FLOAT64, max, mDataDependent, mDependentValues, mMissingData, mpDataDependentCalculated, mRefreshMethods, mScale, and CMatrix< CType >::numCols().

Referenced by CFitProblem::calculate(), and CFitProblem::calculateCrossValidation().

 {
   if (index == 0)
     mpDataDependentCalculated = dependentValues;
 
   C_FLOAT64 Residual;
   C_FLOAT64 s = 0.0;
 
   C_FLOAT64 const * pDataDependent = mDataDependent[index];
   C_FLOAT64 const * pEnd = pDataDependent + mDataDependent.numCols();
   C_FLOAT64 * const * ppDependentValues = mDependentValues.array();
   C_FLOAT64 const * pScale = mScale[index];
 
   std::vector< Refresh * >::const_iterator it = mRefreshMethods.begin();
   std::vector< Refresh * >::const_iterator end = mRefreshMethods.end();
 
   for (; it != end; ++it)
     (**it)();
 
   if (mMissingData)
     {
       for (; pDataDependent != pEnd;
            pDataDependent++, ppDependentValues++, pScale++, dependentValues++)
         {
           *dependentValues = **ppDependentValues;
 
           if (isnan(*pDataDependent)) continue;
 
 #ifdef COPASI_PARAMETERFITTING_RESIDUAL_SCALING
           Residual = (*pDataDependent - *dependentValues) / std::max(1.0, *dependentValues);
 #else
           Residual = (*pDataDependent - *dependentValues) * *pScale;
 #endif
 
           s += Residual * Residual;
         }
     }
   else
     {
       for (; pDataDependent != pEnd;
            pDataDependent++, ppDependentValues++, pScale++, dependentValues++)
         {
           *dependentValues = **ppDependentValues;
 
 #ifdef COPASI_PARAMETERFITTING_RESIDUAL_SCALING
           Residual = (*pDataDependent - *dependentValues) / std::max(1.0, *dependentValues);
 #else
           Residual = (*pDataDependent - *dependentValues) * *pScale;
 #endif
 
           s += Residual * Residual;
         }
     }
 
   return s;
 }

void CExperiment::updateFittedPoints ( )

This method needs to be called whenever the Object Map is changed

Definition at line 336 of file CExperiment.cpp.

References CCopasiVector< T >::add(), CCopasiVector< T >::clear(), dependent, CExperimentObjectMap::getObjectCN(), CExperimentObjectMap::getRole(), mFittingPoints, mpObjectMap, and CCopasiParameterGroup::size().

Referenced by elevateChildren(), and CQExperimentData::saveTable().

 {
   size_t i, imax = mpObjectMap->size();
 
   mFittingPoints.clear();
   CFittingPoint * pPoint;
 
   for (i = 0; i < imax; i++)
     if (mpObjectMap->getRole(i) == dependent)
       {
         pPoint = new CFittingPoint(mpObjectMap->getObjectCN(i));
         mFittingPoints.add(pPoint, true);
       }
 }

void CExperiment::updateFittedPointValues	(	const size_t &	index,
		bool	includeSimulation
	)

This method is used for output to fill the fitted points with the values of the index data record. If index exceedds the number of data records all values are set to NaN. If includeSimulation = false the entries for the simulation results are set to NaN. (This means the simulated time series is not plotted and can be output using a different mechanism)

Definition at line 351 of file CExperiment.cpp.

References CCopasiVector< T >::begin(), C_FLOAT64, CCopasiVector< T >::end(), mDataDependent, mDataTime, mFittingPoints, mNumDataRows, mpDataDependentCalculated, mpTaskType, mScale, CMatrix< CType >::numCols(), and CCopasiTask::timeCourse.

 {
   CCopasiVector< CFittingPoint >::iterator it = mFittingPoints.begin();
   CCopasiVector< CFittingPoint >::iterator end = mFittingPoints.end();
 
   if (index >= mNumDataRows ||
       mpDataDependentCalculated == NULL)
     {
       for (; it != end; ++it)
         (*it)->setValues(std::numeric_limits<C_FLOAT64>::quiet_NaN(),
                          std::numeric_limits<C_FLOAT64>::quiet_NaN(),
                          std::numeric_limits<C_FLOAT64>::quiet_NaN(),
                          std::numeric_limits<C_FLOAT64>::quiet_NaN());
 
       return;
     }
 
   C_FLOAT64 Independent;
 
   if (*mpTaskType == CCopasiTask::timeCourse)
     Independent = mDataTime[index];
   else
     Independent = (C_FLOAT64) index;
 
   C_FLOAT64 Residual;
 
   C_FLOAT64 * pDataDependentCalculated =
     mpDataDependentCalculated + mDataDependent.numCols() * index;
   C_FLOAT64 * pDataDependent = mDataDependent[index];
   C_FLOAT64 * pScale = mScale[index];
 
   for (; it != end; ++it, ++pScale, ++pDataDependentCalculated, ++pDataDependent)
     {
 #ifdef COPASI_PARAMETERFITTING_RESIDUAL_SCALING
       Residual = (*pDataDependentCalculated - *pDataDependent) / (*pDataDependentCalculated > 1 ? *pDataDependentCalculated : 1.0);
 #else
       Residual = (*pDataDependentCalculated - *pDataDependent) * *pScale;
 #endif
 
       (*it)->setValues(Independent,
                        *pDataDependent,
                        includeSimulation ? *pDataDependentCalculated : std::numeric_limits<C_FLOAT64>::quiet_NaN(),
                        Residual);
     }
 
   return;
 }

void CExperiment::updateFittedPointValuesFromExtendedTimeSeries ( const size_t & index )

Fill the fitted points with values from the extended time series

Definition at line 399 of file CExperiment.cpp.

References CCopasiVector< T >::begin(), CCopasiVector< T >::end(), extendedTimeSeriesSize(), mDataDependent, mExtendedTimeSeries, mFittingPoints, and CMatrix< CType >::numCols().

 {
   CCopasiVector< CFittingPoint >::iterator it = mFittingPoints.begin();
   CCopasiVector< CFittingPoint >::iterator end = mFittingPoints.end();
 
   if (index >= extendedTimeSeriesSize())
     {
       for (; it != end; ++it)
         (*it)->setValues(std::numeric_limits<C_FLOAT64>::quiet_NaN(),
                          std::numeric_limits<C_FLOAT64>::quiet_NaN(),
                          std::numeric_limits<C_FLOAT64>::quiet_NaN(),
                          std::numeric_limits<C_FLOAT64>::quiet_NaN());
 
       return;
     }
 
   size_t i;
 
   for (i = 1; it != end; ++it, ++i)
     {
       (*it)->setValues(mExtendedTimeSeries[index * (mDataDependent.numCols() + 1)],
                        std::numeric_limits<C_FLOAT64>::quiet_NaN(),
                        mExtendedTimeSeries[index * (mDataDependent.numCols() + 1) + i] ,
                        std::numeric_limits<C_FLOAT64>::quiet_NaN());
     }
 }

bool CExperiment::updateModelWithIndependentData ( const size_t & index )

Update the model with the independent data of the experiment

Parameters

const size_t & index

Returns: bool success

Definition at line 1217 of file CExperiment.cpp.

References mDataIndependent, mIndependentUpdateMethods, and CVectorCore< CType >::size().

Referenced by CFitProblem::calculate(), and CFitProblem::calculateCrossValidation().

 {
   size_t i, imax = mIndependentUpdateMethods.size();
 
   for (i = 0; i < imax; i++)
     (*mIndependentUpdateMethods[i])(mDataIndependent(index, i));
 
   return true;
 }

Friends And Related Function Documentation

bool operator==	(	const CExperiment &	lhs,
		const CExperiment &	rhs
	)

friend

Comparison operator

Parameters

const	CExperiment & lhs
const	CExperiment & rhs

Returns: bool equal

Definition at line 1394 of file CExperiment.cpp.

 {
   std::string Key = *lhs.getValue("Key").pKEY;
   const_cast<CExperiment *>(&lhs)->setValue("Key", *rhs.getValue("Key").pKEY);
 
   bool Result =
     (*static_cast<const CCopasiParameterGroup *>(&lhs) ==
      *static_cast<const CCopasiParameterGroup *>(&rhs));
 
   const_cast<CExperiment *>(&lhs)->setValue("Key", Key);
 
   return Result;
 }

Member Data Documentation

std::vector< std::string > CExperiment::mColumnName

private

The column names if available after reading a file

Definition at line 610 of file CExperiment.h.

Referenced by getColumnNames(), read(), and readColumnNames().

CVector< C_FLOAT64 > CExperiment::mColumnObjectiveValue

private

Definition at line 673 of file CExperiment.h.

Referenced by calculateStatistics(), compile(), getObjectiveValue(), and printResult().

CVector< C_FLOAT64 > CExperiment::mColumnRMS

private

Definition at line 674 of file CExperiment.h.

Referenced by calculateStatistics(), compile(), getRMS(), and printResult().

CVector< C_FLOAT64 > CExperiment::mColumnScale

private

Definition at line 644 of file CExperiment.h.

Referenced by compile(), getErrorSum(), initializeScalingMatrix(), printResult(), and read().

CVector< size_t > CExperiment::mColumnValidValueCount

private

Definition at line 675 of file CExperiment.h.

Referenced by calculateStatistics(), calculateWeights(), compile(), getColumnValidValueCount(), and read().

CMatrix< C_FLOAT64 > CExperiment::mDataDependent

private

The relevant dependent experimental data after reading a file

Definition at line 630 of file CExperiment.h.

Referenced by calculateStatistics(), calculateWeights(), compile(), getDependentData(), getErrorMeanSD(), getErrorSum(), initializeScalingMatrix(), printResult(), read(), storeExtendedTimeSeriesData(), sumOfSquares(), sumOfSquaresStore(), updateFittedPointValues(), and updateFittedPointValuesFromExtendedTimeSeries().

CMatrix< C_FLOAT64 > CExperiment::mDataIndependent

private

The relevant independent experimental data after reading a file

Definition at line 625 of file CExperiment.h.

Referenced by compile(), getIndependentData(), read(), and updateModelWithIndependentData().

CVector< C_FLOAT64 > CExperiment::mDataTime

private

The vector of time points

Definition at line 620 of file CExperiment.h.

Referenced by getTimeData(), printResult(), read(), and updateFittedPointValues().

CVector< C_FLOAT64 > CExperiment::mDefaultColumnScale

private

Definition at line 646 of file CExperiment.h.

Referenced by calculateWeights(), getDefaultScale(), and read().

std::map< CCopasiObject *, size_t > CExperiment::mDependentObjects

private

A map of all dependent data objects to dependent data columns;

Definition at line 680 of file CExperiment.h.

Referenced by compile(), getColumnValidValueCount(), getDefaultScale(), getDependentObjects(), getErrorMeanSD(), getErrorSum(), getObjectiveValue(), and getRMS().

CVector< C_FLOAT64 * > CExperiment::mDependentValues

private

Definition at line 648 of file CExperiment.h.

Referenced by compile(), storeExtendedTimeSeriesData(), sumOfSquares(), and sumOfSquaresStore().

CVector< C_FLOAT64 > CExperiment::mExtendedTimeSeries

private

Definition at line 685 of file CExperiment.h.

Referenced by CExperiment(), initExtendedTimeSeries(), and updateFittedPointValuesFromExtendedTimeSeries().

size_t CExperiment::mExtendedTimeSeriesSize

private

Definition at line 691 of file CExperiment.h.

Referenced by extendedTimeSeriesSize(), and initExtendedTimeSeries().

CCopasiVector< CFittingPoint > CExperiment::mFittingPoints

private

Definition at line 682 of file CExperiment.h.

Referenced by getFittingPoints(), updateFittedPoints(), updateFittedPointValues(), and updateFittedPointValuesFromExtendedTimeSeries().

std::set< const CCopasiObject * > CExperiment::mIndependentObjects

private

Definition at line 654 of file CExperiment.h.

Referenced by compile(), and getIndependentObjects().

CVector< UpdateMethod * > CExperiment::mIndependentUpdateMethods

private

Definition at line 650 of file CExperiment.h.

Referenced by compile(), restoreModelIndependentData(), and updateModelWithIndependentData().

CVector< C_FLOAT64 > CExperiment::mIndependentValues

private

Definition at line 656 of file CExperiment.h.

Referenced by compile(), and restoreModelIndependentData().

C_FLOAT64 CExperiment::mMean

private

Definition at line 665 of file CExperiment.h.

Referenced by calculateStatistics(), compile(), getErrorMean(), and printResult().

CVector< C_FLOAT64 > CExperiment::mMeans

private

Definition at line 642 of file CExperiment.h.

Referenced by calculateWeights(), and read().

C_FLOAT64 CExperiment::mMeanSD

private

Definition at line 666 of file CExperiment.h.

Referenced by calculateStatistics(), compile(), and getErrorMeanSD().

bool CExperiment::mMissingData

private

Indicates whether we have missing data

Definition at line 640 of file CExperiment.h.

Referenced by calculateWeights(), sumOfSquares(), and sumOfSquaresStore().

size_t CExperiment::mNumDataRows

private

Definition at line 658 of file CExperiment.h.

Referenced by calculateWeights(), getNumDataRows(), printResult(), read(), and updateFittedPointValues().

C_FLOAT64 CExperiment::mObjectiveValue

private

Definition at line 667 of file CExperiment.h.

Referenced by calculateStatistics(), compile(), getObjectiveValue(), and printResult().

C_FLOAT64* CExperiment::mpDataDependentCalculated

private

The relevant dependent experimental data after reading a file

Definition at line 663 of file CExperiment.h.

Referenced by calculateStatistics(), getErrorMeanSD(), getErrorSum(), printResult(), read(), sumOfSquaresStore(), and updateFittedPointValues().

std::string* CExperiment::mpFileName

private

This is realized as a CCopasiParameter type STRING

Definition at line 560 of file CExperiment.h.

Referenced by compare(), getFileName(), initializeParameter(), operator=(), read(), and setFileName().

unsigned C_INT32* CExperiment::mpFirstRow

private

This is realized as a CCopasiParameter type UINT

Definition at line 565 of file CExperiment.h.

Referenced by compare(), getFirstRow(), guessColumnNumber(), initializeParameter(), operator=(), read(), setFirstRow(), setHeaderRow(), and setLastRow().

unsigned C_INT32* CExperiment::mpHeaderRow

private

This is realized as a CCopasiParameter type UINT

Definition at line 600 of file CExperiment.h.

Referenced by getHeaderRow(), initializeParameter(), operator=(), read(), readColumnNames(), setFirstRow(), setHeaderRow(), and setLastRow().

unsigned C_INT32* CExperiment::mpLastRow

private

This is realized as a CCopasiParameter type UINT

Definition at line 570 of file CExperiment.h.

Referenced by getLastRow(), guessColumnNumber(), initializeParameter(), operator=(), read(), setFirstRow(), setHeaderRow(), and setLastRow().

bool* CExperiment::mpNormalizeWeightsPerExperiment

private

Indicates whether the weights of this experiment should be normalized to 1

Definition at line 580 of file CExperiment.h.

Referenced by calculateWeights(), getNormalizeWeightsPerExperiment(), initializeParameter(), operator=(), and setNormalizeWeightsPerExperiment().

unsigned C_INT32* CExperiment::mpNumColumns

private

This is realized as a CCopasiParameter type UINT

Definition at line 605 of file CExperiment.h.

Referenced by compile(), getNumColumns(), initializeParameter(), operator=(), read(), readColumnNames(), and setNumColumns().

CExperimentObjectMap* CExperiment::mpObjectMap

private

This is realized as a CCopasiParameter type GROUP

Definition at line 615 of file CExperiment.h.

Referenced by compile(), elevateChildren(), fixBuild55(), getObjectMap(), printResult(), read(), setWeightMethod(), and updateFittedPoints().

bool* CExperiment::mpRowOriented

private

This is realized as a CCopasiParameter type BOOL

Definition at line 595 of file CExperiment.h.

Referenced by initializeParameter(), isRowOriented(), operator=(), and setIsRowOriented().

std::string* CExperiment::mpSeparator

private

This is realized as a CCopasiParameter type STRING

Definition at line 585 of file CExperiment.h.

Referenced by getSeparator(), guessColumnNumber(), initializeParameter(), operator=(), read(), readColumnNames(), and setSeparator().

CCopasiTask::Type* CExperiment::mpTaskType

private

This is realized as a CCopasiParameter type UINT

Definition at line 575 of file CExperiment.h.

Referenced by calculateStatistics(), compile(), getExperimentType(), initializeParameter(), operator=(), printResult(), read(), setExperimentType(), and updateFittedPointValues().

WeightMethod* CExperiment::mpWeightMethod

private

This is realized as a CCopasiParameter type UINT

Definition at line 590 of file CExperiment.h.

Referenced by calculateWeights(), elevateChildren(), getWeightMethod(), initializeParameter(), initializeScalingMatrix(), operator=(), and setWeightMethod().

std::vector< Refresh * > CExperiment::mRefreshMethods

private

Definition at line 652 of file CExperiment.h.

Referenced by compile(), storeExtendedTimeSeriesData(), sumOfSquares(), and sumOfSquaresStore().

C_FLOAT64 CExperiment::mRMS

private

Definition at line 668 of file CExperiment.h.

Referenced by calculateStatistics(), compile(), getRMS(), and printResult().

CVector< C_FLOAT64 > CExperiment::mRowObjectiveValue

private

Definition at line 670 of file CExperiment.h.

Referenced by calculateStatistics(), compile(), and printResult().

CVector< C_FLOAT64 > CExperiment::mRowRMS

private

Definition at line 671 of file CExperiment.h.

Referenced by calculateStatistics(), compile(), and printResult().

CMatrix< C_FLOAT64 > CExperiment::mScale

private

The individual scale for each residual

Definition at line 635 of file CExperiment.h.

Referenced by calculateStatistics(), getErrorMeanSD(), initializeScalingMatrix(), printResult(), sumOfSquares(), sumOfSquaresStore(), and updateFittedPointValues().

C_FLOAT64* CExperiment::mStorageIt

private

Definition at line 688 of file CExperiment.h.

Referenced by CExperiment(), initExtendedTimeSeries(), and storeExtendedTimeSeriesData().

const std::string CExperiment::TypeName

static

Initial value:

=
{
  "ignored",
  "independent",
  "dependent",
  "Time",
  ""
}

String literals for the GUI to display type names of columns known to COPASI.

Definition at line 79 of file CExperiment.h.

Referenced by CQExperimentData::init(), CQExperimentData::loadTable(), CQExperimentData::saveTable(), and CQExperimentData::slotTypeChanged().

const std::string CExperiment::WeightMethodName

static

Initial value:

=
{
  "Mean",
  "Mean Square",
  "Standard Deviation",
  "Value Scaling",
  ""
}

String literals for the GUI to display weight method known to COPASI.

Definition at line 101 of file CExperiment.h.

Referenced by CQExperimentData::init().

const char * CExperiment::WeightMethodType

static

Initial value:

=
{
  "Mean",
  "MeanSquare",
  "StandardDeviation",
  "ValueScaling",
  NULL
}

XML type names of weight methods known to COPASI.

Definition at line 106 of file CExperiment.h.

const char * CExperiment::XMLType

static

Initial value:

=
{
  "ignored",
  "independent",
  "dependent",
  "time",
  NULL
}

XML type names of tasks known to COPASI.

Definition at line 84 of file CExperiment.h.

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation