11      const std::string row_field_name, 
const std::string col_field_name,
 
   12      boost::shared_ptr<MatrixDouble> mDptr,
 
   13      boost::shared_ptr<VectorDouble> coeff_expansion_ptr);
 
   15  MoFEMErrorCode 
iNtegrate(EntitiesFieldData::EntData &row_data,
 
   16                           EntitiesFieldData::EntData &col_data);
 
   19  boost::shared_ptr<MatrixDouble> 
mDPtr;
 
 
   29                  boost::shared_ptr<MatrixDouble> strain_ptr,
 
   30                  boost::shared_ptr<VectorDouble> temp_ptr,
 
   31                  boost::shared_ptr<MatrixDouble> m_D_ptr,
 
   32                  boost::shared_ptr<VectorDouble> coeff_expansion_ptr,
 
   33                  boost::shared_ptr<MatrixDouble> stress_ptr);
 
   36                  boost::shared_ptr<VectorDouble> temp_ptr,
 
   37                  boost::shared_ptr<MatrixDouble> m_D_ptr,
 
   38                  boost::shared_ptr<VectorDouble> coeff_expansion_ptr,
 
   39                  boost::shared_ptr<double> ref_temp_ptr,
 
   40                  boost::shared_ptr<MatrixDouble> stress_ptr);
 
   42  MoFEMErrorCode 
doWork(
int side, EntityType type, 
EntData &data);
 
   47  boost::shared_ptr<MatrixDouble> 
mDPtr;
 
 
   54    const std::string row_field_name, 
