AbstractParameterisedSystem.cpp

/*

Copyright (C) University of Oxford, 2005-2011

University of Oxford means the Chancellor, Masters and Scholars of the
University of Oxford, having an administrative office at Wellington
Square, Oxford OX1 2JD, UK.

This file is part of Chaste.

Chaste is free software: you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.

Chaste is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
License for more details. The offer of Chaste under the terms of the
License is subject to the License being interpreted in accordance with
English Law and subject to any action against the University of Oxford
being under the jurisdiction of the English Courts.

You should have received a copy of the GNU Lesser General Public License
along with Chaste. If not, see <http://www.gnu.org/licenses/>.

*/

#include <cassert>

#include "AbstractParameterisedSystem.hpp"

#include "Exception.hpp"
#include "VectorHelperFunctions.hpp"

#ifdef CHASTE_CVODE
// CVODE headers
#include <nvector/nvector_serial.h>
#endif

template<typename VECTOR>
AbstractParameterisedSystem<VECTOR>::AbstractParameterisedSystem(unsigned numberOfStateVariables)
    : mNumberOfStateVariables(numberOfStateVariables)
{
    InitialiseEmptyVector(mParameters);
    InitialiseEmptyVector(mStateVariables);
}

template<typename VECTOR>
AbstractParameterisedSystem<VECTOR>::~AbstractParameterisedSystem()
{
}

template<typename VECTOR>
boost::shared_ptr<const AbstractOdeSystemInformation> AbstractParameterisedSystem<VECTOR>::GetSystemInformation() const
{
    assert(mpSystemInfo);
    return mpSystemInfo;
}


template<typename VECTOR>
std::string AbstractParameterisedSystem<VECTOR>::GetSystemName() const
{
    assert(mpSystemInfo);
    return mpSystemInfo->GetSystemName();
}

//
// State variable methods
//

template<typename VECTOR>
unsigned AbstractParameterisedSystem<VECTOR>::GetNumberOfStateVariables() const
{
    return mNumberOfStateVariables;
}

template<typename VECTOR>
VECTOR& AbstractParameterisedSystem<VECTOR>::rGetStateVariables()
{
    return mStateVariables;
}

template<typename VECTOR>
VECTOR AbstractParameterisedSystem<VECTOR>::GetStateVariables()
{
    return CopyVector(mStateVariables);
}

template<typename VECTOR>
void AbstractParameterisedSystem<VECTOR>::SetStateVariables(const VECTOR& rStateVariables)
{
    if ( mNumberOfStateVariables != GetVectorSize(rStateVariables) )
    {
        EXCEPTION("The size of the passed in vector must be that of the number of state variables.");
    }
    CreateVectorIfEmpty(mStateVariables, mNumberOfStateVariables);
    for (unsigned i=0; i<mNumberOfStateVariables; i++)
    {
        SetVectorComponent(mStateVariables, i, GetVectorComponent(rStateVariables, i));
    }
}

template<typename VECTOR>
double AbstractParameterisedSystem<VECTOR>::GetStateVariable(unsigned index) const
{
    if (index >= mNumberOfStateVariables)
    {
        EXCEPTION("The index passed in must be less than the number of state variables.");
    }
    return GetVectorComponent(mStateVariables, index);
}

template<typename VECTOR>
double AbstractParameterisedSystem<VECTOR>::GetStateVariable(const std::string& rName) const
{
    return GetStateVariable(GetStateVariableIndex(rName));
}

template<typename VECTOR>
void AbstractParameterisedSystem<VECTOR>::SetStateVariable(unsigned index, double newValue)
{
    if ( mNumberOfStateVariables <= index )
    {
        EXCEPTION("The index passed in must be less than the number of state variables.");
    }
    SetVectorComponent(mStateVariables, index, newValue);
}

template<typename VECTOR>
void AbstractParameterisedSystem<VECTOR>::SetStateVariable(const std::string& rName, double newValue)
{
    SetStateVariable(GetStateVariableIndex(rName), newValue);
}

template<typename VECTOR>
const std::vector<std::string>& AbstractParameterisedSystem<VECTOR>::rGetStateVariableNames() const
{
    assert(mpSystemInfo);
    return mpSystemInfo->rGetStateVariableNames();
}

template<typename VECTOR>
const std::vector<std::string>& AbstractParameterisedSystem<VECTOR>::rGetStateVariableUnits() const
{
    assert(mpSystemInfo);
    return mpSystemInfo->rGetStateVariableUnits();
}

template<typename VECTOR>
unsigned AbstractParameterisedSystem<VECTOR>::GetStateVariableIndex(const std::string& rName) const
{
    assert(mpSystemInfo);
    return mpSystemInfo->GetStateVariableIndex(rName);
}

template<typename VECTOR>
bool AbstractParameterisedSystem<VECTOR>::HasStateVariable(const std::string& rName) const
{
    assert(mpSystemInfo);
    return mpSystemInfo->HasStateVariable(rName);
}

template<typename VECTOR>
std::string AbstractParameterisedSystem<VECTOR>::GetStateVariableUnits(unsigned index) const
{
    assert(mpSystemInfo);
    return mpSystemInfo->GetStateVariableUnits(index);
}

