Cell model base class. More...

#include <CellModel.h>

Inheritance diagram for Nektar::CellModel:

Public Member Functions
	CellModel (const LibUtilities::SessionReaderSharedPtr &pSession, const MultiRegions::ExpListSharedPtr &pField)

virtual	~CellModel ()

void	Initialise ()
	Initialise the cell model storage and set initial conditions. More...

void	TimeIntegrate (const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble time)
	Time integrate the cell model by one PDE timestep. More...

void	Update (const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble time)
	Compute the derivatives of cell model variables. More...

void	GenerateSummary (SummaryList &s)
	Print a summary of the cell model. More...

size_t	GetNumCellVariables ()

std::string	GetCellVarName (size_t idx)

Array< OneD, NekDouble >	GetCellSolutionCoeffs (size_t idx)

Array< OneD, NekDouble >	GetCellSolution (size_t idx)

Protected Member Functions
virtual void	v_Update (const Array< OneD, const Array< OneD, NekDouble >> &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray, const NekDouble time)=0

virtual void	v_GenerateSummary (SummaryList &s)=0

virtual std::string	v_GetCellVarName (size_t idx)

virtual void	v_SetInitialConditions ()=0

void	LoadCellModel ()

Protected Attributes
LibUtilities::SessionReaderSharedPtr	m_session
	Session. More...

MultiRegions::ExpListSharedPtr	m_field
	Transmembrane potential field from PDE system. More...

size_t	m_nq
	Number of physical points. More...

size_t	m_nvar
	Number of variables in cell model (inc. transmembrane voltage) More...

NekDouble	m_lastTime
	Timestep for pde model. More...

size_t	m_substeps
	Number of substeps to take. More...

Array< OneD, Array< OneD, NekDouble > >	m_cellSol
	Cell model solution variables. More...

Array< OneD, Array< OneD, NekDouble > >	m_wsp
	Cell model integration workspace. More...

bool	m_useNodal
	Flag indicating whether nodal projection in use. More...

StdRegions::StdNodalTriExpSharedPtr	m_nodalTri
	StdNodalTri for cell model calculations. More...

StdRegions::StdNodalTetExpSharedPtr	m_nodalTet

Array< OneD, Array< OneD, NekDouble > >	m_nodalTmp
	Temporary array for nodal projection. More...

std::vector< int >	m_concentrations
	Indices of cell model variables which are concentrations. More...

std::vector< int >	m_gates
	Indices of cell model variables which are gates. More...

Array< OneD, Array< OneD, NekDouble > >	m_gates_tau
	Storage for gate tau values. More...

Detailed Description

Cell model base class.

The CellModel class and derived classes implement a range of cell model ODE systems. A cell model comprises a system of ion concentration variables and zero or more gating variables. Gating variables are time-integrated using the Rush-Larsen method and for each variable y, the corresponding y_inf and tau_y value is computed by Update(). The tau values are stored in separate storage to inarray/outarray, m_gates_tau.

Definition at line 65 of file CellModel.h.

Constructor & Destructor Documentation

◆ CellModel()

Nektar::CellModel::CellModel	(	const LibUtilities::SessionReaderSharedPtr &	pSession,
		const MultiRegions::ExpListSharedPtr &	pField
	)

Cell model base class constructor.

Definition at line 66 of file CellModel.cpp.

 {
     m_session  = pSession;
     m_field    = pField;
     m_lastTime = 0.0;
     m_substeps = pSession->GetParameter("Substeps");
     m_nvar     = 0;
     m_useNodal = false;
  
     // Number of points in nodal space is the number of coefficients
     // in modified basis
     std::set<enum LibUtilities::ShapeType> s;
     for (size_t i = 0; i < m_field->GetNumElmts(); ++i)
     {
         s.insert(m_field->GetExp(i)->DetShapeType());
     }
  
     // Use nodal projection if only triangles
     if (s.size() == 1 && (s.count(LibUtilities::eTriangle) == 1 ||
                           s.count(LibUtilities::eTetrahedron) == 1))
     {
         // This is disabled for now as it causes problems at high order.
         // m_useNodal = true;
     }
  
     // ---------------------------
     // Move to nodal points
     if (m_useNodal)
     {
         m_nq      = pField->GetNcoeffs();
         int order = m_field->GetExp(0)->GetBasis(0)->GetNumModes();
  
         // Set up a nodal tri
         LibUtilities::BasisKey B0(
             LibUtilities::eModified_A, order,
             LibUtilities::PointsKey(order,
                                     LibUtilities::eGaussLobattoLegendre));
         LibUtilities::BasisKey B1(
             LibUtilities::eModified_B, order,
             LibUtilities::PointsKey(order,
                                     LibUtilities::eGaussRadauMAlpha1Beta0));
         LibUtilities::BasisKey B2(
             LibUtilities::eModified_C, order,
             LibUtilities::PointsKey(order,
                                     LibUtilities::eGaussRadauMAlpha2Beta0));
  
         m_nodalTri =
             MemoryManager<StdRegions::StdNodalTriExp>::AllocateSharedPtr(
                 B0, B1, LibUtilities::eNodalTriEvenlySpaced);
         m_nodalTet =
             MemoryManager<StdRegions::StdNodalTetExp>::AllocateSharedPtr(
                 B0, B1, B2, LibUtilities::eNodalTetEvenlySpaced);
     }
     else
     {
         m_nq = pField->GetTotPoints();
     }
 }

References Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eModified_C, Nektar::LibUtilities::eNodalTetEvenlySpaced, Nektar::LibUtilities::eNodalTriEvenlySpaced, Nektar::LibUtilities::eTetrahedron, and Nektar::LibUtilities::eTriangle.

◆ ~CellModel()

virtual Nektar::CellModel::~CellModel ( )

inlinevirtual

Definition at line 71 of file CellModel.h.

72 {

73 }

Member Function Documentation

◆ GenerateSummary()

void Nektar::CellModel::GenerateSummary ( SummaryList & s )

inline

Print a summary of the cell model.

Definition at line 92 of file CellModel.h.

     {
         v_GenerateSummary(s);
     }

References v_GenerateSummary().

◆ GetCellSolution()

Array< OneD, NekDouble > Nektar::CellModel::GetCellSolution ( size_t idx )

Definition at line 342 of file CellModel.cpp.

 {
     return m_cellSol[idx];
 }

◆ GetCellSolutionCoeffs()

Array< OneD, NekDouble > Nektar::CellModel::GetCellSolutionCoeffs ( size_t idx )

Definition at line 310 of file CellModel.cpp.

 {
     ASSERTL0(idx < m_nvar, "Index out of range for cell model.");
  
     Array<OneD, NekDouble> outarray(m_field->GetNcoeffs());
     Array<OneD, NekDouble> tmp;
  
     if (m_useNodal)
     {
         for (size_t i = 0; i < m_field->GetNumElmts(); ++i)
         {
             int coef_offset = m_field->GetCoeff_Offset(i);
             if (m_field->GetExp(0)->DetShapeType() == LibUtilities::eTriangle)
             {
                 m_nodalTri->NodalToModal(m_cellSol[idx] + coef_offset,
                                          tmp = outarray + coef_offset);
             }
             else
             {
                 m_nodalTet->NodalToModal(m_cellSol[idx] + coef_offset,
                                          tmp = outarray + coef_offset);
             }
         }
     }
     else
     {
         m_field->FwdTransLocalElmt(m_cellSol[idx], outarray);
     }
  
     return outarray;
 }

References ASSERTL0, and Nektar::LibUtilities::eTriangle.

◆ GetCellVarName()

std::string Nektar::CellModel::GetCellVarName ( size_t idx )

inline

Definition at line 102 of file CellModel.h.

     {
         return v_GetCellVarName(idx);
     }

References v_GetCellVarName().

◆ GetNumCellVariables()

size_t Nektar::CellModel::GetNumCellVariables ( )

inline

Definition at line 97 of file CellModel.h.

     {
         return m_nvar;
     }

References m_nvar.

◆ Initialise()

void Nektar::CellModel::Initialise ( )

Initialise the cell model storage and set initial conditions.

Initialise the cell model. Allocate workspace and variable storage.

