Classes
struct	BoundaryBCs

struct	CommonData
	[Common data] More...

struct	DomainBCs

struct	Monitor

struct	OpAssembleTraction

struct	OpConstrainBoundaryLhs_dTraction

struct	OpConstrainBoundaryLhs_dU

struct	OpConstrainBoundaryRhs

struct	PostProcEleByDim

struct	PostProcEleByDim< 2 >

struct	PostProcEleByDim< 3 >

Typedefs
using	DomainRhsBCs = NaturalBC< DomainEleOp >::Assembly< A >::LinearForm< I >

using	OpDomainRhsBCs = DomainRhsBCs::OpFlux< DomainBCs, 1, SPACE_DIM >

using	BoundaryRhsBCs = NaturalBC< BoundaryEleOp >::Assembly< A >::LinearForm< I >

using	OpBoundaryRhsBCs = BoundaryRhsBCs::OpFlux< BoundaryBCs, 1, SPACE_DIM >

using	BoundaryLhsBCs = NaturalBC< BoundaryEleOp >::Assembly< A >::BiLinearForm< I >

using	OpBoundaryLhsBCs = BoundaryLhsBCs::OpFlux< BoundaryBCs, 1, SPACE_DIM >

using	PostProcEleDomain = PostProcEleByDim< SPACE_DIM >::PostProcEleDomain

using	SideEle = PostProcEleByDim< SPACE_DIM >::SideEle

using	PostProcEleBdy = PostProcEleByDim< SPACE_DIM >::PostProcEleBdy

Functions
MoFEMErrorCode	addMatBlockOps (MoFEM::Interface &m_field, boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pipeline, std::string field_name, std::string block_name, boost::shared_ptr< MatrixDouble > mat_D_Ptr, Sev sev)

template<typename T1 , typename T2 >
double	surface_distance_function (double t, FTensor::Tensor1< T1, 3 > &t_coords, FTensor::Tensor1< T2, SPACE_DIM > &t_traction)

template<typename T1 , typename T2 >
FTensor::Tensor1< double, 3 >	grad_surface_distance_function (double t, FTensor::Tensor1< T1, 3 > &t_coords, FTensor::Tensor1< T2, SPACE_DIM > &t_traction)

template<typename T1 , typename T2 >
FTensor::Tensor2_symmetric< double, 3 >	hess_surface_distance_function (double t, FTensor::Tensor1< T1, 3 > &t_coords, FTensor::Tensor1< T2, SPACE_DIM > &t_traction)

double	sign (double x)

double	w (const double sdf, const double tn)

double	constrain (double sdf, double tn)

Variables
FTensor::Index< 'i', SPACE_DIM >	i
	[Common data] More...

FTensor::Index< 'j', SPACE_DIM >	j

FTensor::Index< 'k', SPACE_DIM >	k

FTensor::Index< 'l', SPACE_DIM >	l

Typedef Documentation

◆ BoundaryLhsBCs

using ContactOps::BoundaryLhsBCs = typedef NaturalBC<BoundaryEleOp>::Assembly<A>::BiLinearForm<I>

Definition at line 104 of file contact.cpp.

◆ BoundaryRhsBCs

using ContactOps::BoundaryRhsBCs = typedef NaturalBC<BoundaryEleOp>::Assembly<A>::LinearForm<I>

Definition at line 102 of file contact.cpp.

◆ DomainRhsBCs

using ContactOps::DomainRhsBCs = typedef NaturalBC<DomainEleOp>::Assembly<A>::LinearForm<I>

Definition at line 100 of file contact.cpp.

◆ OpBoundaryLhsBCs

using ContactOps::OpBoundaryLhsBCs = typedef BoundaryLhsBCs::OpFlux<BoundaryBCs, 1, SPACE_DIM>

Definition at line 105 of file contact.cpp.

◆ OpBoundaryRhsBCs

using ContactOps::OpBoundaryRhsBCs = typedef BoundaryRhsBCs::OpFlux<BoundaryBCs, 1, SPACE_DIM>

Definition at line 103 of file contact.cpp.

◆ OpDomainRhsBCs

using ContactOps::OpDomainRhsBCs = typedef DomainRhsBCs::OpFlux<DomainBCs, 1, SPACE_DIM>

Definition at line 101 of file contact.cpp.

◆ PostProcEleBdy

using ContactOps::PostProcEleBdy = typedef PostProcEleByDim<SPACE_DIM>::PostProcEleBdy

Definition at line 26 of file PostProcContact.hpp.

◆ PostProcEleDomain

using ContactOps::PostProcEleDomain = typedef PostProcEleByDim<SPACE_DIM>::PostProcEleDomain

Definition at line 24 of file PostProcContact.hpp.

◆ SideEle

using ContactOps::SideEle = typedef PostProcEleByDim<SPACE_DIM>::SideEle

