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::Interface &	m_field

Simple *	simple_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, BlockData >	material_blocks

boost::shared_ptr< FaceEle >	vol_ele_slow_rhs

boost::shared_ptr< FaceEle >	vol_ele_stiff_rhs

boost::shared_ptr< FaceEle >	vol_ele_stiff_lhs

boost::shared_ptr< BoundaryEle >	natural_bdry_ele_slow_rhs

boost::shared_ptr< PostProcFaceOnRefinedMesh >	post_proc

boost::shared_ptr< Monitor >	monitor_ptr

boost::shared_ptr< PreviousData >	data1

boost::shared_ptr< PreviousData >	data2

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< ForcesAndSourcesCore >	null

Range	inner_surface3

boost::shared_ptr< VolEle >	vol_ele_slow_rhs

boost::shared_ptr< VolEle >	vol_ele_stiff_rhs

boost::shared_ptr< VolEle >	vol_ele_stiff_lhs

boost::shared_ptr< FaceEle >	natural_bdry_ele_slow_rhs

boost::shared_ptr< PostProcVolumeOnRefinedMesh >	post_proc

boost::shared_ptr< PreviousData >	data_u

boost::shared_ptr< PreviousData >	data_v

boost::shared_ptr< PreviousData >	data_w

boost::shared_ptr< PreviousData >	data_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< PreviousData >	data3

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< Range >	inner_surface

Range	stimulation_surface

boost::shared_ptr< Ele >	vol_ele_slow_rhs

boost::shared_ptr< Ele >	vol_ele_stiff_rhs

boost::shared_ptr< Ele >	vol_ele_stiff_lhs

boost::shared_ptr< BoundaryEle >	boundary_ele_rhs

boost::shared_ptr< Ele >	vol_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.

      : m_field(core), order(order), cOmm(m_field.get_comm()),
        rAnk(m_field.get_comm_rank()) {
    vol_ele_slow_rhs = boost::shared_ptr<FaceEle>(new FaceEle(m_field));
    natural_bdry_ele_slow_rhs =
        boost::shared_ptr<BoundaryEle>(new BoundaryEle(m_field));
    vol_ele_stiff_rhs = boost::shared_ptr<FaceEle>(new FaceEle(m_field));
    vol_ele_stiff_lhs = boost::shared_ptr<FaceEle>(new FaceEle(m_field));
    post_proc = boost::shared_ptr<PostProcFaceOnRefinedMesh>(
        new PostProcFaceOnRefinedMesh(m_field));
 
    data1 = boost::shared_ptr<PreviousData>(new PreviousData());
    data2 = boost::shared_ptr<PreviousData>(new PreviousData());
  
 
    flux_values_ptr1 =
        boost::shared_ptr<MatrixDouble>(data1, &data1->flux_values);
 
    flux_divs_ptr1 = boost::shared_ptr<VectorDouble>(data1, &data1->flux_divs);
 
    mass_values_ptr1 =
        boost::shared_ptr<VectorDouble>(data1, &data1->mass_values);
 
    mass_dots_ptr1 = boost::shared_ptr<VectorDouble>(data1, &data1->mass_dots);
 
    flux_values_ptr2 =
        boost::shared_ptr<MatrixDouble>(data2, &data2->flux_values);
    flux_divs_ptr2 = boost::shared_ptr<VectorDouble>(data2, &data2->flux_divs);
 
    mass_values_ptr2 =
        boost::shared_ptr<VectorDouble>(data2, &data2->mass_values);
    mass_dots_ptr2 = boost::shared_ptr<VectorDouble>(data2, &data2->mass_dots);
 
 
  }

◆ RDProblem() [2/4]

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

inline

Definition at line 57 of file elec_pys_new.cpp.

      : m_field(core), order(order), cOmm(m_field.get_comm()),
        rAnk(m_field.get_comm_rank()) {
    vol_ele_slow_rhs = boost::shared_ptr<VolEle>(new VolEle(m_field));
    natural_bdry_ele_slow_rhs =
        boost::shared_ptr<FaceEle>(new FaceEle(m_field));
    vol_ele_stiff_rhs = boost::shared_ptr<VolEle>(new VolEle(m_field));
    vol_ele_stiff_lhs = boost::shared_ptr<VolEle>(new VolEle(m_field));
    post_proc = boost::shared_ptr<PostProcVolumeOnRefinedMesh>(
        new PostProcVolumeOnRefinedMesh(m_field));
 
    data_u = boost::shared_ptr<PreviousData>(new PreviousData());
    data_v = boost::shared_ptr<PreviousData>(new PreviousData());
    data_w = boost::shared_ptr<PreviousData>(new PreviousData());
    data_s = boost::shared_ptr<PreviousData>(new PreviousData());
 
    flux_values_ptr_u =
        boost::shared_ptr<MatrixDouble>(data_u, &data_u->flux_values);
 
    flux_divs_ptr_u = boost::shared_ptr<VectorDouble>(data_u, &data_u->flux_divs);
 
    mass_values_ptr_u =
        boost::shared_ptr<VectorDouble>(data_u, &data_u->mass_values);
 
    mass_dots_ptr_u = boost::shared_ptr<VectorDouble>(data_u, &data_u->mass_dots);
 
   
 
    mass_values_ptr_v =
        boost::shared_ptr<VectorDouble>(data_v, &data_v->mass_values);
    mass_dots_ptr_v = boost::shared_ptr<VectorDouble>(data_v, &data_v->mass_dots);
 
 
    mass_values_ptr_w =
        boost::shared_ptr<VectorDouble>(data_w, &data_w->mass_values);
 
    mass_dots_ptr_w = boost::shared_ptr<VectorDouble>(data_w, &data_w->mass_dots);
 
    mass_values_ptr_s =
        boost::shared_ptr<VectorDouble>(data_s, &data_s->mass_values);
 
    mass_dots_ptr_s =
        boost::shared_ptr<VectorDouble>(data_s, &data_s->mass_dots);
  }

◆ RDProblem() [3/4]

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

inline

