v0.14.0
Searching...
No Matches
elec_pys_new.cpp
Go to the documentation of this file.
1#include <stdlib.h>
4
5using namespace MoFEM;
6using namespace ElectroPhysiology;
7
8static char help[] = "...\n\n";
9
10// #define M_PI 3.14159265358979323846 /* pi */
11
12double init_val_u = 0.4;
13double init_val_v = 0.0;
14
15// double alpha = -0.08;
16// double gma = 3;
17// double ep = 0.005;
18
19
20
21struct Istimulus{
22 double operator()(const double x, const double y, const double z, const double t) const{
23 if(y<= -1.6000 && t<= 0.50000){
24 return 80;
25 } else{
26 return 0;
27 }
28 }
29};
30
31struct RhsU {
32double operator() (const double u, const double v) const {
33 return c * u * (u - alpha) * (1.0 - u) - u * v;
34 }
35};
36
37struct RhsV {
38double operator() (const double u, const double v) const {
39 return (gma + mu1*v/(mu2 + u)) * (-v - c * u * (u - b -1.0));
40 }
41};
42
43struct RK4{
44 RhsV rhs_v;
45 double operator()(const double u, const double v, const double dt) const {
46 double k1 = dt * rhs_v(u, v);
47 // double k2 = dt * rhs_v(u, v + 0.5 * k1);
48 // double k3 = dt * rhs_v(u, v + 0.5 * k2);
49 double k4 = dt * rhs_v(u, v + k1);
50 return v + 0.5 * (k1 + k4);
51 }
52};
53
54
55struct RDProblem {
56public:
57 RDProblem(MoFEM::Core &core, const int order)
58 : m_field(core), order(order), cOmm(m_field.get_comm()),
59 rAnk(m_field.get_comm_rank()) {
60 vol_ele_slow_rhs = boost::shared_ptr<VolEle>(new VolEle(m_field));
62 boost::shared_ptr<FaceEle>(new FaceEle(m_field));
63 vol_ele_stiff_rhs = boost::shared_ptr<VolEle>(new VolEle(m_field));
64 vol_ele_stiff_lhs = boost::shared_ptr<VolEle>(new VolEle(m_field));
65 post_proc = boost::shared_ptr<PostProcVolumeOnRefinedMesh>(
67
68 data_u = boost::shared_ptr<PreviousData>(new PreviousData());
69 data_v = boost::shared_ptr<PreviousData>(new PreviousData());
70 data_w = boost::shared_ptr<PreviousData>(new PreviousData());
71 data_s = boost::shared_ptr<PreviousData>(new PreviousData());
72
74 boost::shared_ptr<MatrixDouble>(data_u, &data_u->flux_values);
75
76 flux_divs_ptr_u = boost::shared_ptr<VectorDouble>(data_u, &data_u->flux_divs);
77
79 boost::shared_ptr<VectorDouble>(data_u, &data_u->mass_values);
80
81 mass_dots_ptr_u = boost::shared_ptr<VectorDouble>(data_u, &data_u->mass_dots);
82
83
84
86 boost::shared_ptr<VectorDouble>(data_v, &data_v->mass_values);
87 mass_dots_ptr_v = boost::shared_ptr<VectorDouble>(data_v, &data_v->mass_dots);
88
89
91 boost::shared_ptr<VectorDouble>(data_w, &data_w->mass_values);
92
93 mass_dots_ptr_w = boost::shared_ptr<VectorDouble>(data_w, &data_w->mass_dots);
94
96 boost::shared_ptr<VectorDouble>(data_s, &data_s->mass_values);
97
99 boost::shared_ptr<VectorDouble>(data_s, &data_s->mass_dots);
100 }
101
102 // RDProblem(const int order) : order(order){}
104
105 double global_error;
106
107private:
110 MoFEMErrorCode extract_bd_ents(std::string ESSENTIAL, std::string NATURAL);
112 MoFEMErrorCode update_slow_rhs(std::string mass_field,
113 boost::shared_ptr<VectorDouble> &mass_ptr);
120
122 MoFEMErrorCode apply_IC(std::string mass_field, Range &surface,
123 boost::shared_ptr<VolEle> &initial_ele, double &init);
124 MoFEMErrorCode apply_BC(std::string flux_field);
129
134
137
138 Range inner_surface1; // nb_species times
141
142 MPI_Comm cOmm;
143 const int rAnk;
144
145 int order;
146 int nb_species;
147
148 boost::shared_ptr<VolEle> vol_ele_slow_rhs;
149 boost::shared_ptr<VolEle> vol_ele_stiff_rhs;
150 boost::shared_ptr<VolEle> vol_ele_stiff_lhs;
151 boost::shared_ptr<FaceEle> natural_bdry_ele_slow_rhs;
152 boost::shared_ptr<PostProcVolumeOnRefinedMesh> post_proc;
153 boost::shared_ptr<Monitor> monitor_ptr;
154
155 boost::shared_ptr<PreviousData> data_u; // nb_species times
156 boost::shared_ptr<PreviousData> data_v;
157 boost::shared_ptr<PreviousData> data_w;
158 boost::shared_ptr<PreviousData> data_s;
159
160 boost::shared_ptr<MatrixDouble> flux_values_ptr_u; // nb_species times
161
162
163 boost::shared_ptr<VectorDouble> flux_divs_ptr_u; // nb_species times
164
165
166 boost::shared_ptr<VectorDouble> mass_values_ptr_u; // nb_species times
167 boost::shared_ptr<VectorDouble> mass_values_ptr_v;
168 boost::shared_ptr<VectorDouble> mass_values_ptr_w;
169 boost::shared_ptr<VectorDouble> mass_values_ptr_s;
170
171 boost::shared_ptr<VectorDouble> mass_dots_ptr_u; // nb_species times
172 boost::shared_ptr<VectorDouble> mass_dots_ptr_v;
173 boost::shared_ptr<VectorDouble> mass_dots_ptr_w;
174 boost::shared_ptr<VectorDouble> mass_dots_ptr_s;
175
176 boost::shared_ptr<ForcesAndSourcesCore> null;
177};
178
179
186}
187
191
195
199
201}
202
203
204MoFEMErrorCode RDProblem::extract_bd_ents(std::string essential,
205 std::string natural) {
208 string name = it->getName();
209 if (name.compare(0, 14, natural) == 0) {
210
211 CHKERR it->getMeshsetIdEntitiesByDimension(m_field.get_moab(), 2,
212 natural_bdry_ents, true);
213 } else if (name.compare(0, 14, essential) == 0) {
214 CHKERR it->getMeshsetIdEntitiesByDimension(m_field.get_moab(), 2,
215 essential_bdry_ents, true);
216 }
217 }
219}
220
224 BLOCKSET)) {
225 CHKERR m_field.getInterface<MeshsetsManager>()->getEntitiesByDimension(
226 block_id, BLOCKSET, 3, surface, true);
227 }
229}
231RDProblem::update_slow_rhs(std::string mass_field,
232 boost::shared_ptr<VectorDouble> &mass_ptr) {
234 vol_ele_slow_rhs->getOpPtrVector().push_back(
235 new OpCalculateScalarFieldValues(mass_field, mass_ptr));
237}
238
242
243 vol_ele_slow_rhs->getOpPtrVector().push_back(
244 new OpAssembleSlowRhsV("U", data_u, data_v,RhsU()));
245
246 // natural_bdry_ele_slow_rhs->getOpPtrVector().push_back(
247 // new OpAssembleNaturalBCRhsTau("F", natural_bdry_ents));
248
249 // natural_bdry_ele_slow_rhs->getOpPtrVector().push_back(
250 // new OpEssentialBC("F", essential_bdry_ents));
252}
253
256
258
259 vol_ele_stiff_rhs->getOpPtrVector().push_back(
261 vol_ele_stiff_rhs->getOpPtrVector().push_back(
263 vol_ele_stiff_rhs->getOpPtrVector().push_back(
264 new OpSolveRecovery("V", data_u, data_v, RK4()));
265
266
267
268 vol_ele_stiff_rhs->getOpPtrVector().push_back(
270
271
272 vol_ele_stiff_rhs->getOpPtrVector().push_back(
274 vol_ele_stiff_rhs->getOpPtrVector().push_back(
277}
278
282 vol_ele_stiff_rhs->getOpPtrVector().push_back(
284
285 vol_ele_stiff_rhs->getOpPtrVector().push_back(
287
289}
290
294 vol_ele_stiff_lhs->getOpPtrVector().push_back(
296 vol_ele_stiff_lhs->getOpPtrVector().push_back(
298
299 vol_ele_stiff_lhs->getOpPtrVector().push_back(
302}
303
306 vol_ele_stiff_lhs->getOpPtrVector().push_back(
307 new OpAssembleLhsTauTau<3>("F"));
308 vol_ele_stiff_lhs->getOpPtrVector().push_back(
309 new OpAssembleLhsTauV<3>("F", "U"));
310
311 vol_ele_stiff_lhs->getOpPtrVector().push_back(
312 new OpAssembleLhsVV("U"));
313
314
315
316 vol_ele_stiff_lhs->getOpPtrVector().push_back(
317 new OpAssembleLhsVTau("U", "F"));
319}
320
323 auto vol_rule = [](int, int, int p) -> int { return 2 * p; };
324 vol_ele_slow_rhs->getRuleHook = vol_rule;
325 // natural_bdry_ele_slow_rhs->getRuleHook = vol_rule;
326
327 vol_ele_stiff_rhs->getRuleHook = vol_rule;
328
329 vol_ele_stiff_lhs->getRuleHook = vol_rule;
331}
332
333MoFEMErrorCode RDProblem::apply_IC(std::string mass_field, Range &surface,
334 boost::shared_ptr<VolEle> &initial_ele, double &init_val) {
336 initial_ele->getOpPtrVector().push_back(
337 new OpInitialMass(mass_field, surface, init_val));
339}
340
341MoFEMErrorCode RDProblem::apply_BC(std::string flux_field) {
343 CHKERR m_field.getInterface<ProblemsManager>()->removeDofsOnEntities(
344 "SimpleProblem", flux_field, essential_bdry_ents);
345
347}
350 CHKERR TSSetType(ts, TSARKIMEX);
351 CHKERR TSARKIMEXSetType(ts, TSARKIMEXA2);
352
355
358
361 // CHKERR DMMoFEMTSSetRHSFunction(dm, simple_interface->getBoundaryFEName(),
362 // natural_bdry_ele_slow_rhs, null, null);
364}
365
371
372
374}
375
381}
384 // Create solution vector
387 CHKERR DMoFEMMeshToLocalVector(dm, X, INSERT_VALUES, SCATTER_FORWARD);
388 // Solve problem
389 double ftime = 1;
390 CHKERR TSSetDM(ts, dm);
391 CHKERR TSSetDuration(ts, PETSC_DEFAULT, ftime);
392 CHKERR TSSetSolution(ts, X);
393 CHKERR TSSetFromOptions(ts);
394
395 if (1) {
396 SNES snes;
397 CHKERR TSGetSNES(ts, &snes);
398 KSP ksp;
399 CHKERR SNESGetKSP(snes, &ksp);
400 PC pc;
401 CHKERR KSPGetPC(ksp, &pc);
402 PetscBool is_pcfs = PETSC_FALSE;
403 PetscObjectTypeCompare((PetscObject)pc, PCFIELDSPLIT, &is_pcfs);
404 // Set up FIELDSPLIT
405 // Only is user set -pc_type fieldsplit
406 if (is_pcfs == PETSC_TRUE) {
407 IS is_mass, is_flux;
408 const MoFEM::Problem *problem_ptr;
409 CHKERR DMMoFEMGetProblemPtr(dm, &problem_ptr);
410 CHKERR m_field.getInterface<ISManager>()->isCreateProblemFieldAndRank(
411 problem_ptr->getName(), ROW, "U", 0, 1, &is_mass);
412 CHKERR m_field.getInterface<ISManager>()->isCreateProblemFieldAndRank(
413 problem_ptr->getName(), ROW, "F", 0, 1, &is_flux);
414 // CHKERR ISView(is_flux, PETSC_VIEWER_STDOUT_SELF);
415 // CHKERR ISView(is_mass, PETSC_VIEWER_STDOUT_SELF);
416
417
418 CHKERR PCFieldSplitSetIS(pc, NULL, is_flux);
419 CHKERR PCFieldSplitSetIS(pc, NULL, is_mass);
420
421 CHKERR ISDestroy(&is_mass);
422 CHKERR ISDestroy(&is_flux);
423 }
424 }
425
426 CHKERR TSSolve(ts, X);
428}
429
432 global_error = 0;
433
434 CHKERR setup_system(); // only once
435
436
437 CHKERR add_fe(); // nb_species times
438
439
441
442 // CHKERR set_blockData(material_blocks);
443
444 CHKERR extract_bd_ents("ESSENTIAL", "NATURAL"); // nb_species times
445
448
451
452
453 // natural_bdry_ele_slow_rhs->getOpPtrVector().push_back(
454 // new OpSetContrariantPiolaTransformOnEdge());
455
456 CHKERR push_slow_rhs(); // nb_species times
457
458
460 CHKERR push_stiff_rhs(); // nb_species times
461
462
463
465 CHKERR push_stiff_lhs(); // nb_species times
466
470 boost::shared_ptr<VolEle> initial_mass_ele(new VolEle(m_field));
471
472
474 initial_mass_ele, init_val_u); // nb_species times
476 initial_mass_ele, init_val_v); // nb_species times
477
478
480 initial_mass_ele);
481
482
483 CHKERR apply_BC("F"); // nb_species times
484
485
486 CHKERR loop_fe(); // only once
487 post_proc->generateReferenceElementMesh(); // only once
488
489
491
492
493 monitor_ptr = boost::shared_ptr<Monitor>(
494 new Monitor(cOmm, rAnk, dm, post_proc)); // nb_species times
495 CHKERR output_result(); // only once
496 CHKERR solve(); // only once
498}
499
500int main(int argc, char *argv[]) {
501 const char param_file[] = "param_file.petsc";
503 try {
504 moab::Core mb_instance;
505 moab::Interface &moab = mb_instance;
506 MoFEM::Core core(moab);
507 DMType dm_name = "DMMOFEM";
508 CHKERR DMRegister_MoFEM(dm_name);
509
510 int order = 1;
511 CHKERR PetscOptionsGetInt(PETSC_NULL, "", "-order", &order, PETSC_NULL);
512 RDProblem reac_diff_problem(core, order + 1);
513 CHKERR reac_diff_problem.run_analysis();
514 }
517 return 0;
518}
static Index< 'p', 3 > p
std::string param_file
int main()
MoFEM::FaceElementForcesAndSourcesCore FaceEle
@ ROW
Definition: definitions.h:123
#define CATCH_ERRORS
Catch errors.
Definition: definitions.h:372
@ AINSWORTH_LEGENDRE_BASE
Ainsworth Cole (Legendre) approx. base .
Definition: definitions.h:60
@ DEMKOWICZ_JACOBI_BASE
Definition: definitions.h:66
@ L2
field with C-1 continuity
Definition: definitions.h:88
@ HDIV
field with continuous normal traction
Definition: definitions.h:87
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
@ BLOCKSET
Definition: definitions.h:148
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:416
#define CHKERR
Inline error check.
Definition: definitions.h:535
constexpr int order
double init_val_v
double init_val_u
static char help[]
Definition: elec_pys_new.cpp:8
double init_val_v
double init_val_u
PetscErrorCode DMMoFEMTSSetIFunction(DM dm, const char fe_name[], MoFEM::FEMethod *method, MoFEM::BasicMethod *pre_only, MoFEM::BasicMethod *post_only)
set TS implicit function evaluation function
Definition: DMMoFEM.cpp:786
PetscErrorCode DMoFEMMeshToLocalVector(DM dm, Vec l, InsertMode mode, ScatterMode scatter_mode)
set local (or ghosted) vector values on mesh for partition only
Definition: DMMoFEM.cpp:509
PetscErrorCode DMMoFEMGetProblemPtr(DM dm, const MoFEM::Problem **problem_ptr)
Get pointer to problem data structure.
Definition: DMMoFEM.cpp:412
PetscErrorCode DMRegister_MoFEM(const char sname[])
Register MoFEM problem.
Definition: DMMoFEM.cpp:47
PetscErrorCode DMoFEMLoopFiniteElements(DM dm, const char fe_name[], MoFEM::FEMethod *method, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
Executes FEMethod for finite elements in DM.
Definition: DMMoFEM.cpp:572
PetscErrorCode DMMoFEMTSSetIJacobian(DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
set TS Jacobian evaluation function
Definition: DMMoFEM.cpp:839
PetscErrorCode DMCreateGlobalVector_MoFEM(DM dm, Vec *g)
DMShellSetCreateGlobalVector.
Definition: DMMoFEM.cpp:1153
bool checkMeshset(const int ms_id, const CubitBCType cubit_bc_type) const
check for CUBIT Id and CUBIT type
#define _IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(MESHSET_MANAGER, CUBITBCTYPE, IT)
Iterator that loops over a specific Cubit MeshSet having a particular BC meshset in a moFEM field.
double dt
Definition: heat_method.cpp:26
const double v
phase velocity of light in medium (cm/ns)
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:56
implementation of Data Operators for Forces and Sources
Definition: Common.hpp:10
PetscErrorCode DMMoFEMTSSetMonitor(DM dm, TS ts, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
Set Monitor To TS solver.
Definition: DMMoFEM.cpp:1042
PetscErrorCode DMMoFEMTSSetRHSFunction(DM dm, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
set TS the right hand side function
Definition: DMMoFEM.cpp:868
PetscErrorCode PetscOptionsGetInt(PetscOptions *, const char pre[], const char name[], PetscInt *ivalue, PetscBool *set)
OpCalculateScalarFieldValuesDot OpCalculateScalarValuesDot
auto createTS(MPI_Comm comm)
constexpr double t
plate stiffness
Definition: plate.cpp:59
double operator()(const double x, const double y, const double z, const double t) const
virtual moab::Interface & get_moab()=0
virtual MPI_Comm & get_comm() const =0
Core (interface) class.
Definition: Core.hpp:82
static MoFEMErrorCode Initialize(int *argc, char ***args, const char file[], const char help[])
Initializes the MoFEM database PETSc, MOAB and MPI.
Definition: Core.cpp:72
static MoFEMErrorCode Finalize()
Checks for options to be called at the conclusion of the program.
Definition: Core.cpp:112
Deprecated interface functions.
Section manager is used to create indexes and sections.
Definition: ISManager.hpp:23
Interface for managing meshsets containing materials and boundary conditions.
Get vector field for H-div approximation.
Calculate divergence of vector field.
Get value at integration points for scalar field.
Problem manager is used to build and partition problems.
Simple interface for fast problem set-up.
Definition: Simple.hpp:27
Definition: Simple.cpp:194
MoFEMErrorCode addDataField(const std::string &name, const FieldSpace space, const FieldApproximationBase base, const FieldCoefficientsNumber nb_of_coefficients, const TagType tag_type=MB_TAG_SPARSE, const enum MoFEMTypes bh=MF_ZERO, int verb=-1)
Definition: Simple.cpp:320
MoFEMErrorCode addDomainField(const std::string &name, const FieldSpace space, const FieldApproximationBase base, const FieldCoefficientsNumber nb_of_coefficients, const TagType tag_type=MB_TAG_SPARSE, const enum MoFEMTypes bh=MF_ZERO, int verb=-1)
Definition: Simple.cpp:264
MoFEMErrorCode getOptions()
get options
Definition: Simple.cpp:180
MoFEMErrorCode getDM(DM *dm)
Get DM.
Definition: Simple.cpp:667
MoFEMErrorCode setFieldOrder(const std::string field_name, const int order, const Range *ents=NULL)
Set field order.
Definition: Simple.cpp:473
MoFEMErrorCode addBoundaryField(const std::string &name, const FieldSpace space, const FieldApproximationBase base, const FieldCoefficientsNumber nb_of_coefficients, const TagType tag_type=MB_TAG_SPARSE, const enum MoFEMTypes bh=MF_ZERO, int verb=-1)
Definition: Simple.cpp:282
MoFEMErrorCode setUp(const PetscBool is_partitioned=PETSC_TRUE)
Setup problem.
Definition: Simple.cpp:611
const std::string getDomainFEName() const
Get the Domain FE Name.
Definition: Simple.hpp:341
intrusive_ptr for managing petsc objects
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface refernce to pointer of interface.
Post processing.
boost::shared_ptr< VectorDouble > mass_values_ptr_v
boost::shared_ptr< VolEle > vol_ele_slow_rhs
MoFEMErrorCode update_slow_rhs(std::string mass_fiedl, boost::shared_ptr< VectorDouble > &mass_ptr)
boost::shared_ptr< FaceEle > vol_ele_stiff_lhs
SmartPetscObj< TS > ts
boost::shared_ptr< PreviousData > data_s
MoFEMErrorCode update_stiff_rhs()
Range inner_surface1
SmartPetscObj< DM > dm
MoFEMErrorCode apply_BC(std::string flux_field)
boost::shared_ptr< VolEle > vol_ele_stiff_rhs
MoFEMErrorCode update_slow_rhs(std::string mass_field, boost::shared_ptr< VectorDouble > &mass_ptr)
boost::shared_ptr< Monitor > monitor_ptr
boost::shared_ptr< VectorDouble > mass_values_ptr_s
MoFEMErrorCode push_slow_rhs()
boost::shared_ptr< VectorDouble > mass_dots_ptr_u
boost::shared_ptr< VectorDouble > mass_values_ptr_u
boost::shared_ptr< VectorDouble > mass_dots_ptr_s
Range inner_surface2
Range essential_bdry_ents
MoFEMErrorCode post_proc_fields()
boost::shared_ptr< ForcesAndSourcesCore > null
MoFEMErrorCode loop_fe()
MoFEM::Interface & m_field
Simple * simple_interface
Range inner_surface3
MoFEMErrorCode run_analysis()
MPI_Comm cOmm
MoFEMErrorCode extract_bd_ents(std::string ESSENTIAL, std::string NATURAL)
boost::shared_ptr< VolEle > vol_ele_stiff_lhs
double global_error
boost::shared_ptr< VectorDouble > mass_dots_ptr_v
boost::shared_ptr< BoundaryEle > natural_bdry_ele_slow_rhs
const int rAnk
RDProblem(MoFEM::Core &core, const int order)
MoFEMErrorCode push_stiff_lhs()
MoFEMErrorCode apply_IC(std::string mass_field, Range &surface, boost::shared_ptr< VolEle > &initial_ele, double &init)
MoFEMErrorCode push_stiff_rhs()
boost::shared_ptr< MatrixDouble > flux_values_ptr_u
MoFEMErrorCode extract_initial_ents(int block_id, Range &surface)
MoFEMErrorCode solve()
boost::shared_ptr< FaceEle > natural_bdry_ele_slow_rhs
MoFEMErrorCode apply_IC(std::string mass_field, Range &surface, boost::shared_ptr< FaceEle > &initial_ele, double &init_val)
Range natural_bdry_ents
boost::shared_ptr< PreviousData > data_u
boost::shared_ptr< VectorDouble > mass_dots_ptr_w
boost::shared_ptr< PreviousData > data_v
boost::shared_ptr< PostProcVolumeOnRefinedMesh > post_proc
boost::shared_ptr< VectorDouble > mass_values_ptr_w
MoFEMErrorCode setup_system()
MoFEMErrorCode output_result()
boost::shared_ptr< FaceEle > vol_ele_slow_rhs
MoFEMErrorCode update_stiff_lhs()
MoFEMErrorCode set_integration_rule()
boost::shared_ptr< VectorDouble > flux_divs_ptr_u
boost::shared_ptr< PostProcFaceOnRefinedMesh > post_proc
boost::shared_ptr< PreviousData > data_w
boost::shared_ptr< FaceEle > vol_ele_stiff_rhs
double operator()(const double u, const double v, const double dt) const
RhsV rhs_v
double operator()(const double u, const double v) const
double operator()(const double u, const double v) const
VolumeElementForcesAndSourcesCore VolEle