VectorHelperFunctions.hpp

Go to the documentation of this file.

/*

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/>.

*/

#ifndef VECTORHELPERFUNCTIONS_HPP_
#define VECTORHELPERFUNCTIONS_HPP_

#include <cassert>
#include <vector>

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

template<typename VECTOR>
inline double GetVectorComponent(const VECTOR& rVec, unsigned index);

template<typename VECTOR>
inline void SetVectorComponent(VECTOR& rVec, unsigned index, double value);

template<typename VECTOR>
inline unsigned GetVectorSize(const VECTOR& rVec);

template<typename VECTOR>
inline void InitialiseEmptyVector(VECTOR& rVec);

template<typename VECTOR>
inline void CreateVectorIfEmpty(VECTOR& rVec, unsigned size);

template<typename VECTOR>
inline VECTOR CreateEmptyVector();

template<typename VECTOR>
inline bool IsEmptyVector(VECTOR& rVec);

template<typename VECTOR>
inline void DeleteVector(VECTOR& rVec);

template<typename VECTOR>
inline VECTOR CopyVector(VECTOR& rVec);

template<typename VECTOR>
inline void CopyToStdVector(const VECTOR& rSrc, std::vector<double>& rDest);

template<typename VECTOR>
inline void CopyFromStdVector(const std::vector<double>& rSrc, VECTOR& rDest);

// Specialisations for std::vector<double>

template<>
inline double GetVectorComponent(const std::vector<double>& rVec, unsigned index)
{
    assert(index < rVec.size());
    return rVec[index];
}

template<>
inline void SetVectorComponent(std::vector<double>& rVec, unsigned index, double value)
{
    assert(index < rVec.size());
    rVec[index] = value;
}

template<>
inline unsigned GetVectorSize(const std::vector<double>& rVec)
{
    return rVec.size();
}

template<>
inline void InitialiseEmptyVector(std::vector<double>& rVec)
{
}

template<>
inline void CreateVectorIfEmpty(std::vector<double>& rVec, unsigned size)
{
    if (rVec.empty())
    {
        rVec.resize(size);
    }
}

template<>
inline std::vector<double> CreateEmptyVector()
{
    return std::vector<double>();
}

template<>
inline bool IsEmptyVector(std::vector<double>& rVec)
{
    return rVec.empty();
}

template<>
inline void DeleteVector(std::vector<double>& rVec)
{
}

template<>
inline std::vector<double> CopyVector(std::vector<double>& rVec)
{
    return rVec;
}

template<>
inline void CopyToStdVector(const std::vector<double>& rSrc, std::vector<double>& rDest)
{
    rDest = rSrc;
}

template<>
inline void CopyFromStdVector(const std::vector<double>& rSrc, std::vector<double>& rDest)
{
    rDest = rSrc;
}

// Specialisations for N_Vector

#ifdef CHASTE_CVODE

template<>
inline double GetVectorComponent(const N_Vector& rVec, unsigned index)
{
    assert(rVec != NULL);
    return NV_Ith_S(rVec, index);
}

template<>
inline void SetVectorComponent(N_Vector& rVec, unsigned index, double value)
{
    assert(rVec != NULL);
    NV_Ith_S(rVec, index) = value;
}

template<>
inline unsigned GetVectorSize(const N_Vector& rVec)
{
    assert(rVec != NULL);
    return NV_LENGTH_S(rVec);
}

template<>
inline void InitialiseEmptyVector(N_Vector& rVec)
{
    rVec = NULL;
}

template<>
inline void CreateVectorIfEmpty(N_Vector& rVec, unsigned size)
{
    if (rVec == NULL)
    {
        rVec = N_VNew_Serial(size);
    }
}

template<>
inline N_Vector CreateEmptyVector()
{
    return NULL;
}

template<>
inline bool IsEmptyVector(N_Vector& rVec)
{
    return rVec == NULL;
}

template<>
inline void DeleteVector(N_Vector& rVec)
{
    if (rVec)
    {
        rVec->ops->nvdestroy(rVec);
        rVec = NULL;
    }
}

template<>
inline N_Vector CopyVector(N_Vector& rVec)
{
    N_Vector copy = NULL;
    if (rVec)
    {
        copy = N_VClone(rVec);
        unsigned size = NV_LENGTH_S(rVec);
        for (unsigned i=0; i<size; i++)
        {
            NV_Ith_S(copy, i) = NV_Ith_S(rVec, i);
        }
    }
    return copy;
}

template<>
inline void CopyToStdVector(const N_Vector& rSrc, std::vector<double>& rDest)
{
    // Check for no-op
    realtype* p_src = NV_DATA_S(rSrc);
    if (p_src == &(rDest[0])) return;
    // Set dest size
    long size = NV_LENGTH_S(rSrc);
    rDest.resize(size);
    // Copy data
    for (long i=0; i<size; i++)
    {
        rDest[i] = p_src[i];
    }
}

template<>
inline void CopyFromStdVector(const std::vector<double>& rSrc, N_Vector& rDest)
{
    // Check for no-op
    realtype* p_dest = NV_DATA_S(rDest);
    if (p_dest == &(rSrc[0])) return;

    // Check dest size
    long size = NV_LENGTH_S(rDest);
    assert(size == (long)rSrc.size());

    // Copy data
    for (long i=0; i<size; i++)
    {
        p_dest[i] = rSrc[i];
    }
}

inline std::vector<double> MakeStdVec(N_Vector v)
{
    std::vector<double> sv;
    CopyToStdVector(v, sv);
    return sv;
}

#endif // CHASTE_CVODE

// End of helper functions

#endif /*VECTORHELPERFUNCTIONS_HPP_*/