MoFEM::DataOperator Struct Reference

base operator to do operations at Gauss Pt. level More...

#include <src/finite_elements/DataOperators.hpp>

Inheritance diagram for MoFEM::DataOperator:

Collaboration diagram for MoFEM::DataOperator:

Public Member Functions
	DataOperator (const bool symm=true)
virtual	~DataOperator ()=default
virtual MoFEMErrorCode	doWork (int row_side, int col_side, EntityType row_type, EntityType col_type, DataForcesAndSourcesCore::EntData &row_data, DataForcesAndSourcesCore::EntData &col_data)
	Operator for bi-linear form, usually to calculate values on left hand side. More...
virtual MoFEMErrorCode	opLhs (DataForcesAndSourcesCore &row_data, DataForcesAndSourcesCore &col_data)
virtual MoFEMErrorCode	doWork (int side, EntityType type, DataForcesAndSourcesCore::EntData &data)
	Operator for linear form, usually to calculate values on right hand side. More...
virtual MoFEMErrorCode	opRhs (DataForcesAndSourcesCore &data, const bool error_if_no_base=false)
bool	getSymm () const
	Get if operator uses symmetry of DOFs or not. More...
void	setSymm ()
	set if operator is executed taking in account symmetry More...
void	unSetSymm ()
	unset if operator is executed for non symmetric problem More...

Public Attributes
bool	sYmm
	If true assume that matrix is symmetric structure. More...
std::array< bool, MBMAXTYPE >	doEntities
	If true operator is executed for entity. More...
bool &	doVertices
	\deprectaed If false skip vertices More...
bool &	doEdges
	\deprectaed If false skip edges More...
bool &	doQuads
	\deprectaed More...
bool &	doTris
	\deprectaed More...
bool &	doTets
	\deprectaed More...
bool &	doPrisms
	\deprectaed More...

Private Member Functions
template<bool Symm>
MoFEMErrorCode	opLhs (DataForcesAndSourcesCore &row_data, DataForcesAndSourcesCore &col_data)
template<bool ErrorIfNoBase>
MoFEMErrorCode	opRhs (DataForcesAndSourcesCore &data, const std::array< bool, MBMAXTYPE > &do_entities)

Detailed Description

base operator to do operations at Gauss Pt. level

Definition at line 36 of file DataOperators.hpp.

Constructor & Destructor Documentation

DataOperator()

MoFEM::DataOperator::DataOperator

(

const bool

symm = true

)

Definition at line 33 of file DataOperators.cpp.

    :

      sYmm(symm),

      doEntities{true, true, true, true, true, true,
                 true, true, true, true, true, true},

      doVertices(doEntities[MBVERTEX]), doEdges(doEntities[MBEDGE]),
      doQuads(doEntities[MBQUAD]), doTris(doEntities[MBTRI]),
      doTets(doEntities[MBTET]), doPrisms(doEntities[MBPRISM]) {

  /// This not yet implemented, switch off.
  doEntities[MBPOLYGON] = false;
  doEntities[MBPYRAMID] = false;
  doEntities[MBKNIFE] = false;
  doEntities[MBHEX] = false;
  doEntities[MBPOLYHEDRON] = false;
}

~DataOperator()

virtual MoFEM::DataOperator::~DataOperator ( )

virtualdefault

Member Function Documentation

doWork() [1/2]

virtual MoFEMErrorCode MoFEM::DataOperator::doWork ( int  row_side, int  col_side, EntityType  row_type, EntityType  col_type, DataForcesAndSourcesCore::EntData &  row_data, DataForcesAndSourcesCore::EntData &  col_data  )

virtual

Operator for bi-linear form, usually to calculate values on left hand side.