Definition at line 25 of file PostProcContact.hpp.

Function Documentation

◆ addMatBlockOps()

MoFEMErrorCode ContactOps::addMatBlockOps	(	MoFEM::Interface &	m_field,
		boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &	pipeline,
		std::string	field_name,
		std::string	block_name,
		boost::shared_ptr< MatrixDouble >	mat_D_Ptr,
		Sev	sev
	)

[Calculate elasticity tensor]

Definition at line 755 of file contact.cpp.

                                                      {
  MoFEMFunctionBegin;
 
  struct OpMatBlocks : public DomainEleOp {
    OpMatBlocks(std::string field_name, boost::shared_ptr<MatrixDouble> m,
                double bulk_modulus_K, double shear_modulus_G,
                MoFEM::Interface &m_field, Sev sev,
                std::vector<const CubitMeshSets *> meshset_vec_ptr)
        : DomainEleOp(field_name, DomainEleOp::OPROW), matDPtr(m),
          bulkModulusKDefault(bulk_modulus_K),
          shearModulusGDefault(shear_modulus_G) {
      std::fill(&(doEntities[MBEDGE]), &(doEntities[MBMAXTYPE]), false);
      CHK_THROW_MESSAGE(extractBlockData(m_field, meshset_vec_ptr, sev),
                        "Can not get data from block");
    }
 
    MoFEMErrorCode doWork(int side, EntityType type,
                          EntitiesFieldData::EntData &data) {
      MoFEMFunctionBegin;
 
      for (auto &b : blockData) {
 
        if (b.blockEnts.find(getFEEntityHandle()) != b.blockEnts.end()) {
          CHKERR getMatDPtr(matDPtr, b.bulkModulusK, b.shearModulusG);
          MoFEMFunctionReturnHot(0);
        }
      }
 
      CHKERR getMatDPtr(matDPtr, bulkModulusKDefault, shearModulusGDefault);
      MoFEMFunctionReturn(0);
    }
 
  private:
    boost::shared_ptr<MatrixDouble> matDPtr;
 
    struct BlockData {
      double bulkModulusK;
      double shearModulusG;
      Range blockEnts;
    };
 
    double bulkModulusKDefault;
    double shearModulusGDefault;
    std::vector<BlockData> blockData;
 
    MoFEMErrorCode
    extractBlockData(MoFEM::Interface &m_field,
                     std::vector<const CubitMeshSets *> meshset_vec_ptr,
                     Sev sev) {
      MoFEMFunctionBegin;
 
      for (auto m : meshset_vec_ptr) {
        MOFEM_TAG_AND_LOG("WORLD", sev, "MatBlock") << *m;
        std::vector<double> block_data;
        CHKERR m->getAttributes(block_data);
        if (block_data.size() != 2) {
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                  "Expected that block has two attribute");
        }
        auto get_block_ents = [&]() {
          Range ents;
          CHKERR
          m_field.get_moab().get_entities_by_handle(m->meshset, ents, true);
          return ents;
        };
 
        double young_modulus = block_data[0];
        double poisson_ratio = block_data[1];
        double bulk_modulus_K = young_modulus / (3 * (1 - 2 * poisson_ratio));
        double shear_modulus_G = young_modulus / (2 * (1 + poisson_ratio));
 
        MOFEM_TAG_AND_LOG("WORLD", sev, "MatBlock")
            << "E = " << young_modulus << " nu = " << poisson_ratio;
 
        blockData.push_back(
            {bulk_modulus_K, shear_modulus_G, get_block_ents()});
      }
      MOFEM_LOG_CHANNEL("WORLD");
      MoFEMFunctionReturn(0);
    }
 
    MoFEMErrorCode getMatDPtr(boost::shared_ptr<MatrixDouble> mat_D_ptr,
                              double bulk_modulus_K, double shear_modulus_G) {
      MoFEMFunctionBegin;
      //! [Calculate elasticity tensor]
      auto set_material_stiffness = [&]() {
        FTensor::Index<'i', SPACE_DIM> i;
        FTensor::Index<'j', SPACE_DIM> j;
        FTensor::Index<'k', SPACE_DIM> k;
        FTensor::Index<'l', SPACE_DIM> l;
        constexpr auto t_kd = FTensor::Kronecker_Delta_symmetric<int>();
        double A = (SPACE_DIM == 2)
                       ? 2 * shear_modulus_G /
                             (bulk_modulus_K + (4. / 3.) * shear_modulus_G)
                       : 1;
        auto t_D = getFTensor4DdgFromMat<SPACE_DIM, SPACE_DIM, 0>(*mat_D_ptr);
        t_D(i, j, k, l) =
            2 * shear_modulus_G * ((t_kd(i, k) ^ t_kd(j, l)) / 4.) +
            A * (bulk_modulus_K - (2. / 3.) * shear_modulus_G) * t_kd(i, j) *
                t_kd(k, l);
      };
      //! [Calculate elasticity tensor]
      constexpr auto size_symm = (SPACE_DIM * (SPACE_DIM + 1)) / 2;
      mat_D_ptr->resize(size_symm * size_symm, 1);
      set_material_stiffness();
      MoFEMFunctionReturn(0);
    }
  };
 
  double bulk_modulus_K = young_modulus / (3 * (1 - 2 * poisson_ratio));
  double shear_modulus_G = young_modulus / (2 * (1 + poisson_ratio));
  pipeline.push_back(new OpMatBlocks(
      field_name, mat_D_Ptr, bulk_modulus_K, shear_modulus_G, m_field, sev,
 
      // Get blockset using regular expression
      m_field.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(std::regex(
 
          (boost::format("%s(.*)") % block_name).str()
 
              ))
 
          ));
 
  MoFEMFunctionReturn(0);
}