const std::string col_field_name,
 
   55    boost::shared_ptr<MatrixDouble> mDptr,
 
   56    boost::shared_ptr<VectorDouble> coeff_expansion_ptr)
 
   59      mDPtr(mDptr), coeffExpansionPtr(coeff_expansion_ptr) {
 
 
   65                                     EntitiesFieldData::EntData &col_data) {
 
   68  auto &locMat = AssemblyDomainEleOp::locMat;
 
   70  const auto nb_integration_pts = row_data.getN().size1();
 
   71  const auto nb_row_base_functions = row_data.getN().size2();
 
   72  auto t_w = getFTensor0IntegrationWeight();
 
   73  auto t_row_diff_base = row_data.getFTensor1DiffN<
SPACE_DIM>();
 
   74  auto t_D = getFTensor4DdgFromMat<SPACE_DIM, SPACE_DIM, 0>(*
mDPtr);
 
   83  t_coeff_exp(
i, 
j) = 0;
 
   85    t_coeff_exp(d, d) = (*coeffExpansionPtr)[d];
 
   88  t_eigen_strain(
i, 
j) = (t_D(
i, 
j, 
k, 
l) * t_coeff_exp(
k, 
l));
 
   90  for (
auto gg = 0; gg != nb_integration_pts; ++gg) {
 
   92    double alpha = getMeasure() * t_w;
 
   94    for (; rr != AssemblyDomainEleOp::nbRows / 
SPACE_DIM; ++rr) {
 
   95      auto t_mat = getFTensor1FromMat<SPACE_DIM, 1>(locMat, rr * 
SPACE_DIM);
 
   96      auto t_col_base = col_data.getFTensor0N(gg, 0);
 
   97      for (
auto cc = 0; cc != AssemblyDomainEleOp::nbCols; cc++) {
 
  100            (t_row_diff_base(
j) * t_eigen_strain(
i, 
j)) * (t_col_base * alpha);
 
  108    for (; rr != nb_row_base_functions; ++rr)
 
 
  118    const std::string 
field_name, boost::shared_ptr<MatrixDouble> strain_ptr,
 
  119    boost::shared_ptr<VectorDouble> temp_ptr,
 
  120    boost::shared_ptr<MatrixDouble> m_D_ptr,
 
  121    boost::shared_ptr<VectorDouble> coeff_expansion_ptr,
 
  122    boost::shared_ptr<MatrixDouble> stress_ptr)
 
  124      tempPtr(temp_ptr), mDPtr(m_D_ptr), coeffExpansionPtr(coeff_expansion_ptr),
 
  125      stressPtr(stress_ptr) {
 
  127  std::fill(&doEntities[MBEDGE], &doEntities[MBMAXTYPE], 
false);
 
 
  131    boost::shared_ptr<MatrixDouble> strain_ptr,
 
  132    boost::shared_ptr<VectorDouble> temp_ptr,
 
  133    boost::shared_ptr<MatrixDouble> m_D_ptr,
 
  134    boost::shared_ptr<VectorDouble> coeff_expansion_ptr,
 
  135    boost::shared_ptr<double> ref_temp_ptr,
 
  136    boost::shared_ptr<MatrixDouble> stress_ptr)
 
  138      tempPtr(temp_ptr), mDPtr(m_D_ptr), coeffExpansionPtr(coeff_expansion_ptr),
 
  139      refTempPtr(ref_temp_ptr), stressPtr(stress_ptr) {}
 
 
  145  const auto nb_gauss_pts = getGaussPts().size2();
 
  148  auto t_D = getFTensor4DdgFromMat<SPACE_DIM, SPACE_DIM, 0>(*
mDPtr);
 
  149  auto t_strain = getFTensor2SymmetricFromMat<SPACE_DIM>(*
strainPtr);
 
  150  auto t_stress = getFTensor2SymmetricFromMat<SPACE_DIM>(*
stressPtr);
 
  151  auto t_temp = getFTensor0FromVec(*
tempPtr);
 
  159  t_coeff_exp(
i, 
j) = 0;
 
  161    t_coeff_exp(d, d) = (*coeffExpansionPtr)[d];
 
  164  for (
size_t gg = 0; gg != nb_gauss_pts; ++gg) {
 
  167        (t_strain(
k, 
l) - t_coeff_exp(
k, 
l) * (t_temp - (*refTempPtr)));
 
 
  176struct SetTargetTemperature;
 
  182template <AssemblyType A, IntegrationType I, 
typename OpBase>
 
  186template <AssemblyType A, IntegrationType I, typename OpBase>
 
  190template <AssemblyType A, IntegrationType I, typename OpBase>
 
  193    MoFEM::OpFluxRhsImpl<ThermoElasticOps::SetTargetTemperature, 1, 1, A, I,
 
  203      boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pipeline,
 
  205      boost::shared_ptr<VectorDouble> temp_ptr, std::string block_name, 
Sev sev
 
  215    auto add_op = [&](
auto &&meshset_vec_ptr) {
 
  217      for (
auto m : meshset_vec_ptr) {
 
  218        std::vector<double> block_data;
 
  219        m->getAttributes(block_data);
 
  220        if (block_data.size() < 2) {
 
  222                  "Expected two parameters");
 
  224        double target_temperature = block_data[0];
 
  227        auto ents_ptr = boost::make_shared<Range>();
 
  232            << 
"Add " << *
m << 
" target temperature " << target_temperature
 
  233            << 
" penalty " << beta;
 
  235        pipeline.push_back(
new OP_SOURCE(
 
  237            [target_temperature, beta](
double, 
double, 
double) {
 
  238              return target_temperature * beta;
 
  241        pipeline.push_back(
new OP_TEMP(
 
  243            [beta](
double, 
double, 
double) { 
return -beta; }, ents_ptr));
 
  252            (boost::format(
"%s(.*)") % block_name).str()
 
 
 
  264template <AssemblyType A, IntegrationType I, 
typename OpBase>
 
  265struct AddFluxToLhsPipelineImpl<
 
  274  static MoFEMErrorCode 
add(
 
  276      boost::ptr_deque<ForcesAndSourcesCore::UserDataOperator> &pipeline,
 
  278      boost::shared_ptr<VectorDouble> temp_ptr, std::string block_name, Sev sev
 
  283    using OP_MASS = 
typename FormsIntegrators<OpBase>::template Assembly<
 
  286    auto add_op = [&](
auto &&meshset_vec_ptr) {
 
  288      for (
auto m : meshset_vec_ptr) {
 
  289        std::vector<double> block_data;
 
  290        m->getAttributes(block_data);
 
  291        if (block_data.size() != 2) {
 
  293                  "Expected two parameters");
 
  297        auto ents_ptr = boost::make_shared<Range>();
 
  302            << 
"Add " << *
m << 
" penalty " << beta;
 
  304        pipeline.push_back(
new OP_MASS(
 
  306            [beta](
double, 
double, 
double) { 
return -beta; }, ents_ptr));
 
  313        m_field.
getInterface<MeshsetsManager>()->getCubitMeshsetPtr(std::regex(
 
  315            (boost::format(
"%s(.*)") % block_name).str()
 
 
 
#define MOFEM_TAG_AND_LOG(channel, severity, tag)
Tag and log in channel.
EntitiesFieldData::EntData EntData
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
@ MOFEM_DATA_INCONSISTENCY
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
SeverityLevel
Severity levels.
#define MOFEM_LOG_CHANNEL(channel)
Set and reset channel.
MoFEMErrorCode getCubitMeshsetPtr(const int ms_id, const CubitBCType cubit_bc_type, const CubitMeshSets **cubit_meshset_ptr) const
get cubit meshset
FTensor::Index< 'i', SPACE_DIM > i
FTensor::Index< 'l', 3 > l
FTensor::Index< 'j', 3 > j
FTensor::Index< 'k', 3 > k
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
constexpr IntegrationType I
constexpr auto field_name
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::BiLinearForm< GAUSS >::OpMass< 1, SPACE_DIM > OpMass
[Only used with Hooke equation (linear material model)]
FTensor::Index< 'm', 3 > m
static MoFEMErrorCode add(boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pipeline, MoFEM::Interface &m_field, const std::string field_name, boost::shared_ptr< VectorDouble > temp_ptr, std::string block_name, Sev sev)
AddFluxToLhsPipelineImpl()=delete
static MoFEMErrorCode add(boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pipeline, MoFEM::Interface &m_field, const std::string field_name, boost::shared_ptr< VectorDouble > temp_ptr, std::string block_name, Sev sev)
AddFluxToRhsPipelineImpl()=delete
virtual moab::Interface & get_moab()=0
Deprecated interface functions.
Interface for managing meshsets containing materials and boundary conditions.
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
boost::shared_ptr< MatrixDouble > mDPtr
OpKCauchyThermoElasticity(const std::string row_field_name, const std::string col_field_name, boost::shared_ptr< MatrixDouble > mDptr, boost::shared_ptr< VectorDouble > coeff_expansion_ptr)
boost::shared_ptr< VectorDouble > coeffExpansionPtr
MoFEMErrorCode iNtegrate(EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
DEPRECATED OpStressThermal(const std::string field_name, boost::shared_ptr< MatrixDouble > strain_ptr, boost::shared_ptr< VectorDouble > temp_ptr, boost::shared_ptr< MatrixDouble > m_D_ptr, boost::shared_ptr< VectorDouble > coeff_expansion_ptr, boost::shared_ptr< MatrixDouble > stress_ptr)
boost::shared_ptr< VectorDouble > coeffExpansionPtr
MoFEMErrorCode doWork(int side, EntityType type, EntData &data)
[Calculate stress]
boost::shared_ptr< MatrixDouble > strainPtr
boost::shared_ptr< MatrixDouble > stressPtr
boost::shared_ptr< double > refTempPtr
boost::shared_ptr< VectorDouble > tempPtr
boost::shared_ptr< MatrixDouble > mDPtr