Reimplemented in ReactionDiffusion::OpAssembleLhsVV, ReactionDiffusion::OpAssembleLhsVTau, ElecPhys::OpDamp_dofs_to_field_data, ElectroPhysiology::OpAssembleLhsVV, ElecPhys::OpAssembleLhsVV, ReactionDiffusion::OpAssembleLhsTauV< dim >, ElectroPhysiology::OpAssembleLhsVTau, ElecPhys::OpAssembleLhsVTau, ElectroPhysiology::OpAssembleLhsVV, ReactionDiffusion::OpAssembleLhsTauTau< dim >, ElecPhys::OpAssembleLhsTauV< dim >, ElectroPhysiology::OpAssembleLhsTauV< dim >, ElectroPhysiology::OpAssembleLhsVTau, ElecPhys::OpAssembleLhsTauTau< dim >, ElectroPhysiology::OpAssembleLhsTauV< dim >, ElectroPhysiology::OpAssembleLhsTauTau< dim >, ElectroPhysiology::OpAssembleLhsTauTau< dim >, StdRDOperators::OpAssembleStiffLhs< DIM >, OpAssemble, UFOperators2D::OpAssembleStiffLhs, UFOperators::OpAssembleStiffLhs< DIM >, OpCalculateMassMatrix, ReactionDiffusionEquation::OpAssembleStiffLhs< DIM >, OpPlasticTools::OpCalculateContrainsLhs_dTAU, OpPlasticTools::OpCalculateContrainsLhs_dU, MyOp2, OpPlasticTools::OpCalculatePlasticFlowLhs_dTAU, OpPlasticTools::OpCalculatePlasticFlowLhs_dU, OpContactTools::OpConstrainDomainLhs_dU, CallingOp, OpAssembleMat, OpFace, PrismOpLhs, OpContactTools::OpSpringLhs, QuadOpLhs, StdRDOperators::OpAssembleMass, OpElasticTools::OpStiffnessMatrixLhs, MyOp, OpContactTools::OpConstrainBoundaryLhs_dTraction, ReactionDiffusionEquation::OpAssembleMass, OpRowCol, OpVolume, OpAssembleMat, OpContactTools::OpConstrainBoundaryLhs_dU, and PoissonOps::OpLhsUU.

Definition at line 45 of file DataOperators.hpp.

                                                                           {
    MoFEMFunctionBeginHot;
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
    MoFEMFunctionReturnHot(0);
  }

doWork() [2/2]

virtual MoFEMErrorCode MoFEM::DataOperator::doWork ( int  side, EntityType  type, DataForcesAndSourcesCore::EntData &  data  )

virtual

Operator for linear form, usually to calculate values on right hand side.