Definition at line 14 of file mixed_reac_diff.cpp.

  : m_field(core)
  , order(order)
  , cOmm(m_field.get_comm())
  , rAnk(m_field.get_comm_rank()) {
    vol_ele_slow_rhs = boost::shared_ptr<FaceEle>(new FaceEle(m_field));
    natural_bdry_ele_slow_rhs =
        boost::shared_ptr<BoundaryEle>(new BoundaryEle(m_field));
    vol_ele_stiff_rhs = boost::shared_ptr<FaceEle>(new FaceEle(m_field));
    vol_ele_stiff_lhs = boost::shared_ptr<FaceEle>(new FaceEle(m_field));
    post_proc = boost::shared_ptr<PostProcFaceOnRefinedMesh>(
        new PostProcFaceOnRefinedMesh(m_field));
 
    data1 = boost::shared_ptr<PreviousData>(new PreviousData());
    data2 = boost::shared_ptr<PreviousData>(new PreviousData());
    data3 = boost::shared_ptr<PreviousData>(new PreviousData());
 
    flux_values_ptr1 =
        boost::shared_ptr<MatrixDouble>(data1, &data1->flux_values);
 
    flux_divs_ptr1 = boost::shared_ptr<VectorDouble>(data1, &data1->flux_divs);
 
    mass_values_ptr1 =
        boost::shared_ptr<VectorDouble>(data1, &data1->mass_values);
 
    mass_dots_ptr1 = boost::shared_ptr<VectorDouble>(data1, &data1->mass_dots);
 
    flux_values_ptr2 =
        boost::shared_ptr<MatrixDouble>(data2, &data2->flux_values);
    flux_divs_ptr2 = boost::shared_ptr<VectorDouble>(data2, &data2->flux_divs);
 
    mass_values_ptr2 =
        boost::shared_ptr<VectorDouble>(data2, &data2->mass_values);
    mass_dots_ptr2 = boost::shared_ptr<VectorDouble>(data2, &data2->mass_dots);
 
    flux_values_ptr3 =
        boost::shared_ptr<MatrixDouble>(data3, &data3->flux_values);
    flux_divs_ptr3 = boost::shared_ptr<VectorDouble>(data3, &data3->flux_divs);
 
    mass_values_ptr3 =
        boost::shared_ptr<VectorDouble>(data3, &data3->mass_values);
 
    mass_dots_ptr3 = boost::shared_ptr<VectorDouble>(data3, &data3->mass_dots);
  }

◆ 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.

      : moab(mb_instance)
      , m_field(core)
      , order(order)
      , nb_species(n_species)
      , cOmm(m_field.get_comm())
      , rAnk(m_field.get_comm_rank()) 
      {
    vol_ele_slow_rhs = boost::shared_ptr<Ele>(new Ele(m_field));
    vol_ele_stiff_rhs = boost::shared_ptr<Ele>(new Ele(m_field));
    vol_ele_stiff_lhs = boost::shared_ptr<Ele>(new Ele(m_field));
 
    boundary_ele_rhs = boost::shared_ptr<BoundaryEle>(new BoundaryEle(m_field));
 
    vol_mass_ele = boost::shared_ptr<Ele>(new Ele(m_field));
 
    post_proc = boost::shared_ptr<PostProcFaceOnRefinedMesh>(
        new PostProcFaceOnRefinedMesh(m_field));
 
    data.resize(nb_species);
    values_ptr.resize(nb_species);
    grads_ptr.resize(nb_species);
    dots_ptr.resize(nb_species);
    inner_surface.resize(nb_species);
 
    for (int i = 0; i < nb_species; ++i) {
      data[i] = boost::shared_ptr<PreviousData>(new PreviousData());
      grads_ptr[i] = boost::shared_ptr<MatrixDouble>(data[i], &data[i]->grads);
      values_ptr[i] =
          boost::shared_ptr<VectorDouble>(data[i], &data[i]->values);
      dots_ptr[i] =
          boost::shared_ptr<VectorDouble>(data[i], &data[i]->dot_values);
    }
  }

Member Function Documentation

◆ add_fe() [1/4]

MoFEMErrorCode RDProblem::add_fe ( )

private

