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, const NekDouble time,
179 const NekDouble lambda)
180{
181 boost::ignore_unused(time);
182
183 int nvariables = inarray.size();
184 int nq = m_fields[0]->GetNpoints();
185
186 Array<OneD, NekDouble> grad0(nq), grad1(nq), grad2(nq), grad(nq);
187 Array<OneD, NekDouble> ggrad0(nq), ggrad1(nq), ggrad2(nq), ggrad(nq),
188 temp(nq);
189
190 // We solve ( \sigma\nabla^2 - HHlambda ) Y[i] = rhs [i]
191 // inarray = input: \hat{rhs} -> output: \hat{Y}
192 // outarray = output: nabla^2 \hat{Y}
193 // where \hat = modal coeffs
194 for (int i = 0; i < nvariables; ++i)
195 {
196 // Only apply diffusion to first variable.
197 if (i > 1)
198 {
199 Vmath::Vcopy(nq, &inarray[i][0], 1, &outarray[i][0], 1);
200 continue;
201 }
202 if (i == 0)
203 {
204 StdRegions::ConstFactorMap factors;
205 factors[StdRegions::eFactorLambda] =
206 (1.0 / lambda) * (m_capMembrane * m_chi);
207 if (m_spacedim == 1)
208 {
209 // Take first partial derivative
210 m_fields[i]->PhysDeriv(inarray[1], ggrad0);
211 // Take second partial derivative
212 m_fields[i]->PhysDeriv(0, ggrad0, ggrad0);
213 // Multiply by Intracellular-Conductivity
214 if (m_session->DefinesFunction("IntracellularConductivity") &&
215 m_session->DefinesFunction("ExtracellularConductivity"))
216 {
217 Vmath::Smul(nq, m_session->GetParameter("sigmaix"), ggrad0,
218 1, ggrad0, 1);
219 }
220 // Add partial derivatives together
221 Vmath::Vcopy(nq, ggrad0, 1, ggrad, 1);
222 Vmath::Smul(nq, -1.0, ggrad, 1, ggrad, 1);
223 // Multiply 1.0/timestep/lambda
224 Vmath::Smul(nq, -factors[StdRegions::eFactorLambda], inarray[i],
225 1, temp, 1);
226 Vmath::Vadd(nq, ggrad, 1, temp, 1, m_fields[i]->UpdatePhys(),
227 1);
228 // Solve a system of equations with Helmholtz solver and
229 // transform back into physical space.
230 m_fields[i]->HelmSolve(m_fields[i]->GetPhys(),
231 m_fields[i]->UpdateCoeffs(), factors);
232 m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
233 m_fields[i]->UpdatePhys());
234 m_fields[i]->SetPhysState(true);
235 // Copy the solution vector (required as m_fields must be set).
236 outarray[i] = m_fields[i]->GetPhys();
237 }
238
239 if (m_spacedim == 2)
240 {
241 // Take first partial derivative
242 m_fields[i]->PhysDeriv(inarray[1], ggrad0, ggrad1);
243 // Take second partial derivative
244 m_fields[i]->PhysDeriv(0, ggrad0, ggrad0);
245 m_fields[i]->PhysDeriv(1, ggrad1, ggrad1);
246 // Multiply by Intracellular-Conductivity
247 if (m_session->DefinesFunction("IntracellularConductivity") &&
248 m_session->DefinesFunction("ExtracellularConductivity"))
249 {
250 Vmath::Smul(nq, m_session->GetParameter("sigmaix"), ggrad0,
251 1, ggrad0, 1);
252 Vmath::Smul(nq, m_session->GetParameter("sigmaiy"), ggrad1,
253 1, ggrad1, 1);
254 }
255 // Add partial derivatives together
256 Vmath::Vadd(nq, ggrad0, 1, ggrad1, 1, ggrad, 1);
257 Vmath::Smul(nq, -1.0, ggrad, 1, ggrad, 1);
258 // Multiply 1.0/timestep/lambda
259 Vmath::Smul(nq, -factors[StdRegions::eFactorLambda], inarray[i],
260 1, temp, 1);
261 Vmath::Vadd(nq, ggrad, 1, temp, 1, m_fields[i]->UpdatePhys(),
262 1);
263 // Solve a system of equations with Helmholtz solver and
264 // transform back into physical space.
265 m_fields[i]->HelmSolve(m_fields[i]->GetPhys(),
266 m_fields[i]->UpdateCoeffs(), factors,
267 m_vardiffi);
268 m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
269 m_fields[i]->UpdatePhys());
270 m_fields[i]->SetPhysState(true);
271 // Copy the solution vector (required as m_fields must be set).
272 outarray[i] = m_fields[i]->GetPhys();
273 }
274
275 if (m_spacedim == 3)
276 {
277 // Take first partial derivative
278 m_fields[i]->PhysDeriv(inarray[1], ggrad0, ggrad1, ggrad2);
279 // Take second partial derivative
280 m_fields[i]->PhysDeriv(0, ggrad0, ggrad0);
281 m_fields[i]->PhysDeriv(1, ggrad1, ggrad1);
282 m_fields[i]->PhysDeriv(2, ggrad2, ggrad2);
283 // Multiply by Intracellular-Conductivity
284 if (m_session->DefinesFunction("IntracellularConductivity") &&
285 m_session->DefinesFunction("ExtracellularConductivity"))
286 {
287 Vmath::Smul(nq, m_session->GetParameter("sigmaix"), ggrad0,
288 1, ggrad0, 1);
289 Vmath::Smul(nq, m_session->GetParameter("sigmaiy"), ggrad1,
290 1, ggrad1, 1);
291 Vmath::Smul(nq, m_session->GetParameter("sigmaiz"), ggrad2,
292 1, ggrad2, 1);
293 }
294 // Add partial derivatives together
295 Vmath::Vadd(nq, ggrad0, 1, ggrad1, 1, ggrad, 1);
296 Vmath::Vadd(nq, ggrad2, 1, ggrad, 1, ggrad, 1);
297 Vmath::Smul(nq, -1.0, ggrad, 1, ggrad, 1);
298 // Multiply 1.0/timestep/lambda
299 Vmath::Smul(nq, -factors[StdRegions::eFactorLambda], inarray[i],
300 1, temp, 1);
301 Vmath::Vadd(nq, ggrad, 1, temp, 1, m_fields[i]->UpdatePhys(),
302 1);
303 // Solve a system of equations with Helmholtz solver and
304 // transform back into physical space.
305 m_fields[i]->HelmSolve(m_fields[i]->GetPhys(),
306 m_fields[i]->UpdateCoeffs(), factors,
307 m_vardiffi);
308 m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
309 m_fields[i]->UpdatePhys());
310 m_fields[i]->SetPhysState(true);
311 // Copy the solution vector (required as m_fields must be set).
312 outarray[i] = m_fields[i]->GetPhys();
313 }
314 }
315 if (i == 1)
316 {
317 StdRegions::ConstFactorMap factors;
318 factors[StdRegions::eFactorLambda] = 0.0;
319 if (m_spacedim == 1)
320 {
321 // Take first partial derivative
322 m_fields[i]->PhysDeriv(m_fields[0]->UpdatePhys(), grad0);
323 // Take second derivative
324 m_fields[i]->PhysDeriv(0, grad0, grad0);
325 // Multiply by Intracellular-Conductivity
326 if (m_session->DefinesFunction("IntracellularConductivity") &&
327 m_session->DefinesFunction("ExtracellularConductivity"))
328 {
329 Vmath::Smul(nq, m_session->GetParameter("sigmaix"), grad0,
330 1, grad0, 1);
331 }
332 // and sum terms
333 Vmath::Vcopy(nq, grad0, 1, grad, 1);
334 Vmath::Smul(nq,
335 (-1.0 * m_session->GetParameter("sigmaix")) /
336 (m_session->GetParameter("sigmaix") +
337 m_session->GetParameter("sigmaix")),
338 grad, 1, grad, 1);
339 // Now solve Poisson problem for \phi_e
340 m_fields[i]->SetPhys(grad);
341 m_fields[i]->HelmSolve(m_fields[i]->GetPhys(),
342 m_fields[i]->UpdateCoeffs(), factors);
343 m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
344 m_fields[i]->UpdatePhys());
345 m_fields[i]->SetPhysState(true);
346 // Copy the solution vector (required as m_fields must be set).
347 outarray[i] = m_fields[i]->GetPhys();
348 }
349
350 if (m_spacedim == 2)
351 {
352 // Take first partial derivative
353 m_fields[i]->PhysDeriv(m_fields[0]->UpdatePhys(), grad0, grad1);
354 // Take second derivative
355 m_fields[i]->PhysDeriv(0, grad0, grad0);
356 m_fields[i]->PhysDeriv(1, grad1, grad1);
357 // Multiply by Intracellular-Conductivity
358 if (m_session->DefinesFunction("IntracellularConductivity") &&
359 m_session->DefinesFunction("ExtracellularConductivity"))
360 {
361 Vmath::Smul(nq, m_session->GetParameter("sigmaix"), grad0,
362 1, grad0, 1);
363 Vmath::Smul(nq, m_session->GetParameter("sigmaiy"), grad1,
364 1, grad1, 1);
365 }
366 // and sum terms
367 Vmath::Vadd(nq, grad0, 1, grad1, 1, grad, 1);
368 Vmath::Smul(nq, -1.0, grad, 1, grad, 1);
369 // Now solve Poisson problem for \phi_e
370 m_fields[i]->SetPhys(grad);
371 m_fields[i]->HelmSolve(m_fields[i]->GetPhys(),
372 m_fields[i]->UpdateCoeffs(), factors,
373 m_vardiffie);
374 m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
375 m_fields[i]->UpdatePhys());
376 m_fields[i]->SetPhysState(true);
377 // Copy the solution vector (required as m_fields must be set).
378 outarray[i] = m_fields[i]->GetPhys();
379 }
380
381 if (m_spacedim == 3)
382 {
383 // Take first partial derivative
384 m_fields[i]->PhysDeriv(m_fields[0]->UpdatePhys(), grad0, grad1,
385 grad2);
386 // Take second derivative
387 m_fields[i]->PhysDeriv(0, grad0, grad0);
388 m_fields[i]->PhysDeriv(1, grad1, grad1);
389 m_fields[i]->PhysDeriv(2, grad2, grad2);
390 // Multiply by Intracellular-Conductivity
391 if (m_session->DefinesFunction("IntracellularConductivity") &&
392 m_session->DefinesFunction("ExtracellularConductivity"))
393 {
394 Vmath::Smul(nq, m_session->GetParameter("sigmaix"), grad0,
395 1, grad0, 1);
396 Vmath::Smul(nq, m_session->GetParameter("sigmaiy"), grad1,
397 1, grad1, 1);
398 Vmath::Smul(nq, m_session->GetParameter("sigmaiz"), grad2,
399 1, grad2, 1);
400 }
401 // and sum terms
402 Vmath::Vadd(nq, grad0, 1, grad1, 1, grad, 1);
403 Vmath::Vadd(nq, grad2, 1, grad, 1, grad, 1);
404 Vmath::Smul(nq, -1.0, grad, 1, grad, 1);
405 // Now solve Poisson problem for \phi_e
406 m_fields[i]->SetPhys(grad);
407 m_fields[i]->HelmSolve(m_fields[i]->GetPhys(),
408 m_fields[i]->UpdateCoeffs(), factors,
409 m_vardiffie);
410 m_fields[i]->BwdTrans(m_fields[i]->GetCoeffs(),
411 m_fields[i]->UpdatePhys());
412 m_fields[i]->SetPhysState(true);
413 // Copy the solution vector (required as m_fields must be set).
414 outarray[i] = m_fields[i]->GetPhys();
415 }
416 }
417 }
418}
419
420void Bidomain::DoOdeRhs(
421 const Array<OneD, const Array<OneD, NekDouble>> &inarray,
422 Array<OneD, Array<OneD, NekDouble>> &outarray, const NekDouble time)
423{
424 int nq = m_fields[0]->GetNpoints();
425 m_cell->TimeIntegrate(inarray, outarray, time);
426 if (m_stimDuration > 0 && time < m_stimDuration)
427 {
428 Array<OneD, NekDouble> x0(nq);
429 Array<OneD, NekDouble> x1(nq);
430 Array<OneD, NekDouble> x2(nq);
431 Array<OneD, NekDouble> result(nq);
432
433 // get the coordinates
434 m_fields[0]->GetCoords(x0, x1, x2);
435
436 LibUtilities::EquationSharedPtr ifunc =
437 m_session->GetFunction("Stimulus", "u");
438 ifunc->Evaluate(x0, x1, x2, time, result);
439
440 Vmath::Vadd(nq, outarray[0], 1, result, 1, outarray[0], 1);
441 }
442 Vmath::Smul(nq, 1.0 / m_capMembrane, outarray[0], 1, outarray[0], 1);
443}
444
445void Bidomain::v_SetInitialConditions(NekDouble initialtime,
446 bool dumpInitialConditions,
447 const int domain)
448{
449 EquationSystem::v_SetInitialConditions(initialtime, dumpInitialConditions,
450 domain);
451 m_cell->Initialise();
452}
453
454/**
455 *
456 */
457void Bidomain::v_GenerateSummary(SummaryList &s)
458{
459 UnsteadySystem::v_GenerateSummary(s);
460
461 /// @TODO Update summary
462 ASSERTL0(false, "Update the generate summary");
463 //
464 // out << "\tChi : " << m_chi << endl;
465 // out << "\tCm : " << m_capMembrane << endl;
466 // if (m_session->DefinesFunction("IntracellularConductivity",
467 // "AnisotropicConductivityX") &&
468 // m_session->GetFunctionType("IntracellularConductivity",
469 // "AnisotropicConductivityX") ==
470 // LibUtilities::eFunctionTypeExpression)
471 // {
472 // out << "\tIntra-Diffusivity-x : "
473 // << m_session->GetFunction("IntracellularConductivity",
474 // "AnisotropicConductivityX")->GetExpression()
475 // << endl;
476 // }
477 // if (m_session->DefinesFunction("IntracellularConductivity",
478 // "AnisotropicConductivityY") &&
479 // m_session->GetFunctionType("IntracellularConductivity",
480 // "AnisotropicConductivityY") ==
481 // LibUtilities::eFunctionTypeExpression)
482 // {
483 // out << "\tIntra-Diffusivity-y : "
484 // << m_session->GetFunction("IntracellularConductivity",
485 // "AnisotropicConductivityY")->GetExpression()
486 // << endl;
487 // }
488 // if (m_session->DefinesFunction("IntracellularConductivity",
489 // "AnisotropicConductivityZ") &&
490 // m_session->GetFunctionType("IntracellularConductivity",
491 // "AnisotropicConductivityZ") ==
492 // LibUtilities::eFunctionTypeExpression)
493 // {
494 // out << "\tIntra-Diffusivity-z : "
495 // << m_session->GetFunction("IntracellularConductivity",
496 // "AnisotropicConductivityZ")->GetExpression()
497 // << endl;
498 // }
499 // if (m_session->DefinesFunction("ExtracellularConductivity",
500 // "AnisotropicConductivityX") &&
501 // m_session->GetFunctionType("ExtracellularConductivity",
502 // "AnisotropicConductivityX") ==
503 // LibUtilities::eFunctionTypeExpression)
504 // {
505 // out << "\tExtra-Diffusivity-x : "
506 // << m_session->GetFunction("ExtracellularConductivity",
507 // "AnisotropicConductivityX")->GetExpression()
508 // << endl;
509 // }
510 // if (m_session->DefinesFunction("ExtracellularConductivity",
511 // "AnisotropicConductivityY") &&
512 // m_session->GetFunctionType("ExtracellularConductivity",
513 // "AnisotropicConductivityY") ==
514 // LibUtilities::eFunctionTypeExpression)
515 // {
516 // out << "\tExtra-Diffusivity-y : "
517 // << m_session->GetFunction("ExtracellularConductivity",
518 // "AnisotropicConductivityY")->GetExpression()
519 // << endl;
520 // }
521 // if (m_session->DefinesFunction("ExtracellularConductivity",
522 // "AnisotropicConductivityZ") &&
523 // m_session->GetFunctionType("ExtracellularConductivity",
524 // "AnisotropicConductivityZ") ==
525 // LibUtilities::eFunctionTypeExpression)
526 // {
527 // out << "\tExtra-Diffusivity-z : "
528 // << m_session->GetFunction("ExtracellularConductivity",
529 // "AnisotropicConductivityZ")->GetExpression()
530 // << endl;
531 // }
532 m_cell->GenerateSummary(s);
533}
534
535} // namespace Nektar
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:215
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
virtual void v_SetInitialConditions(NekDouble initialtime, bool dumpInitialConditions, const int domain) override
Sets a custom initial condition.
Definition: Bidomain.cpp:445
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
virtual 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::~Bidomain
virtual ~Bidomain()
Desctructor.
Definition: Bidomain.cpp:166
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:420
Nektar::Bidomain::m_cell
CellModelSharedPtr m_cell
Cell model.
Definition: Bidomain.h:97
Nektar::Bidomain::v_GenerateSummary
virtual void v_GenerateSummary(SummaryList &s) override
Prints a summary of the model parameters.
Definition: Bidomain.cpp:457
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::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:198
Nektar::LibUtilities::NekFactory::CreateInstance
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:144
Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineProjection
void DefineProjection(FuncPointerT func, ObjectPointerT obj)
Definition: TimeIntegrationSchemeOperators.h:96
Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineOdeRhs
void DefineOdeRhs(FuncPointerT func, ObjectPointerT obj)
Definition: TimeIntegrationSchemeOperators.h:88
Nektar::LibUtilities::TimeIntegrationSchemeOperators::DefineImplicitSolve
void DefineImplicitSolve(FuncPointerT func, ObjectPointerT obj)
Definition: TimeIntegrationSchemeOperators.h:104
Nektar::SolverUtils::EquationSystem::m_spacedim
int m_spacedim
Spatial dimension (>= expansion dim).
Definition: EquationSystem.h:400
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:982
Nektar::SolverUtils::EquationSystem::m_fields
Array< OneD, MultiRegions::ExpListSharedPtr > m_fields
Array holding all dependent variables.
Definition: EquationSystem.h:363
Nektar::SolverUtils::EquationSystem::m_session
LibUtilities::SessionReaderSharedPtr m_session
The session reader.
Definition: EquationSystem.h:356
Nektar::SolverUtils::UnsteadySystem
Base class for unsteady solvers.
Definition: UnsteadySystem.h:48
Nektar::SolverUtils::UnsteadySystem::m_ode
LibUtilities::TimeIntegrationSchemeOperators m_ode
The time integration scheme operators to use.
Definition: UnsteadySystem.h:79
Nektar::SolverUtils::UnsteadySystem::m_filters
std::vector< std::pair< std::string, FilterSharedPtr > > m_filters
Definition: UnsteadySystem.h:110
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:953
Nektar::SolverUtils::UnsteadySystem::m_explicitDiffusion
bool m_explicitDiffusion
Indicates if explicit or implicit treatment of diffusion is used.
Definition: UnsteadySystem.h:97
Nektar::SolverUtils::UnsteadySystem::v_GenerateSummary
virtual SOLVER_UTILS_EXPORT void v_GenerateSummary(SummaryList &s) override
Print a summary of time stepping parameters.
Definition: UnsteadySystem.cpp:607
Nektar::SolverUtils::UnsteadySystem::v_InitObject
virtual SOLVER_UTILS_EXPORT void v_InitObject(bool DeclareField=true) override
Init object for UnsteadySystem class.
Definition: UnsteadySystem.cpp:87
Nektar::LibUtilities::SessionReaderSharedPtr
std::shared_ptr< SessionReader > SessionReaderSharedPtr
Definition: SessionReader.h:115
Nektar::LibUtilities::EquationSharedPtr
std::shared_ptr< Equation > EquationSharedPtr
Definition: Equation.h:129
Nektar::SolverUtils::SummaryList
std::vector< std::pair< std::string, std::string > > SummaryList
Definition: Misc.h:48
Nektar::SolverUtils::GetEquationSystemFactory
EquationSystemFactory & GetEquationSystemFactory()
Definition: EquationSystem.cpp:103
Nektar::SpatialDomains::MeshGraphSharedPtr
std::shared_ptr< MeshGraph > MeshGraphSharedPtr
Definition: MeshGraph.h:176
Nektar::StdRegions::ConstFactorMap
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition: StdRegions.hpp:408
Nektar::VarcoeffHashingTest::factors
StdRegions::ConstFactorMap factors
Definition: TestVarcoeffHashing.cpp:52
Nektar
The above copyright notice and this permission notice shall be included.
Definition: CoupledSolver.h:2
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.cpp:354
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.cpp:245
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1191
Generated on Wed Jan 31 2024 08:26:49 for Nektar++ by doxygen 1.9.4