EshelbianPlasticity::MatPhysicalEquations::OpCalculateHelmholtzFreeEnergy Struct Reference

Inheritance diagram for EshelbianPlasticity::MatPhysicalEquations::OpCalculateHelmholtzFreeEnergy:

Collaboration diagram for EshelbianPlasticity::MatPhysicalEquations::OpCalculateHelmholtzFreeEnergy:

Public Member Functions
	OpCalculateHelmholtzFreeEnergy (boost::shared_ptr< DataAtIntegrationPts > data_ptr, boost::shared_ptr< MatOps::MatElastic > physics_ptr, boost::shared_ptr< double > total_helmholtz_free_energy_ptr)
MoFEMErrorCode	doWork (int side, EntityType type, EntData &data)

Private Attributes
boost::shared_ptr< DataAtIntegrationPts >	dataAtPts
boost::shared_ptr< MatOps::MatElastic >	physicsPtr
boost::shared_ptr< double >	totalHelmholtzFreeEnergyPtr

Detailed Description

Definition at line 50 of file EshelbianMatCore.cpp.

Constructor & Destructor Documentation

OpCalculateHelmholtzFreeEnergy()

EshelbianPlasticity::MatPhysicalEquations::OpCalculateHelmholtzFreeEnergy::OpCalculateHelmholtzFreeEnergy ( boost::shared_ptr< DataAtIntegrationPts >  data_ptr, boost::shared_ptr< MatOps::MatElastic >  physics_ptr, boost::shared_ptr< double >  total_helmholtz_free_energy_ptr  )

inline

Definition at line 52 of file EshelbianMatCore.cpp.

        : VolUserDataOperator(NOSPACE, OPSPACE), dataAtPts(data_ptr),
          physicsPtr(physics_ptr),
          totalHelmholtzFreeEnergyPtr(total_helmholtz_free_energy_ptr) {
      if (!dataAtPts)
        CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                          "Mat core energy data is not allocated");
      if (!physicsPtr)
        CHK_THROW_MESSAGE(MOFEM_DATA_INCONSISTENCY,
                          "Mat core physical equations are not allocated");
    }

Member Function Documentation

doWork()

MoFEMErrorCode EshelbianPlasticity::MatPhysicalEquations::OpCalculateHelmholtzFreeEnergy::doWork	(	int	side,
		EntityType	type,
		EntData &	data
	)