Definition at line 236 of file elec_phys_2D.cpp.

                                 {
  MoFEMFunctionBegin;
  CHKERR simple_interface->addDomainField("U", L2,
                                          AINSWORTH_LEGENDRE_BASE, 1);
  CHKERR simple_interface->addDataField("V", L2, 
                                          AINSWORTH_LEGENDRE_BASE, 1);
 
  CHKERR simple_interface->addDomainField("F", HCURL,
                                          AINSWORTH_LEGENDRE_BASE, 1);
 
  CHKERR simple_interface->addBoundaryField("F", HCURL,
                                            DEMKOWICZ_JACOBI_BASE, 1);
 
  
 
  CHKERR simple_interface->setFieldOrder("U", order - 1);
  CHKERR simple_interface->setFieldOrder("V", order - 1);
  CHKERR simple_interface->setFieldOrder("F", order);
 
 
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                     {
  MoFEMFunctionBegin;
  CHKERR simple_interface->addDomainField(field_name, H1,
                                          AINSWORTH_LEGENDRE_BASE, 1);
  CHKERR simple_interface->addDataField("ERROR", L2, AINSWORTH_LEGENDRE_BASE,
                                        1);
  // CHKERR simple_interface->addBoundaryField(field_name, H1,
  //                                           AINSWORTH_LEGENDRE_BASE, 1);
  CHKERR simple_interface->setFieldOrder(field_name, order);
  CHKERR simple_interface->setFieldOrder("ERROR", 0);
 
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                       {
  MoFEMFunctionBegin;
  CHKERR simple_interface->addDomainField(mass_field, L2,
                                          AINSWORTH_LEGENDRE_BASE, 1);
 
  CHKERR simple_interface->addDomainField(flux_field, HCURL,
                                          AINSWORTH_LEGENDRE_BASE, 1);
 
  CHKERR simple_interface->addBoundaryField(flux_field, HCURL,
                                            DEMKOWICZ_JACOBI_BASE, 1);
  CHKERR simple_interface->addDataField("ERROR", L2, AINSWORTH_LEGENDRE_BASE,
                                        1);
 
  CHKERR simple_interface->setFieldOrder(mass_field, order - 1);
  CHKERR simple_interface->setFieldOrder(flux_field, order);
  CHKERR simple_interface->setFieldOrder("ERROR", 0); // approximation order for error
 
  MoFEMFunctionReturn(0);
}

◆ apply_BC() [1/3]

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

private

Definition at line 442 of file elec_phys_2D.cpp.

                                                       {
  MoFEMFunctionBegin;
  CHKERR m_field.getInterface<ProblemsManager>()->removeDofsOnEntities(
      "SimpleProblem", flux_field, essential_bdry_ents);
 
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                          {
  MoFEMFunctionBegin;
  initial_ele->getOpPtrVector().push_back(
      new OpInitialMass(mass_field, surface));
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                      {
  MoFEMFunctionBegin;
  initial_ele->getOpPtrVector().push_back(
      new OpInitialMass(mass_field, surface, init_val));
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                             {
  MoFEMFunctionBegin;
  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
    string name = it->getName();
    if (name.compare(0, 14, natural) == 0) {
 
      CHKERR it->getMeshsetIdEntitiesByDimension(m_field.get_moab(), 1,
                                                 natural_bdry_ents, true);
    } else if (name.compare(0, 14, essential) == 0) {
      CHKERR it->getMeshsetIdEntitiesByDimension(m_field.get_moab(), 1,
                                                 essential_bdry_ents, true);
    } 
  }
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                              {
  MoFEMFunctionBegin;
  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
    string name = it->getName();
    if (name.compare(0, 14, natural) == 0) {
 
      CHKERR it->getMeshsetIdEntitiesByDimension(m_field.get_moab(), 1,
                                                 natural_bdry_ents, true);
    } else if (name.compare(0, 14, essential) == 0) {
      CHKERR it->getMeshsetIdEntitiesByDimension(m_field.get_moab(), 1,
                                                 essential_bdry_ents, true);
    } else if (name.compare(0, 14, internal) == 0) {
      CHKERR it->getMeshsetIdEntitiesByDimension(m_field.get_moab(), 1,
                                                 internal_edge_ents, true);
    }
  }
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                           {
  MoFEMFunctionBegin;
  if (m_field.getInterface<MeshsetsManager>()->checkMeshset(block_id,
                                                            BLOCKSET)) {
    CHKERR m_field.getInterface<MeshsetsManager>()->getEntitiesByDimension(
        block_id, BLOCKSET, 2, surface, true);
  }
  MoFEMFunctionReturn(0);
}

◆ 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.

                                  {
  MoFEMFunctionBegin;
  CHKERR TSSetType(ts, TSARKIMEX);
  CHKERR TSARKIMEXSetType(ts, TSARKIMEXA2);
 
  CHKERR DMMoFEMTSSetIJacobian(dm, simple_interface->getDomainFEName(),
                               vol_ele_stiff_lhs, null, null);
 
  CHKERR DMMoFEMTSSetIFunction(dm, simple_interface->getDomainFEName(),
                               vol_ele_stiff_rhs, null, null);
 
  CHKERR DMMoFEMTSSetRHSFunction(dm, simple_interface->getDomainFEName(),
                                 vol_ele_slow_rhs, null, null);
  CHKERR DMMoFEMTSSetRHSFunction(dm, simple_interface->getBoundaryFEName(),
                                 natural_bdry_ele_slow_rhs, null, null);
  MoFEMFunctionReturn(0);
}

◆ 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.

                                          {
    MoFEMFunctionBegin;
    CHKERR DMMoFEMTSSetMonitor(dm, ts, simple_interface->getDomainFEName(),
                               monitor_ptr, null, null);
    MoFEMFunctionReturn(0);
  }

◆ 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.

                                           {
  MoFEMFunctionBegin;
  post_proc->addFieldValuesPostProc("U");
  post_proc->addFieldValuesPostProc("F");
  post_proc->addFieldValuesPostProc("V");
 
  MoFEMFunctionReturn(0);
  }

◆ 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.

                                                               {
  MoFEMFunctionBegin;
  post_proc->addFieldValuesPostProc(field_name);
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                 {
  MoFEMFunctionBegin;
  post_proc->addFieldValuesPostProc(mass_field);
  post_proc->addFieldValuesPostProc(flux_field);
  MoFEMFunctionReturn(0);
}

◆ push_mass_ele()

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

private

Definition at line 420 of file std_reac_diff.cpp.

                                                            {
  MoFEMFunctionBegin;
  vol_mass_ele->getOpPtrVector().push_back(
      new OpAssembleMass(field_name, mass_matrix));
  MoFEMFunctionReturn(0);
}

◆ push_slow_rhs() [1/4]

MoFEMErrorCode RDProblem::push_slow_rhs ( )

private

Definition at line 240 of file elec_pys_new.cpp.

                         {
  MoFEMFunctionBegin;
 
  vol_ele_slow_rhs->getOpPtrVector().push_back(
      new OpAssembleSlowRhsV("U", data_u, data_v,RhsU()));
 
  // natural_bdry_ele_slow_rhs->getOpPtrVector().push_back(
  //     new OpAssembleNaturalBCRhsTau("F", natural_bdry_ents));
 
  // natural_bdry_ele_slow_rhs->getOpPtrVector().push_back(
  //     new OpEssentialBC("F", essential_bdry_ents));
  MoFEMFunctionReturn(0);
}

◆ push_slow_rhs() [2/4]

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

private

Definition at line 330 of file mixed_reac_diff.cpp.

                                                                             {
  MoFEMFunctionBegin;
 
  vol_ele_slow_rhs->getOpPtrVector().push_back(
      new OpAssembleSlowRhsV(mass_field, data, ExactFunction(), ExactFunctionDot(), ExactFunctionLap()));
 
  natural_bdry_ele_slow_rhs->getOpPtrVector().push_back(
      new OpSkeletonSource(mass_field, 
                           KinkFunction(),
                           ExactFunction(), 
                           internal_edge_ents));
 
  natural_bdry_ele_slow_rhs->getOpPtrVector().push_back(
      new OpAssembleNaturalBCRhsTau(flux_field, natural_bdry_ents));
 
  natural_bdry_ele_slow_rhs->getOpPtrVector().push_back(
      new OpEssentialBC(flux_field, essential_bdry_ents));
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                {
  MoFEMFunctionBegin;
 
  vol_ele_slow_rhs->getOpPtrVector().push_back(
      new OpAssembleSlowRhsV(mass_field, data_1, data_2, RhsU()));
 
  // natural_bdry_ele_slow_rhs->getOpPtrVector().push_back(
  //     new OpAssembleNaturalBCRhsTau(flux_field, natural_bdry_ents));
 
  natural_bdry_ele_slow_rhs->getOpPtrVector().push_back(
      new OpEssentialBC(flux_field, essential_bdry_ents));
 
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                             {
  MoFEMFunctionBegin;
 
  vol_ele_slow_rhs->getOpPtrVector().push_back(
      new OpAssembleSlowRhs(field_name, data, ExactFunction(),
                             ExactFunctionDot(), ExactFunctionLap()));
  MoFEMFunctionReturn(0);
}

◆ push_stiff_lhs() [1/4]

MoFEMErrorCode RDProblem::push_stiff_lhs ( )

private

Definition at line 304 of file elec_pys_new.cpp.

                                         {
  MoFEMFunctionBegin;
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpAssembleLhsTauTau<3>("F"));
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpAssembleLhsTauV<3>("F", "U"));
 
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpAssembleLhsVV("U"));
 
 
 
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpAssembleLhsVTau("U", "F"));
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                            {
  MoFEMFunctionBegin;
 
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpAssembleStiffLhs<2>(field_name, data, block_map));
 
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                            {
  MoFEMFunctionBegin;
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpAssembleLhsTauTau<3>(flux_field, data, block_map));
 
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpAssembleLhsVV(mass_field));
 
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpAssembleLhsTauV<3>(flux_field, mass_field, data, block_map));
 
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpAssembleLhsVTau(mass_field, flux_field));
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                            {
  MoFEMFunctionBegin;
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpAssembleLhsTauTau<3>(flux_field, data1, block_map));
 
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpAssembleLhsVV(mass_field, data1, data2, DRhsU_u()));
 
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpAssembleLhsTauV<3>(flux_field, mass_field, data1, block_map));
 
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpAssembleLhsVTau(mass_field, flux_field));
  MoFEMFunctionReturn(0);
}