//
// Initial condition methods
//

template<typename VECTOR>
void AbstractParameterisedSystem<VECTOR>::SetDefaultInitialConditions(const VECTOR& rInitialConditions)
{
    if (GetVectorSize(rInitialConditions) != mNumberOfStateVariables)
    {
        EXCEPTION("The number of initial conditions must be that of the number of state variables.");
    }
    assert(mpSystemInfo);
    std::vector<double> inits;
    CopyToStdVector(rInitialConditions, inits);
    mpSystemInfo->SetDefaultInitialConditions(inits);
}

template<typename VECTOR>
void AbstractParameterisedSystem<VECTOR>::SetDefaultInitialCondition(unsigned index, double initialCondition)
{
    if (index >= mNumberOfStateVariables)
    {
        EXCEPTION("Index is greater than the number of state variables.");
    }
    assert(mpSystemInfo);
    mpSystemInfo->SetDefaultInitialCondition(index, initialCondition);
}

template<typename VECTOR>
VECTOR AbstractParameterisedSystem<VECTOR>::GetInitialConditions() const
{
    assert(mpSystemInfo);
    VECTOR v;
    InitialiseEmptyVector(v);
    CreateVectorIfEmpty(v, mNumberOfStateVariables);
    CopyFromStdVector(mpSystemInfo->GetInitialConditions(), v);
    return v;
}

template<typename VECTOR>
void AbstractParameterisedSystem<VECTOR>::ResetToInitialConditions()
{
    VECTOR inits = GetInitialConditions();
    SetStateVariables(inits);
    DeleteVector(inits);
}

//
// Parameter methods
//

template<typename VECTOR>
unsigned AbstractParameterisedSystem<VECTOR>::GetNumberOfParameters() const
{
    return GetVectorSize(mParameters);
}

template<typename VECTOR>
double AbstractParameterisedSystem<VECTOR>::GetParameter(unsigned index) const
{
    if (index >= GetVectorSize(mParameters))
    {
        EXCEPTION("The index passed in must be less than the number of parameters.");
    }
    return GetVectorComponent(mParameters, index);
}

template<typename VECTOR>
void AbstractParameterisedSystem<VECTOR>::SetParameter(unsigned index, double value)
{
    if (index >= GetVectorSize(mParameters))
    {
        EXCEPTION("The index passed in must be less than the number of parameters.");
    }
    SetVectorComponent(mParameters, index, value);
}

template<typename VECTOR>
void AbstractParameterisedSystem<VECTOR>::SetParameter(const std::string& rName, double value)
{
    SetVectorComponent(mParameters, GetParameterIndex(rName), value);
}

template<typename VECTOR>
double AbstractParameterisedSystem<VECTOR>::GetParameter(const std::string& rName) const
{
    return GetParameter(GetParameterIndex(rName));
}

template<typename VECTOR>
const std::vector<std::string>& AbstractParameterisedSystem<VECTOR>::rGetParameterNames() const
{
    assert(mpSystemInfo);
    return mpSystemInfo->rGetParameterNames();
}

template<typename VECTOR>
const std::vector<std::string>& AbstractParameterisedSystem<VECTOR>::rGetParameterUnits() const
{
    assert(mpSystemInfo);
    return mpSystemInfo->rGetParameterUnits();
}

template<typename VECTOR>
unsigned AbstractParameterisedSystem<VECTOR>::GetParameterIndex(const std::string& rName) const
{
    assert(mpSystemInfo);
    return mpSystemInfo->GetParameterIndex(rName);
}

template<typename VECTOR>
bool AbstractParameterisedSystem<VECTOR>::HasParameter(const std::string& rName) const
{
    assert(mpSystemInfo);
    return mpSystemInfo->HasParameter(rName);
}

template<typename VECTOR>
std::string AbstractParameterisedSystem<VECTOR>::GetParameterUnits(unsigned index) const
{
    assert(mpSystemInfo);
    return mpSystemInfo->GetParameterUnits(index);
}

//
// "Any variable" methods
//

template<typename VECTOR>
double AbstractParameterisedSystem<VECTOR>::GetAnyVariable(unsigned index, double time,
                                                           VECTOR* pDerivedQuantities)
{
    if (index < mNumberOfStateVariables)
    {
        return GetVectorComponent(mStateVariables, index);
    }
    else if (index - mNumberOfStateVariables < GetVectorSize(mParameters))
    {
        return GetVectorComponent(mParameters, index - mNumberOfStateVariables);
    }
    else
    {
        unsigned offset = mNumberOfStateVariables + GetVectorSize(mParameters);
        if (index - offset < GetNumberOfDerivedQuantities())
        {
            VECTOR dqs;
            if (pDerivedQuantities == NULL)
            {
                dqs = ComputeDerivedQuantitiesFromCurrentState(time);
                pDerivedQuantities = &dqs;
            }
            double value = GetVectorComponent(*pDerivedQuantities, index - offset);
            if (pDerivedQuantities == &dqs)
            {
                DeleteVector(dqs);
            }
            return value;
        }
        else
        {
            EXCEPTION("Invalid index passed to GetAnyVariable.");
        }
    }
}