Definition at line 129 of file CellModel.cpp.

 {
     ASSERTL1(m_nvar > 0, "Cell model must have at least 1 variable.");
  
     m_cellSol = Array<OneD, Array<OneD, NekDouble>>(m_nvar);
     m_wsp     = Array<OneD, Array<OneD, NekDouble>>(m_nvar);
     for (size_t i = 0; i < m_nvar; ++i)
     {
         m_cellSol[i] = Array<OneD, NekDouble>(m_nq);
         m_wsp[i]     = Array<OneD, NekDouble>(m_nq);
     }
     m_gates_tau = Array<OneD, Array<OneD, NekDouble>>(m_gates.size());
     for (size_t i = 0; i < m_gates.size(); ++i)
     {
         m_gates_tau[i] = Array<OneD, NekDouble>(m_nq);
     }
  
     if (m_session->DefinesFunction("CellModelInitialConditions"))
     {
         LoadCellModel();
     }
     else
     {
         v_SetInitialConditions();
     }
 }

References ASSERTL1.

◆ LoadCellModel()

void Nektar::CellModel::LoadCellModel ( )

protected

Definition at line 347 of file CellModel.cpp.

 {
     const bool root           = (m_session->GetComm()->GetRank() == 0);
     const std::string fncName = "CellModelInitialConditions";
     const size_t nvar         = m_cellSol[0].size();
     std::string varName;
     Array<OneD, NekDouble> coeffs(m_field->GetNcoeffs());
     Array<OneD, NekDouble> tmp;
     size_t j = 0;
  
     SpatialDomains::MeshGraphSharedPtr vGraph = m_field->GetGraph();
  
     if (root)
     {
         cout << "Cell model initial conditions: " << endl;
     }
  
     // First determine all the files we need to load
     std::set<std::string> filelist;
     for (j = 1; j < nvar; ++j)
     {
         // Get the name of the jth variable
         varName = GetCellVarName(j);
  
         if (m_session->GetFunctionType(fncName, varName) ==
             LibUtilities::eFunctionTypeFile)
         {
             filelist.insert(m_session->GetFunctionFilename(fncName, varName));
         }
     }
  
     // Read files
     typedef std::vector<LibUtilities::FieldDefinitionsSharedPtr> FDef;
     typedef std::vector<std::vector<NekDouble>> FData;
     std::map<std::string, FDef> FieldDef;
     std::map<std::string, FData> FieldData;
     LibUtilities::FieldMetaDataMap fieldMetaDataMap;
  
     for (auto &setIt : filelist)
     {
         if (root)
         {
             cout << "  - Reading file: " << setIt << endl;
         }
         FieldDef[setIt]  = FDef(0);
         FieldData[setIt] = FData(0);
         LibUtilities::FieldIOSharedPtr fld =
             LibUtilities::FieldIO::CreateForFile(m_session, setIt);
         fld->Import(setIt, FieldDef[setIt], FieldData[setIt], fieldMetaDataMap);
     }
  
     // Get time of checkpoint from file if available
     auto iter = fieldMetaDataMap.find("Time");
     if (iter != fieldMetaDataMap.end())
     {
         m_lastTime = boost::lexical_cast<NekDouble>(iter->second);
     }
  
     // Load each cell model variable
     // j=0 and j=1 are for transmembrane or intra/extra-cellular volt.
     Vmath::Zero(m_nq, m_cellSol[0], 1);
     for (j = 1; j < m_cellSol.size(); ++j)
     {
         // Get the name of the jth variable
         varName = GetCellVarName(j);
  
         // Check if this variable is defined in a file or analytically
         if (m_session->GetFunctionType(fncName, varName) ==
             LibUtilities::eFunctionTypeFile)
         {
             const std::string file =
                 m_session->GetFunctionFilename(fncName, varName);
  
             if (root)
             {
                 cout << "  - Field " << varName << ": from file " << file
                      << endl;
             }
  
             // Extract the data into the modal coefficients
             for (size_t i = 0; i < FieldDef[file].size(); ++i)
             {
                 m_field->ExtractDataToCoeffs(
                     FieldDef[file][i], FieldData[file][i], varName, coeffs);
             }
  
             // If using nodal cell model then we do a modal->nodal transform
             // otherwise we do a backward transform onto physical points.
             if (m_useNodal)
             {
                 for (size_t i = 0; i < m_field->GetNumElmts(); ++i)
                 {
                     int coef_offset = m_field->GetCoeff_Offset(i);
                     if (m_field->GetExp(0)->DetShapeType() ==
                         LibUtilities::eTriangle)
                     {
                         m_nodalTri->ModalToNodal(coeffs + coef_offset,
                                                  tmp = m_cellSol[j] +
                                                        coef_offset);
                     }
                     else
                     {
                         m_nodalTet->ModalToNodal(coeffs + coef_offset,
                                                  tmp = m_cellSol[j] +
                                                        coef_offset);
                     }
                 }
             }
             else
             {
                 m_field->BwdTrans(coeffs, m_cellSol[j]);
             }
         }
         else if (m_session->GetFunctionType(fncName, varName) ==
                  LibUtilities::eFunctionTypeExpression)
         {
             LibUtilities::EquationSharedPtr equ =
                 m_session->GetFunction(fncName, varName);
  
             if (root)
             {
                 cout << "  - Field " << varName << ": " << equ->GetExpression()
                      << endl;
             }
  
             const size_t nphys = m_field->GetNpoints();
             Array<OneD, NekDouble> x0(nphys);
             Array<OneD, NekDouble> x1(nphys);
             Array<OneD, NekDouble> x2(nphys);
             m_field->GetCoords(x0, x1, x2);
  
             if (m_useNodal)
             {
                 Array<OneD, NekDouble> phys(nphys);
                 Array<OneD, NekDouble> tmpCoeffs(
                     max(m_nodalTri->GetNcoeffs(), m_nodalTet->GetNcoeffs()));
  
                 equ->Evaluate(x0, x1, x2, phys);
                 for (size_t i = 0; i < m_field->GetNumElmts(); ++i)
                 {
                     int phys_offset = m_field->GetPhys_Offset(i);
                     int coef_offset = m_field->GetCoeff_Offset(i);
                     if (m_field->GetExp(0)->DetShapeType() ==
                         LibUtilities::eTriangle)
                     {
                         m_field->GetExp(0)->FwdTrans(phys + phys_offset,
                                                      tmpCoeffs);
                         m_nodalTri->ModalToNodal(tmpCoeffs, tmp = m_cellSol[j] +
                                                                   coef_offset);
                     }
                     else
                     {
                         m_field->GetExp(0)->FwdTrans(phys + phys_offset,
                                                      tmpCoeffs);
                         m_nodalTet->ModalToNodal(tmpCoeffs, tmp = m_cellSol[j] +
                                                                   coef_offset);
                     }
                 }
             }
             else
             {
                 equ->Evaluate(x0, x1, x2, m_cellSol[j]);
             }
         }
     }
 }