◆ push_stiff_rhs() [1/4]

MoFEMErrorCode RDProblem::push_stiff_rhs ( )

private

Definition at line 280 of file elec_pys_new.cpp.

                          {
  MoFEMFunctionBegin;
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpAssembleStiffRhsTau<3>("F", data_u));
 
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpAssembleStiffRhsV<3>("U", data_u, inner_surface2));
 
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                            {
  MoFEMFunctionBegin;
 
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpAssembleStiffRhs<2>(field_name, data, block_map, ExactFunction(),
                                ExactFunctionDot(), ExactFunctionLap()));
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                            {
  MoFEMFunctionBegin;
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpAssembleStiffRhsTau<3>(flux_field, data, block_map));
 
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpAssembleStiffRhsV<3>(mass_field, data, block_map, ExactFunction(),
                                 ExactFunctionDot(), ExactFunctionLap()));
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                         {
  MoFEMFunctionBegin;
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpAssembleStiffRhsTau<3>(flux_field, data1, block_map));
 
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpAssembleStiffRhsV<3>(mass_field, data1, data2, RhsU(), block_map, surface));
  MoFEMFunctionReturn(0);
}

◆ resolve_slow_rhs()

MoFEMErrorCode RDProblem::resolve_slow_rhs ( )

private

Definition at line 427 of file std_reac_diff.cpp.

                                           {
  MoFEMFunctionBegin;
  CHKERR DMoFEMLoopFiniteElements(dm, simple_interface->getDomainFEName(),
                                  vol_mass_ele);
  CHKERR MatAssemblyBegin(mass_matrix, MAT_FINAL_ASSEMBLY);
  CHKERR MatAssemblyEnd(mass_matrix, MAT_FINAL_ASSEMBLY);
  // Create and septup KSP (linear solver), we need this to calculate g(t,u) =
  // M^-1G(t,u)
  mass_Ksp = createKSP(m_field.get_comm());
  CHKERR KSPSetOperators(mass_Ksp, mass_matrix, mass_matrix);
  CHKERR KSPSetFromOptions(mass_Ksp);
  CHKERR KSPSetUp(mass_Ksp);
  MoFEMFunctionReturn(0);
}

◆ run_analysis() [1/4]

MoFEMErrorCode RDProblem::run_analysis ( )

