v0.14.0
Loading...
Searching...
No Matches
Public Member Functions | Public Attributes | Private Member Functions | Private Attributes | List of all members
RDProblem Struct Reference
Collaboration diagram for RDProblem:
[legend]

Public Member Functions

 RDProblem (MoFEM::Core &core, const int order)
 
MoFEMErrorCode run_analysis ()
 
 RDProblem (MoFEM::Core &core, const int order)
 
MoFEMErrorCode run_analysis ()
 
 RDProblem (MoFEM::Core &core, const int order)
 
MoFEMErrorCode run_analysis (int nb_sp)
 
 RDProblem (moab::Core &mb_instance, MoFEM::Core &core, const int order, const int n_species)
 
MoFEMErrorCode run_analysis ()
 

Public Attributes

double global_error
 

Private Member Functions

MoFEMErrorCode setup_system ()
 
MoFEMErrorCode add_fe ()
 
MoFEMErrorCode set_blockData (std::map< int, BlockData > &block_data_map)
 
MoFEMErrorCode extract_bd_ents (std::string ESSENTIAL, std::string NATURAL)
 
MoFEMErrorCode extract_initial_ents (int block_id, Range &surface)
 
MoFEMErrorCode update_slow_rhs (std::string mass_fiedl, boost::shared_ptr< VectorDouble > &mass_ptr)
 
MoFEMErrorCode push_slow_rhs (std::string mass_field, std::string flux_field, boost::shared_ptr< PreviousData > &data1, boost::shared_ptr< PreviousData > &data2)
 
MoFEMErrorCode update_vol_fe (boost::shared_ptr< FaceEle > &vol_ele, boost::shared_ptr< PreviousData > &data)
 
MoFEMErrorCode update_stiff_rhs (std::string mass_field, std::string flux_field, boost::shared_ptr< VectorDouble > &mass_ptr, boost::shared_ptr< MatrixDouble > &flux_ptr, boost::shared_ptr< VectorDouble > &mass_dot_ptr, boost::shared_ptr< VectorDouble > &flux_div_ptr)
 
MoFEMErrorCode push_stiff_rhs (std::string mass_field, std::string flux_field, boost::shared_ptr< PreviousData > &data1, boost::shared_ptr< PreviousData > &data2, std::map< int, BlockData > &block_map, Range &surface)
 
MoFEMErrorCode update_stiff_lhs (std::string mass_fiedl, std::string flux_field, boost::shared_ptr< VectorDouble > &mass_ptr, boost::shared_ptr< MatrixDouble > &flux_ptr)
 
MoFEMErrorCode push_stiff_lhs (std::string mass_field, std::string flux_field, boost::shared_ptr< PreviousData > &datau, boost::shared_ptr< PreviousData > &datav, std::map< int, BlockData > &block_map)
 
MoFEMErrorCode set_integration_rule ()
 
MoFEMErrorCode apply_IC (std::string mass_field, Range &surface, boost::shared_ptr< FaceEle > &initial_ele, double &init_val)
 
MoFEMErrorCode apply_BC (std::string flux_field)
 
MoFEMErrorCode loop_fe ()
 
MoFEMErrorCode post_proc_fields ()
 
MoFEMErrorCode output_result ()
 
MoFEMErrorCode solve ()
 
MoFEMErrorCode setup_system ()
 
MoFEMErrorCode add_fe ()
 
MoFEMErrorCode extract_bd_ents (std::string ESSENTIAL, std::string NATURAL)
 
MoFEMErrorCode extract_initial_ents (int block_id, Range &surface)
 
MoFEMErrorCode update_slow_rhs (std::string mass_field, boost::shared_ptr< VectorDouble > &mass_ptr)
 
MoFEMErrorCode push_slow_rhs ()
 
MoFEMErrorCode update_stiff_rhs ()
 
MoFEMErrorCode push_stiff_rhs ()
 
MoFEMErrorCode update_stiff_lhs ()
 
MoFEMErrorCode push_stiff_lhs ()
 
MoFEMErrorCode set_integration_rule ()
 
MoFEMErrorCode apply_IC (std::string mass_field, Range &surface, boost::shared_ptr< VolEle > &initial_ele, double &init)
 
MoFEMErrorCode apply_BC (std::string flux_field)
 
MoFEMErrorCode loop_fe ()
 
MoFEMErrorCode post_proc_fields ()
 
MoFEMErrorCode output_result ()
 
MoFEMErrorCode solve ()
 
MoFEMErrorCode setup_system ()
 
MoFEMErrorCode add_fe (std::string mass_field, std::string flux_field)
 
MoFEMErrorCode set_blockData (std::map< int, BlockData > &block_data_map)
 
MoFEMErrorCode extract_bd_ents (std::string ESSENTIAL, std::string NATURAL, std::string internal)
 
MoFEMErrorCode extract_initial_ents (int block_id, Range &surface)
 
MoFEMErrorCode update_slow_rhs (std::string mass_fiedl, boost::shared_ptr< VectorDouble > &mass_ptr)
 
MoFEMErrorCode push_slow_rhs (std::string mass_field, std::string flux_field, boost::shared_ptr< PreviousData > &data)
 
MoFEMErrorCode update_vol_fe (boost::shared_ptr< FaceEle > &vol_ele, boost::shared_ptr< PreviousData > &data)
 
MoFEMErrorCode update_stiff_rhs (std::string mass_field, std::string flux_field, boost::shared_ptr< VectorDouble > &mass_ptr, boost::shared_ptr< MatrixDouble > &flux_ptr, boost::shared_ptr< VectorDouble > &mass_dot_ptr, boost::shared_ptr< VectorDouble > &flux_div_ptr)
 
MoFEMErrorCode push_stiff_rhs (std::string mass_field, std::string flux_field, boost::shared_ptr< PreviousData > &data, std::map< int, BlockData > &block_map)
 
MoFEMErrorCode update_stiff_lhs (std::string mass_fiedl, std::string flux_field, boost::shared_ptr< VectorDouble > &mass_ptr, boost::shared_ptr< MatrixDouble > &flux_ptr)
 
MoFEMErrorCode push_stiff_lhs (std::string mass_field, std::string flux_field, boost::shared_ptr< PreviousData > &data, std::map< int, BlockData > &block_map)
 
MoFEMErrorCode set_integration_rule ()
 
MoFEMErrorCode apply_IC (std::string mass_field, Range &surface, boost::shared_ptr< FaceEle > &initial_ele)
 
MoFEMErrorCode apply_BC (std::string flux_field)
 
MoFEMErrorCode loop_fe ()
 
MoFEMErrorCode post_proc_fields (std::string mass_field, std::string flux_field)
 
MoFEMErrorCode output_result ()
 
MoFEMErrorCode solve ()
 
MoFEMErrorCode setup_system ()
 
MoFEMErrorCode add_fe (std::string field_name)
 
MoFEMErrorCode set_blockData (std::map< int, BlockData > &block_data_map)
 
MoFEMErrorCode set_initial_values (std::string field_name, int block_id, Range &surface, double &init_val)
 
MoFEMErrorCode update_slow_rhs (std::string mass_fiedl, boost::shared_ptr< VectorDouble > &mass_ptr)
 
MoFEMErrorCode push_slow_rhs (std::string mass_name, boost::shared_ptr< PreviousData > &data)
 
MoFEMErrorCode push_mass_ele (std::string field_name)
 
MoFEMErrorCode resolve_slow_rhs ()
 
MoFEMErrorCode update_vol_fe (boost::shared_ptr< Ele > &vol_ele, boost::shared_ptr< PreviousData > &data)
 
MoFEMErrorCode update_stiff_rhs (std::string field_name, boost::shared_ptr< VectorDouble > &values_ptr, boost::shared_ptr< MatrixDouble > &grads_ptr, boost::shared_ptr< VectorDouble > &dots_ptr)
 
MoFEMErrorCode push_stiff_rhs (std::string field_name, boost::shared_ptr< PreviousData > &data, std::map< int, BlockData > &block_map)
 
MoFEMErrorCode update_stiff_lhs (std::string field_name, boost::shared_ptr< VectorDouble > &values_ptr, boost::shared_ptr< MatrixDouble > &grads_ptr)
 
MoFEMErrorCode push_stiff_lhs (std::string field_name, boost::shared_ptr< PreviousData > &data, std::map< int, BlockData > &block_map)
 
MoFEMErrorCode set_integration_rule ()
 
MoFEMErrorCode set_fe_in_loop ()
 
MoFEMErrorCode post_proc_fields (std::string field_name)
 
MoFEMErrorCode output_result ()
 
MoFEMErrorCode solve ()
 

Private Attributes

MoFEM::Interfacem_field
 
Simplesimple_interface
 
SmartPetscObj< DM > dm
 
SmartPetscObj< TS > ts
 
Range essential_bdry_ents
 
Range natural_bdry_ents
 
Range inner_surface1
 
Range inner_surface2
 
MPI_Comm cOmm
 
const int rAnk
 
int order
 
int nb_species
 
std::map< int, BlockDatamaterial_blocks
 
boost::shared_ptr< FaceElevol_ele_slow_rhs
 
boost::shared_ptr< FaceElevol_ele_stiff_rhs
 
boost::shared_ptr< FaceElevol_ele_stiff_lhs
 
boost::shared_ptr< BoundaryElenatural_bdry_ele_slow_rhs
 
boost::shared_ptr< PostProcFaceOnRefinedMeshpost_proc
 
boost::shared_ptr< Monitormonitor_ptr
 
boost::shared_ptr< PreviousDatadata1
 
boost::shared_ptr< PreviousDatadata2
 
boost::shared_ptr< MatrixDouble > flux_values_ptr1
 