References Nektar::LibUtilities::eFunctionTypeExpression, Nektar::LibUtilities::eFunctionTypeFile, Nektar::LibUtilities::eTriangle, and Vmath::Zero().

◆ TimeIntegrate()

void Nektar::CellModel::TimeIntegrate	(	const Array< OneD, const Array< OneD, NekDouble >> &	inarray,
		Array< OneD, Array< OneD, NekDouble >> &	outarray,
		const NekDouble	time
	)

Time integrate the cell model by one PDE timestep.

Integrates the cell model for one PDE time-step. Cell model is sub-stepped.

Ion concentrations and membrane potential are integrated using forward Euler, while gating variables are integrated using the Rush-Larsen scheme.

Definition at line 164 of file CellModel.cpp.

 {
     int phys_offset = 0;
     int coef_offset = 0;
     size_t nvar     = inarray.size();
     Array<OneD, NekDouble> tmp;
  
     // ---------------------------
     // Check nodal temp array set up
     if (m_useNodal)
     {
         if (!m_nodalTmp.size())
         {
             m_nodalTmp = Array<OneD, Array<OneD, NekDouble>>(nvar);
             for (size_t k = 0; k < nvar; ++k)
             {
                 m_nodalTmp[k] = Array<OneD, NekDouble>(m_nq);
             }
         }
  
         // Move to nodal points
         Array<OneD, NekDouble> tmpCoeffs(
             max(m_nodalTri->GetNcoeffs(), m_nodalTet->GetNcoeffs()));
  
         for (size_t k = 0; k < nvar; ++k)
         {
             for (size_t i = 0; i < m_field->GetNumElmts(); ++i)
             {
                 phys_offset = m_field->GetPhys_Offset(i);
                 coef_offset = m_field->GetCoeff_Offset(i);
                 if (m_field->GetExp(0)->DetShapeType() ==
                     LibUtilities::eTriangle)
                 {
                     m_field->GetExp(0)->FwdTrans(inarray[k] + phys_offset,
                                                  tmpCoeffs);
                     m_nodalTri->ModalToNodal(tmpCoeffs,
                                              tmp = m_nodalTmp[k] + coef_offset);
                 }
                 else
                 {
                     m_field->GetExp(0)->FwdTrans(inarray[k] + phys_offset,
                                                  tmpCoeffs);
                     m_nodalTet->ModalToNodal(tmpCoeffs,
                                              tmp = m_nodalTmp[k] + coef_offset);
                 }
             }
         }
         // Copy new transmembrane potential into cell model
         Vmath::Vcopy(m_nq, m_nodalTmp[0], 1, m_cellSol[0], 1);
     }
     else
     {
         // Copy new transmembrane potential into cell model
         Vmath::Vcopy(m_nq, inarray[0], 1, m_cellSol[0], 1);
     }
     // -------------------------
  
     NekDouble delta_t = (time - m_lastTime) / m_substeps;
  
     // Perform substepping
     for (size_t i = 0; i < m_substeps - 1; ++i)
     {
         Update(m_cellSol, m_wsp, time);
         // Voltage
         Vmath::Svtvp(m_nq, delta_t, m_wsp[0], 1, m_cellSol[0], 1, m_cellSol[0],
                      1);
         // Ion concentrations
         for (size_t j = 0; j < m_concentrations.size(); ++j)
         {
             Vmath::Svtvp(m_nq, delta_t, m_wsp[m_concentrations[j]], 1,
                          m_cellSol[m_concentrations[j]], 1,
                          m_cellSol[m_concentrations[j]], 1);
         }
         // Gating variables: Rush-Larsen scheme
         for (size_t j = 0; j < m_gates.size(); ++j)
         {
             Vmath::Sdiv(m_nq, -delta_t, m_gates_tau[j], 1, m_gates_tau[j], 1);
             Vmath::Vexp(m_nq, m_gates_tau[j], 1, m_gates_tau[j], 1);
             Vmath::Vsub(m_nq, m_cellSol[m_gates[j]], 1, m_wsp[m_gates[j]], 1,
                         m_cellSol[m_gates[j]], 1);
             Vmath::Vvtvp(m_nq, m_cellSol[m_gates[j]], 1, m_gates_tau[j], 1,
                          m_wsp[m_gates[j]], 1, m_cellSol[m_gates[j]], 1);
         }
     }
  
     // Perform final cell model step
     Update(m_cellSol, m_wsp, time);
  
     // Output dV/dt from last step but integrate remaining cell model vars
     // Transform cell model I_total from nodal to modal space
     if (m_useNodal)
     {
         Array<OneD, NekDouble> tmpCoeffs(
             max(m_nodalTri->GetNcoeffs(), m_nodalTet->GetNcoeffs()));
  
         for (size_t k = 0; k < nvar; ++k)
         {
             for (size_t i = 0; i < m_field->GetNumElmts(); ++i)
             {
                 int phys_offset = m_field->GetPhys_Offset(i);
                 int coef_offset = m_field->GetCoeff_Offset(i);
                 if (m_field->GetExp(0)->DetShapeType() ==
                     LibUtilities::eTriangle)
                 {
                     m_nodalTri->NodalToModal(m_wsp[k] + coef_offset, tmpCoeffs);
                     m_field->GetExp(0)->BwdTrans(tmpCoeffs, tmp = outarray[k] +
                                                                   phys_offset);
                 }
                 else
                 {
                     m_nodalTet->NodalToModal(m_wsp[k] + coef_offset, tmpCoeffs);
                     m_field->GetExp(0)->BwdTrans(tmpCoeffs, tmp = outarray[k] +
                                                                   phys_offset);
                 }
             }
         }
     }
     else
     {
         Vmath::Vcopy(m_nq, m_wsp[0], 1, outarray[0], 1);
     }
  
     // Ion concentrations
     for (size_t j = 0; j < m_concentrations.size(); ++j)
     {
         Vmath::Svtvp(m_nq, delta_t, m_wsp[m_concentrations[j]], 1,
                      m_cellSol[m_concentrations[j]], 1,
                      m_cellSol[m_concentrations[j]], 1);
     }
  
     // Gating variables: Rush-Larsen scheme
     for (size_t j = 0; j < m_gates.size(); ++j)
     {
         Vmath::Sdiv(m_nq, -delta_t, m_gates_tau[j], 1, m_gates_tau[j], 1);
         Vmath::Vexp(m_nq, m_gates_tau[j], 1, m_gates_tau[j], 1);
         Vmath::Vsub(m_nq, m_cellSol[m_gates[j]], 1, m_wsp[m_gates[j]], 1,
                     m_cellSol[m_gates[j]], 1);
         Vmath::Vvtvp(m_nq, m_cellSol[m_gates[j]], 1, m_gates_tau[j], 1,
                      m_wsp[m_gates[j]], 1, m_cellSol[m_gates[j]], 1);
     }
  
     m_lastTime = time;
 }