Definition at line 530 of file elec_phys_2D.cpp.

                                         {
    MoFEMFunctionBegin;
    global_error = 0;
 
    CHKERR setup_system(); // only once
 
    CHKERR add_fe(); // nb_species times
 
    CHKERR simple_interface->setUp();
 
    CHKERR set_blockData(material_blocks);
 
    CHKERR extract_bd_ents("ESSENTIAL", "NATURAL"); // nb_species times
 
    CHKERR extract_initial_ents(2, inner_surface1);
    CHKERR extract_initial_ents(3, inner_surface2);
 
    CHKERR update_slow_rhs("U", mass_values_ptr1);
    CHKERR update_slow_rhs("V", mass_values_ptr2);
 
    natural_bdry_ele_slow_rhs->getOpPtrVector().push_back(
        new OpSetContrariantPiolaTransformOnEdge());
 
    CHKERR push_slow_rhs("U", "F", data1, data2); // nb_species times
 
    CHKERR update_vol_fe(vol_ele_stiff_rhs, data1);
 
    CHKERR update_stiff_rhs("U", "F", mass_values_ptr1,
                            flux_values_ptr1, mass_dots_ptr1, flux_divs_ptr1);
    vol_ele_stiff_rhs->getOpPtrVector().push_back(
        new OpCalculateScalarFieldValues("V", mass_values_ptr2));
    CHKERR push_stiff_rhs("U", "F", data1, data2,
                          material_blocks, inner_surface2); // nb_species times
 
    CHKERR update_vol_fe(vol_ele_stiff_lhs, data1);
 
    CHKERR update_stiff_lhs("U", "F", mass_values_ptr1,
                            flux_values_ptr1);
 
    vol_ele_stiff_lhs->getOpPtrVector().push_back(
        new OpCalculateScalarFieldValues("V", mass_values_ptr2));
    CHKERR push_stiff_lhs("U", "F", data1, data2,
                              material_blocks); // nb_species times
    vol_ele_stiff_lhs->getOpPtrVector().push_back(
        new OpSolveRecovery("V", data1, data2, RK4()));
 
    CHKERR set_integration_rule();
    dm = simple_interface->getDM();
    ts = createTS(m_field.get_comm());
    boost::shared_ptr<FaceEle> initial_mass_ele(new FaceEle(m_field));
 
    CHKERR apply_IC("U", inner_surface1, initial_mass_ele,
                    init_val_u); // nb_species times
    CHKERR apply_IC("V", inner_surface1, initial_mass_ele,
                    init_val_v); // nb_species times
 
    CHKERR DMoFEMLoopFiniteElements(dm, simple_interface->getDomainFEName(),
                                    initial_mass_ele);
 
    CHKERR apply_BC("F"); // nb_species times
 
    CHKERR loop_fe();                          // only once
    post_proc->generateReferenceElementMesh(); // only once
 
    CHKERR post_proc_fields();
 
    monitor_ptr = boost::shared_ptr<Monitor>(
        new Monitor(cOmm, rAnk, dm, post_proc)); // nb_species times
    CHKERR output_result();                      // only once
    CHKERR solve();                              // only once
    MoFEMFunctionReturn(0);
  }