boost::shared_ptr< MatrixDouble > flux_values_ptr2
 
boost::shared_ptr< VectorDouble > flux_divs_ptr1
 
boost::shared_ptr< VectorDouble > flux_divs_ptr2
 
boost::shared_ptr< VectorDouble > mass_values_ptr1
 
boost::shared_ptr< VectorDouble > mass_values_ptr2
 
boost::shared_ptr< VectorDouble > mass_dots_ptr1
 
boost::shared_ptr< VectorDouble > mass_dots_ptr2
 
boost::shared_ptr< ForcesAndSourcesCorenull
 
Range inner_surface3
 
boost::shared_ptr< VolElevol_ele_slow_rhs
 
boost::shared_ptr< VolElevol_ele_stiff_rhs
 
boost::shared_ptr< VolElevol_ele_stiff_lhs
 
boost::shared_ptr< FaceElenatural_bdry_ele_slow_rhs
 
boost::shared_ptr< PostProcVolumeOnRefinedMeshpost_proc
 
boost::shared_ptr< PreviousDatadata_u
 
boost::shared_ptr< PreviousDatadata_v
 
boost::shared_ptr< PreviousDatadata_w
 
boost::shared_ptr< PreviousDatadata_s
 
boost::shared_ptr< MatrixDouble > flux_values_ptr_u
 
boost::shared_ptr< VectorDouble > flux_divs_ptr_u
 
boost::shared_ptr< VectorDouble > mass_values_ptr_u
 
boost::shared_ptr< VectorDouble > mass_values_ptr_v
 
boost::shared_ptr< VectorDouble > mass_values_ptr_w
 
boost::shared_ptr< VectorDouble > mass_values_ptr_s
 
boost::shared_ptr< VectorDouble > mass_dots_ptr_u
 
boost::shared_ptr< VectorDouble > mass_dots_ptr_v
 
boost::shared_ptr< VectorDouble > mass_dots_ptr_w
 
boost::shared_ptr< VectorDouble > mass_dots_ptr_s
 
Range internal_edge_ents
 
boost::shared_ptr< PreviousDatadata3
 
boost::shared_ptr< MatrixDouble > flux_values_ptr3
 
boost::shared_ptr< VectorDouble > flux_divs_ptr3
 
boost::shared_ptr< VectorDouble > mass_values_ptr3
 
boost::shared_ptr< VectorDouble > mass_dots_ptr3
 
moab::Interface & moab
 
SmartPetscObj< Mat > mass_matrix
 
SmartPetscObj< KSP > mass_Ksp
 
Range bdry_ents
 
std::vector< Rangeinner_surface
 
Range stimulation_surface
 
boost::shared_ptr< Elevol_ele_slow_rhs
 
boost::shared_ptr< Elevol_ele_stiff_rhs
 
boost::shared_ptr< Elevol_ele_stiff_lhs
 
boost::shared_ptr< BoundaryEleboundary_ele_rhs
 
boost::shared_ptr< Elevol_mass_ele
 
std::vector< boost::shared_ptr< PreviousData > > data
 
std::vector< boost::shared_ptr< MatrixDouble > > grads_ptr
 
std::vector< boost::shared_ptr< VectorDouble > > values_ptr
 
std::vector< boost::shared_ptr< VectorDouble > > dots_ptr
 

Detailed Description

Definition at line 91 of file elec_phys_2D.cpp.

Constructor & Destructor Documentation

◆ RDProblem() [1/4]

RDProblem::RDProblem ( MoFEM::Core core,
const int  order 
)
inline

Definition at line 93 of file elec_phys_2D.cpp.

94 : m_field(core), order(order), cOmm(m_field.get_comm()),
96 vol_ele_slow_rhs = boost::shared_ptr<FaceEle>(new FaceEle(m_field));
98 boost::shared_ptr<BoundaryEle>(new BoundaryEle(m_field));
99 vol_ele_stiff_rhs = boost::shared_ptr<FaceEle>(new FaceEle(m_field));
100 vol_ele_stiff_lhs = boost::shared_ptr<FaceEle>(new FaceEle(m_field));
101 post_proc = boost::shared_ptr<PostProcFaceOnRefinedMesh>(
103
104 data1 = boost::shared_ptr<PreviousData>(new PreviousData());
105 data2 = boost::shared_ptr<PreviousData>(new PreviousData());
106
107
109 boost::shared_ptr<MatrixDouble>(data1, &data1->flux_values);
110
111 flux_divs_ptr1 = boost::shared_ptr<VectorDouble>(data1, &data1->flux_divs);
112
114 boost::shared_ptr<VectorDouble>(data1, &data1->mass_values);
115
116 mass_dots_ptr1 = boost::shared_ptr<VectorDouble>(data1, &data1->mass_dots);
117
119 boost::shared_ptr<MatrixDouble>(data2, &data2->flux_values);
120 flux_divs_ptr2 = boost::shared_ptr<VectorDouble>(data2, &data2->flux_divs);
121
123 boost::shared_ptr<VectorDouble>(data2, &data2->mass_values);
124 mass_dots_ptr2 = boost::shared_ptr<VectorDouble>(data2, &data2->mass_dots);
125
126
127 }
MoFEM::FaceElementForcesAndSourcesCore FaceEle
ElementsAndOps< SPACE_DIM >::BoundaryEle BoundaryEle
virtual MPI_Comm & get_comm() const =0
virtual int get_comm_rank() const =0
Postprocess on face.
boost::shared_ptr< MatrixDouble > flux_values_ptr2
boost::shared_ptr< FaceEle > vol_ele_stiff_lhs
boost::shared_ptr< PreviousData > data1
boost::shared_ptr< VectorDouble > flux_divs_ptr2
MoFEM::Interface & m_field
MPI_Comm cOmm
boost::shared_ptr< VectorDouble > flux_divs_ptr1
boost::shared_ptr< BoundaryEle > natural_bdry_ele_slow_rhs
const int rAnk
boost::shared_ptr< VectorDouble > mass_values_ptr2
boost::shared_ptr< VectorDouble > mass_dots_ptr1
boost::shared_ptr< VectorDouble > mass_values_ptr1
boost::shared_ptr< VectorDouble > mass_dots_ptr2
boost::shared_ptr< PreviousData > data2
boost::shared_ptr< FaceEle > vol_ele_slow_rhs
boost::shared_ptr< PostProcFaceOnRefinedMesh > post_proc
boost::shared_ptr< MatrixDouble > flux_values_ptr1
boost::shared_ptr< FaceEle > vol_ele_stiff_rhs

◆ RDProblem() [2/4]

RDProblem::RDProblem ( MoFEM::Core core,
const int  order 
)
inline

Definition at line 57 of file elec_pys_new.cpp.

58 : m_field(core), order(order), cOmm(m_field.get_comm()),
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 }
Post processing.
boost::shared_ptr< VectorDouble > mass_values_ptr_v
boost::shared_ptr< PreviousData > data_s
boost::shared_ptr< VectorDouble > mass_values_ptr_s
boost::shared_ptr< VectorDouble > mass_dots_ptr_u
boost::shared_ptr< VectorDouble > mass_values_ptr_u
boost::shared_ptr< VectorDouble > mass_dots_ptr_s
boost::shared_ptr< VectorDouble > mass_dots_ptr_v
boost::shared_ptr< MatrixDouble > flux_values_ptr_u
boost::shared_ptr< PreviousData > data_u
boost::shared_ptr< VectorDouble > mass_dots_ptr_w
boost::shared_ptr< PreviousData > data_v
boost::shared_ptr< VectorDouble > mass_values_ptr_w
boost::shared_ptr< VectorDouble > flux_divs_ptr_u
boost::shared_ptr< PreviousData > data_w
VolumeElementForcesAndSourcesCore VolEle

◆ RDProblem() [3/4]

RDProblem::RDProblem ( MoFEM::Core core,
const int  order 
)
inline

Definition at line 14 of file mixed_reac_diff.cpp.

15 : m_field(core)
16 , order(order)
19 vol_ele_slow_rhs = boost::shared_ptr<FaceEle>(new FaceEle(m_field));
21 boost::shared_ptr<BoundaryEle>(new BoundaryEle(m_field));
22 vol_ele_stiff_rhs = boost::shared_ptr<FaceEle>(new FaceEle(m_field));
23 vol_ele_stiff_lhs = boost::shared_ptr<FaceEle>(new FaceEle(m_field));
24 post_proc = boost::shared_ptr<PostProcFaceOnRefinedMesh>(
26
27 data1 = boost::shared_ptr<PreviousData>(new PreviousData());
28 data2 = boost::shared_ptr<PreviousData>(new PreviousData());
29 data3 = boost::shared_ptr<PreviousData>(new PreviousData());
30
32 boost::shared_ptr<MatrixDouble>(data1, &data1->flux_values);
33
34 flux_divs_ptr1 = boost::shared_ptr<VectorDouble>(data1, &data1->flux_divs);
35
37 boost::shared_ptr<VectorDouble>(data1, &data1->mass_values);
38
39 mass_dots_ptr1 = boost::shared_ptr<VectorDouble>(data1, &data1->mass_dots);
40
42 boost::shared_ptr<MatrixDouble>(data2, &data2->flux_values);
43 flux_divs_ptr2 = boost::shared_ptr<VectorDouble>(data2, &data2->flux_divs);
44
46 boost::shared_ptr<VectorDouble>(data2, &data2->mass_values);
47 mass_dots_ptr2 = boost::shared_ptr<VectorDouble>(data2, &data2->mass_dots);
48
50 boost::shared_ptr<MatrixDouble>(data3, &data3->flux_values);
51 flux_divs_ptr3 = boost::shared_ptr<VectorDouble>(data3, &data3->flux_divs);
52
54 boost::shared_ptr<VectorDouble>(data3, &data3->mass_values);
55
56 mass_dots_ptr3 = boost::shared_ptr<VectorDouble>(data3, &data3->mass_dots);
57 }
boost::shared_ptr< VectorDouble > flux_divs_ptr3
boost::shared_ptr< VectorDouble > mass_values_ptr3
boost::shared_ptr< MatrixDouble > flux_values_ptr3
boost::shared_ptr< VectorDouble > mass_dots_ptr3
boost::shared_ptr< PreviousData > data3

