AbstractIonicModel.cpp

Go to the documentation of this file.

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   This file is part of CEPS.
 
   CEPS is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
   CEPS 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 General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with CEPS (see file LICENSE at root of project).
   If not, see <https://www.gnu.org/licenses/>.
 
 
   Copyright 2019-2024 Inria, Universite de Bordeaux
 
   Authors, in alphabetical order:
 
     Pierre-Elliott BECUE, Florian CARO, Yves COUDIERE(*), Andjela DAVIDOVIC, 
     Charlie DOUANLA-LONTSI, Marc FUENTES, Mehdi JUHOOR, Michael LEGUEBE(*), 
     Pauline MIGERDITICHAN, Valentin PANNETIER(*), Nejib ZEMZEMI.
     * : currently active authors
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include "ode/ionicModels/AbstractIonicModel.hpp"
 
AbstractIonicModel::
~AbstractIonicModel()
{
  ceps::destroyTabular(m_constants);
  ceps::destroyTabular(m_dconstants);
}
 
CepsString
AbstractIonicModel::getName() const
{
  return m_name;
}
 
Unknown*
AbstractIonicModel::getUnknown() const
{
  return m_unknown;
}
 
ScalarField<DegreeOfFreedom>*
AbstractIonicModel::getCm() const
{
  return m_cm;
}
 
void
AbstractIonicModel::setCm(ScalarField<DegreeOfFreedom>* cm)
{
  m_cm = cm;
}
 
CepsReal
AbstractIonicModel::getPaperCm(CepsBool cepsUnit) const
{
  if (cepsUnit)
    return convertCmToCepsUnit(m_paperCm);
  return m_paperCm;
}
 
CepsReal
AbstractIonicModel::getPaperStim() const
{
  return convertDtvToCepsUnit(m_paperStim/m_paperCm)*getPaperCm(true);
}
 
void
AbstractIonicModel::addStimulation(ScalarSourceTerm* stim)
{
  m_stims.push_back(stim);
}
 
CepsReal
AbstractIonicModel::getStimulation(DegreeOfFreedom* x, CepsReal t) const
{
  CepsReal res = 0.;
  for (ScalarSourceTerm* stim: m_stims)
    res += stim->getValue(x,t);
  return convertCurrentFromCepsUnit(res);
}
 
CepsUInt
AbstractIonicModel::getNbStateVariables() const
{
  return m_nStateVars;
}
 
CepsString
AbstractIonicModel::getStateVariableName(CepsUInt i) const
{
  CEPS_ABORT_IF(i>=m_nStateVars,
    "Requesting name of state variable #" << i << " of ionic model which has " << m_nStateVars
  );
  return m_stateVarNames[i];
}
 
CepsReal
AbstractIonicModel::convertVoltageToCepsUnit(const CepsReal& v) const
{
  return v;
}
 
CepsReal
AbstractIonicModel::convertVoltageFromCepsUnit(const CepsReal& v) const
{
  return v;
}
 
CepsReal
AbstractIonicModel::convertDtvToCepsUnit(const CepsReal& dtv) const
{
  return dtv;
}
 
CepsReal
AbstractIonicModel::convertCurrentFromCepsUnit(const CepsReal& i) const
{
  return i;
}
 
CepsReal
AbstractIonicModel::convertCmToCepsUnit(const CepsReal& cm) const
{
  return cm;
}
 
CepsReal
AbstractIonicModel::convertCmFromCepsUnit(const CepsReal& cm) const
{
  return cm;
}
 
void
AbstractIonicModel::setLinkedSolver(IonicSolver* solver)
{
  m_solver = solver;
}
 
IonicSolver*
AbstractIonicModel::getLinkedSolver() const
{
  return m_solver;
}
 
// Protected ---------------------------------------------------------------------------------------
 
AbstractIonicModel::
AbstractIonicModel(
  Unknown*                      u, 
  const CepsSet<CepsAttribute>& attrs
):
  ceps::HoldsAttributes(attrs),
  m_unknown   (u),
  m_constants (nullptr),
  m_dconstants(nullptr),
  m_cm        (nullptr),
  m_nStateVars(0),
  m_name      ("")
{
  CEPS_ABORT_IF(ceps::isNullPtr(u),
    "Pointer to unknown is null"
  );
}
 
CepsReal
AbstractIonicModel::getCmInternal(CepsReal t, DegreeOfFreedom* dof) const
{
  if (ceps::isNullPtr(m_cm))
    return m_paperCm;
 
  return convertCmFromCepsUnit(m_cm->getValue(dof,t));
}
 
CepsReal
AbstractIonicModel::sigmoid(CepsReal v, CepsReal c, CepsReal k) const
{
  return 1/(2.+std::expm1((v-c)/k));
}
 
CepsReal
AbstractIonicModel::gaussian(CepsReal v, CepsReal c, CepsReal s) const
{
  return std::exp(-std::pow(v-c,2)/s);
}
 
CepsReal
AbstractIonicModel::uOverExpm1u(CepsReal u) const
{
  if (std::abs(u)<std::numeric_limits<CepsReal>::epsilon()*1.e2)
    return 1;
  else
    return u/std::expm1(u);
}