Reimplemented in FractureMechanics::OpPrint, MoFEM::OpSetInvJacH1ForFlatPrism, MoFEM::OpCalculateInvJacForFlatPrism, MoFEM::OpSetInvJacH1ForFatPrism, MoFEM::OpCalculateInvJacForFatPrism, MoFEM::OpMultiplyDeterminantOfJacobianAndWeightsForFatPrisms, MoFEM::OpSetContrariantPiolaTransformOnEdge, MoFEM::OpSetContravariantPiolaTransformFace, MoFEM::OpMakeHdivFromHcurl, MoFEM::OpSetInvJacHcurlFace, MoFEM::OpSetInvJacH1ForFace, MoFEM::OpCalculateInvJacForFace, MoFEM::OpCalculateJacForFace, MoFEM::OpCalculateHVecTensorDivergence< Tensor_Dim0, Tensor_Dim1 >, MoFEM::OpCalculateHTensorTensorField< Tensor_Dim0, Tensor_Dim1 >, MoFEM::OpCalculateHVecTensorField< Tensor_Dim0, Tensor_Dim1 >, MoFEM::OpCalculateHcurlVectorCurl< Tensor_Dim >, MoFEM::OpCalculateHdivVectorDivergence< Tensor_Dim1, Tensor_Dim2 >, MoFEM::OpCalculateHdivVectorField_General< Tensor_Dim, double, ublas::row_major, DoubleAllocator >, MoFEM::OpCalculateHdivVectorField_General< Tensor_Dim0, T, L, A >, MoFEM::OpCalculateVectorFieldGradientDot< Tensor_Dim0, Tensor_Dim1 >, ReactionDiffusion::OpError, MoFEM::OpCalculateVectorFieldGradient_General< Tensor_Dim0, Tensor_Dim1, double, ublas::row_major, DoubleAllocator >, OpContactTools::OpPostProcContact, MoFEM::OpCalculateScalarFieldGradient_General< Tensor_Dim, double, ublas::row_major, DoubleAllocator >, MoFEM::OpCalculateTensor2SymmetricFieldValuesDot< Tensor_Dim >, MoFEM::OpCalculateTensor2SymmetricFieldValues< Tensor_Dim >, ReactionDiffusion::OpAssembleStiffRhsV< dim >, MoFEM::OpCalculateTensor2FieldValuesDot< Tensor_Dim0, Tensor_Dim1 >, MoFEM::OpSetCovariantPiolaTransformOnEdge, StdRDOperators::OpError, OpAleLhsPre_dX_dx< S >, ElecPhys::OpAssembleStiffRhsV< dim >, MoFEM::OpGetHoTangentOnEdge, MoFEM::OpSetCovariantPiolaTransformOnFace, ReactionDiffusion::OpAssembleStiffRhsTau< dim >, MoFEM::OpSetContravariantPiolaTransformOnFace, ElectroPhysiology::OpAssembleStiffRhsV< dim >, StdRDOperators::OpAssembleNaturalBCRhs, MoFEM::OpGetCoordsAndNormalsOnPrism, MoFEM::OpCalculateTensor2FieldValues_General< Tensor_Dim0, Tensor_Dim1, double, ublas::row_major, DoubleAllocator >, ElectroPhysiology::OpAssembleStiffRhsV< dim >, ReactionDiffusion::OpAssembleNaturalBCRhsTau, MoFEM::OpGetCoordsAndNormalsOnFace, MoFEM::OpCalculateTensor2FieldValues_General< Tensor_Dim0, Tensor_Dim1, T, L, A >, ElecPhys::OpAssembleStiffRhsTau< dim >, ElectroPhysiology::OpAssembleStiffRhsTau< dim >, ElectroPhysiology::OpAssembleStiffRhsTau< dim >, ReactionDiffusion::OpAssembleSlowRhsV, MoFEM::OpCalculateVectorFieldValuesDot< Tensor_Dim >, OpAssemble, MoFEM::OpGetDataAndGradient< RANK, DIM >, MoFEM::OpGetDataAndGradient< 3, 3 >, UFOperators2D::OpAssembleNaturalBCRhs, UFOperators::OpAssembleNaturalBCRhs, OpCalculateStiffnessScaledByDensityField, ElecPhys::OpAssembleSlowRhsV, ReactionDiffusion::OpInitialMass, ElectroPhysiology::OpAssembleSlowRhsV, StdRDOperators::OpAssembleStiffRhs< DIM >, MoFEM::OpSetCovariantPiolaTransform, ElectroPhysiology::OpAssembleSlowRhsV, MoFEM::OpCalculateVectorFieldValues_General< Tensor_Dim, double, ublas::row_major, DoubleAllocator >, MoFEM::OpSetHoCovariantPiolaTransform, ElecPhys::OpInitialMass, ReactionDiffusion::OpSkeletonSource, MoFEM::OpSetHoContravariantPiolaTransform, MoFEM::OpCalculateVectorFieldValues_General< Tensor_Dim, T, L, A >, StdRDOperators::OpAssembleSlowRhs, MoFEM::OpSetContravariantPiolaTransform, ElectroPhysiology::OpSolveRecovery, ElectroPhysiology::OpSolveRecovery, OpCheckValsDiffVals, OpCalculateHomogeneousStiffness< S >, OpCalculateEshelbyStress, MoFEM::OpSetHoInvJacHdivAndHcurl, OpCheckValsDiffVals, OpCalculateEnergy, ReactionDiffusion::OpEssentialBC, UFOperators::OpAssembleStiffRhs< DIM >, UFOperators2D::OpAssembleStiffRhs, MoFEM::OpSetHoInvJacH1, ElecPhys::OpEssentialBC, OpCalculateStress< S >, OpValsDiffVals, ReactionDiffusionEquation::OpAssembleStiffRhs< DIM >, ElectroPhysiology::OpInitialMass, MoFEM::OpSetInvJacHdivAndHcurl, MoFEM::OpCalculateScalarFieldValuesDot, ElectroPhysiology::OpInitialMass, OpCalculateStrainAle, MyOp2, OpCalculateStrain< D >, OpAssembleVec, MoFEM::OpSetInvJacH1, OpValsDiffVals, Example::OpSecond, StdRDOperators::OpComputeSlowValue, OpVolumeSide, ReactionDiffusionEquation::OpAssembleSlowRhs, Example::OpFirst, OpContactTools::OpConstrainDomainRhs, Example::OpZero, OpPlasticTools::OpCalculateContrainsRhs, AnalyticalDirichletBC::ApproxField::OpRhs< FUNEVAL >, CallingOp, MoFEM::OpCalculateScalarFieldValues, OpContactTools::OpConstrainBoundaryTraction, OpPlasticTools::OpCalculatePlasticFlowRhs, ReactionDiffusion::OpComputeSlowValue, OpAssembleVec, OpFace, OpElasticTools::OpPostProcElastic, OpPlasticTools::OpPlasticStress, Example::OpError, ElectroPhysiology::OpEssentialBC, PrismOpRhs, OpVolume, OpPlasticTools::OpCalculatePlasticSurface, PoissonOps::OpRhsU, OpContactTools::OpSpringRhs, QuadOpRhs, Example::OpError, OpFace, PrismOpCheck, OpElasticTools::OpForceRhs, QuadOpCheck, PrismOp, ElectroPhysiology::OpEssentialBC, MoFEM::OpCalculateScalarFieldValues_General< T, A >, MoFEM::OpCalculateScalarFieldValues_General< double, DoubleAllocator >, OpElasticTools::OpInternalForceRhs, SkeletonFE::OpFaceSide, SkeletonFE::OpFaceSide, OpElasticTools::OpStress, OpDivergence, OpContactTools::OpConstrainBoundaryRhs, OpTetCurl, OpFace, OpTetDivergence, OpElasticTools::OpStrain, MyOp, OpRow, OpVolume, OpContactTools::OpInternalDomainContactRhs, and OpCheck.

