Nektar++
Bidomain.cpp
Go to the documentation of this file.
1///////////////////////////////////////////////////////////////////////////////
2//
3// File: Bidomain.cpp
4//
5// For more information, please see: http://www.nektar.info
6//
7// The MIT License
8//
9// Copyright (c) 2006 Division of Applied Mathematics, Brown University (USA),
10// Department of Aeronautics, Imperial College London (UK), and Scientific
11// Computing and Imaging Institute, University of Utah (USA).
12//
13// Permission is hereby granted, free of charge, to any person obtaining a
14// copy of this software and associated documentation files (the "Software"),
15// to deal in the Software without restriction, including without limitation
16// the rights to use, copy, modify, merge, publish, distribute, sublicense,
17// and/or sell copies of the Software, and to permit persons to whom the
18// Software is furnished to do so, subject to the following conditions:
19//
20// The above copyright notice and this permission notice shall be included
21// in all copies or substantial portions of the Software.
22//
23// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
24// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
26// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
28// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
29// DEALINGS IN THE SOFTWARE.
30//
31// Description: Bidomain cardiac electrophysiology homogenised model.
32//
33///////////////////////////////////////////////////////////////////////////////
34
35#include <iostream>
36
37#include <CardiacEPSolver/EquationSystems/Bidomain.h>
38#include <CardiacEPSolver/Filters/FilterCheckpointCellModel.h>
39
40using namespace std;
41
42namespace Nektar
43{
44/**
45 * @class Bidomain
46 *
47 * Base model of cardiac electrophysiology of the form
48 * \f{align*}{
49 * \frac{\partial u}{\partial t} = \nabla^2 u + J_{ion},
50 * \f}
51 * where the reaction term, \f$J_{ion}\f$ is defined by a specific cell
52 * model.
53 *
54 * This implementation, at present, treats the reaction terms explicitly
55 * and the diffusive element implicitly.
56 */
57
58/**
59 * Registers the class with the Factory.
60 */
61string Bidomain::className = GetEquationSystemFactory().RegisterCreatorFunction(
62 "Bidomain", Bidomain::create,
63 "Bidomain model of cardiac electrophysiology with 3D diffusion.");
64
65/**
66 *
67 */
68Bidomain::Bidomain(const LibUtilities::SessionReaderSharedPtr &pSession,
69 const SpatialDomains::MeshGraphSharedPtr &pGraph)
70 : UnsteadySystem(pSession, pGraph)
71{
72}
73
74void Bidomain::v_InitObject(bool DeclareField)
75{
76 UnsteadySystem::v_InitObject(DeclareField);
77 m_session->LoadParameter("Chi", m_chi);
78 m_session->LoadParameter("Cm", m_capMembrane);
79
80 std::string vCellModel;
81 m_session->LoadSolverInfo("CELLMODEL", vCellModel, "");
82
83 ASSERTL0(vCellModel != "", "Cell Model not specified.");
84
85 m_cell = GetCellModelFactory().CreateInstance(vCellModel, m_session,
86 m_fields[0]);
87 m_intVariables.push_back(0);
88 m_intVariables.push_back(1);
89
90 // Load variable coefficients
91 StdRegions::VarCoeffType varCoeffEnum[3] = {StdRegions::eVarCoeffD00,
92 StdRegions::eVarCoeffD11,
93 StdRegions::eVarCoeffD22};
94 std::string varName[3] = {"AnisotropicConductivityX",
95 "AnisotropicConductivityY",
96 "AnisotropicConductivityZ"};
97
98 if (m_session->DefinesFunction("IntracellularConductivity") &&
99 m_session->DefinesFunction("ExtracellularConductivity"))
100 {
101 for (int i = 0; i < m_spacedim; ++i)
102 {
103 int nq = m_fields[0]->GetNpoints();
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 =
118 m_session->GetFunction("IntracellularConductivity", varName[i]);
119 LibUtilities::EquationSharedPtr ifunc2 =
120 m_session->GetFunction("ExtracellularConductivity", varName[i]);
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 }
126 Vmath::Vadd(nq, tmp1[i], 1, tmp2[i], 1, tmp3[i], 1);
127 m_vardiffi[varCoeffEnum[i]] = tmp1[i];
128 m_vardiffie[varCoeffEnum[i]] = tmp3[i];
129 }
130 }
131
132 if (m_session->DefinesParameter("StimulusDuration"))
133 {
134 ASSERTL0(m_session->DefinesFunction("Stimulus", "u"),
135 "Stimulus function not defined.");
136 m_session->LoadParameter("StimulusDuration", m_stimDuration);
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.
145 for (auto &x : m_filters)
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
155 if (!m_explicitDiffusion)
156 {
157 m_ode.DefineImplicitSolve(&Bidomain::DoImplicitSolve, this);
158 }
159 m_ode.DefineOdeRhs(&Bidomain::DoOdeRhs, this);
160 m_ode.DefineProjection(&Bidomain::DoDummyProjection, this);
161}
162
163/**
164 *
165 */
166Bidomain::~Bidomain()
167{
168}
169
170/**
171 * @param inarray Input array.
172 * @param outarray Output array.
173 * @param time Current simulation time.
174 * @param lambda Timestep.
175 */
176void Bidomain::DoImplicitSolve(
177 const Array<OneD, const Array<OneD, NekDouble>> &inarray,
178 Array<OneD, Array<OneD, NekDouble>> &outarray,
179 [[maybe_unused]] const NekDouble time, const NekDouble lambda)
180{
181 int nvariables = inarray.size();
182 int nq = m_fields[0]->GetNpoints();
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 {
202 StdRegions::ConstFactorMap factors;
203 factors[StdRegions::eFactorLambda] =
204 (1.0 / lambda) * (m_capMembrane * m_chi);
205 if (m_spacedim == 1)
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
212 if (m_session->DefinesFunction("IntracellularConductivity") &&
213 m_session->DefinesFunction("ExtracellularConductivity"))
214 {
215 Vmath::Smul(nq, m_session->GetParameter("sigmaix"), ggrad0,
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
222 Vmath::Smul(nq, -factors[StdRegions::eFactorLambda], inarray[i],
223 1, temp, 1);
224 Vmath::Vadd(nq, ggrad, 1, temp, 1, m_fields[i]->UpdatePhys(),
225 1);
226 // Solve a system of equations with Helmholtz solver and
227 // transform back into physical space.
228 m_fields[i]->HelmSolve(m_fields[i]->GetPhys(),
229 m_fields[i]->UpdateCoeffs(), factors);
230 m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
231 m_fields[i]->UpdatePhys());
232 m_fields[i]->SetPhysState(true);
233 // Copy the solution vector (required as m_fields must be set).
234 outarray[i] = m_fields[i]->GetPhys();
235 }
236
237 if (m_spacedim == 2)
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
245 if (m_session->DefinesFunction("IntracellularConductivity") &&
246 m_session->DefinesFunction("ExtracellularConductivity"))
247 {
248 Vmath::Smul(nq, m_session->GetParameter("sigmaix"), ggrad0,
249 1, ggrad0, 1);
250 Vmath::Smul(nq, m_session->GetParameter("sigmaiy"), ggrad1,
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
257 Vmath::Smul(nq, -factors[StdRegions::eFactorLambda], inarray[i],
258 1, temp, 1);
259 Vmath::Vadd(nq, ggrad, 1, temp, 1, m_fields[i]->UpdatePhys(),
260 1);
261 // Solve a system of equations with Helmholtz solver and
262 // transform back into physical space.
263 m_fields[i]->HelmSolve(m_fields[i]->GetPhys(),
264 m_fields[i]->UpdateCoeffs(), factors,
265 m_vardiffi);
266 m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
267 m_fields[i]->UpdatePhys());
268 m_fields[i]->SetPhysState(true);
269 // Copy the solution vector (required as m_fields must be set).
270 outarray[i] = m_fields[i]->GetPhys();
271 }
272
273 if (m_spacedim == 3)
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
282 if (m_session->DefinesFunction("IntracellularConductivity") &&
283 m_session->DefinesFunction("ExtracellularConductivity"))
284 {
285 Vmath::Smul(nq, m_session->GetParameter("sigmaix"), ggrad0,
286 1, ggrad0, 1);
287 Vmath::Smul(nq, m_session->GetParameter("sigmaiy"), ggrad1,
288 1, ggrad1, 1);
289 Vmath::Smul(nq, m_session->GetParameter("sigmaiz"), ggrad2,
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
297 Vmath::Smul(nq, -factors[StdRegions::eFactorLambda], inarray[i],
298 1, temp, 1);
299 Vmath::Vadd(nq, ggrad, 1, temp, 1, m_fields[i]->UpdatePhys(),
300 1);
301 // Solve a system of equations with Helmholtz solver and
302 // transform back into physical space.
303 m_fields[i]->HelmSolve(m_fields[i]->GetPhys(),
304 m_fields[i]->UpdateCoeffs(), factors,
305 m_vardiffi);
306 m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
307 m_fields[i]->UpdatePhys());
308 m_fields[i]->SetPhysState(true);
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 {
315 StdRegions::ConstFactorMap factors;
316 factors[StdRegions::eFactorLambda] = 0.0;
317 if (m_spacedim == 1)
318 {
319 // Take first partial derivative
320 m_fields[i]->PhysDeriv(m_fields[0]->UpdatePhys(), grad0);
321 // Take second derivative
322 m_fields[i]->PhysDeriv(0, grad0, grad0);
323 // Multiply by Intracellular-Conductivity
324 if (m_session->DefinesFunction("IntracellularConductivity") &&
325 m_session->DefinesFunction("ExtracellularConductivity"))
326 {
327 Vmath::Smul(nq, m_session->GetParameter("sigmaix"), grad0,
328 1, grad0, 1);
329 }
330 // and sum terms
331 Vmath::Vcopy(nq, grad0, 1, grad, 1);
332 Vmath::Smul(nq,
333 (-1.0 * m_session->GetParameter("sigmaix")) /
334 (m_session->GetParameter("sigmaix") +
335 m_session->GetParameter("sigmaix")),
336 grad, 1, grad, 1);
337 // Now solve Poisson problem for \phi_e
338 m_fields[i]->SetPhys(grad);
339 m_fields[i]->HelmSolve(m_fields[i]->GetPhys(),
340 m_fields[i]->UpdateCoeffs(), factors);
341 m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
342 m_fields[i]->UpdatePhys());
343 m_fields[i]->SetPhysState(true);
344 // Copy the solution vector (required as m_fields must be set).
345 outarray[i] = m_fields[i]->GetPhys();
346 }
347
348 if (m_spacedim == 2)
349 {
350 // Take first partial derivative
351 m_fields[i]->PhysDeriv(m_fields[0]->UpdatePhys(), grad0, grad1);
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
356 if (m_session->DefinesFunction("IntracellularConductivity") &&
357 m_session->DefinesFunction("ExtracellularConductivity"))
358 {
359 Vmath::Smul(nq, m_session->GetParameter("sigmaix"), grad0,
360 1, grad0, 1);
361 Vmath::Smul(nq, m_session->GetParameter("sigmaiy"), grad1,
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);
369 m_fields[i]->HelmSolve(m_fields[i]->GetPhys(),
370 m_fields[i]->UpdateCoeffs(), factors,
371 m_vardiffie);
372 m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
373 m_fields[i]->UpdatePhys());
374 m_fields[i]->SetPhysState(true);
375 // Copy the solution vector (required as m_fields must be set).
376 outarray[i] = m_fields[i]->GetPhys();
377 }
378
379 if (m_spacedim == 3)
380 {
381 // Take first partial derivative
382 m_fields[i]->PhysDeriv(m_fields[0]->UpdatePhys(), grad0, grad1,
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
389 if (m_session->DefinesFunction("IntracellularConductivity") &&
390 m_session->DefinesFunction("ExtracellularConductivity"))
391 {
392 Vmath::Smul(nq, m_session->GetParameter("sigmaix"), grad0,
393 1, grad0, 1);
394 Vmath::Smul(nq, m_session->GetParameter("sigmaiy"), grad1,
395 1, grad1, 1);
396 Vmath::Smul(nq, m_session->GetParameter("sigmaiz"), grad2,
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);
405 m_fields[i]->HelmSolve(m_fields[i]->GetPhys(),
406 m_fields[i]->UpdateCoeffs(), factors,
407 m_vardiffie);
408 m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
409 m_fields[i]->UpdatePhys());
410 m_fields[i]->SetPhysState(true);
411 // Copy the solution vector (required as m_fields must be set).
412 outarray[i] = m_fields[i]->GetPhys();
413 }
414 }
415 }
416}
417
418void Bidomain::DoOdeRhs(
419 const Array<OneD, const Array<OneD, NekDouble>> &inarray,
420 Array<OneD, Array<OneD, NekDouble>> &outarray, const NekDouble time)
421{
422 int nq = m_fields[0]->GetNpoints();
423 m_cell->TimeIntegrate(inarray, outarray, time);
424 if (m_stimDuration > 0 && time < m_stimDuration)
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 =
435 m_session->GetFunction("Stimulus", "u");
436 ifunc->Evaluate(x0, x1, x2, time, result);
437
438 Vmath::Vadd(nq, outarray[0], 1, result, 1, outarray[0], 1);
439 }
440 Vmath::Smul(nq, 1.0 / m_capMembrane, outarray[0], 1, outarray[0], 1);
441}
442
443void Bidomain::v_SetInitialConditions(NekDouble initialtime,
444 bool dumpInitialConditions,
445 const int domain)
446{
447 EquationSystem::v_SetInitialConditions(initialtime, dumpInitialConditions,
448 domain);
449 m_cell->Initialise();
450}
451
452/**
453 *
454 */
455void Bidomain::v_GenerateSummary(SummaryList &s)
456{
457 UnsteadySystem::v_GenerateSummary(s);
458
459 /// @TODO Update summary
460 ASSERTL0(false, "Update the generate 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}
532
533} // namespace Nektar
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:208
Nektar::Bidomain::create
static EquationSystemSharedPtr create(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Creates an instance of this class.
Definition: Bidomain.h:53
Nektar::Bidomain::m_chi
NekDouble m_chi
Definition: Bidomain.h:99
Nektar::Bidomain::v_SetInitialConditions
void v_SetInitialConditions(NekDouble initialtime, bool dumpInitialConditions, const int domain) override
Sets a custom initial condition.
Definition: Bidomain.cpp:443
Nektar::Bidomain::tmp3
Array< OneD, Array< OneD, NekDouble > > tmp3
Definition: Bidomain.h:107
Nektar::Bidomain::className
static std::string className
Name of class.
Definition: Bidomain.h:64
Nektar::Bidomain::tmp2
Array< OneD, Array< OneD, NekDouble > > tmp2
Definition: Bidomain.h:106
Nektar::Bidomain::m_vardiffi
StdRegions::VarCoeffMap m_vardiffi
Definition: Bidomain.h:102
Nektar::Bidomain::v_InitObject
void v_InitObject(bool DeclareField=true) override
Init object for UnsteadySystem class.
Definition: Bidomain.cpp:74
Nektar::Bidomain::tmp1
Array< OneD, Array< OneD, NekDouble > > tmp1
Definition: Bidomain.h:105
Nektar::Bidomain::DoOdeRhs
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
Nektar::Bidomain::m_cell
CellModelSharedPtr m_cell
Cell model.
Definition: Bidomain.h:97
Nektar::Bidomain::v_GenerateSummary
void v_GenerateSummary(SummaryList &s) override
Prints a summary of the model parameters.
Definition: Bidomain.cpp:455
Nektar::Bidomain::m_capMembrane
NekDouble m_capMembrane
Definition: Bidomain.h:99
Nektar::Bidomain::m_vardiffie
StdRegions::VarCoeffMap m_vardiffie
Definition: Bidomain.h:103
Nektar::Bidomain::Bidomain
Bidomain(const LibUtilities::SessionReaderSharedPtr &pSession, const SpatialDomains::MeshGraphSharedPtr &pGraph)
Constructor.
Definition: Bidomain.cpp:68
Nektar::Bidomain::~Bidomain
~Bidomain() override
Desctructor.
Definition: Bidomain.cpp:166
Nektar::Bidomain::m_stimDuration
NekDouble m_stimDuration
Stimulus current.
Definition: Bidomain.h:110
Nektar::Bidomain::DoImplicitSolve
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
Nektar::LibUtilities::NekFactory::RegisterCreatorFunction
tKey RegisterCreatorFunction(tKey idKey, CreatorFunction classCreator, std::string pDesc="")
Register a class with the factory.
Definition: NekFactory.hpp:197
Nektar::LibUtilities::NekFactory::CreateInstance
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:143
Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineProjection
void DefineProjection(FuncPointerT func, ObjectPointerT obj)
Definition: TimeIntegrationSchemeOperators.h:92
Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
Definition: TimeIntegrationSchemeOperators.h:84
Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineImplicitSolve
void DefineImplicitSolve(FuncPointerT func, ObjectPointerT obj)
Definition: TimeIntegrationSchemeOperators.h:100
Nektar::SolverUtils::EquationSystem::m_spacedim
int m_spacedim
Spatial dimension (>= expansion dim).
Definition: EquationSystem.h:396
Nektar::SolverUtils::EquationSystem::v_SetInitialConditions
virtual SOLVER_UTILS_EXPORT void v_SetInitialConditions(NekDouble initialtime=0.0, bool dumpInitialConditions=true, const int domain=0)
Definition: EquationSystem.cpp:986
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:359
Nektar::SolverUtils::EquationSystem::m_session
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
Definition: EquationSystem.h:352
Nektar::SolverUtils::UnsteadySystem
Base class for unsteady solvers.
Definition: UnsteadySystem.h:46
Nektar::SolverUtils::UnsteadySystem::m_ode
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
Definition: UnsteadySystem.h:88
Nektar::SolverUtils::UnsteadySystem::m_filters
std::vector< std::pair< std::string, FilterSharedPtr > > m_filters
Definition: UnsteadySystem.h:119
Nektar::SolverUtils::UnsteadySystem::DoDummyProjection
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
Nektar::SolverUtils::UnsteadySystem::m_explicitDiffusion
bool m_explicitDiffusion
Indicates if explicit or implicit treatment of diffusion is used.
Definition: UnsteadySystem.h:106
Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary
SOLVER_UTILS_EXPORT void v_GenerateSummary(SummaryList &s) override
Print a summary of time stepping parameters.
Definition: UnsteadySystem.cpp:606
Nektar::SolverUtils::UnsteadySystem::v_InitObject
SOLVER_UTILS_EXPORT void v_InitObject(bool DeclareField=true) override
Init object for UnsteadySystem class.
Definition: UnsteadySystem.cpp:85
Nektar::LibUtilities::SessionReaderSharedPtr
std::shared_ptr< SessionReader > SessionReaderSharedPtr
Definition: SessionReader.h:113
Nektar::LibUtilities::EquationSharedPtr
std::shared_ptr< Equation > EquationSharedPtr
Definition: Equation.h:125
Nektar::SolverUtils::SummaryList
std::vector< std::pair< std::string, std::string > > SummaryList
Definition: Misc.h:46
Nektar::SolverUtils::GetEquationSystemFactory
EquationSystemFactory & GetEquationSystemFactory()
Definition: EquationSystem.cpp:99
Nektar::SpatialDomains::MeshGraphSharedPtr
std::shared_ptr< MeshGraph > MeshGraphSharedPtr
Definition: MeshGraph.h:174
Nektar::StdRegions::ConstFactorMap
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition: StdRegions.hpp:402
Nektar::VarcoeffHashingTest::factors
StdRegions::ConstFactorMap factors
Definition: TestVarcoeffHashing.cpp:51
Nektar::GetCellModelFactory
CellModelFactory & GetCellModelFactory()
Definition: CellModel.cpp:46
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Vmath::Vadd
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
Vmath::Smul
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
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.hpp:825
Generated on Wed Jan 31 2024 09:35:57 for Nektar++ by doxygen 1.9.4