◆ RDProblem() [4/4]

RDProblem::RDProblem ( moab::Core &  mb_instance,
MoFEM::Core core,
const int  order,
const int  n_species 
)
inline

Definition at line 24 of file std_reac_diff.cpp.

26 : moab(mb_instance)
27 , m_field(core)
28 , order(order)
29 , nb_species(n_species)
32 {
33 vol_ele_slow_rhs = boost::shared_ptr<Ele>(new Ele(m_field));
34 vol_ele_stiff_rhs = boost::shared_ptr<Ele>(new Ele(m_field));
35 vol_ele_stiff_lhs = boost::shared_ptr<Ele>(new Ele(m_field));
36
37 boundary_ele_rhs = boost::shared_ptr<BoundaryEle>(new BoundaryEle(m_field));
38
39 vol_mass_ele = boost::shared_ptr<Ele>(new Ele(m_field));
40
41 post_proc = boost::shared_ptr<PostProcFaceOnRefinedMesh>(
43
44 data.resize(nb_species);
45 values_ptr.resize(nb_species);
46 grads_ptr.resize(nb_species);
47 dots_ptr.resize(nb_species);
49
50 for (int i = 0; i < nb_species; ++i) {
51 data[i] = boost::shared_ptr<PreviousData>(new PreviousData());
52 grads_ptr[i] = boost::shared_ptr<MatrixDouble>(data[i], &data[i]->grads);
53 values_ptr[i] =
54 boost::shared_ptr<VectorDouble>(data[i], &data[i]->values);
55 dots_ptr[i] =
56 boost::shared_ptr<VectorDouble>(data[i], &data[i]->dot_values);
57 }
58 }
FTensor::Index< 'i', SPACE_DIM > i
FaceElementForcesAndSourcesCore Ele
std::vector< Range > inner_surface
moab::Interface & moab
boost::shared_ptr< Ele > vol_mass_ele
boost::shared_ptr< BoundaryEle > boundary_ele_rhs
std::vector< boost::shared_ptr< VectorDouble > > values_ptr
std::vector< boost::shared_ptr< VectorDouble > > dots_ptr
std::vector< boost::shared_ptr< PreviousData > > data
std::vector< boost::shared_ptr< MatrixDouble > > grads_ptr

Member Function Documentation

◆ add_fe() [1/4]

MoFEMErrorCode RDProblem::add_fe ( )
private

Definition at line 236 of file elec_phys_2D.cpp.

236 {
242
245
248
249
250
254
255
257}
@ 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
@ HCURL
field with continuous tangents
Definition: definitions.h:86
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
#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
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 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
Simple * simple_interface

◆ add_fe() [2/4]

MoFEMErrorCode RDProblem::add_fe ( )
private

◆ add_fe() [3/4]

MoFEMErrorCode RDProblem::add_fe ( std::string  field_name)
private

Definition at line 257 of file std_reac_diff.cpp.

257 {
262 1);
263 // CHKERR simple_interface->addBoundaryField(field_name, H1,
264 // AINSWORTH_LEGENDRE_BASE, 1);
267
269}
@ H1
continuous field
Definition: definitions.h:85
constexpr auto field_name

◆ add_fe() [4/4]

MoFEMErrorCode RDProblem::add_fe ( std::string  mass_field,
std::string  flux_field 
)
private

Definition at line 236 of file mixed_reac_diff.cpp.

237 {
241
244
248 1);
249
250 CHKERR simple_interface->setFieldOrder(mass_field, order - 1);
252 CHKERR simple_interface->setFieldOrder("ERROR", 0); // approximation order for error
253
255}

◆ apply_BC() [1/3]

MoFEMErrorCode RDProblem::apply_BC ( std::string  flux_field)
private

Definition at line 442 of file elec_phys_2D.cpp.

442 {
444 CHKERR m_field.getInterface<ProblemsManager>()->removeDofsOnEntities(
445 "SimpleProblem", flux_field, essential_bdry_ents);
446
448}
Problem manager is used to build and partition problems.
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface refernce to pointer of interface.
Range essential_bdry_ents

◆ apply_BC() [2/3]

MoFEMErrorCode RDProblem::apply_BC ( std::string  flux_field)
private

◆ apply_BC() [3/3]

MoFEMErrorCode RDProblem::apply_BC ( std::string  flux_field)
private

◆ apply_IC() [1/3]

MoFEMErrorCode RDProblem::apply_IC ( std::string  mass_field,
Range surface,
boost::shared_ptr< FaceEle > &  initial_ele 
)
private

Definition at line 448 of file mixed_reac_diff.cpp.

449 {
451 initial_ele->getOpPtrVector().push_back(
452 new OpInitialMass(mass_field, surface));
454}

◆ apply_IC() [2/3]

MoFEMErrorCode RDProblem::apply_IC ( std::string  mass_field,
Range surface,
boost::shared_ptr< FaceEle > &  initial_ele,
double init_val 
)
private

Definition at line 433 of file elec_phys_2D.cpp.

435 {
437 initial_ele->getOpPtrVector().push_back(
438 new OpInitialMass(mass_field, surface, init_val));
440}

◆ apply_IC() [3/3]

MoFEMErrorCode RDProblem::apply_IC ( std::string  mass_field,
Range surface,
boost::shared_ptr< VolEle > &  initial_ele,
double init 
)
private

◆ extract_bd_ents() [1/3]

MoFEMErrorCode RDProblem::extract_bd_ents ( std::string  ESSENTIAL,
std::string  NATURAL 
)
private

Definition at line 279 of file elec_phys_2D.cpp.

280 {
283 string name = it->getName();
284 if (name.compare(0, 14, natural) == 0) {
285
286 CHKERR it->getMeshsetIdEntitiesByDimension(m_field.get_moab(), 1,
287 natural_bdry_ents, true);
288 } else if (name.compare(0, 14, essential) == 0) {
289 CHKERR it->getMeshsetIdEntitiesByDimension(m_field.get_moab(), 1,
290 essential_bdry_ents, true);
291 }
292 }
294}
@ BLOCKSET
Definition: definitions.h:148
#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.
virtual moab::Interface & get_moab()=0
Range natural_bdry_ents

◆ extract_bd_ents() [2/3]

MoFEMErrorCode RDProblem::extract_bd_ents ( std::string  ESSENTIAL,
std::string  NATURAL 
)
private

◆ extract_bd_ents() [3/3]

MoFEMErrorCode RDProblem::extract_bd_ents ( std::string  ESSENTIAL,
std::string  NATURAL,
std::string  internal 
)
private

Definition at line 291 of file mixed_reac_diff.cpp.

293 {
296 string name = it->getName();
297 if (name.compare(0, 14, natural) == 0) {
298
299 CHKERR it->getMeshsetIdEntitiesByDimension(m_field.get_moab(), 1,
300 natural_bdry_ents, true);
301 } else if (name.compare(0, 14, essential) == 0) {
302 CHKERR it->getMeshsetIdEntitiesByDimension(m_field.get_moab(), 1,
303 essential_bdry_ents, true);
304 } else if (name.compare(0, 14, internal) == 0) {
305 CHKERR it->getMeshsetIdEntitiesByDimension(m_field.get_moab(), 1,
306 internal_edge_ents, true);
307 }
308 }
310}
Range internal_edge_ents

◆ extract_initial_ents() [1/3]

MoFEMErrorCode RDProblem::extract_initial_ents ( int  block_id,
Range surface 
)
private

Definition at line 296 of file elec_phys_2D.cpp.

296 {
299 BLOCKSET)) {
300 CHKERR m_field.getInterface<MeshsetsManager>()->getEntitiesByDimension(
301 block_id, BLOCKSET, 2, surface, true);
302 }
304}
bool checkMeshset(const int ms_id, const CubitBCType cubit_bc_type) const
check for CUBIT Id and CUBIT type
Interface for managing meshsets containing materials and boundary conditions.

◆ extract_initial_ents() [2/3]

MoFEMErrorCode RDProblem::extract_initial_ents ( int  block_id,
Range surface 
)
private

◆ extract_initial_ents() [3/3]

MoFEMErrorCode RDProblem::extract_initial_ents ( int  block_id,
Range surface 
)
private

◆ loop_fe() [1/3]

MoFEMErrorCode RDProblem::loop_fe ( )
private

Definition at line 449 of file elec_phys_2D.cpp.

449 {
451 CHKERR TSSetType(ts, TSARKIMEX);
452 CHKERR TSARKIMEXSetType(ts, TSARKIMEXA2);
453
456
459
465}
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 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 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
const std::string getBoundaryFEName() const
Get the Boundary FE Name.
Definition: Simple.hpp:334
const std::string getDomainFEName() const
Get the Domain FE Name.
Definition: Simple.hpp:327
SmartPetscObj< TS > ts
SmartPetscObj< DM > dm
boost::shared_ptr< ForcesAndSourcesCore > null

◆ loop_fe() [2/3]

MoFEMErrorCode RDProblem::loop_fe ( )
private

◆ loop_fe() [3/3]