◆ 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.

                                                {
  MoFEMFunctionBegin;
  global_error = 0;
  // set nb_species
  CHKERR setup_system(); // only once
  nb_species = nb_sp;
  if (nb_species == 1 || nb_species == 2 || nb_species == 3) {
    CHKERR add_fe("MASS1", "FLUX1"); // nb_species times
    if (nb_species == 2 || nb_species == 3) {
      CHKERR add_fe("MASS2", "FLUX2");
      if (nb_species == 3) {
        CHKERR add_fe("MASS3", "FLUX3");
      }
    }
  }
 
  CHKERR simple_interface->setUp();
 
  CHKERR set_blockData(material_blocks);
 
  CHKERR extract_bd_ents("ESSENTIAL", "NATURAL", "INTERNAL"); // nb_species times
 
  if (nb_species == 1 || nb_species == 2 || nb_species == 3) {
    CHKERR extract_initial_ents(2, inner_surface1);
    CHKERR update_slow_rhs("MASS1", mass_values_ptr1);
    if (nb_species == 1) {
      vol_ele_slow_rhs->getOpPtrVector().push_back(new OpComputeSlowValue(
          "MASS1", data1, data1, data1, material_blocks));
    } else if (nb_species == 2 || nb_species == 3) {
      CHKERR extract_initial_ents(3, inner_surface2);
      CHKERR update_slow_rhs("MASS2", mass_values_ptr2);
      if (nb_species == 2) {
        vol_ele_slow_rhs->getOpPtrVector().push_back(new OpComputeSlowValue(
            "MASS1", data1, data2, data2, material_blocks));
      } else if (nb_species == 3) {
        CHKERR extract_initial_ents(4, inner_surface3);
        CHKERR update_slow_rhs("MASS3", mass_values_ptr3);
        vol_ele_slow_rhs->getOpPtrVector().push_back(new OpComputeSlowValue(
            "MASS1", data1, data2, data3, material_blocks));
      }
    }
  }
  natural_bdry_ele_slow_rhs->getOpPtrVector().push_back(
      new OpSetContrariantPiolaTransformOnEdge());
 
  if (nb_species == 1 || nb_species == 2 || nb_species == 3) {
    CHKERR push_slow_rhs("MASS1", "FLUX1", data1); // nb_species times
    if (nb_species == 2 || nb_species == 3) {
      CHKERR push_slow_rhs("MASS2", "FLUX2", data2);
      if (nb_species == 3) {
        CHKERR push_slow_rhs("MASS3", "FLUX3", data3);
      }
    }
  }
 
  CHKERR update_vol_fe(vol_ele_stiff_rhs, data1);
 
  if (nb_species == 1 || nb_species == 2 || nb_species == 3) {
    CHKERR update_stiff_rhs("MASS1", "FLUX1", mass_values_ptr1,
                            flux_values_ptr1, mass_dots_ptr1, flux_divs_ptr1);
    CHKERR push_stiff_rhs("MASS1", "FLUX1", data1,
                          material_blocks); // nb_species times
    if (nb_species == 2 || nb_species == 3) {
      CHKERR update_stiff_rhs("MASS2", "FLUX2", mass_values_ptr2,
                              flux_values_ptr2, mass_dots_ptr2, flux_divs_ptr2);
      CHKERR push_stiff_rhs("MASS2", "FLUX2", data2, material_blocks);
      if (nb_species == 3) {
        CHKERR update_stiff_rhs("MASS3", "FLUX3", mass_values_ptr3,
                                flux_values_ptr3, mass_dots_ptr3,
                                flux_divs_ptr3);
        CHKERR push_stiff_rhs("MASS3", "FLUX3", data3, material_blocks);
      }
    }
  }
 
  CHKERR update_vol_fe(vol_ele_stiff_lhs, data1);
 
  if (nb_species == 1 || nb_species == 2 || nb_species == 3) {
    CHKERR update_stiff_lhs("MASS1", "FLUX1", mass_values_ptr1,
                            flux_values_ptr1);
    CHKERR push_stiff_lhs("MASS1", "FLUX1", data1,
                          material_blocks); // nb_species times
    if (nb_species == 2 || nb_species == 3) {
      CHKERR update_stiff_lhs("MASS2", "FLUX2", mass_values_ptr2,
                              flux_values_ptr2);
      CHKERR push_stiff_lhs("MASS2", "FLUX2", data2, material_blocks);
      if (nb_species == 3) {
        CHKERR update_stiff_lhs("MASS3", "FLUX3", mass_values_ptr3,
                                flux_values_ptr3);
        CHKERR push_stiff_lhs("MASS3", "FLUX3", data3, material_blocks);
      }
    }
  }
  
 
  // vol_ele_stiff_lhs->getOpPtrVector().push_back(
  //     new OpError(ExactFunction(), ExactFunctionLap(), ExactFunctionGrad(), data1, material_blocks, global_error));
  CHKERR set_integration_rule();
  dm = simple_interface->getDM();
  ts = createTS(m_field.get_comm());
  boost::shared_ptr<FaceEle> initial_mass_ele(new FaceEle(m_field));
 
  if (nb_species == 1 || nb_species == 2 || nb_species == 3) {
    CHKERR apply_IC("MASS1", inner_surface1,
                    initial_mass_ele); // nb_species times
    if (nb_species == 2 || nb_species == 3) {
      CHKERR apply_IC("MASS2", inner_surface2, initial_mass_ele);
      if (nb_species == 3) {
        CHKERR apply_IC("MASS3", inner_surface3, initial_mass_ele);
      }
    }
  }
  CHKERR DMoFEMLoopFiniteElements(dm, simple_interface->getDomainFEName(),
                                  initial_mass_ele);
 
  if (nb_species == 1 || nb_species == 2 || nb_species == 3) {
    CHKERR apply_BC("FLUX1"); // nb_species times
    if (nb_species == 2 || nb_species == 3) {
      CHKERR apply_BC("FLUX2");
      if (nb_species == 3) {
        CHKERR apply_BC("FLUX3");
      }
    }
  }
 
  CHKERR loop_fe();                          // only once
  post_proc->generateReferenceElementMesh(); // only once
 
 
 
  if (nb_species == 1 || nb_species == 2 || nb_species == 3) {
    CHKERR post_proc_fields("MASS1", "FLUX1");
    post_proc->addFieldValuesPostProc("ERROR");
    if (nb_species == 2 || nb_species == 3) {
      CHKERR post_proc_fields("MASS2", "FLUX2");
      if (nb_species == 3) {
        CHKERR post_proc_fields("MASS3", "FLUX3");
      }
    }
  }
 
  //the double global_vector is a global_vector which sums errors in each element
 
  // Vec gVec;
  // CHKERR VecCreateMPI(PETSC_COMM_WORLD, 1, 1, &gVec);
  // double err_per_step = 0;
 
  // auto compute_global_error = [&gVec](double &g_err, double &err_out) {
  //   MoFEMFunctionBegin;
 
  //   CHKERR VecZeroEntries(gVec);
  //   CHKERR VecAssemblyBegin(gVec);
  //   CHKERR VecAssemblyEnd(gVec);
 
  //   int ind[1] = {0};
  //   CHKERR VecSetValues(gVec, 1, ind, &err_out, ADD_VALUES);
  //   CHKERR VecAssemblyBegin(gVec);
  //   CHKERR VecAssemblyEnd(gVec);
 
  //   CHKERR VecGetValues(gVec, 1, ind, &err_out);
 
  //   MoFEMFunctionReturn(0);
  // };
 
  // Vec error_per_proc;
  // CHKERR VecCreateMPI(cOmm, 1, PETSC_DECIDE, &error_per_proc);
  // auto get_global_error = [&]() {
  //   MoFEMFunctionBegin;  
  //   CHKERR VecSetValue(error_per_proc, m_field.get_comm_rank(), global_error, INSERT_VALUES);
  //   MoFEMFunctionReturn(0);
  // };
 
  // auto reinitialize_global = [&]() { 
  //   MoFEMFunctionBegin;
  //   CHKERR get_global_error();
  //   CHKERR VecAssemblyBegin(error_per_proc);
  //   CHKERR VecAssemblyEnd(error_per_proc);
  //   double error_sum;
  //   CHKERR VecSum(error_per_proc, &error_sum);
  //   CHKERR PetscPrintf(PETSC_COMM_WORLD, "Error : %3.4e \n",
  //                     error_sum);
  //   global_error = 0;
  //   MoFEMFunctionReturn(0);
  //  };
 
  // vol_ele_stiff_lhs->postProcessHook = reinitialize_global;
 
 
 
  monitor_ptr = boost::shared_ptr<Monitor>(
      new Monitor(cOmm, rAnk, dm, post_proc, global_error)); // nb_species times
  CHKERR output_result();          // only once
  CHKERR solve();                  // only once
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                         {
  MoFEMFunctionBegin;
  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(m_field, BLOCKSET, it)) {
    string name = it->getName();
    const int id = it->getMeshsetId();
    if (name.compare(0, 14, "REGION1") == 0) {
      CHKERR m_field.getInterface<MeshsetsManager>()->getEntitiesByDimension(
          id, BLOCKSET, 2, block_map[id].block_ents, true);
      block_map[id].B0 = 1e-3;
      block_map[id].block_id = id;
    } else if (name.compare(0, 14, "REGION2") == 0) {
      CHKERR m_field.getInterface<MeshsetsManager>()->getEntitiesByDimension(
          id, BLOCKSET, 2, block_map[id].block_ents, true);
      block_map[id].B0 = 1e-1;
      block_map[id].block_id = id;
    } 
  }
  MoFEMFunctionReturn(0);
}

◆ 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