template<typename VECTOR>
double AbstractParameterisedSystem<VECTOR>::GetAnyVariable(const std::string& rName,
                                                           double time,
                                                           VECTOR* pDerivedQuantities)
{
    return GetAnyVariable(GetAnyVariableIndex(rName), time, pDerivedQuantities);
}

template<typename VECTOR>
unsigned AbstractParameterisedSystem<VECTOR>::GetAnyVariableIndex(const std::string& rName) const
{
    assert(mpSystemInfo);
    return mpSystemInfo->GetAnyVariableIndex(rName);
}

template<typename VECTOR>
bool AbstractParameterisedSystem<VECTOR>::HasAnyVariable(const std::string& rName) const
{
    assert(mpSystemInfo);
    return mpSystemInfo->HasAnyVariable(rName);
}

template<typename VECTOR>
void AbstractParameterisedSystem<VECTOR>::SetAnyVariable(unsigned index, double value)
{
    if (index < mNumberOfStateVariables)
    {
        SetVectorComponent(mStateVariables, index, value);
    }
    else if (index - mNumberOfStateVariables < GetVectorSize(mParameters))
    {
        SetVectorComponent(mParameters, index - mNumberOfStateVariables, value);
    }
    else
    {
        EXCEPTION("Cannot set the value of a derived quantity, or invalid index.");
    }
}

template<typename VECTOR>
void AbstractParameterisedSystem<VECTOR>::SetAnyVariable(const std::string& rName, double value)
{
    SetAnyVariable(GetAnyVariableIndex(rName), value);
}

template<typename VECTOR>
std::string AbstractParameterisedSystem<VECTOR>::GetAnyVariableUnits(unsigned index) const
{
    assert(mpSystemInfo);
    return mpSystemInfo->GetAnyVariableUnits(index);
}

template<typename VECTOR>
std::string AbstractParameterisedSystem<VECTOR>::GetAnyVariableUnits(const std::string& rName) const
{
    return GetAnyVariableUnits(GetAnyVariableIndex(rName));
}

//
// "Derived quantities" methods
//

template<typename VECTOR>
unsigned AbstractParameterisedSystem<VECTOR>::GetNumberOfDerivedQuantities() const
{
    assert(mpSystemInfo);
    return mpSystemInfo->rGetDerivedQuantityNames().size();
}

template<typename VECTOR>
VECTOR AbstractParameterisedSystem<VECTOR>::ComputeDerivedQuantities(double time,
                                                                     const VECTOR& rState)
{
    EXCEPTION("This ODE system does not define derived quantities.");
}

template<typename VECTOR>
VECTOR AbstractParameterisedSystem<VECTOR>::ComputeDerivedQuantitiesFromCurrentState(double time)
{
    return this->ComputeDerivedQuantities(time, mStateVariables);
}

template<typename VECTOR>
const std::vector<std::string>& AbstractParameterisedSystem<VECTOR>::rGetDerivedQuantityNames() const
{
    assert(mpSystemInfo);
    return mpSystemInfo->rGetDerivedQuantityNames();
}

template<typename VECTOR>
const std::vector<std::string>& AbstractParameterisedSystem<VECTOR>::rGetDerivedQuantityUnits() const
{
    assert(mpSystemInfo);
    return mpSystemInfo->rGetDerivedQuantityUnits();
}

template<typename VECTOR>
unsigned AbstractParameterisedSystem<VECTOR>::GetDerivedQuantityIndex(const std::string& rName) const
{
    assert(mpSystemInfo);
    return mpSystemInfo->GetDerivedQuantityIndex(rName);
}

template<typename VECTOR>
bool AbstractParameterisedSystem<VECTOR>::HasDerivedQuantity(const std::string& rName) const
{
    assert(mpSystemInfo);
    return mpSystemInfo->HasDerivedQuantity(rName);
}

template<typename VECTOR>
std::string AbstractParameterisedSystem<VECTOR>::GetDerivedQuantityUnits(unsigned index) const
{
    assert(mpSystemInfo);
    return mpSystemInfo->GetDerivedQuantityUnits(index);
}


template<typename VECTOR>
unsigned AbstractParameterisedSystem<VECTOR>::GetNumberOfAttributes() const
{
    assert(mpSystemInfo);
    return mpSystemInfo->GetNumberOfAttributes();
}

template<typename VECTOR>
bool AbstractParameterisedSystem<VECTOR>::HasAttribute(const std::string& rName) const
{
    assert(mpSystemInfo);
    return mpSystemInfo->HasAttribute(rName);
}

template<typename VECTOR>
double AbstractParameterisedSystem<VECTOR>::GetAttribute(const std::string& rName) const
{
    assert(mpSystemInfo);
    return mpSystemInfo->GetAttribute(rName);
}



// Explicit instantiation

template class AbstractParameterisedSystem<std::vector<double> >;
#ifdef CHASTE_CVODE
template class AbstractParameterisedSystem<N_Vector>;
#endif

---