Definition at line 60 of file DataOperators.hpp.

                                                                       {
    MoFEMFunctionBeginHot;
    SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED, "not implemented");
    MoFEMFunctionReturnHot(0);
  }

getSymm()

bool MoFEM::DataOperator::getSymm

(

)

const

Get if operator uses symmetry of DOFs or not.

If symmetry is used, only not repeating combinations of entities are looped. For an example pair of (Vertex, Edge_0) and (Edge_0, Vertex) will calculate the same matrices only transposed. Implementing that this can be exploited by integrating only one pair.

Returns

true if symmetry

Definition at line 95 of file DataOperators.hpp.

{ return sYmm; }

opLhs() [1/2]

MoFEMErrorCode MoFEM::DataOperator::opLhs ( DataForcesAndSourcesCore &  row_data, DataForcesAndSourcesCore &  col_data  )

virtual

Definition at line 111 of file DataOperators.cpp.

                                                                       {
  if (getSymm())
    return opLhs<true>(row_data, col_data);
  else
    return opLhs<false>(row_data, col_data);
}

opLhs() [2/2]

template<bool Symm>

MoFEMErrorCode MoFEM::DataOperator::opLhs ( DataForcesAndSourcesCore &  row_data, DataForcesAndSourcesCore &  col_data  )

private

Definition at line 54 of file DataOperators.cpp.

                                                                       {
  MoFEMFunctionBeginHot;

  auto do_col_entity =
      [&](boost::ptr_vector<DataForcesAndSourcesCore::EntData> &row_ent_data,
          const int ss, const EntityType row_type, const EntityType low_type,
          const EntityType hi_type) {
        MoFEMFunctionBegin;
        for (EntityType col_type = low_type; col_type != hi_type; ++col_type) {
          auto &col_ent_data = col_data.dataOnEntities[col_type];
          for (size_t SS = 0; SS != col_ent_data.size(); SS++) {
            if (col_ent_data[SS].getFieldData().size())
              CHKERR doWork(ss, SS, row_type, col_type, row_ent_data[ss],
                            col_ent_data[SS]);
          }
        }
        MoFEMFunctionReturn(0);
      };

  auto do_row_entity = [&](const EntityType type) {
    MoFEMFunctionBegin;
    auto &row_ent_data = row_data.dataOnEntities[type];
    for (size_t ss = 0; ss != row_ent_data.size(); ++ss) {
      size_t SS = 0;
      if (Symm)
        SS = ss;
      for (; SS < col_data.dataOnEntities[type].size(); SS++) {
        CHKERR doWork(ss, SS, type, type, row_ent_data[ss],
                      col_data.dataOnEntities[type][SS]);
      }
      if (!Symm)
        CHKERR do_col_entity(row_ent_data, ss, type, MBVERTEX, type);
      CHKERR do_col_entity(row_ent_data, ss, type,
                           static_cast<EntityType>(type + 1), MBMAXTYPE);
    }
    MoFEMFunctionReturn(0);
  };

  for (EntityType row_type = MBVERTEX; row_type != MBENTITYSET; ++row_type) {
    if (doEntities[row_type]) {
      CHKERR do_row_entity(row_type);
    }
  }

  if (doEntities[MBENTITYSET]) {
    for (unsigned int mm = 0; mm != row_data.dataOnEntities[MBENTITYSET].size();
         ++mm) {
      if (!row_data.dataOnEntities[MBENTITYSET][mm].getFieldData().empty()) {
        CHKERR do_row_entity(MBENTITYSET);
      }
    }
  }

  MoFEMFunctionReturnHot(0);
}