Definition at line 442 of file std_reac_diff.cpp.

                                         {
  MoFEMFunctionBegin;
  CHKERR TSSetType(ts, TSARKIMEX);
  CHKERR TSARKIMEXSetType(ts, TSARKIMEXA2);
 
  CHKERR DMMoFEMTSSetIJacobian(dm, simple_interface->getDomainFEName(),
                               vol_ele_stiff_lhs, null, null);
 
  CHKERR DMMoFEMTSSetIFunction(dm, simple_interface->getDomainFEName(),
                               vol_ele_stiff_rhs, null, null);
 
  CHKERR DMMoFEMTSSetRHSFunction(dm, simple_interface->getDomainFEName(),
                                 vol_ele_slow_rhs, null, null);
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                               {
  MoFEMFunctionBegin;
  if (m_field.getInterface<MeshsetsManager>()->checkMeshset(block_id,
                                                            BLOCKSET)) {
    CHKERR m_field.getInterface<MeshsetsManager>()->getEntitiesByDimension(
        block_id, BLOCKSET, 2, surface, true);
  }
  if (!surface.empty()) {
    Range surface_verts;
    CHKERR moab.get_connectivity(surface, surface_verts, false);
    CHKERR m_field.getInterface<FieldBlas>()->setField(
        init_val, MBVERTEX, surface_verts, field_name);
  }
 
  MoFEMFunctionReturn(0);
}

◆ set_integration_rule() [1/4]

MoFEMErrorCode RDProblem::set_integration_rule ( )

private

Definition at line 421 of file elec_phys_2D.cpp.

                                               {
  MoFEMFunctionBegin;
  auto vol_rule = [](int, int, int p) -> int { return 2 * p; };
  vol_ele_slow_rhs->getRuleHook = vol_rule;
  natural_bdry_ele_slow_rhs->getRuleHook = vol_rule;
 
  vol_ele_stiff_rhs->getRuleHook = vol_rule;
 
  vol_ele_stiff_lhs->getRuleHook = vol_rule;
  MoFEMFunctionReturn(0);
}

◆ 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.

                                       {
  MoFEMFunctionBegin;
  CHKERR m_field.getInterface(simple_interface);
  CHKERR simple_interface->getOptions();
  CHKERR simple_interface->loadFile();
  MoFEMFunctionReturn(0);
}

◆ 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.

                                  {
    MoFEMFunctionBegin;
    // Create solution vector
    SmartPetscObj<Vec> X;
    CHKERR DMCreateGlobalVector_MoFEM(dm, X);
    CHKERR DMoFEMMeshToLocalVector(dm, X, INSERT_VALUES, SCATTER_FORWARD);
    // Solve problem
    double ftime = 1;
    CHKERR TSSetDM(ts, dm);
    CHKERR TSSetDuration(ts, PETSC_DEFAULT, ftime);
    CHKERR TSSetSolution(ts, X);
    CHKERR TSSetFromOptions(ts);
 
    if (1) {
      SNES snes;
      CHKERR TSGetSNES(ts, &snes);
      KSP ksp;
      CHKERR SNESGetKSP(snes, &ksp);
      PC pc;
      CHKERR KSPGetPC(ksp, &pc);
      PetscBool is_pcfs = PETSC_FALSE;
      PetscObjectTypeCompare((PetscObject)pc, PCFIELDSPLIT, &is_pcfs);
      // Set up FIELDSPLIT
      // Only is user set -pc_type fieldsplit
      if (is_pcfs == PETSC_TRUE) {
        IS is_mass, is_flux;
        const MoFEM::Problem *problem_ptr;
        CHKERR DMMoFEMGetProblemPtr(dm, &problem_ptr);
        CHKERR m_field.getInterface<ISManager>()->isCreateProblemFieldAndRank(
            problem_ptr->getName(), ROW, "U", 0, 1, &is_mass);
        CHKERR m_field.getInterface<ISManager>()->isCreateProblemFieldAndRank(
            problem_ptr->getName(), ROW, "F", 0, 1, &is_flux);
        // CHKERR ISView(is_flux, PETSC_VIEWER_STDOUT_SELF);
        // CHKERR ISView(is_mass, PETSC_VIEWER_STDOUT_SELF);
 
        CHKERR PCFieldSplitSetIS(pc, NULL, is_mass);
        CHKERR PCFieldSplitSetIS(pc, NULL, is_flux);
        
 
        CHKERR ISDestroy(&is_flux);
        CHKERR ISDestroy(&is_mass);
      }
    }
 
    CHKERR TSSolve(ts, X);
    MoFEMFunctionReturn(0);
  }

◆ 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.

                                                                    {
  MoFEMFunctionBegin;
  vol_ele_slow_rhs->getOpPtrVector().push_back(
      new OpCalculateScalarFieldValues(mass_field, mass_ptr));
  MoFEMFunctionReturn(0);
}

◆ 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.

                            {
  MoFEMFunctionBegin;
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpCalculateScalarFieldValues("U", mass_values_ptr_u));
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpCalculateScalarFieldValues("V", mass_values_ptr_v));
 
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpCalculateHVecVectorField<3>("F", flux_values_ptr_u));
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                      {
  MoFEMFunctionBegin;
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpCalculateScalarFieldValues(field_name, values_ptr));
 
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpCalculateScalarFieldGradient<2>(field_name, grads_ptr));
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                     {
  MoFEMFunctionBegin;
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpCalculateScalarFieldValues(mass_field, mass_ptr));
 
  vol_ele_stiff_lhs->getOpPtrVector().push_back(
      new OpCalculateHVecVectorField<3>(flux_field, flux_ptr));
  MoFEMFunctionReturn(0);
}

◆ 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.

                            {
 
  MoFEMFunctionBegin;
 
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpCalculateScalarFieldValues("U", mass_values_ptr_u));
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpCalculateScalarFieldValues("V", mass_values_ptr_v));
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpSolveRecovery("V", data_u, data_v, RK4()));
 
  
 
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpCalculateScalarValuesDot("U", mass_dots_ptr_u));
 
 
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpCalculateHVecVectorField<3>("F", flux_values_ptr_u));
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpCalculateHdivVectorDivergence<3, 3>("F", flux_divs_ptr_u));
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                     {
 
  MoFEMFunctionBegin;
 
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpCalculateScalarFieldValues(field_name, values_ptr));
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpCalculateScalarValuesDot(field_name, dots_ptr));
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpCalculateScalarFieldGradient<2>(field_name, grads_ptr));
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                         {
 
  MoFEMFunctionBegin;
 
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpCalculateScalarFieldValues(mass_field, mass_ptr));
 
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpCalculateHVecVectorField<3>(flux_field, flux_ptr));
 
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpCalculateScalarValuesDot(mass_field, mass_dot_ptr));
 
  vol_ele_stiff_rhs->getOpPtrVector().push_back(
      new OpCalculateHdivVectorDivergence<3, 2>(flux_field, flux_div_ptr));
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                             {
  MoFEMFunctionBegin;
  auto det_ptr = boost::make_shared<VectorDouble>();
  auto jac_ptr = boost::make_shared<MatrixDouble>();
  auto inv_jac_ptr = boost::make_shared<MatrixDouble>();
  vol_ele->getOpPtrVector().push_back(new OpCalculateHOJacForFace(jac_ptr));
  vol_ele->getOpPtrVector().
      push_back(new OpInvertMatrix<2>(jac_ptr, det_ptr, inv_jac_ptr));
  vol_ele->getOpPtrVector().push_back(new OpSetInvJacH1ForFace(inv_jac_ptr));
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                             {
  MoFEMFunctionBegin;
  auto det_ptr = boost::make_shared<VectorDouble>();
  auto jac_ptr = boost::make_shared<MatrixDouble>();
  auto inv_jac_ptr = boost::make_shared<MatrixDouble>();
  vol_ele->getOpPtrVector().push_back(new OpCalculateHOJacForFace(jac_ptr));
  vol_ele->getOpPtrVector().push_back(
      new OpInvertMatrix<2>(jac_ptr, det_ptr, inv_jac_ptr));
  vol_ele->getOpPtrVector().push_back(new OpMakeHdivFromHcurl());
  vol_ele->getOpPtrVector().push_back(
      new OpSetContravariantPiolaTransformOnFace2D(jac_ptr));
  vol_ele->getOpPtrVector().push_back(new OpSetInvJacHcurlFace(inv_jac_ptr));
  MoFEMFunctionReturn(0);
}

◆ 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.

                                                                             {
  MoFEMFunctionBegin;
  auto det_ptr = boost::make_shared<VectorDouble>();
  auto jac_ptr = boost::make_shared<MatrixDouble>();
  auto inv_jac_ptr = boost::make_shared<MatrixDouble>();
  vol_ele->getOpPtrVector().push_back(new OpCalculateHOJacForFace(jac_ptr));
  vol_ele->getOpPtrVector().push_back(
      new OpInvertMatrix<2>(jac_ptr, det_ptr, inv_jac_ptr));
  vol_ele->getOpPtrVector().push_back(new OpMakeHdivFromHcurl());
  vol_ele->getOpPtrVector().push_back(
      new OpSetContravariantPiolaTransformOnFace2D(jac_ptr));
  vol_ele->getOpPtrVector().push_back(new OpSetInvJacHcurlFace(inv_jac_ptr));
  MoFEMFunctionReturn(0);
}

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:

users_modules/softmech/chemo_mech/elec_phys_2D.cpp
users_modules/softmech/chemo_mech/elec_pys_new.cpp
users_modules/softmech/chemo_mech/mixed_reac_diff.cpp
users_modules/softmech/chemo_mech/std_reac_diff.cpp

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ RDProblem() [1/4]

◆ RDProblem() [2/4]

◆ RDProblem() [3/4]

◆ RDProblem() [4/4]

Member Function Documentation

◆ add_fe() [1/4]

◆ add_fe() [2/4]

◆ add_fe() [3/4]

◆ add_fe() [4/4]

◆ apply_BC() [1/3]

◆ apply_BC() [2/3]

◆ apply_BC() [3/3]

◆ apply_IC() [1/3]

◆ apply_IC() [2/3]

◆ apply_IC() [3/3]

◆ extract_bd_ents() [1/3]

◆ extract_bd_ents() [2/3]

◆ extract_bd_ents() [3/3]

◆ extract_initial_ents() [1/3]

◆ extract_initial_ents() [2/3]

◆ extract_initial_ents() [3/3]

◆ loop_fe() [1/3]

◆ loop_fe() [2/3]

◆ loop_fe() [3/3]

◆ output_result() [1/4]

◆ output_result() [2/4]

◆ output_result() [3/4]

◆ output_result() [4/4]

◆ post_proc_fields() [1/4]

◆ post_proc_fields() [2/4]

◆ post_proc_fields() [3/4]

◆ post_proc_fields() [4/4]

◆ push_mass_ele()

◆ push_slow_rhs() [1/4]

◆ push_slow_rhs() [2/4]

◆ push_slow_rhs() [3/4]

◆ push_slow_rhs() [4/4]

◆ push_stiff_lhs() [1/4]

◆ push_stiff_lhs() [2/4]

◆ push_stiff_lhs() [3/4]

◆ push_stiff_lhs() [4/4]

◆ push_stiff_rhs() [1/4]

◆ push_stiff_rhs() [2/4]

◆ push_stiff_rhs() [3/4]

◆ push_stiff_rhs() [4/4]

◆ resolve_slow_rhs()

◆ run_analysis() [1/4]

◆ run_analysis() [2/4]

◆ run_analysis() [3/4]

◆ run_analysis() [4/4]

◆ set_blockData() [1/3]

◆ set_blockData() [2/3]

◆ set_blockData() [3/3]

◆ set_fe_in_loop()

◆ set_initial_values()

◆ set_integration_rule() [1/4]

◆ set_integration_rule() [2/4]

◆ set_integration_rule() [3/4]

◆ set_integration_rule() [4/4]

◆ setup_system() [1/4]

◆ setup_system() [2/4]

◆ setup_system() [3/4]

◆ setup_system() [4/4]

◆ solve() [1/4]

◆ solve() [2/4]

◆ solve() [3/4]

◆ solve() [4/4]

◆ update_slow_rhs() [1/4]

◆ update_slow_rhs() [2/4]

◆ update_slow_rhs() [3/4]

◆ update_slow_rhs() [4/4]

◆ update_stiff_lhs() [1/4]

◆ update_stiff_lhs() [2/4]

◆ update_stiff_lhs() [3/4]