v0.14.0
Loading...
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
368 post_proc->addFieldValuesPostProc("U");
369 // post_proc->addFieldValuesPostProc("F");
370 post_proc->addFieldValuesPostProc("V");
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()
Definition: adol-c_atom.cpp:46
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.
keeps basic data about problem
Problem manager is used to build and partition problems.
Simple interface for fast problem set-up.
Definition: Simple.hpp:27
MoFEMErrorCode loadFile(const std::string options, const std::string mesh_file_name, LoadFileFunc loadFunc=defaultLoadFileFunc)
Load mesh file.
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)
Add field on domain.
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)
Add field on domain.
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)
Add field on boundary.
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 add_fe()
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