opRhs() [1/2]

MoFEMErrorCode MoFEM::DataOperator::opRhs ( DataForcesAndSourcesCore &  data, const bool  error_if_no_base = false  )

virtual

Definition at line 171 of file DataOperators.cpp.

                                                                {
  if (error_if_no_base)
    return opRhs<true>(data, doEntities);
  else
    return opRhs<false>(data, doEntities);
}

opRhs() [2/2]

template<bool ErrorIfNoBase>

MoFEMErrorCode MoFEM::DataOperator::opRhs ( DataForcesAndSourcesCore &  data, const std::array< bool, MBMAXTYPE > &  do_entities  )

private

Definition at line 121 of file DataOperators.cpp.

                                                                  {
  MoFEMFunctionBegin;

  auto do_entity = [&](auto type) {
    MoFEMFunctionBegin;

    auto &ent_data = data.dataOnEntities[type];
    const size_t size = ent_data.size();
    for (size_t ss = 0; ss != size; ++ss) {

      auto &side_data = ent_data[ss];

      if (ErrorIfNoBase) {
        if (side_data.getFieldData().size() &&
            (side_data.getBase() == NOBASE ||
             side_data.getBase() == LASTBASE)) {
          for (VectorDofs::iterator it = side_data.getFieldDofs().begin();
               it != side_data.getFieldDofs().end(); it++)
            if ((*it) && (*it)->getActive())
              SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "No base on");
        }
      }

      CHKERR doWork(ss, type, side_data);
    }

    MoFEMFunctionReturn(0);
  };

  for (EntityType row_type = MBVERTEX; row_type != MBENTITYSET; ++row_type) {
    if (do_entities[row_type]) {
      CHKERR do_entity(row_type);
    }
  }

  if (do_entities[MBENTITYSET]) {
    // This is odd behaviour, diffrent than for other entities. Should be
    // changed that behaviour is consistent,
    for (unsigned int mm = 0; mm != data.dataOnEntities[MBENTITYSET].size();
         ++mm) {
      if (!data.dataOnEntities[MBENTITYSET][mm].getFieldData().empty()) {
        CHKERR doWork(mm, MBENTITYSET, data.dataOnEntities[MBENTITYSET][mm]);
      }
    }
  }

  MoFEMFunctionReturn(0);
}

setSymm()

void MoFEM::DataOperator::setSymm

(

)

set if operator is executed taking in account symmetry

Definition at line 98 of file DataOperators.hpp.

{ sYmm = true; }

unSetSymm()

void MoFEM::DataOperator::unSetSymm

(

)

unset if operator is executed for non symmetric problem

Definition at line 101 of file DataOperators.hpp.

{ sYmm = false; }

Member Data Documentation

doEdges

bool& MoFEM::DataOperator::doEdges

\deprectaed If false skip edges

Examples

ElasticityMixedFormulation.hpp.

Definition at line 79 of file DataOperators.hpp.

doEntities

std::array<bool, MBMAXTYPE> MoFEM::DataOperator::doEntities

If true operator is executed for entity.

Definition at line 73 of file DataOperators.hpp.

doPrisms

bool& MoFEM::DataOperator::doPrisms

\deprectaed

Examples

ElasticityMixedFormulation.hpp.

Definition at line 83 of file DataOperators.hpp.

doQuads

bool& MoFEM::DataOperator::doQuads

\deprectaed

Examples

ElasticityMixedFormulation.hpp.

Definition at line 80 of file DataOperators.hpp.

doTets

bool& MoFEM::DataOperator::doTets

\deprectaed

Examples

ElasticityMixedFormulation.hpp.

Definition at line 82 of file DataOperators.hpp.

doTris

bool& MoFEM::DataOperator::doTris

\deprectaed

Examples

ElasticityMixedFormulation.hpp.

Definition at line 81 of file DataOperators.hpp.

doVertices

bool& MoFEM::DataOperator::doVertices

\deprectaed If false skip vertices

Examples

ElasticityMixedFormulation.hpp.

Definition at line 78 of file DataOperators.hpp.

sYmm

bool MoFEM::DataOperator::sYmm

If true assume that matrix is symmetric structure.

Examples

MagneticElement.hpp, PoissonOperators.hpp, and UnsaturatedFlow.hpp.

Definition at line 70 of file DataOperators.hpp.

---

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

• src/finite_elements/DataOperators.hpp
• src/finite_elements/impl/DataOperators.cpp