Definition at line 183 of file EshelbianMatCore.cpp.

                                              {
  MoFEMFunctionBegin;
  (void)side;
  (void)type;
  (void)data;
 
  auto mat_ops_data = physicsPtr->matOpsDataPtr;
  if (!mat_ops_data)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Mat core material data is not allocated");
 
  const int nb_integration_pts = getGaussPts().size2();
  if (nb_integration_pts <= 0)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Mat core energy operator has no integration points");
 
  auto mat_grad_ptr = mat_ops_data->getCommonDataPtr("grad");
  auto mat_F_ptr = mat_ops_data->getActiveDataPtr("F");
  auto mat_energy_ptr = physicsPtr->getEnergyDensityPtr();
  if (!mat_grad_ptr || !mat_F_ptr || !mat_energy_ptr)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Mat core energy evaluation has incomplete material data");
  if (mat_grad_ptr->size1() != nb_integration_pts ||
      mat_grad_ptr->size2() != SPACE_DIM * SPACE_DIM)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Mat core energy gradient data has size %zu x %zu; expected %d "
            "x %d",
            mat_grad_ptr->size1(), mat_grad_ptr->size2(), nb_integration_pts,
            SPACE_DIM * SPACE_DIM);
 
  mat_F_ptr->resize(SPACE_DIM, SPACE_DIM, false);
  mat_energy_ptr->resize(1, 1, false);
 
  const auto get_material_tag = [&]() {
    if (physicsPtr->tagVsRangePtr) {
      for (const auto &tag_range_pair : *physicsPtr->tagVsRangePtr) {
        if (tag_range_pair.second.find(getFEEntityHandle()) !=
            tag_range_pair.second.end())
          return tag_range_pair.first;
      }
    }
#ifndef NDEBUG
    if (MatOps::MatOpsTagsRegistry::getTagName(physicsPtr->tAg).empty())
      CHK_THROW_MESSAGE(MOFEM_OPERATION_UNSUCCESSFUL,
                        "ADOL-C tag not found " +
                            std::to_string(physicsPtr->tAg));
#endif
    return physicsPtr->tAg;
  };
 
  const int material_tag = get_material_tag();
  auto *fe_ptr = const_cast<FEMethod *>(getFEMethod());
  if (!fe_ptr)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Mat core energy operator has no finite-element method");
  const EntityHandle ent = fe_ptr->getFEEntityHandle();
  if (!ent)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "Mat core energy operator has no finite-element entity");
 
  using GaussLayout = DataLayoutTraits<DataLayout::GaussByCoeffs>;
  auto get_grad_at_pts = MatrixSizeHelper<
      GetFTensor2FromMatType<SPACE_DIM, SPACE_DIM, -1, GaussLayout>,
      GaussLayout>::get(*mat_grad_ptr, nb_integration_pts);
 
  FTENSOR_INDEX(SPACE_DIM, i);
  FTENSOR_INDEX(SPACE_DIM, J);
  auto t_grad_at_pts = get_grad_at_pts();
  dataAtPts->energyAtPts.resize(nb_integration_pts, false);
  auto t_energy_at_pts = getFTensor0FromVec(dataAtPts->energyAtPts);
 
  for (int gg = 0; gg != nb_integration_pts; ++gg) {
    auto t_F =
        getFTensor2FromPtr<SPACE_DIM, SPACE_DIM>(mat_F_ptr->data().data());
    t_F(i, J) = t_grad_at_pts(i, J);
    CHKERR physicsPtr->setParams(fe_ptr, gg);
    CHKERR physicsPtr->evaluateVariable(material_tag, ent, gg);
 
    auto t_energy = getFTensor0FromMat(mat_energy_ptr);
    const double energy_density = t_energy;
    if (!std::isfinite(energy_density))
      SETERRQ(PETSC_COMM_SELF, PETSC_ERR_FP,
              "Mat core returned non-finite energy density at point %d on "
              "entity %lu",
              gg, static_cast<unsigned long>(ent));
    t_energy_at_pts = energy_density;
 
    ++t_grad_at_pts;
    ++t_energy_at_pts;
  }
 
  if (totalHelmholtzFreeEnergyPtr) {
    if (!std::isfinite(*totalHelmholtzFreeEnergyPtr))
      SETERRQ(PETSC_COMM_SELF, PETSC_ERR_FP,
              "Mat core accumulated energy is non-finite before integration");
    const double element_measure = getMeasure();
    if (!std::isfinite(element_measure) || element_measure < 0.)
      SETERRQ(PETSC_COMM_SELF, PETSC_ERR_FP,
              "Mat core element measure is invalid: %.16g", element_measure);
 
    auto t_w = getFTensor0IntegrationWeight();
    auto t_energy_at_pts_integral = getFTensor0FromVec(dataAtPts->energyAtPts);
    auto t_plasticF = dataAtPts->getFTensorPlasticF(nb_integration_pts);
    double local_energy = 0;
    for (int gg = 0; gg != nb_integration_pts; ++gg) {
      const double weight = t_w;
      const double energy_density = t_energy_at_pts_integral;
      const double det_plasticF = determinantTensor3by3(t_plasticF);
      if (!std::isfinite(weight) || !std::isfinite(det_plasticF) ||
          det_plasticF <= 0.)
        SETERRQ(PETSC_COMM_SELF, PETSC_ERR_FP,
                "Invalid Mat core energy quadrature data at point %d on "
                "entity %lu",
                gg, static_cast<unsigned long>(ent));
      local_energy += weight * det_plasticF * energy_density;
 
      ++t_w;
      ++t_energy_at_pts_integral;
      ++t_plasticF;
    }
 
    const double element_energy = element_measure * local_energy;
    const double accumulated_energy =
        *totalHelmholtzFreeEnergyPtr + element_energy;
    if (!std::isfinite(element_energy) || !std::isfinite(accumulated_energy))
      SETERRQ(PETSC_COMM_SELF, PETSC_ERR_FP,
              "Mat core integrated energy is non-finite on entity %lu",
              static_cast<unsigned long>(ent));
    *totalHelmholtzFreeEnergyPtr = accumulated_energy;
  }
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

dataAtPts

boost::shared_ptr<DataAtIntegrationPts> EshelbianPlasticity::MatPhysicalEquations::OpCalculateHelmholtzFreeEnergy::dataAtPts

private

Definition at line 70 of file EshelbianMatCore.cpp.

physicsPtr

boost::shared_ptr<MatOps::MatElastic> EshelbianPlasticity::MatPhysicalEquations::OpCalculateHelmholtzFreeEnergy::physicsPtr

private

Definition at line 71 of file EshelbianMatCore.cpp.

totalHelmholtzFreeEnergyPtr

boost::shared_ptr<double> EshelbianPlasticity::MatPhysicalEquations::OpCalculateHelmholtzFreeEnergy::totalHelmholtzFreeEnergyPtr

private

Definition at line 72 of file EshelbianMatCore.cpp.

---

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

• users_modules/eshelbian_plasticity/src/impl/EshelbianMatCore.cpp