◆ constrain()

double ContactOps::constrain	(	double	sdf,
		double	tn
	)

inline

Examples: ContactOps.hpp.

Definition at line 268 of file ContactOps.hpp.

                                               {
  const auto s = sign(w(sdf, tn));
  return (1 - s) / 2;
}

◆ grad_surface_distance_function()

template<typename T1 , typename T2 >

FTensor::Tensor1< double, 3 > ContactOps::grad_surface_distance_function	(	double	t,
		FTensor::Tensor1< T1, 3 > &	t_coords,
		FTensor::Tensor1< T2, SPACE_DIM > &	t_traction
	)

inline

Examples: ContactOps.hpp.

Definition at line 221 of file ContactOps.hpp.

                                                                          {
#ifdef PYTHON_SFD
  if (auto sdf_ptr = sdfPythonWeakPtr.lock()) {
    std::vector<double> grad_sdf;
    CHK_MOAB_THROW(
        sdf_ptr->evalGradSdf(t, t_coords(0), t_coords(1), t_coords(2),
                             t_traction(0), t_traction(1),
                             (SPACE_DIM == 3) ? t_traction(2) : 0, grad_sdf),
        "Failed python call");
    return FTensor::Tensor1<double, 3>{grad_sdf[0], grad_sdf[1], grad_sdf[2]};
  }
#endif
  return FTensor::Tensor1<double, 3>{0., 1., 0.};
};

◆ hess_surface_distance_function()

template<typename T1 , typename T2 >

FTensor::Tensor2_symmetric< double, 3 > ContactOps::hess_surface_distance_function	(	double	t,
		FTensor::Tensor1< T1, 3 > &	t_coords,
		FTensor::Tensor1< T2, SPACE_DIM > &	t_traction
	)

inline

Examples: ContactOps.hpp.

Definition at line 239 of file ContactOps.hpp.

                                                                          {
#ifdef PYTHON_SFD
  if (auto sdf_ptr = sdfPythonWeakPtr.lock()) {
    std::vector<double> hess_sdf;
    CHK_MOAB_THROW(
        sdf_ptr->evalHessSdf(t, t_coords(0), t_coords(1), t_coords(2),
                             t_traction(0), t_traction(1),
                             (SPACE_DIM == 3) ? t_traction(2) : 0, hess_sdf),
        "Failed python call");
    return FTensor::Tensor2_symmetric<double, 3>{hess_sdf[0], hess_sdf[1],
                                                 hess_sdf[2], hess_sdf[3],
                                                 hess_sdf[4], hess_sdf[5]};
  }
#endif
  return FTensor::Tensor2_symmetric<double, 3>{0., 0., 0., 0., 0., 0.};
};

◆ sign()

double ContactOps::sign ( double x )

inline

Examples: ContactOps.hpp.

Definition at line 257 of file ContactOps.hpp.

                             {
  if (x == 0)
    return 0;
  else if (x > 0)
    return 1;
  else
    return -1;
};

◆ surface_distance_function()

template<typename T1 , typename T2 >

double ContactOps::surface_distance_function	(	double	t,
		FTensor::Tensor1< T1, 3 > &	t_coords,
		FTensor::Tensor1< T2, SPACE_DIM > &	t_traction
	)

inline

Examples: ContactOps.hpp.

Definition at line 204 of file ContactOps.hpp.

                                                                     {
#ifdef PYTHON_SFD
  if (auto sdf_ptr = sdfPythonWeakPtr.lock()) {
    double sdf;
    CHK_MOAB_THROW(sdf_ptr->evalSdf(t, t_coords(0), t_coords(1), t_coords(2),
                                    t_traction(0), t_traction(1),
                                    (SPACE_DIM == 3) ? t_traction(2) : 0, sdf),
                   "Failed python call");
    return sdf;
  }
#endif
  return t_coords(1) + 0.5;
};