References Nektar::LibUtilities::eTriangle, Vmath::Sdiv(), Vmath::Svtvp(), Vmath::Vcopy(), Vmath::Vexp(), Vmath::Vsub(), and Vmath::Vvtvp().

◆ Update()

void Nektar::CellModel::Update	(	const Array< OneD, const Array< OneD, NekDouble >> &	inarray,
		Array< OneD, Array< OneD, NekDouble >> &	outarray,
		const NekDouble	time
	)

inline

Compute the derivatives of cell model variables.

Definition at line 84 of file CellModel.h.

     {
         v_Update(inarray, outarray, time);
     }

References v_Update().

◆ v_GenerateSummary()

virtual void Nektar::CellModel::v_GenerateSummary ( SummaryList & s )

protectedpure virtual

Implemented in Nektar::Winslow99, Nektar::TenTusscher06, Nektar::PanditGilesDemir03, Nektar::LuoRudy91, Nektar::Fox02, Nektar::CellModelFitzHughNagumo, Nektar::FentonKarma, Nektar::CourtemancheRamirezNattel98, and Nektar::CellModelAlievPanfilov.

Referenced by GenerateSummary().

◆ v_GetCellVarName()

virtual std::string Nektar::CellModel::v_GetCellVarName ( size_t idx )

inlineprotectedvirtual