MoFEMErrorCode RDProblem::loop_fe ( )
private

◆ output_result() [1/4]

MoFEMErrorCode RDProblem::output_result ( )
private

Definition at line 476 of file elec_phys_2D.cpp.

476 {
481 }
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
boost::shared_ptr< Monitor > monitor_ptr

◆ output_result() [2/4]

MoFEMErrorCode RDProblem::output_result ( )
private

◆ output_result() [3/4]

MoFEMErrorCode RDProblem::output_result ( )
private

◆ output_result() [4/4]

MoFEMErrorCode RDProblem::output_result ( )
private

◆ post_proc_fields() [1/4]

MoFEMErrorCode RDProblem::post_proc_fields ( )
private

Definition at line 467 of file elec_phys_2D.cpp.

467 {
469 post_proc->addFieldValuesPostProc("U");
470 post_proc->addFieldValuesPostProc("F");
471 post_proc->addFieldValuesPostProc("V");
472
474 }

◆ post_proc_fields() [2/4]

MoFEMErrorCode RDProblem::post_proc_fields ( )
private

◆ post_proc_fields() [3/4]

MoFEMErrorCode RDProblem::post_proc_fields ( std::string  field_name)
private

Definition at line 458 of file std_reac_diff.cpp.

458 {
460 post_proc->addFieldValuesPostProc(field_name);
462}

◆ post_proc_fields() [4/4]

MoFEMErrorCode RDProblem::post_proc_fields ( std::string  mass_field,
std::string  flux_field 
)
private

Definition at line 518 of file mixed_reac_diff.cpp.

519 {
521 post_proc->addFieldValuesPostProc(mass_field);
522 post_proc->addFieldValuesPostProc(flux_field);
524}

◆ push_mass_ele()

MoFEMErrorCode RDProblem::push_mass_ele ( std::string  field_name)
private

Definition at line 420 of file std_reac_diff.cpp.

