A model for cardiac conduction. More...
#include <Bidomain.h>
Inheritance diagram for Nektar::Bidomain:
Static Public Member Functions | |
| static EquationSystemSharedPtr | create (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph) |
| Creates an instance of this class. More... | |
Static Public Attributes | |
| static std::string | className |
| Name of class. More... | |
 Static Public Attributes inherited from Nektar::SolverUtils::UnsteadySystem | |
| static std::string | cmdSetStartTime |
| static std::string | cmdSetStartChkNum |
Protected Member Functions | |
| Bidomain (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph) | |
| Constructor. More... | |
| void | v_InitObject (bool DeclareField=true) override |
| Init object for UnsteadySystem class. More... | |
| void | DoImplicitSolve (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, NekDouble time, NekDouble lambda) |
| Solve for the diffusion term. More... | |
| void | DoOdeRhs (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time) |
| Computes the reaction terms \(f(u,v)\) and \(g(u,v)\). More... | |
| void | v_SetInitialConditions (NekDouble initialtime, bool dumpInitialConditions, const int domain) override |
| Sets a custom initial condition. More... | |
| void | v_GenerateSummary (SummaryList &s) override |
| Prints a summary of the model parameters. More... | |
| Protected Member Functions inherited from Nektar::SolverUtils::UnsteadySystem | |
| SOLVER_UTILS_EXPORT | UnsteadySystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph) |
| Initialises UnsteadySystem class members. More... | |
| SOLVER_UTILS_EXPORT void | v_InitObject (bool DeclareField=true) override |
| Init object for UnsteadySystem class. More... | |
| SOLVER_UTILS_EXPORT void | v_DoSolve () override |
| Solves an unsteady problem. More... | |
| virtual SOLVER_UTILS_EXPORT void | v_PrintStatusInformation (const int step, const NekDouble cpuTime) |
| Print Status Information. More... | |
| virtual SOLVER_UTILS_EXPORT void | v_PrintSummaryStatistics (const NekDouble intTime) |
| Print Summary Statistics. More... | |
| SOLVER_UTILS_EXPORT void | v_DoInitialise (bool dumpInitialConditions=true) override |
| Sets up initial conditions. More... | |
| SOLVER_UTILS_EXPORT void | v_GenerateSummary (SummaryList &s) override |
| Print a summary of time stepping parameters. More... | |
| virtual SOLVER_UTILS_EXPORT NekDouble | v_GetTimeStep (const Array< OneD, const Array< OneD, NekDouble > > &inarray) |
| Return the timestep to be used for the next step in the time-marching loop. More... | |
| virtual SOLVER_UTILS_EXPORT bool | v_PreIntegrate (int step) |
| virtual SOLVER_UTILS_EXPORT bool | v_PostIntegrate (int step) |
| virtual SOLVER_UTILS_EXPORT bool | v_RequireFwdTrans () |
| virtual SOLVER_UTILS_EXPORT void | v_SteadyStateResidual (int step, Array< OneD, NekDouble > &L2) |
| virtual SOLVER_UTILS_EXPORT bool | v_UpdateTimeStepCheck () |
| SOLVER_UTILS_EXPORT NekDouble | MaxTimeStepEstimator () |
| Get the maximum timestep estimator for cfl control. More... | |
| SOLVER_UTILS_EXPORT void | CheckForRestartTime (NekDouble &time, int &nchk) |
| SOLVER_UTILS_EXPORT void | SVVVarDiffCoeff (const Array< OneD, Array< OneD, NekDouble > > vel, StdRegions::VarCoeffMap &varCoeffMap) |
| Evaluate the SVV diffusion coefficient according to Moura's paper where it should proportional to h time velocity. More... | |
| SOLVER_UTILS_EXPORT void | DoDummyProjection (const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time) |
| Perform dummy projection. More... | |
| Protected Member Functions inherited from Nektar::SolverUtils::EquationSystem | |
| SOLVER_UTILS_EXPORT | EquationSystem (const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph) |
| Initialises EquationSystem class members. More... | |
| virtual SOLVER_UTILS_EXPORT void | v_InitObject (bool DeclareFeld=true) |
| Initialisation object for EquationSystem. More... | |
| virtual SOLVER_UTILS_EXPORT void | v_DoInitialise (bool dumpInitialConditions=true) |
| Virtual function for initialisation implementation. More... | |
| virtual SOLVER_UTILS_EXPORT void | v_DoSolve () |
| Virtual function for solve implementation. More... | |
| virtual SOLVER_UTILS_EXPORT NekDouble | v_LinfError (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray) |
| Virtual function for the L_inf error computation between fields and a given exact solution. More... | |
| virtual SOLVER_UTILS_EXPORT NekDouble | v_L2Error (unsigned int field, const Array< OneD, NekDouble > &exactsoln=NullNekDouble1DArray, bool Normalised=false) |
| Virtual function for the L_2 error computation between fields and a given exact solution. More... | |
| virtual SOLVER_UTILS_EXPORT void | v_TransCoeffToPhys () |
| Virtual function for transformation to physical space. More... | |
| virtual SOLVER_UTILS_EXPORT void | v_TransPhysToCoeff () |
| Virtual function for transformation to coefficient space. More... | |
| virtual SOLVER_UTILS_EXPORT void | v_GenerateSummary (SummaryList &l) |
| Virtual function for generating summary information. More... | |
| virtual SOLVER_UTILS_EXPORT void | v_SetInitialConditions (NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0) |
| virtual SOLVER_UTILS_EXPORT void | v_EvaluateExactSolution (unsigned int field, Array< OneD, NekDouble > &outfield, const NekDouble time) |
| virtual SOLVER_UTILS_EXPORT void | v_Output (void) |
| virtual SOLVER_UTILS_EXPORT MultiRegions::ExpListSharedPtr | v_GetPressure (void) |
| virtual SOLVER_UTILS_EXPORT bool | v_NegatedOp (void) |
| Virtual function to identify if operator is negated in DoSolve. More... | |
| virtual SOLVER_UTILS_EXPORT void | v_ExtraFldOutput (std::vector< Array< OneD, NekDouble > > &fieldcoeffs, std::vector< std::string > &variables) |
Private Attributes | |
| CellModelSharedPtr | m_cell |
| Cell model. More... | |
| NekDouble | m_chi |
| NekDouble | m_capMembrane |
| NekDouble | m_sigmaix |
| NekDouble | m_sigmaiy |
| NekDouble | m_sigmaiz |
| NekDouble | m_sigmaex |
| NekDouble | m_sigmaey |
| NekDouble | m_sigmaez |
| StdRegions::VarCoeffMap | m_vardiffi |
| StdRegions::VarCoeffMap | m_vardiffie |
| Array< OneD, Array< OneD, NekDouble > > | tmp1 |
| Array< OneD, Array< OneD, NekDouble > > | tmp2 |
| Array< OneD, Array< OneD, NekDouble > > | tmp3 |
| NekDouble | m_stimDuration |
| Stimulus current. More... | |
Friends | |
| class | MemoryManager< Bidomain > |
Additional Inherited Members | |
| Protected Types inherited from Nektar::SolverUtils::EquationSystem | |
| enum | HomogeneousType { eHomogeneous1D , eHomogeneous2D , eHomogeneous3D , eNotHomogeneous } |
| Parameter for homogeneous expansions. More... | |
| Protected Attributes inherited from Nektar::SolverUtils::UnsteadySystem | |
| LibUtilities::TimeIntegrationSchemeSharedPtr | m_intScheme |
| Wrapper to the time integration scheme. More... | |
| LibUtilities::TimeIntegrationSchemeOperators | m_ode |
| The time integration scheme operators to use. More... | |
| Array< OneD, Array< OneD, NekDouble > > | m_previousSolution |
| Storage for previous solution for steady-state check. More... | |
| std::vector< int > | m_intVariables |
| NekDouble | m_cflSafetyFactor |
| CFL safety factor (comprise between 0 to 1). More... | |
| NekDouble | m_CFLGrowth |
| CFL growth rate. More... | |
| NekDouble | m_CFLEnd |
| Maximun cfl in cfl growth. More... | |
| int | m_abortSteps |
| Number of steps between checks for abort conditions. More... | |
| bool | m_explicitDiffusion |
| Indicates if explicit or implicit treatment of diffusion is used. More... | |
| bool | m_explicitAdvection |
| Indicates if explicit or implicit treatment of advection is used. More... | |
| bool | m_explicitReaction |
| Indicates if explicit or implicit treatment of reaction is used. More... | |
| int | m_steadyStateSteps |
| Check for steady state at step interval. More... | |
| NekDouble | m_steadyStateTol |
| Tolerance to which steady state should be evaluated at. More... | |
| int | m_filtersInfosteps |
| Number of time steps between outputting filters information. More... | |
| std::vector< std::pair< std::string, FilterSharedPtr > > | m_filters |
| bool | m_homoInitialFwd |
| Flag to determine if simulation should start in homogeneous forward transformed state. More... | |
| std::ofstream | m_errFile |
| NekDouble | m_epsilon |
| Diffusion coefficient. More... | |
| Protected Attributes inherited from Nektar::SolverUtils::EquationSystem | |
| LibUtilities::CommSharedPtr | m_comm |
| Communicator. More... | |
| bool | m_verbose |
| LibUtilities::SessionReaderSharedPtr | m_session |
| The session reader. More... | |
| std::map< std::string, SolverUtils::SessionFunctionSharedPtr > | m_sessionFunctions |
| Map of known SessionFunctions. More... | |
| LibUtilities::FieldIOSharedPtr | m_fld |
| Field input/output. More... | |
| Array< OneD, MultiRegions::ExpListSharedPtr > | m_fields |
| Array holding all dependent variables. More... | |
| SpatialDomains::BoundaryConditionsSharedPtr | m_boundaryConditions |
| Pointer to boundary conditions object. More... | |
| SpatialDomains::MeshGraphSharedPtr | m_graph |
| Pointer to graph defining mesh. More... | |
| std::string | m_sessionName |
| Name of the session. More... | |
| NekDouble | m_time |
| Current time of simulation. More... | |
| int | m_initialStep |
| Number of the step where the simulation should begin. More... | |
| NekDouble | m_fintime |
| Finish time of the simulation. More... | |
| NekDouble | m_timestep |
| Time step size. More... | |
| NekDouble | m_lambda |
| Lambda constant in real system if one required. More... | |
| NekDouble | m_checktime |
| Time between checkpoints. More... | |
| NekDouble | m_lastCheckTime |
| NekDouble | m_TimeIncrementFactor |
| int | m_nchk |
| Number of checkpoints written so far. More... | |
| int | m_steps |
| Number of steps to take. More... | |
| int | m_checksteps |
| Number of steps between checkpoints. More... | |
| int | m_infosteps |
| Number of time steps between outputting status information. More... | |
| int | m_iterPIT = 0 |
| Number of parallel-in-time time iteration. More... | |
| int | m_windowPIT = 0 |
| Index of windows for parallel-in-time time iteration. More... | |
| int | m_spacedim |
| Spatial dimension (>= expansion dim). More... | |
| int | m_expdim |
| Expansion dimension. More... | |
| bool | m_singleMode |
| Flag to determine if single homogeneous mode is used. More... | |
| bool | m_halfMode |
| Flag to determine if half homogeneous mode is used. More... | |
| bool | m_multipleModes |
| Flag to determine if use multiple homogenenous modes are used. More... | |
| bool | m_useFFT |
| Flag to determine if FFT is used for homogeneous transform. More... | |
| bool | m_homogen_dealiasing |
| Flag to determine if dealiasing is used for homogeneous simulations. More... | |
| bool | m_specHP_dealiasing |
| Flag to determine if dealisising is usde for the Spectral/hp element discretisation. More... | |
| enum MultiRegions::ProjectionType | m_projectionType |
| Type of projection; e.g continuous or discontinuous. More... | |
| Array< OneD, Array< OneD, NekDouble > > | m_traceNormals |
| Array holding trace normals for DG simulations in the forwards direction. More... | |
| Array< OneD, bool > | m_checkIfSystemSingular |
| Flag to indicate if the fields should be checked for singularity. More... | |
| LibUtilities::FieldMetaDataMap | m_fieldMetaDataMap |
| Map to identify relevant solver info to dump in output fields. More... | |
| Array< OneD, NekDouble > | m_movingFrameVelsxyz |
| Moving frame of reference velocities (u, v, w, omega_x, omega_y, omega_z, a_x, a_y, a_z, domega_x, domega_y, domega_z) More... | |
| Array< OneD, NekDouble > | m_movingFrameData |
| Moving frame of reference angles with respect to the. More... | |
| boost::numeric::ublas::matrix< NekDouble > | m_movingFrameProjMat |
| Projection matrix for transformation between inertial and moving. More... | |
| int | m_NumQuadPointsError |
| Number of Quadrature points used to work out the error. More... | |
| enum HomogeneousType | m_HomogeneousType |
| NekDouble | m_LhomX |
| physical length in X direction (if homogeneous) More... | |
| NekDouble | m_LhomY |
| physical length in Y direction (if homogeneous) More... | |
| NekDouble | m_LhomZ |
| physical length in Z direction (if homogeneous) More... | |
| int | m_npointsX |
| number of points in X direction (if homogeneous) More... | |
| int | m_npointsY |
| number of points in Y direction (if homogeneous) More... | |
| int | m_npointsZ |
| number of points in Z direction (if homogeneous) More... | |
| int | m_HomoDirec |
| number of homogenous directions More... | |
| Static Protected Attributes inherited from Nektar::SolverUtils::EquationSystem | |
| static std::string | equationSystemTypeLookupIds [] |
| static std::string | projectionTypeLookupIds [] |
Detailed Description
A model for cardiac conduction.
Base model of cardiac electrophysiology of the form
\begin{align*} \frac{\partial u}{\partial t} = \nabla^2 u + J_{ion}, \end{align*}
where the reaction term, \(J_{ion}\) is defined by a specific cell model.
This implementation, at present, treats the reaction terms explicitly and the diffusive element implicitly.
Definition at line 47 of file Bidomain.h.
Constructor & Destructor Documentation
◆ ~Bidomain()
|
override |
◆ Bidomain()
|
protected |
Constructor.
Definition at line 68 of file Bidomain.cpp.
70 : UnsteadySystem(pSession, pGraph)
71{
72}
SOLVER_UTILS_EXPORT UnsteadySystem(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Initialises UnsteadySystem class members.
Definition: UnsteadySystem.cpp:74
Member Function Documentation
◆ create()
|
inlinestatic |
Creates an instance of this class.
Definition at line 53 of file Bidomain.h.
56 {
58 MemoryManager<Bidomain>::AllocateSharedPtr(pSession, pGraph);
59 p->InitObject();
61 }
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:166
std::shared_ptr< EquationSystem > EquationSystemSharedPtr
A shared pointer to an EquationSystem object.
Definition: EquationSystem.h:65
References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and CellMLToNektar.cellml_metadata::p.
◆ DoImplicitSolve()
|
protected |
Solve for the diffusion term.
- Parameters
-
inarray Input array. outarray Output array. time Current simulation time. lambda Timestep.
Definition at line 176 of file Bidomain.cpp.
180{
181 int nvariables = inarray.size();
183
184 Array<OneD, NekDouble> grad0(nq), grad1(nq), grad2(nq), grad(nq);
185 Array<OneD, NekDouble> ggrad0(nq), ggrad1(nq), ggrad2(nq), ggrad(nq),
186 temp(nq);
187
188 // We solve ( \sigma\nabla^2 - HHlambda ) Y[i] = rhs [i]
189 // inarray = input: \hat{rhs} -> output: \hat{Y}
190 // outarray = output: nabla^2 \hat{Y}
191 // where \hat = modal coeffs
192 for (int i = 0; i < nvariables; ++i)
193 {
194 // Only apply diffusion to first variable.
195 if (i > 1)
196 {
197 Vmath::Vcopy(nq, &inarray[i][0], 1, &outarray[i][0], 1);
198 continue;
199 }
200 if (i == 0)
201 {
206 {
207 // Take first partial derivative
208 m_fields[i]->PhysDeriv(inarray[1], ggrad0);
209 // Take second partial derivative
210 m_fields[i]->PhysDeriv(0, ggrad0, ggrad0);
211 // Multiply by Intracellular-Conductivity
214 {
216 1, ggrad0, 1);
217 }
218 // Add partial derivatives together
219 Vmath::Vcopy(nq, ggrad0, 1, ggrad, 1);
220 Vmath::Smul(nq, -1.0, ggrad, 1, ggrad, 1);
221 // Multiply 1.0/timestep/lambda
223 1, temp, 1);
225 1);
226 // Solve a system of equations with Helmholtz solver and
227 // transform back into physical space.
231 m_fields[i]->UpdatePhys());
233 // Copy the solution vector (required as m_fields must be set).
234 outarray[i] = m_fields[i]->GetPhys();
235 }
236
238 {
239 // Take first partial derivative
240 m_fields[i]->PhysDeriv(inarray[1], ggrad0, ggrad1);
241 // Take second partial derivative
242 m_fields[i]->PhysDeriv(0, ggrad0, ggrad0);
243 m_fields[i]->PhysDeriv(1, ggrad1, ggrad1);
244 // Multiply by Intracellular-Conductivity
247 {
249 1, ggrad0, 1);
251 1, ggrad1, 1);
252 }
253 // Add partial derivatives together
254 Vmath::Vadd(nq, ggrad0, 1, ggrad1, 1, ggrad, 1);
255 Vmath::Smul(nq, -1.0, ggrad, 1, ggrad, 1);
256 // Multiply 1.0/timestep/lambda
258 1, temp, 1);
260 1);
261 // Solve a system of equations with Helmholtz solver and
262 // transform back into physical space.
265 m_vardiffi);
267 m_fields[i]->UpdatePhys());
269 // Copy the solution vector (required as m_fields must be set).
270 outarray[i] = m_fields[i]->GetPhys();
271 }
272
274 {
275 // Take first partial derivative
276 m_fields[i]->PhysDeriv(inarray[1], ggrad0, ggrad1, ggrad2);
277 // Take second partial derivative
278 m_fields[i]->PhysDeriv(0, ggrad0, ggrad0);
279 m_fields[i]->PhysDeriv(1, ggrad1, ggrad1);
280 m_fields[i]->PhysDeriv(2, ggrad2, ggrad2);
281 // Multiply by Intracellular-Conductivity
284 {
286 1, ggrad0, 1);
288 1, ggrad1, 1);
290 1, ggrad2, 1);
291 }
292 // Add partial derivatives together
293 Vmath::Vadd(nq, ggrad0, 1, ggrad1, 1, ggrad, 1);
294 Vmath::Vadd(nq, ggrad2, 1, ggrad, 1, ggrad, 1);
295 Vmath::Smul(nq, -1.0, ggrad, 1, ggrad, 1);
296 // Multiply 1.0/timestep/lambda
298 1, temp, 1);
300 1);
301 // Solve a system of equations with Helmholtz solver and
302 // transform back into physical space.
305 m_vardiffi);
307 m_fields[i]->UpdatePhys());
309 // Copy the solution vector (required as m_fields must be set).
310 outarray[i] = m_fields[i]->GetPhys();
311 }
312 }
313 if (i == 1)
314 {
318 {
319 // Take first partial derivative
321 // Take second derivative
322 m_fields[i]->PhysDeriv(0, grad0, grad0);
323 // Multiply by Intracellular-Conductivity
326 {
328 1, grad0, 1);
329 }
330 // and sum terms
331 Vmath::Vcopy(nq, grad0, 1, grad, 1);
332 Vmath::Smul(nq,
336 grad, 1, grad, 1);
337 // Now solve Poisson problem for \phi_e
338 m_fields[i]->SetPhys(grad);
342 m_fields[i]->UpdatePhys());
344 // Copy the solution vector (required as m_fields must be set).
345 outarray[i] = m_fields[i]->GetPhys();
346 }
347
349 {
350 // Take first partial derivative
352 // Take second derivative
353 m_fields[i]->PhysDeriv(0, grad0, grad0);
354 m_fields[i]->PhysDeriv(1, grad1, grad1);
355 // Multiply by Intracellular-Conductivity
358 {
360 1, grad0, 1);
362 1, grad1, 1);
363 }
364 // and sum terms
365 Vmath::Vadd(nq, grad0, 1, grad1, 1, grad, 1);
366 Vmath::Smul(nq, -1.0, grad, 1, grad, 1);
367 // Now solve Poisson problem for \phi_e
368 m_fields[i]->SetPhys(grad);
371 m_vardiffie);
373 m_fields[i]->UpdatePhys());
375 // Copy the solution vector (required as m_fields must be set).
376 outarray[i] = m_fields[i]->GetPhys();
377 }
378
380 {
381 // Take first partial derivative
383 grad2);
384 // Take second derivative
385 m_fields[i]->PhysDeriv(0, grad0, grad0);
386 m_fields[i]->PhysDeriv(1, grad1, grad1);
387 m_fields[i]->PhysDeriv(2, grad2, grad2);
388 // Multiply by Intracellular-Conductivity
391 {
393 1, grad0, 1);
395 1, grad1, 1);
397 1, grad2, 1);
398 }
399 // and sum terms
400 Vmath::Vadd(nq, grad0, 1, grad1, 1, grad, 1);
401 Vmath::Vadd(nq, grad2, 1, grad, 1, grad, 1);
402 Vmath::Smul(nq, -1.0, grad, 1, grad, 1);
403 // Now solve Poisson problem for \phi_e
404 m_fields[i]->SetPhys(grad);
407 m_vardiffie);
409 m_fields[i]->UpdatePhys());
411 // Copy the solution vector (required as m_fields must be set).
412 outarray[i] = m_fields[i]->GetPhys();
413 }
414 }
415 }
416}
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:359
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition: StdRegions.hpp:402
StdRegions::ConstFactorMap factors
Definition: TestVarcoeffHashing.cpp:51
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.hpp:180
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*x.
Definition: Vmath.hpp:100
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.hpp:825
References Nektar::StdRegions::eFactorLambda, Nektar::VarcoeffHashingTest::factors, m_capMembrane, m_chi, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_session, Nektar::SolverUtils::EquationSystem::m_spacedim, m_vardiffi, m_vardiffie, Vmath::Smul(), Vmath::Vadd(), and Vmath::Vcopy().
Referenced by v_InitObject().
◆ DoOdeRhs()
|
protected |
Computes the reaction terms \(f(u,v)\) and \(g(u,v)\).
Definition at line 418 of file Bidomain.cpp.
421{
423 m_cell->TimeIntegrate(inarray, outarray, time);
425 {
426 Array<OneD, NekDouble> x0(nq);
427 Array<OneD, NekDouble> x1(nq);
428 Array<OneD, NekDouble> x2(nq);
429 Array<OneD, NekDouble> result(nq);
430
431 // get the coordinates
432 m_fields[0]->GetCoords(x0, x1, x2);
433
434 LibUtilities::EquationSharedPtr ifunc =
436 ifunc->Evaluate(x0, x1, x2, time, result);
437
438 Vmath::Vadd(nq, outarray[0], 1, result, 1, outarray[0], 1);
439 }
441}
std::shared_ptr< Equation > EquationSharedPtr
Definition: Equation.h:125
References m_capMembrane, m_cell, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::EquationSystem::m_session, m_stimDuration, Vmath::Smul(), and Vmath::Vadd().
Referenced by v_InitObject().
◆ v_GenerateSummary()
|
overrideprotectedvirtual |
Prints a summary of the model parameters.
@TODO Update summary
Reimplemented from Nektar::SolverUtils::UnsteadySystem.
Definition at line 455 of file Bidomain.cpp.
456{
458
459 /// @TODO Update summary
461 //
462 // out << "\tChi : " << m_chi << endl;
463 // out << "\tCm : " << m_capMembrane << endl;
464 // if (m_session->DefinesFunction("IntracellularConductivity",
465 // "AnisotropicConductivityX") &&
466 // m_session->GetFunctionType("IntracellularConductivity",
467 // "AnisotropicConductivityX") ==
468 // LibUtilities::eFunctionTypeExpression)
469 // {
470 // out << "\tIntra-Diffusivity-x : "
471 // << m_session->GetFunction("IntracellularConductivity",
472 // "AnisotropicConductivityX")->GetExpression()
473 // << endl;
474 // }
475 // if (m_session->DefinesFunction("IntracellularConductivity",
476 // "AnisotropicConductivityY") &&
477 // m_session->GetFunctionType("IntracellularConductivity",
478 // "AnisotropicConductivityY") ==
479 // LibUtilities::eFunctionTypeExpression)
480 // {
481 // out << "\tIntra-Diffusivity-y : "
482 // << m_session->GetFunction("IntracellularConductivity",
483 // "AnisotropicConductivityY")->GetExpression()
484 // << endl;
485 // }
486 // if (m_session->DefinesFunction("IntracellularConductivity",
487 // "AnisotropicConductivityZ") &&
488 // m_session->GetFunctionType("IntracellularConductivity",
489 // "AnisotropicConductivityZ") ==
490 // LibUtilities::eFunctionTypeExpression)
491 // {
492 // out << "\tIntra-Diffusivity-z : "
493 // << m_session->GetFunction("IntracellularConductivity",
494 // "AnisotropicConductivityZ")->GetExpression()
495 // << endl;
496 // }
497 // if (m_session->DefinesFunction("ExtracellularConductivity",
498 // "AnisotropicConductivityX") &&
499 // m_session->GetFunctionType("ExtracellularConductivity",
500 // "AnisotropicConductivityX") ==
501 // LibUtilities::eFunctionTypeExpression)
502 // {
503 // out << "\tExtra-Diffusivity-x : "
504 // << m_session->GetFunction("ExtracellularConductivity",
505 // "AnisotropicConductivityX")->GetExpression()
506 // << endl;
507 // }
508 // if (m_session->DefinesFunction("ExtracellularConductivity",
509 // "AnisotropicConductivityY") &&
510 // m_session->GetFunctionType("ExtracellularConductivity",
511 // "AnisotropicConductivityY") ==
512 // LibUtilities::eFunctionTypeExpression)
513 // {
514 // out << "\tExtra-Diffusivity-y : "
515 // << m_session->GetFunction("ExtracellularConductivity",
516 // "AnisotropicConductivityY")->GetExpression()
517 // << endl;
518 // }
519 // if (m_session->DefinesFunction("ExtracellularConductivity",
520 // "AnisotropicConductivityZ") &&
521 // m_session->GetFunctionType("ExtracellularConductivity",
522 // "AnisotropicConductivityZ") ==
523 // LibUtilities::eFunctionTypeExpression)
524 // {
525 // out << "\tExtra-Diffusivity-z : "
526 // << m_session->GetFunction("ExtracellularConductivity",
527 // "AnisotropicConductivityZ")->GetExpression()
528 // << endl;
529 // }
530 m_cell->GenerateSummary(s);
531}
SOLVER_UTILS_EXPORT void v_GenerateSummary(SummaryList &s) override
Print a summary of time stepping parameters.
Definition: UnsteadySystem.cpp:606
References ASSERTL0, m_cell, and Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary().
◆ v_InitObject()
|
overrideprotectedvirtual |
Init object for UnsteadySystem class.
Initialization object for UnsteadySystem class.
Reimplemented from Nektar::SolverUtils::UnsteadySystem.
Definition at line 74 of file Bidomain.cpp.
75{
76 UnsteadySystem::v_InitObject(DeclareField);
79
80 std::string vCellModel;
82
84
86 m_fields[0]);
87 m_intVariables.push_back(0);
88 m_intVariables.push_back(1);
89
90 // Load variable coefficients
94 std::string varName[3] = {"AnisotropicConductivityX",
95 "AnisotropicConductivityY",
96 "AnisotropicConductivityZ"};
97
100 {
102 {
104 Array<OneD, NekDouble> x0(nq);
105 Array<OneD, NekDouble> x1(nq);
106 Array<OneD, NekDouble> x2(nq);
107
108 // get the coordinates
109 m_fields[0]->GetCoords(x0, x1, x2);
110 tmp1 = Array<OneD, const Array<OneD, NekDouble>>(nq);
111 tmp2 = Array<OneD, const Array<OneD, NekDouble>>(nq);
112 tmp3 = Array<OneD, const Array<OneD, NekDouble>>(nq);
113 tmp1[i] = Array<OneD, NekDouble>(nq);
114 tmp2[i] = Array<OneD, NekDouble>(nq);
115 tmp3[i] = Array<OneD, NekDouble>(nq);
116
117 LibUtilities::EquationSharedPtr ifunc1 =
119 LibUtilities::EquationSharedPtr ifunc2 =
121 for (int j = 0; j < nq; j++)
122 {
123 tmp1[i][j] = ifunc1->Evaluate(x0[j], x1[j], x2[j], 0.0);
124 tmp2[i][j] = ifunc2->Evaluate(x0[j], x1[j], x2[j], 0.0);
125 }
129 }
130 }
131
133 {
135 "Stimulus function not defined.");
137 }
138 else
139 {
140 m_stimDuration = 0;
141 }
142
143 // Search through the loaded filters and pass the cell model to any
144 // CheckpointCellModel filters loaded.
146 {
147 if (x.first == "CheckpointCellModel")
148 {
149 std::shared_ptr<FilterCheckpointCellModel> c =
150 std::dynamic_pointer_cast<FilterCheckpointCellModel>(x.second);
151 c->SetCellModel(m_cell);
152 }
153 }
154
156 {
158 }
161}
void DoOdeRhs(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Computes the reaction terms and .
Definition: Bidomain.cpp:418
void DoImplicitSolve(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, NekDouble time, NekDouble lambda)
Solve for the diffusion term.
Definition: Bidomain.cpp:176
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:143
void DefineProjection(FuncPointerT func, ObjectPointerT obj)
Definition: TimeIntegrationSchemeOperators.h:92
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
Definition: TimeIntegrationSchemeOperators.h:84
void DefineImplicitSolve(FuncPointerT func, ObjectPointerT obj)
Definition: TimeIntegrationSchemeOperators.h:100
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
Definition: UnsteadySystem.h:88
std::vector< std::pair< std::string, FilterSharedPtr > > m_filters
Definition: UnsteadySystem.h:119
SOLVER_UTILS_EXPORT void DoDummyProjection(const Array< OneD, const Array< OneD, NekDouble > > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray, const NekDouble time)
Perform dummy projection.
Definition: UnsteadySystem.cpp:949
bool m_explicitDiffusion
Indicates if explicit or implicit treatment of diffusion is used.
Definition: UnsteadySystem.h:106
std::vector< int > m_intVariables
Definition: UnsteadySystem.h:93
SOLVER_UTILS_EXPORT void v_InitObject(bool DeclareField=true) override
Init object for UnsteadySystem class.
Definition: UnsteadySystem.cpp:85
References ASSERTL0, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineImplicitSolve(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs(), Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineProjection(), Nektar::SolverUtils::UnsteadySystem::DoDummyProjection(), DoImplicitSolve(), DoOdeRhs(), Nektar::StdRegions::eVarCoeffD00, Nektar::StdRegions::eVarCoeffD11, Nektar::StdRegions::eVarCoeffD22, Nektar::GetCellModelFactory(), m_capMembrane, m_cell, m_chi, Nektar::SolverUtils::UnsteadySystem::m_explicitDiffusion, Nektar::SolverUtils::EquationSystem::m_fields, Nektar::SolverUtils::UnsteadySystem::m_filters, Nektar::SolverUtils::UnsteadySystem::m_intVariables, Nektar::SolverUtils::UnsteadySystem::m_ode, Nektar::SolverUtils::EquationSystem::m_session, Nektar::SolverUtils::EquationSystem::m_spacedim, m_stimDuration, m_vardiffi, m_vardiffie, tmp1, tmp2, tmp3, Nektar::SolverUtils::UnsteadySystem::v_InitObject(), and Vmath::Vadd().
◆ v_SetInitialConditions()
|
overrideprotectedvirtual |
Sets a custom initial condition.
Reimplemented from Nektar::SolverUtils::EquationSystem.
Definition at line 443 of file Bidomain.cpp.
446{
447 EquationSystem::v_SetInitialConditions(initialtime, dumpInitialConditions,
448 domain);
449 m_cell->Initialise();
450}
virtual SOLVER_UTILS_EXPORT void v_SetInitialConditions(NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
Definition: EquationSystem.cpp:986
References m_cell, and Nektar::SolverUtils::EquationSystem::v_SetInitialConditions().
Friends And Related Function Documentation
◆ MemoryManager< Bidomain >
|
friend |
Definition at line 1 of file Bidomain.h.
Member Data Documentation
◆ className
|
static |
Initial value:
"Bidomain", Bidomain::create,
"Bidomain model of cardiac electrophysiology with 3D diffusion.")
static EquationSystemSharedPtr create(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Creates an instance of this class.
Definition: Bidomain.h:53
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, std::string pDesc="")
Register a class with the factory.
Definition: NekFactory.hpp:197
EquationSystemFactory & GetEquationSystemFactory()
Definition: EquationSystem.cpp:99
Name of class.
Registers the class with the Factory.
Definition at line 64 of file Bidomain.h.
◆ m_capMembrane
|
private |
Definition at line 99 of file Bidomain.h.
Referenced by DoImplicitSolve(), DoOdeRhs(), and v_InitObject().
◆ m_cell
|
private |
Cell model.
Definition at line 97 of file Bidomain.h.
Referenced by DoOdeRhs(), v_GenerateSummary(), v_InitObject(), and v_SetInitialConditions().
◆ m_chi
|
private |
Definition at line 99 of file Bidomain.h.
Referenced by DoImplicitSolve(), and v_InitObject().
◆ m_sigmaex
|
private |
Definition at line 99 of file Bidomain.h.
◆ m_sigmaey
|
private |
Definition at line 100 of file Bidomain.h.
◆ m_sigmaez
|
private |
Definition at line 100 of file Bidomain.h.
◆ m_sigmaix
|
private |
Definition at line 99 of file Bidomain.h.
◆ m_sigmaiy
|
private |
Definition at line 99 of file Bidomain.h.
◆ m_sigmaiz
|
private |
Definition at line 99 of file Bidomain.h.
◆ m_stimDuration
|
private |
Stimulus current.
Definition at line 110 of file Bidomain.h.
Referenced by DoOdeRhs(), and v_InitObject().
◆ m_vardiffi
|
private |
Definition at line 102 of file Bidomain.h.
Referenced by DoImplicitSolve(), and v_InitObject().
◆ m_vardiffie
|
private |
Definition at line 103 of file Bidomain.h.
Referenced by DoImplicitSolve(), and v_InitObject().
◆ tmp1
Definition at line 105 of file Bidomain.h.
Referenced by v_InitObject().
◆ tmp2
Definition at line 106 of file Bidomain.h.
Referenced by v_InitObject().
◆ tmp3
Definition at line 107 of file Bidomain.h.
Referenced by v_InitObject().
