StdRDOperators::OpComputeSlowValue Struct Reference

#include <users_modules/softmech/chemo_mech/src/rd_stdOperators.hpp>

Inheritance diagram for StdRDOperators::OpComputeSlowValue:

Collaboration diagram for StdRDOperators::OpComputeSlowValue:

Public Member Functions
	OpComputeSlowValue (std::string mass_field, boost::shared_ptr< PreviousData > &data1, boost::shared_ptr< PreviousData > &data2, boost::shared_ptr< PreviousData > &data3, std::map< int, BlockData > &block_map)
MoFEMErrorCode	doWork (int side, EntityType type, EntData &data)

Private Attributes
std::string	massField
boost::shared_ptr< PreviousData >	commonData1
boost::shared_ptr< PreviousData >	commonData2
boost::shared_ptr< PreviousData >	commonData3
std::map< int, BlockData >	setOfBlock

Detailed Description

Definition at line 121 of file rd_stdOperators.hpp.

Constructor & Destructor Documentation

OpComputeSlowValue()

StdRDOperators::OpComputeSlowValue::OpComputeSlowValue	(	std::string	mass_field,
		boost::shared_ptr< PreviousData > &	data1,
		boost::shared_ptr< PreviousData > &	data2,
		boost::shared_ptr< PreviousData > &	data3,
		std::map< int, BlockData > &	block_map
	)

Definition at line 122 of file rd_stdOperators.hpp.

      : OpEle(mass_field, OpEle::OPROW), commonData1(data1), commonData2(data2),
        commonData3(data3), massField(mass_field), setOfBlock(block_map) {}

Member Function Documentation

doWork()

MoFEMErrorCode StdRDOperators::OpComputeSlowValue::doWork	(	int	side,
		EntityType	type,
		EntData &	data
	)

Definition at line 129 of file rd_stdOperators.hpp.

                                                                  {
    MoFEMFunctionBegin;
    boost::shared_ptr<VectorDouble> slow_value_ptr1(commonData1,
                                                    &commonData1->slow_values);
    boost::shared_ptr<VectorDouble> slow_value_ptr2(commonData2,
                                                    &commonData2->slow_values);
    boost::shared_ptr<VectorDouble> slow_value_ptr3(commonData3,
                                                    &commonData3->slow_values);
 
    VectorDouble &vec1 = *slow_value_ptr1;
    VectorDouble &vec2 = *slow_value_ptr2;
    VectorDouble &vec3 = *slow_value_ptr3;
    const int nb_integration_pts = getGaussPts().size2();
    if (type == MBVERTEX) {
      vec1.resize(nb_integration_pts, false);
      vec2.resize(nb_integration_pts, false);
      vec3.resize(nb_integration_pts, false);
      vec1.clear();
      vec2.clear();
      vec3.clear();
    }
    const int nb_dofs = data.getIndices().size();
 
    if (nb_dofs) {
      auto find_block_data = [&]() {
        EntityHandle fe_ent = getFEEntityHandle();
        BlockData *block_raw_ptr = nullptr;
        for (auto &m : setOfBlock) {
          if (m.second.block_ents.find(fe_ent) != m.second.block_ents.end()) {
            block_raw_ptr = &m.second;
            break;
          }
        }
        return block_raw_ptr;
      };
 
      auto block_data_ptr = find_block_data();
      if (!block_data_ptr)
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "Block not found");
 
      auto &block_data = *block_data_ptr;
 
      const int nb_integration_pts = getGaussPts().size2();
 
      auto t_slow_values1 = getFTensor0FromVec(vec1);
      auto t_slow_values2 = getFTensor0FromVec(vec2);
      auto t_slow_values3 = getFTensor0FromVec(vec3);
 
      auto t_mass_values1 = getFTensor0FromVec(commonData1->values);
      auto t_mass_values2 = getFTensor0FromVec(commonData2->values);
      auto t_mass_values3 = getFTensor0FromVec(commonData3->values);
 
      // cout << "r1 : " << block_data.rate[0] << endl;
 
      for (int gg = 0; gg != nb_integration_pts; ++gg) {
        t_slow_values1 = block_data.rate[0] * t_mass_values1 *
                         (1.0 - block_data.coef(0, 0) * t_mass_values1 -
                          block_data.coef(0, 1) * t_mass_values2 -
                          block_data.coef(0, 2) * t_mass_values3);
        t_slow_values2 = block_data.rate[1] * t_mass_values2 *
                         (1.0 - block_data.coef(1, 0) * t_mass_values1 -
                          block_data.coef(1, 1) * t_mass_values2 -
                          block_data.coef(1, 2) * t_mass_values3);
 
        t_slow_values3 = block_data.rate[2] * t_mass_values3 *
                         (1.0 - block_data.coef(2, 0) * t_mass_values1 -
                          block_data.coef(2, 1) * t_mass_values2 -
                          block_data.coef(2, 2) * t_mass_values3);
        ++t_slow_values1;
        ++t_slow_values2;
        ++t_slow_values3;
 
        ++t_mass_values1;
        ++t_mass_values2;
        ++t_mass_values3;
      }
    }
    MoFEMFunctionReturn(0);
  }

Member Data Documentation

commonData1

boost::shared_ptr<PreviousData> StdRDOperators::OpComputeSlowValue::commonData1

private

Definition at line 211 of file rd_stdOperators.hpp.

commonData2

boost::shared_ptr<PreviousData> StdRDOperators::OpComputeSlowValue::commonData2

private

Definition at line 212 of file rd_stdOperators.hpp.

commonData3

boost::shared_ptr<PreviousData> StdRDOperators::OpComputeSlowValue::commonData3

private

Definition at line 213 of file rd_stdOperators.hpp.

massField

std::string StdRDOperators::OpComputeSlowValue::massField

private

Definition at line 210 of file rd_stdOperators.hpp.

setOfBlock

std::map<int, BlockData> StdRDOperators::OpComputeSlowValue::setOfBlock

private

Definition at line 214 of file rd_stdOperators.hpp.

---

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

• users_modules/softmech/chemo_mech/src/rd_stdOperators.hpp