Reimplemented in Nektar::FentonKarma, and Nektar::CourtemancheRamirezNattel98.

Definition at line 152 of file CellModel.h.

     {
         return "Var" + boost::lexical_cast<std::string>(idx);
     }

Referenced by GetCellVarName().

◆ v_SetInitialConditions()

virtual void Nektar::CellModel::v_SetInitialConditions ( )

protectedpure virtual

Implemented in Nektar::Winslow99, Nektar::TenTusscher06, Nektar::LuoRudy91, Nektar::Fox02, Nektar::CellModelFitzHughNagumo, Nektar::FentonKarma, Nektar::CourtemancheRamirezNattel98, and Nektar::CellModelAlievPanfilov.

◆ v_Update()

virtual void Nektar::CellModel::v_Update	(	const Array< OneD, const Array< OneD, NekDouble >> &	inarray,
		Array< OneD, Array< OneD, NekDouble >> &	outarray,
		const NekDouble	time
	)

protectedpure virtual

Implemented in Nektar::Winslow99, Nektar::TenTusscher06, Nektar::PanditGilesDemir03, Nektar::LuoRudy91, Nektar::Fox02, Nektar::CellModelFitzHughNagumo, Nektar::FentonKarma, Nektar::CourtemancheRamirezNattel98, and Nektar::CellModelAlievPanfilov.

Referenced by Update().

Member Data Documentation

◆ m_cellSol

Array<OneD, Array<OneD, NekDouble> > Nektar::CellModel::m_cellSol

protected

Cell model solution variables.

Definition at line 126 of file CellModel.h.

Referenced by Nektar::CellModelAlievPanfilov::v_SetInitialConditions(), Nektar::CourtemancheRamirezNattel98::v_SetInitialConditions(), Nektar::FentonKarma::v_SetInitialConditions(), Nektar::CellModelFitzHughNagumo::v_SetInitialConditions(), Nektar::Fox02::v_SetInitialConditions(), Nektar::LuoRudy91::v_SetInitialConditions(), Nektar::TenTusscher06::v_SetInitialConditions(), and Nektar::Winslow99::v_SetInitialConditions().

◆ m_concentrations

std::vector<int> Nektar::CellModel::m_concentrations

protected

Indices of cell model variables which are concentrations.

Definition at line 139 of file CellModel.h.

Referenced by Nektar::CellModelAlievPanfilov::CellModelAlievPanfilov(), Nektar::CellModelFitzHughNagumo::CellModelFitzHughNagumo(), Nektar::CourtemancheRamirezNattel98::CourtemancheRamirezNattel98(), Nektar::Fox02::Fox02(), Nektar::LuoRudy91::LuoRudy91(), Nektar::TenTusscher06::TenTusscher06(), and Nektar::Winslow99::Winslow99().