420 {
422 vol_mass_ele->getOpPtrVector().push_back(
425}
SmartPetscObj< Mat > mass_matrix

◆ push_slow_rhs() [1/4]

MoFEMErrorCode RDProblem::push_slow_rhs ( )
private

Definition at line 240 of file elec_pys_new.cpp.

240 {
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}

◆ push_slow_rhs() [2/4]

MoFEMErrorCode RDProblem::push_slow_rhs ( std::string  mass_field,
std::string  flux_field,
boost::shared_ptr< PreviousData > &  data 
)
private

◆ push_slow_rhs() [3/4]

MoFEMErrorCode RDProblem::push_slow_rhs ( std::string  mass_field,
std::string  flux_field,
boost::shared_ptr< PreviousData > &  data1,
boost::shared_ptr< PreviousData > &  data2 
)
private

Definition at line 316 of file elec_phys_2D.cpp.

318 {
320
321 vol_ele_slow_rhs->getOpPtrVector().push_back(
322 new OpAssembleSlowRhsV(mass_field, data_1, data_2, RhsU()));
323
324 // natural_bdry_ele_slow_rhs->getOpPtrVector().push_back(
325 // new OpAssembleNaturalBCRhsTau(flux_field, natural_bdry_ents));
326
327 natural_bdry_ele_slow_rhs->getOpPtrVector().push_back(
328 new OpEssentialBC(flux_field, essential_bdry_ents));
329
331}

◆ push_slow_rhs() [4/4]

MoFEMErrorCode RDProblem::push_slow_rhs ( std::string  mass_name,
boost::shared_ptr< PreviousData > &  data 
)
private

Definition at line 334 of file std_reac_diff.cpp.

◆ push_stiff_lhs() [1/4]

MoFEMErrorCode RDProblem::push_stiff_lhs ( )
private

Definition at line 304 of file elec_pys_new.cpp.

304 {
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}

◆ push_stiff_lhs() [2/4]

MoFEMErrorCode RDProblem::push_stiff_lhs ( std::string  field_name,
boost::shared_ptr< PreviousData > &  data,
std::map< int, BlockData > &  block_map 
)
private

Definition at line 397 of file std_reac_diff.cpp.

399 {
401
402 vol_ele_stiff_lhs->getOpPtrVector().push_back(
403 new OpAssembleStiffLhs<2>(field_name, data, block_map));
404
406}

◆ push_stiff_lhs() [3/4]

MoFEMErrorCode RDProblem::push_stiff_lhs ( std::string  mass_field,
std::string  flux_field,
boost::shared_ptr< PreviousData > &  data,
std::map< int, BlockData > &  block_map 
)
private

Definition at line 417 of file mixed_reac_diff.cpp.

420 {
422 vol_ele_stiff_lhs->getOpPtrVector().push_back(
423 new OpAssembleLhsTauTau<3>(flux_field, data, block_map));
424
425 vol_ele_stiff_lhs->getOpPtrVector().push_back(
426 new OpAssembleLhsVV(mass_field));
427
428 vol_ele_stiff_lhs->getOpPtrVector().push_back(
429 new OpAssembleLhsTauV<3>(flux_field, mass_field, data, block_map));
430
431 vol_ele_stiff_lhs->getOpPtrVector().push_back(
432 new OpAssembleLhsVTau(mass_field, flux_field));
434}

◆ push_stiff_lhs() [4/4]

MoFEMErrorCode RDProblem::push_stiff_lhs ( std::string  mass_field,
std::string  flux_field,
boost::shared_ptr< PreviousData > &  datau,
boost::shared_ptr< PreviousData > &  datav,
std::map< int, BlockData > &  block_map 
)
private

Definition at line 400 of file elec_phys_2D.cpp.

404 {
406 vol_ele_stiff_lhs->getOpPtrVector().push_back(
407 new OpAssembleLhsTauTau<3>(flux_field, data1, block_map));
408
409 vol_ele_stiff_lhs->getOpPtrVector().push_back(
410 new OpAssembleLhsVV(mass_field, data1, data2, DRhsU_u()));
411
412 vol_ele_stiff_lhs->getOpPtrVector().push_back(
413 new OpAssembleLhsTauV<3>(flux_field, mass_field, data1, block_map));
414
415 vol_ele_stiff_lhs->getOpPtrVector().push_back(
416 new OpAssembleLhsVTau(mass_field, flux_field));
418}

◆ push_stiff_rhs() [1/4]

MoFEMErrorCode RDProblem::push_stiff_rhs ( )
private

Definition at line 280 of file elec_pys_new.cpp.

◆ push_stiff_rhs() [2/4]

MoFEMErrorCode RDProblem::push_stiff_rhs ( std::string  field_name,
boost::shared_ptr< PreviousData > &  data,
std::map< int, BlockData > &  block_map 
)
private

Definition at line 373 of file std_reac_diff.cpp.

◆ push_stiff_rhs() [3/4]

MoFEMErrorCode RDProblem::push_stiff_rhs ( std::string  mass_field,
std::string  flux_field,
boost::shared_ptr< PreviousData > &  data,
std::map< int, BlockData > &  block_map 
)
private

Definition at line 390 of file mixed_reac_diff.cpp.

393 {
395 vol_ele_stiff_rhs->getOpPtrVector().push_back(
396 new OpAssembleStiffRhsTau<3>(flux_field, data, block_map));
397
398 vol_ele_stiff_rhs->getOpPtrVector().push_back(
399 new OpAssembleStiffRhsV<3>(mass_field, data, block_map, ExactFunction(),
402}

◆ push_stiff_rhs() [4/4]

MoFEMErrorCode RDProblem::push_stiff_rhs ( std::string  mass_field,
std::string  flux_field,
boost::shared_ptr< PreviousData > &  data1,
boost::shared_ptr< PreviousData > &  data2,
std::map< int, BlockData > &  block_map,
Range surface 
)
private

Definition at line 372 of file elec_phys_2D.cpp.

377 {
379 vol_ele_stiff_rhs->getOpPtrVector().push_back(
380 new OpAssembleStiffRhsTau<3>(flux_field, data1, block_map));
381
382 vol_ele_stiff_rhs->getOpPtrVector().push_back(
383 new OpAssembleStiffRhsV<3>(mass_field, data1, data2, RhsU(), block_map, surface));
385}

◆ resolve_slow_rhs()

MoFEMErrorCode RDProblem::resolve_slow_rhs ( )
private

Definition at line 427 of file std_reac_diff.cpp.

427 {
431 CHKERR MatAssemblyBegin(mass_matrix, MAT_FINAL_ASSEMBLY);
432 CHKERR MatAssemblyEnd(mass_matrix, MAT_FINAL_ASSEMBLY);
433 // Create and septup KSP (linear solver), we need this to calculate g(t,u) =
434 // M^-1G(t,u)
436 CHKERR KSPSetOperators(mass_Ksp, mass_matrix, mass_matrix);
437 CHKERR KSPSetFromOptions(mass_Ksp);
438 CHKERR KSPSetUp(mass_Ksp);
440}
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
auto createKSP(MPI_Comm comm)
SmartPetscObj< KSP > mass_Ksp

◆ run_analysis() [1/4]

MoFEMErrorCode RDProblem::run_analysis ( )

Definition at line 530 of file elec_phys_2D.cpp.

530 {
532 global_error = 0;
533
534 CHKERR setup_system(); // only once
535
536 CHKERR add_fe(); // nb_species times
537
539
541
542 CHKERR extract_bd_ents("ESSENTIAL", "NATURAL"); // nb_species times
543
546
549
550 natural_bdry_ele_slow_rhs->getOpPtrVector().push_back(
552
553 CHKERR push_slow_rhs("U", "F", data1, data2); // nb_species times
554
556
559 vol_ele_stiff_rhs->getOpPtrVector().push_back(
561 CHKERR push_stiff_rhs("U", "F", data1, data2,
562 material_blocks, inner_surface2); // nb_species times
563
565
568
569 vol_ele_stiff_lhs->getOpPtrVector().push_back(
571 CHKERR push_stiff_lhs("U", "F", data1, data2,
572 material_blocks); // nb_species times
573 vol_ele_stiff_lhs->getOpPtrVector().push_back(
574 new OpSolveRecovery("V", data1, data2, RK4()));
575
579 boost::shared_ptr<FaceEle> initial_mass_ele(new FaceEle(m_field));
580
581 CHKERR apply_IC("U", inner_surface1, initial_mass_ele,
582 init_val_u); // nb_species times
583 CHKERR apply_IC("V", inner_surface1, initial_mass_ele,
584 init_val_v); // nb_species times
585
587 initial_mass_ele);
588
589 CHKERR apply_BC("F"); // nb_species times
590
591 CHKERR loop_fe(); // only once
592 post_proc->generateReferenceElementMesh(); // only once
593
595
596 monitor_ptr = boost::shared_ptr<Monitor>(
597 new Monitor(cOmm, rAnk, dm, post_proc)); // nb_species times
598 CHKERR output_result(); // only once
599 CHKERR solve(); // only once
601 }
double init_val_v
double init_val_u
auto createTS(MPI_Comm comm)
OpSetContravariantPiolaTransformOnEdge2D OpSetContrariantPiolaTransformOnEdge
Get value at integration points for scalar field.
MoFEMErrorCode getDM(DM *dm)
Get DM.
Definition: Simple.cpp:667
MoFEMErrorCode setUp(const PetscBool is_partitioned=PETSC_TRUE)
Setup problem.
Definition: Simple.cpp:611
MoFEMErrorCode update_slow_rhs(std::string mass_fiedl, boost::shared_ptr< VectorDouble > &mass_ptr)
std::map< int, BlockData > material_blocks
MoFEMErrorCode update_stiff_rhs()
Range inner_surface1
MoFEMErrorCode apply_BC(std::string flux_field)
MoFEMErrorCode add_fe()
MoFEMErrorCode push_slow_rhs()
MoFEMErrorCode update_vol_fe(boost::shared_ptr< FaceEle > &vol_ele, boost::shared_ptr< PreviousData > &data)
MoFEMErrorCode post_proc_fields()
MoFEMErrorCode loop_fe()
MoFEMErrorCode extract_bd_ents(std::string ESSENTIAL, std::string NATURAL)
double global_error
MoFEMErrorCode set_blockData(std::map< int, BlockData > &block_data_map)
MoFEMErrorCode push_stiff_lhs()
MoFEMErrorCode push_stiff_rhs()
MoFEMErrorCode extract_initial_ents(int block_id, Range &surface)
MoFEMErrorCode solve()
MoFEMErrorCode apply_IC(std::string mass_field, Range &surface, boost::shared_ptr< FaceEle > &initial_ele, double &init_val)
MoFEMErrorCode setup_system()
MoFEMErrorCode output_result()
MoFEMErrorCode update_stiff_lhs()
MoFEMErrorCode set_integration_rule()

◆ run_analysis() [2/4]

MoFEMErrorCode RDProblem::run_analysis ( )

◆ run_analysis() [3/4]

MoFEMErrorCode RDProblem::run_analysis ( )

◆ run_analysis() [4/4]

MoFEMErrorCode RDProblem::run_analysis ( int  nb_sp)

Definition at line 580 of file mixed_reac_diff.cpp.

580 {
582 global_error = 0;
583 // set nb_species
584 CHKERR setup_system(); // only once
585 nb_species = nb_sp;
586 if (nb_species == 1 || nb_species == 2 || nb_species == 3) {
587 CHKERR add_fe("MASS1", "FLUX1"); // nb_species times
588 if (nb_species == 2 || nb_species == 3) {
589 CHKERR add_fe("MASS2", "FLUX2");
590 if (nb_species == 3) {
591 CHKERR add_fe("MASS3", "FLUX3");
592 }
593 }
594 }
595
597
599
600 CHKERR extract_bd_ents("ESSENTIAL", "NATURAL", "INTERNAL"); // nb_species times
601
602 if (nb_species == 1 || nb_species == 2 || nb_species == 3) {
605 if (nb_species == 1) {
606 vol_ele_slow_rhs->getOpPtrVector().push_back(new OpComputeSlowValue(
607 "MASS1", data1, data1, data1, material_blocks));
608 } else if (nb_species == 2 || nb_species == 3) {
611 if (nb_species == 2) {
612 vol_ele_slow_rhs->getOpPtrVector().push_back(new OpComputeSlowValue(
613 "MASS1", data1, data2, data2, material_blocks));
614 } else if (nb_species == 3) {
617 vol_ele_slow_rhs->getOpPtrVector().push_back(new OpComputeSlowValue(
618 "MASS1", data1, data2, data3, material_blocks));
619 }
620 }
621 }
622 natural_bdry_ele_slow_rhs->getOpPtrVector().push_back(
624
625 if (nb_species == 1 || nb_species == 2 || nb_species == 3) {
626 CHKERR push_slow_rhs("MASS1", "FLUX1", data1); // nb_species times
627 if (nb_species == 2 || nb_species == 3) {
628 CHKERR push_slow_rhs("MASS2", "FLUX2", data2);
629 if (nb_species == 3) {
630 CHKERR push_slow_rhs("MASS3", "FLUX3", data3);
631 }
632 }
633 }
634
636
637 if (nb_species == 1 || nb_species == 2 || nb_species == 3) {
638 CHKERR update_stiff_rhs("MASS1", "FLUX1", mass_values_ptr1,
640 CHKERR push_stiff_rhs("MASS1", "FLUX1", data1,
641 material_blocks); // nb_species times
642 if (nb_species == 2 || nb_species == 3) {
643 CHKERR update_stiff_rhs("MASS2", "FLUX2", mass_values_ptr2,
645 CHKERR push_stiff_rhs("MASS2", "FLUX2", data2, material_blocks);
646 if (nb_species == 3) {
647 CHKERR update_stiff_rhs("MASS3", "FLUX3", mass_values_ptr3,
650 CHKERR push_stiff_rhs("MASS3", "FLUX3", data3, material_blocks);
651 }
652 }
653 }
654
656
657 if (nb_species == 1 || nb_species == 2 || nb_species == 3) {
658 CHKERR update_stiff_lhs("MASS1", "FLUX1", mass_values_ptr1,
660 CHKERR push_stiff_lhs("MASS1", "FLUX1", data1,
661 material_blocks); // nb_species times
662 if (nb_species == 2 || nb_species == 3) {
663 CHKERR update_stiff_lhs("MASS2", "FLUX2", mass_values_ptr2,
665 CHKERR push_stiff_lhs("MASS2", "FLUX2", data2, material_blocks);
666 if (nb_species == 3) {
667 CHKERR update_stiff_lhs("MASS3", "FLUX3", mass_values_ptr3,
669 CHKERR push_stiff_lhs("MASS3", "FLUX3", data3, material_blocks);
670 }
671 }
672 }
673
674
675 // vol_ele_stiff_lhs->getOpPtrVector().push_back(
676 // new OpError(ExactFunction(), ExactFunctionLap(), ExactFunctionGrad(), data1, material_blocks, global_error));
680 boost::shared_ptr<FaceEle> initial_mass_ele(new FaceEle(m_field));
681
682 if (nb_species == 1 || nb_species == 2 || nb_species == 3) {
684 initial_mass_ele); // nb_species times
685 if (nb_species == 2 || nb_species == 3) {
686 CHKERR apply_IC("MASS2", inner_surface2, initial_mass_ele);
687 if (nb_species == 3) {
688 CHKERR apply_IC("MASS3", inner_surface3, initial_mass_ele);
689 }
690 }
691 }
693 initial_mass_ele);
694
695 if (nb_species == 1 || nb_species == 2 || nb_species == 3) {
696 CHKERR apply_BC("FLUX1"); // nb_species times
697 if (nb_species == 2 || nb_species == 3) {
698 CHKERR apply_BC("FLUX2");
699 if (nb_species == 3) {
700 CHKERR apply_BC("FLUX3");
701 }
702 }
703 }
704
705 CHKERR loop_fe(); // only once
706 post_proc->generateReferenceElementMesh(); // only once
707
708
709
710 if (nb_species == 1 || nb_species == 2 || nb_species == 3) {
711 CHKERR post_proc_fields("MASS1", "FLUX1");
712 post_proc->addFieldValuesPostProc("ERROR");
713 if (nb_species == 2 || nb_species == 3) {
714 CHKERR post_proc_fields("MASS2", "FLUX2");
715 if (nb_species == 3) {
716 CHKERR post_proc_fields("MASS3", "FLUX3");
717 }
718 }
719 }
720
721 //the double global_vector is a global_vector which sums errors in each element
722
723 // Vec gVec;
724 // CHKERR VecCreateMPI(PETSC_COMM_WORLD, 1, 1, &gVec);
725 // double err_per_step = 0;
726
727 // auto compute_global_error = [&gVec](double &g_err, double &err_out) {
728 // MoFEMFunctionBegin;
729
730 // CHKERR VecZeroEntries(gVec);
731 // CHKERR VecAssemblyBegin(gVec);
732 // CHKERR VecAssemblyEnd(gVec);
733
734 // int ind[1] = {0};
735 // CHKERR VecSetValues(gVec, 1, ind, &err_out, ADD_VALUES);
736 // CHKERR VecAssemblyBegin(gVec);
737 // CHKERR VecAssemblyEnd(gVec);
738
739 // CHKERR VecGetValues(gVec, 1, ind, &err_out);
740
741 // MoFEMFunctionReturn(0);
742 // };
743
744 // Vec error_per_proc;
745 // CHKERR VecCreateMPI(cOmm, 1, PETSC_DECIDE, &error_per_proc);
746 // auto get_global_error = [&]() {
747 // MoFEMFunctionBegin;
748 // CHKERR VecSetValue(error_per_proc, m_field.get_comm_rank(), global_error, INSERT_VALUES);
749 // MoFEMFunctionReturn(0);
750 // };
751
752 // auto reinitialize_global = [&]() {
753 // MoFEMFunctionBegin;
754 // CHKERR get_global_error();
755 // CHKERR VecAssemblyBegin(error_per_proc);
756 // CHKERR VecAssemblyEnd(error_per_proc);
757 // double error_sum;
758 // CHKERR VecSum(error_per_proc, &error_sum);
759 // CHKERR PetscPrintf(PETSC_COMM_WORLD, "Error : %3.4e \n",
760 // error_sum);
761 // global_error = 0;
762 // MoFEMFunctionReturn(0);
763 // };
764
765 // vol_ele_stiff_lhs->postProcessHook = reinitialize_global;
766
767
768
769 monitor_ptr = boost::shared_ptr<Monitor>(
770 new Monitor(cOmm, rAnk, dm, post_proc, global_error)); // nb_species times
771 CHKERR output_result(); // only once
772 CHKERR solve(); // only once
774}
Range inner_surface3

◆ set_blockData() [1/3]

MoFEMErrorCode RDProblem::set_blockData ( std::map< int, BlockData > &  block_data_map)
private

Definition at line 259 of file elec_phys_2D.cpp.

259 {
262 string name = it->getName();
263 const int id = it->getMeshsetId();
264 if (name.compare(0, 14, "REGION1") == 0) {
265 CHKERR m_field.getInterface<MeshsetsManager>()->getEntitiesByDimension(
266 id, BLOCKSET, 2, block_map[id].block_ents, true);
267 block_map[id].B0 = 1e-3;
268 block_map[id].block_id = id;
269 } else if (name.compare(0, 14, "REGION2") == 0) {
270 CHKERR m_field.getInterface<MeshsetsManager>()->getEntitiesByDimension(
271 id, BLOCKSET, 2, block_map[id].block_ents, true);
272 block_map[id].B0 = 1e-1;
273 block_map[id].block_id = id;
274 }
275 }
277}

◆ set_blockData() [2/3]

MoFEMErrorCode RDProblem::set_blockData ( std::map< int, BlockData > &  block_data_map)
private

◆ set_blockData() [3/3]

MoFEMErrorCode RDProblem::set_blockData ( std::map< int, BlockData > &  block_data_map)
private

◆ set_fe_in_loop()

MoFEMErrorCode RDProblem::set_fe_in_loop ( )
private

◆ set_initial_values()

MoFEMErrorCode RDProblem::set_initial_values ( std::string  field_name,
int  block_id,
Range surface,
double init_val 
)
private

Definition at line 306 of file std_reac_diff.cpp.

308 {
311 BLOCKSET)) {
312 CHKERR m_field.getInterface<MeshsetsManager>()->getEntitiesByDimension(
313 block_id, BLOCKSET, 2, surface, true);
314 }
315 if (!surface.empty()) {
316 Range surface_verts;
317 CHKERR moab.get_connectivity(surface, surface_verts, false);
319 init_val, MBVERTEX, surface_verts, field_name);
320 }
321
323}
Basic algebra on fields.
Definition: FieldBlas.hpp:21

◆ set_integration_rule() [1/4]

MoFEMErrorCode RDProblem::set_integration_rule ( )
private

Definition at line 421 of file elec_phys_2D.cpp.

421 {
423 auto vol_rule = [](int, int, int p) -> int { return 2 * p; };
424 vol_ele_slow_rhs->getRuleHook = vol_rule;
425 natural_bdry_ele_slow_rhs->getRuleHook = vol_rule;
426
427 vol_ele_stiff_rhs->getRuleHook = vol_rule;
428
429 vol_ele_stiff_lhs->getRuleHook = vol_rule;
431}
static Index< 'p', 3 > p

◆ set_integration_rule() [2/4]

MoFEMErrorCode RDProblem::set_integration_rule ( )
private

◆ set_integration_rule() [3/4]

MoFEMErrorCode RDProblem::set_integration_rule ( )
private

◆ set_integration_rule() [4/4]

MoFEMErrorCode RDProblem::set_integration_rule ( )
private

◆ setup_system() [1/4]

MoFEMErrorCode RDProblem::setup_system ( )
private

Definition at line 228 of file elec_phys_2D.cpp.

228 {
234}
MoFEMErrorCode getOptions()
get options
Definition: Simple.cpp:180
MoFEMErrorCode loadFile(const std::string options, const std::string mesh_file_name)
Load mesh file.
Definition: Simple.cpp:194

◆ setup_system() [2/4]

MoFEMErrorCode RDProblem::setup_system ( )
private

◆ setup_system() [3/4]

MoFEMErrorCode RDProblem::setup_system ( )
private

◆ setup_system() [4/4]

MoFEMErrorCode RDProblem::setup_system ( )
private

◆ solve() [1/4]

MoFEMErrorCode RDProblem::solve ( )
private

Definition at line 482 of file elec_phys_2D.cpp.

482 {
484 // Create solution vector
487 CHKERR DMoFEMMeshToLocalVector(dm, X, INSERT_VALUES, SCATTER_FORWARD);
488 // Solve problem
489 double ftime = 1;
490 CHKERR TSSetDM(ts, dm);
491 CHKERR TSSetDuration(ts, PETSC_DEFAULT, ftime);
492 CHKERR TSSetSolution(ts, X);
493 CHKERR TSSetFromOptions(ts);
494
495 if (1) {
496 SNES snes;
497 CHKERR TSGetSNES(ts, &snes);
498 KSP ksp;
499 CHKERR SNESGetKSP(snes, &ksp);
500 PC pc;
501 CHKERR KSPGetPC(ksp, &pc);
502 PetscBool is_pcfs = PETSC_FALSE;
503 PetscObjectTypeCompare((PetscObject)pc, PCFIELDSPLIT, &is_pcfs);
504 // Set up FIELDSPLIT
505 // Only is user set -pc_type fieldsplit
506 if (is_pcfs == PETSC_TRUE) {
507 IS is_mass, is_flux;
508 const MoFEM::Problem *problem_ptr;
509 CHKERR DMMoFEMGetProblemPtr(dm, &problem_ptr);
510 CHKERR m_field.getInterface<ISManager>()->isCreateProblemFieldAndRank(
511 problem_ptr->getName(), ROW, "U", 0, 1, &is_mass);
512 CHKERR m_field.getInterface<ISManager>()->isCreateProblemFieldAndRank(
513 problem_ptr->getName(), ROW, "F", 0, 1, &is_flux);
514 // CHKERR ISView(is_flux, PETSC_VIEWER_STDOUT_SELF);
515 // CHKERR ISView(is_mass, PETSC_VIEWER_STDOUT_SELF);
516
517 CHKERR PCFieldSplitSetIS(pc, NULL, is_mass);
518 CHKERR PCFieldSplitSetIS(pc, NULL, is_flux);
519
520
521 CHKERR ISDestroy(&is_flux);
522 CHKERR ISDestroy(&is_mass);
523 }
524 }
525
526 CHKERR TSSolve(ts, X);
528 }
@ ROW
Definition: definitions.h:123
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 DMCreateGlobalVector_MoFEM(DM dm, Vec *g)
DMShellSetCreateGlobalVector.
Definition: DMMoFEM.cpp:1153
Section manager is used to create indexes and sections.
Definition: ISManager.hpp:23
keeps basic data about problem
intrusive_ptr for managing petsc objects

◆ solve() [2/4]

MoFEMErrorCode RDProblem::solve ( )
private

◆ solve() [3/4]

MoFEMErrorCode RDProblem::solve ( )
private

◆ solve() [4/4]

MoFEMErrorCode RDProblem::solve ( )
private

◆ update_slow_rhs() [1/4]

MoFEMErrorCode RDProblem::update_slow_rhs ( std::string  mass_fiedl,
boost::shared_ptr< VectorDouble > &  mass_ptr 
)
private

Definition at line 307 of file elec_phys_2D.cpp.

308 {
310 vol_ele_slow_rhs->getOpPtrVector().push_back(
311 new OpCalculateScalarFieldValues(mass_field, mass_ptr));
313}

◆ update_slow_rhs() [2/4]

MoFEMErrorCode RDProblem::update_slow_rhs ( std::string  mass_fiedl,
boost::shared_ptr< VectorDouble > &  mass_ptr 
)
private

◆ update_slow_rhs() [3/4]

MoFEMErrorCode RDProblem::update_slow_rhs ( std::string  mass_fiedl,
boost::shared_ptr< VectorDouble > &  mass_ptr 
)
private

◆ update_slow_rhs() [4/4]

MoFEMErrorCode RDProblem::update_slow_rhs ( std::string  mass_field,
boost::shared_ptr< VectorDouble > &  mass_ptr 
)
private

◆ update_stiff_lhs() [1/4]

MoFEMErrorCode RDProblem::update_stiff_lhs ( )
private

Definition at line 292 of file elec_pys_new.cpp.

292 {
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}
Get vector field for H-div approximation.

◆ update_stiff_lhs() [2/4]

MoFEMErrorCode RDProblem::update_stiff_lhs ( std::string  field_name,
boost::shared_ptr< VectorDouble > &  values_ptr,
boost::shared_ptr< MatrixDouble > &  grads_ptr 
)
private

Definition at line 385 of file std_reac_diff.cpp.

387 {
389 vol_ele_stiff_lhs->getOpPtrVector().push_back(
391
392 vol_ele_stiff_lhs->getOpPtrVector().push_back(
395}
Get field gradients at integration pts for scalar filed rank 0, i.e. vector field.

◆ update_stiff_lhs() [3/4]

MoFEMErrorCode RDProblem::update_stiff_lhs ( std::string  mass_fiedl,
std::string  flux_field,
boost::shared_ptr< VectorDouble > &  mass_ptr,
boost::shared_ptr< MatrixDouble > &  flux_ptr 
)
private

Definition at line 388 of file elec_phys_2D.cpp.

390 {
392 vol_ele_stiff_lhs->getOpPtrVector().push_back(
393 new OpCalculateScalarFieldValues(mass_field, mass_ptr));
394
395 vol_ele_stiff_lhs->getOpPtrVector().push_back(
396 new OpCalculateHVecVectorField<3>(flux_field, flux_ptr));
398}

◆ update_stiff_lhs() [4/4]

MoFEMErrorCode RDProblem::update_stiff_lhs ( std::string  mass_fiedl,
std::string  flux_field,
boost::shared_ptr< VectorDouble > &  mass_ptr,
boost::shared_ptr< MatrixDouble > &  flux_ptr 
)
private

◆ update_stiff_rhs() [1/4]

MoFEMErrorCode RDProblem::update_stiff_rhs ( )
private

Definition at line 255 of file elec_pys_new.cpp.

255 {
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}
OpCalculateScalarFieldValuesDot OpCalculateScalarValuesDot
Calculate divergence of vector field.

◆ update_stiff_rhs() [2/4]

MoFEMErrorCode RDProblem::update_stiff_rhs ( std::string  field_name,
boost::shared_ptr< VectorDouble > &  values_ptr,
boost::shared_ptr< MatrixDouble > &  grads_ptr,
boost::shared_ptr< VectorDouble > &  dots_ptr 
)
private

Definition at line 358 of file std_reac_diff.cpp.

361 {
362
364
365 vol_ele_stiff_rhs->getOpPtrVector().push_back(
367 vol_ele_stiff_rhs->getOpPtrVector().push_back(
369 vol_ele_stiff_rhs->getOpPtrVector().push_back(
372}

◆ update_stiff_rhs() [3/4]

MoFEMErrorCode RDProblem::update_stiff_rhs ( std::string  mass_field,
std::string  flux_field,
boost::shared_ptr< VectorDouble > &  mass_ptr,
boost::shared_ptr< MatrixDouble > &  flux_ptr,
boost::shared_ptr< VectorDouble > &  mass_dot_ptr,
boost::shared_ptr< VectorDouble > &  flux_div_ptr 
)
private

Definition at line 350 of file elec_phys_2D.cpp.

354 {
355
357
358 vol_ele_stiff_rhs->getOpPtrVector().push_back(
359 new OpCalculateScalarFieldValues(mass_field, mass_ptr));
360
361 vol_ele_stiff_rhs->getOpPtrVector().push_back(
362 new OpCalculateHVecVectorField<3>(flux_field, flux_ptr));
363
364 vol_ele_stiff_rhs->getOpPtrVector().push_back(
365 new OpCalculateScalarValuesDot(mass_field, mass_dot_ptr));
366
367 vol_ele_stiff_rhs->getOpPtrVector().push_back(
368 new OpCalculateHdivVectorDivergence<3, 2>(flux_field, flux_div_ptr));
370}

◆ update_stiff_rhs() [4/4]

MoFEMErrorCode RDProblem::update_stiff_rhs ( std::string  mass_field,
std::string  flux_field,
boost::shared_ptr< VectorDouble > &  mass_ptr,
boost::shared_ptr< MatrixDouble > &  flux_ptr,
boost::shared_ptr< VectorDouble > &  mass_dot_ptr,
boost::shared_ptr< VectorDouble > &  flux_div_ptr 
)
private

◆ update_vol_fe() [1/3]

MoFEMErrorCode RDProblem::update_vol_fe ( boost::shared_ptr< Ele > &  vol_ele,
boost::shared_ptr< PreviousData > &  data 
)
private

Definition at line 344 of file std_reac_diff.cpp.

345 {
347 auto det_ptr = boost::make_shared<VectorDouble>();
348 auto jac_ptr = boost::make_shared<MatrixDouble>();
349 auto inv_jac_ptr = boost::make_shared<MatrixDouble>();
350 vol_ele->getOpPtrVector().push_back(new OpCalculateHOJacForFace(jac_ptr));
351 vol_ele->getOpPtrVector().
352 push_back(new OpInvertMatrix<2>(jac_ptr, det_ptr, inv_jac_ptr));
353 vol_ele->getOpPtrVector().push_back(new OpSetInvJacH1ForFace(inv_jac_ptr));
355}
OpCalculateHOJacForFaceImpl< 2 > OpCalculateHOJacForFace

◆ update_vol_fe() [2/3]

MoFEMErrorCode RDProblem::update_vol_fe ( boost::shared_ptr< FaceEle > &  vol_ele,
boost::shared_ptr< PreviousData > &  data 
)
private

Definition at line 333 of file elec_phys_2D.cpp.

334 {
336 auto det_ptr = boost::make_shared<VectorDouble>();
337 auto jac_ptr = boost::make_shared<MatrixDouble>();
338 auto inv_jac_ptr = boost::make_shared<MatrixDouble>();
339 vol_ele->getOpPtrVector().push_back(new OpCalculateHOJacForFace(jac_ptr));
340 vol_ele->getOpPtrVector().push_back(
341 new OpInvertMatrix<2>(jac_ptr, det_ptr, inv_jac_ptr));
342 vol_ele->getOpPtrVector().push_back(new OpMakeHdivFromHcurl());
343 vol_ele->getOpPtrVector().push_back(
345 vol_ele->getOpPtrVector().push_back(new OpSetInvJacHcurlFace(inv_jac_ptr));
347}
OpSetInvJacHcurlFaceImpl< 2 > OpSetInvJacHcurlFace
OpSetContravariantPiolaTransformOnFace2DImpl< 2 > OpSetContravariantPiolaTransformOnFace2D
Make Hdiv space from Hcurl space in 2d.

◆ update_vol_fe() [3/3]

MoFEMErrorCode RDProblem::update_vol_fe ( boost::shared_ptr< FaceEle > &  vol_ele,
boost::shared_ptr< PreviousData > &  data 
)
private

Definition at line 352 of file mixed_reac_diff.cpp.

353 {
355 auto det_ptr = boost::make_shared<VectorDouble>();
356 auto jac_ptr = boost::make_shared<MatrixDouble>();
357 auto inv_jac_ptr = boost::make_shared<MatrixDouble>();
358 vol_ele->getOpPtrVector().push_back(new OpCalculateHOJacForFace(jac_ptr));
359 vol_ele->getOpPtrVector().push_back(
360 new OpInvertMatrix<2>(jac_ptr, det_ptr, inv_jac_ptr));
361 vol_ele->getOpPtrVector().push_back(new OpMakeHdivFromHcurl());
362 vol_ele->getOpPtrVector().push_back(
364 vol_ele->getOpPtrVector().push_back(new OpSetInvJacHcurlFace(inv_jac_ptr));
366}

Member Data Documentation

◆ bdry_ents

Range RDProblem::bdry_ents
private

Definition at line 116 of file std_reac_diff.cpp.

◆ boundary_ele_rhs

boost::shared_ptr<BoundaryEle> RDProblem::boundary_ele_rhs
private

Definition at line 134 of file std_reac_diff.cpp.

◆ cOmm

MPI_Comm RDProblem::cOmm
private

Definition at line 189 of file elec_phys_2D.cpp.

◆ data

std::vector<boost::shared_ptr<PreviousData> > RDProblem::data
private

Definition at line 141 of file std_reac_diff.cpp.

◆ data1

boost::shared_ptr< PreviousData > RDProblem::data1
private

Definition at line 205 of file elec_phys_2D.cpp.

◆ data2

boost::shared_ptr< PreviousData > RDProblem::data2
private

Definition at line 206 of file elec_phys_2D.cpp.

◆ data3

boost::shared_ptr<PreviousData> RDProblem::data3
private

Definition at line 135 of file mixed_reac_diff.cpp.

◆ data_s

boost::shared_ptr<PreviousData> RDProblem::data_s
private

Definition at line 158 of file elec_pys_new.cpp.

◆ data_u

boost::shared_ptr<PreviousData> RDProblem::data_u
private

Definition at line 155 of file elec_pys_new.cpp.

◆ data_v

boost::shared_ptr<PreviousData> RDProblem::data_v
private

Definition at line 156 of file elec_pys_new.cpp.

◆ data_w

boost::shared_ptr<PreviousData> RDProblem::data_w
private

Definition at line 157 of file elec_pys_new.cpp.

◆ dm

SmartPetscObj< DM > RDProblem::dm
private

Definition at line 179 of file elec_phys_2D.cpp.

◆ dots_ptr

std::vector<boost::shared_ptr<VectorDouble> > RDProblem::dots_ptr
private

Definition at line 145 of file std_reac_diff.cpp.

◆ essential_bdry_ents

Range RDProblem::essential_bdry_ents
private

Definition at line 182 of file elec_phys_2D.cpp.

◆ flux_divs_ptr1

boost::shared_ptr< VectorDouble > RDProblem::flux_divs_ptr1
private

Definition at line 213 of file elec_phys_2D.cpp.

◆ flux_divs_ptr2

boost::shared_ptr< VectorDouble > RDProblem::flux_divs_ptr2
private

Definition at line 214 of file elec_phys_2D.cpp.

◆ flux_divs_ptr3

boost::shared_ptr<VectorDouble> RDProblem::flux_divs_ptr3
private

Definition at line 143 of file mixed_reac_diff.cpp.

◆ flux_divs_ptr_u

boost::shared_ptr<VectorDouble> RDProblem::flux_divs_ptr_u
private

Definition at line 163 of file elec_pys_new.cpp.

◆ flux_values_ptr1

boost::shared_ptr< MatrixDouble > RDProblem::flux_values_ptr1
private

Definition at line 209 of file elec_phys_2D.cpp.

◆ flux_values_ptr2

boost::shared_ptr< MatrixDouble > RDProblem::flux_values_ptr2
private

Definition at line 210 of file elec_phys_2D.cpp.

◆ flux_values_ptr3

boost::shared_ptr<MatrixDouble> RDProblem::flux_values_ptr3
private

Definition at line 139 of file mixed_reac_diff.cpp.

◆ flux_values_ptr_u

boost::shared_ptr<MatrixDouble> RDProblem::flux_values_ptr_u
private

Definition at line 160 of file elec_pys_new.cpp.

◆ global_error

double RDProblem::global_error

Definition at line 132 of file elec_phys_2D.cpp.

◆ grads_ptr

std::vector<boost::shared_ptr<MatrixDouble> > RDProblem::grads_ptr
private

Definition at line 143 of file std_reac_diff.cpp.

◆ inner_surface

std::vector<Range> RDProblem::inner_surface
private

Definition at line 118 of file std_reac_diff.cpp.

◆ inner_surface1

Range RDProblem::inner_surface1
private

Definition at line 185 of file elec_phys_2D.cpp.

◆ inner_surface2

Range RDProblem::inner_surface2
private

Definition at line 186 of file elec_phys_2D.cpp.

◆ inner_surface3

Range RDProblem::inner_surface3
private

Definition at line 140 of file elec_pys_new.cpp.

◆ internal_edge_ents

Range RDProblem::internal_edge_ents
private

Definition at line 111 of file mixed_reac_diff.cpp.

◆ m_field

MoFEM::Interface & RDProblem::m_field
private

Definition at line 177 of file elec_phys_2D.cpp.

◆ mass_dots_ptr1

boost::shared_ptr< VectorDouble > RDProblem::mass_dots_ptr1
private

Definition at line 221 of file elec_phys_2D.cpp.

◆ mass_dots_ptr2

boost::shared_ptr< VectorDouble > RDProblem::mass_dots_ptr2
private

Definition at line 222 of file elec_phys_2D.cpp.

◆ mass_dots_ptr3

boost::shared_ptr<VectorDouble> RDProblem::mass_dots_ptr3
private

Definition at line 151 of file mixed_reac_diff.cpp.

◆ mass_dots_ptr_s

boost::shared_ptr<VectorDouble> RDProblem::mass_dots_ptr_s
private

Definition at line 174 of file elec_pys_new.cpp.

◆ mass_dots_ptr_u

boost::shared_ptr<VectorDouble> RDProblem::mass_dots_ptr_u
private

Definition at line 171 of file elec_pys_new.cpp.

◆ mass_dots_ptr_v

boost::shared_ptr<VectorDouble> RDProblem::mass_dots_ptr_v
private

Definition at line 172 of file elec_pys_new.cpp.

◆ mass_dots_ptr_w

boost::shared_ptr<VectorDouble> RDProblem::mass_dots_ptr_w
private

Definition at line 173 of file elec_pys_new.cpp.

◆ mass_Ksp

SmartPetscObj<KSP> RDProblem::mass_Ksp
private

Definition at line 114 of file std_reac_diff.cpp.

◆ mass_matrix

SmartPetscObj<Mat> RDProblem::mass_matrix
private

Definition at line 113 of file std_reac_diff.cpp.

◆ mass_values_ptr1

boost::shared_ptr< VectorDouble > RDProblem::mass_values_ptr1
private

Definition at line 217 of file elec_phys_2D.cpp.

◆ mass_values_ptr2

boost::shared_ptr< VectorDouble > RDProblem::mass_values_ptr2
private

Definition at line 218 of file elec_phys_2D.cpp.

◆ mass_values_ptr3

boost::shared_ptr<VectorDouble> RDProblem::mass_values_ptr3
private

Definition at line 147 of file mixed_reac_diff.cpp.

◆ mass_values_ptr_s

boost::shared_ptr<VectorDouble> RDProblem::mass_values_ptr_s
private

Definition at line 169 of file elec_pys_new.cpp.

◆ mass_values_ptr_u

boost::shared_ptr<VectorDouble> RDProblem::mass_values_ptr_u
private

Definition at line 166 of file elec_pys_new.cpp.

◆ mass_values_ptr_v

boost::shared_ptr<VectorDouble> RDProblem::mass_values_ptr_v
private

Definition at line 167 of file elec_pys_new.cpp.

◆ mass_values_ptr_w

boost::shared_ptr<VectorDouble> RDProblem::mass_values_ptr_w
private

Definition at line 168 of file elec_pys_new.cpp.

◆ material_blocks

std::map< int, BlockData > RDProblem::material_blocks
private

Definition at line 195 of file elec_phys_2D.cpp.

◆ moab

moab::Interface& RDProblem::moab
private

Definition at line 109 of file std_reac_diff.cpp.

◆ monitor_ptr

boost::shared_ptr< Monitor > RDProblem::monitor_ptr
private

Definition at line 203 of file elec_phys_2D.cpp.

◆ natural_bdry_ele_slow_rhs [1/2]

boost::shared_ptr< BoundaryEle > RDProblem::natural_bdry_ele_slow_rhs
private

Definition at line 200 of file elec_phys_2D.cpp.

◆ natural_bdry_ele_slow_rhs [2/2]

boost::shared_ptr<FaceEle> RDProblem::natural_bdry_ele_slow_rhs
private

Definition at line 151 of file elec_pys_new.cpp.

◆ natural_bdry_ents

Range RDProblem::natural_bdry_ents
private

Definition at line 183 of file elec_phys_2D.cpp.

◆ nb_species

int RDProblem::nb_species
private

Definition at line 193 of file elec_phys_2D.cpp.

◆ null

boost::shared_ptr< ForcesAndSourcesCore > RDProblem::null
private

Definition at line 225 of file elec_phys_2D.cpp.

◆ order

int RDProblem::order
private

Definition at line 192 of file elec_phys_2D.cpp.

◆ post_proc [1/2]

boost::shared_ptr< PostProcFaceOnRefinedMesh > RDProblem::post_proc
private

Definition at line 202 of file elec_phys_2D.cpp.

◆ post_proc [2/2]

boost::shared_ptr<PostProcVolumeOnRefinedMesh> RDProblem::post_proc
private

Definition at line 152 of file elec_pys_new.cpp.

◆ rAnk

const int RDProblem::rAnk
private

Definition at line 190 of file elec_phys_2D.cpp.

◆ simple_interface

Simple * RDProblem::simple_interface
private

Definition at line 178 of file elec_phys_2D.cpp.

◆ stimulation_surface

Range RDProblem::stimulation_surface
private

Definition at line 119 of file std_reac_diff.cpp.

◆ ts

SmartPetscObj< TS > RDProblem::ts
private

Definition at line 180 of file elec_phys_2D.cpp.

◆ values_ptr

std::vector<boost::shared_ptr<VectorDouble> > RDProblem::values_ptr
private

Definition at line 144 of file std_reac_diff.cpp.

◆ vol_ele_slow_rhs [1/3]

boost::shared_ptr< FaceEle > RDProblem::vol_ele_slow_rhs
private

Definition at line 197 of file elec_phys_2D.cpp.

◆ vol_ele_slow_rhs [2/3]

boost::shared_ptr<VolEle> RDProblem::vol_ele_slow_rhs
private

Definition at line 148 of file elec_pys_new.cpp.

◆ vol_ele_slow_rhs [3/3]

boost::shared_ptr<Ele> RDProblem::vol_ele_slow_rhs
private

Definition at line 131 of file std_reac_diff.cpp.

◆ vol_ele_stiff_lhs [1/3]

boost::shared_ptr< FaceEle > RDProblem::vol_ele_stiff_lhs
private

Definition at line 199 of file elec_phys_2D.cpp.

◆ vol_ele_stiff_lhs [2/3]

boost::shared_ptr<VolEle> RDProblem::vol_ele_stiff_lhs
private

Definition at line 150 of file elec_pys_new.cpp.

◆ vol_ele_stiff_lhs [3/3]

boost::shared_ptr<Ele> RDProblem::vol_ele_stiff_lhs
private

Definition at line 133 of file std_reac_diff.cpp.

◆ vol_ele_stiff_rhs [1/3]

boost::shared_ptr< FaceEle > RDProblem::vol_ele_stiff_rhs
private

Definition at line 198 of file elec_phys_2D.cpp.

◆ vol_ele_stiff_rhs [2/3]

boost::shared_ptr<VolEle> RDProblem::vol_ele_stiff_rhs
private

Definition at line 149 of file elec_pys_new.cpp.

◆ vol_ele_stiff_rhs [3/3]

boost::shared_ptr<Ele> RDProblem::vol_ele_stiff_rhs
private

Definition at line 132 of file std_reac_diff.cpp.

◆ vol_mass_ele

boost::shared_ptr<Ele> RDProblem::vol_mass_ele
private

Definition at line 136 of file std_reac_diff.cpp.


The documentation for this struct was generated from the following files: