BackwardEulerNobleVargheseKohlNoble1998.hpp

Go to the documentation of this file.

#ifndef _CML_noble_varghese_kohl_noble_1998_basic_backward_
#define _CML_noble_varghese_kohl_noble_1998_basic_backward_

#include "ChasteSerialization.hpp"
#include <boost/serialization/base_object.hpp>
#include "AbstractBackwardEulerCardiacCell.hpp"
#include "AbstractStimulusFunction.hpp"

class BackwardEulerNobleVargheseKohlNoble1998 : public AbstractBackwardEulerCardiacCell<12>
{
    friend class TestFastSlowBackwardEulerNoble98; // Friend class for the purposes of testing

private:
    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & archive, const unsigned int version)
    {
        // This calls serialize on the base class.
        archive & boost::serialization::base_object<AbstractBackwardEulerCardiacCell<12> >(*this);
    }

public:
    BackwardEulerNobleVargheseKohlNoble1998(boost::shared_ptr<AbstractIvpOdeSolver> /* unused */,
                                            boost::shared_ptr<AbstractStimulusFunction> pIntracellularStimulus);

    BackwardEulerNobleVargheseKohlNoble1998(boost::shared_ptr<AbstractStimulusFunction> pIntracellularStimulus);

private:
    void MakeVars();

public:
    ~BackwardEulerNobleVargheseKohlNoble1998(void)
    {
    }

    void VerifyGatingVariables();

    void VerifyStateVariables();

    double GetIIonic();

    void ComputeResidual(double var_environment__time, const double rCurrentGuess[12], double rResidual[12]);

    void ComputeJacobian(double var_environment__time, const double rCurrentGuess[12], double rJacobian[12][12]);

protected:
    void UpdateTransmembranePotential(double var_environment__time);

    void ComputeOneStepExceptVoltage(double var_environment__time);

};


#include "SerializationExportWrapper.hpp"
CHASTE_CLASS_EXPORT(BackwardEulerNobleVargheseKohlNoble1998)

namespace boost
{
namespace serialization
{
template<class Archive>
inline void save_construct_data(
    Archive & ar, const BackwardEulerNobleVargheseKohlNoble1998 * t, const unsigned int file_version)
{
    const boost::shared_ptr<AbstractIvpOdeSolver> p_solver = t->GetSolver();
    const boost::shared_ptr<AbstractStimulusFunction> p_stimulus = t->GetStimulusFunction();
    ar << p_solver;
    ar << p_stimulus;
}

template<class Archive>
inline void load_construct_data(
    Archive & ar, BackwardEulerNobleVargheseKohlNoble1998 * t, const unsigned int file_version)
{
    boost::shared_ptr<AbstractIvpOdeSolver> p_solver;
    boost::shared_ptr<AbstractStimulusFunction> p_stimulus;
    ar >> p_solver;
    ar >> p_stimulus;
    ::new(t)BackwardEulerNobleVargheseKohlNoble1998(p_solver, p_stimulus);
}
}
} // namespace ...


#endif