◆ m_field

MultiRegions::ExpListSharedPtr Nektar::CellModel::m_field

protected

Transmembrane potential field from PDE system.

Definition at line 115 of file CellModel.h.

◆ m_gates

std::vector<int> Nektar::CellModel::m_gates

protected

Indices of cell model variables which are gates.

Definition at line 141 of file CellModel.h.

Referenced by Nektar::CourtemancheRamirezNattel98::CourtemancheRamirezNattel98(), Nektar::FentonKarma::FentonKarma(), Nektar::Fox02::Fox02(), Nektar::LuoRudy91::LuoRudy91(), Nektar::TenTusscher06::TenTusscher06(), and Nektar::Winslow99::Winslow99().

◆ m_gates_tau

Array<OneD, Array<OneD, NekDouble> > Nektar::CellModel::m_gates_tau

protected

Storage for gate tau values.

Definition at line 143 of file CellModel.h.

Referenced by Nektar::CourtemancheRamirezNattel98::v_Update(), Nektar::FentonKarma::v_Update(), Nektar::LuoRudy91::v_Update(), and Nektar::TenTusscher06::v_Update().

◆ m_lastTime

NekDouble Nektar::CellModel::m_lastTime

protected

Timestep for pde model.

Definition at line 121 of file CellModel.h.

◆ m_nodalTet

StdRegions::StdNodalTetExpSharedPtr Nektar::CellModel::m_nodalTet

protected

Definition at line 134 of file CellModel.h.

◆ m_nodalTmp

Array<OneD, Array<OneD, NekDouble> > Nektar::CellModel::m_nodalTmp

protected

Temporary array for nodal projection.

Definition at line 136 of file CellModel.h.

◆ m_nodalTri

StdRegions::StdNodalTriExpSharedPtr Nektar::CellModel::m_nodalTri

protected

StdNodalTri for cell model calculations.

Definition at line 133 of file CellModel.h.

◆ m_nq

size_t Nektar::CellModel::m_nq

protected

Number of physical points.

Definition at line 117 of file CellModel.h.

◆ m_nvar

size_t Nektar::CellModel::m_nvar

protected

Number of variables in cell model (inc. transmembrane voltage)

Definition at line 119 of file CellModel.h.

Referenced by Nektar::CellModelAlievPanfilov::CellModelAlievPanfilov(), Nektar::CellModelFitzHughNagumo::CellModelFitzHughNagumo(), Nektar::CourtemancheRamirezNattel98::CourtemancheRamirezNattel98(), Nektar::FentonKarma::FentonKarma(), Nektar::Fox02::Fox02(), GetNumCellVariables(), Nektar::LuoRudy91::LuoRudy91(), Nektar::TenTusscher06::TenTusscher06(), and Nektar::Winslow99::Winslow99().

◆ m_session

LibUtilities::SessionReaderSharedPtr Nektar::CellModel::m_session

protected

Session.

Definition at line 113 of file CellModel.h.

◆ m_substeps

size_t Nektar::CellModel::m_substeps

protected

Number of substeps to take.

Definition at line 123 of file CellModel.h.

◆ m_useNodal

bool Nektar::CellModel::m_useNodal

protected

Flag indicating whether nodal projection in use.

Definition at line 131 of file CellModel.h.

◆ m_wsp

Array<OneD, Array<OneD, NekDouble> > Nektar::CellModel::m_wsp

protected

Cell model integration workspace.

Definition at line 128 of file CellModel.h.

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ CellModel()

◆ ~CellModel()

Member Function Documentation

◆ GenerateSummary()

◆ GetCellSolution()

◆ GetCellSolutionCoeffs()

◆ GetCellVarName()

◆ GetNumCellVariables()

◆ Initialise()

◆ LoadCellModel()

◆ TimeIntegrate()

◆ Update()

◆ v_GenerateSummary()

◆ v_GetCellVarName()

◆ v_SetInitialConditions()

◆ v_Update()

Member Data Documentation

◆ m_cellSol

◆ m_concentrations

◆ m_field

◆ m_gates

◆ m_gates_tau

◆ m_lastTime

◆ m_nodalTet

◆ m_nodalTmp

◆ m_nodalTri

◆ m_nq

◆ m_nvar

◆ m_session

◆ m_substeps

◆ m_useNodal

◆ m_wsp