EshelbianMat.cpp

Go to the documentation of this file.

/**
 * \file EshelbianMat.cpp
 * \brief Implementation of automatic differentiation
 */
 
#include <MoFEM.hpp>
using namespace MoFEM;
 
#include <MatrixFunction.hpp>
 
#include <EshelbianPlasticity.hpp>
 
#include <EshelbianAux.hpp>
 
#include <EshelbianTopologicalDerivative.hpp>
 
#include <boost/math/constants/constants.hpp>
 
constexpr double third = boost::math::constants::third<double>();
 
namespace EshelbianPlasticity {
 
UserDataOperator *PhysicalEquations::returnOpJacobian(
    const bool eval_rhs, const bool eval_lhs,
    boost::shared_ptr<DataAtIntegrationPts> data_ptr,
    boost::shared_ptr<PhysicalEquations> physics_ptr) {
  return nullptr;
}
 
VolUserDataOperator *PhysicalEquations::returnOpSpatialPhysical(
    const std::string &field_name,
    boost::shared_ptr<DataAtIntegrationPts> data_ptr, const double alpha_u) {
  return nullptr;
}
 
VolUserDataOperator *PhysicalEquations::returnOpSpatialPhysicalExternalStrain(
    const std::string &field_name,
    boost::shared_ptr<DataAtIntegrationPts> data_ptr,
    boost::shared_ptr<ExternalStrainVec> external_strain_vec_ptr,
    std::map<std::string, boost::shared_ptr<ScalingMethod>> smv) {
  return nullptr;
}
 
VolUserDataOperator *PhysicalEquations::returnOpSpatialPhysical_du_du(
    std::string row_field, std::string col_field,
    boost::shared_ptr<DataAtIntegrationPts> data_ptr, const double alpha) {
  return nullptr;
}
 
VolUserDataOperator *PhysicalEquations::returnOpTopoSpatialPhysical(
    const std::string &field_name,
    boost::shared_ptr<DataAtIntegrationPts> data_ptr,
    SmartPetscObj<Vec> assemble_vec,
    boost::shared_ptr<TopologicalData> topo_ptr, const double alpha_u,
    boost::shared_ptr<double> J_ptr) {
  return nullptr;
}
 
VolUserDataOperator *PhysicalEquations::returnOpCalculateEnergy(
    boost::shared_ptr<DataAtIntegrationPts> data_ptr,
    boost::shared_ptr<double> total_energy_ptr) {
  return nullptr;
}
 
VolUserDataOperator *PhysicalEquations::returnOpCalculateStretchFromStress(
    boost::shared_ptr<DataAtIntegrationPts> data_ptr,
    boost::shared_ptr<PhysicalEquations> physics_ptr,
    boost::shared_ptr<MatrixDouble> strain_ptr) {
  return nullptr;
}
 
VolUserDataOperator *PhysicalEquations::returnOpCalculateStretchFromStress(
    boost::shared_ptr<DataAtIntegrationPts> data_ptr,
    boost::shared_ptr<PhysicalEquations> physics_ptr,
    boost::shared_ptr<MatrixDouble> strain_ptr,
    VectorPtr external_pressure_ptr) {
  return returnOpCalculateStretchFromStress(
      std::move(data_ptr), std::move(physics_ptr), std::move(strain_ptr));
}
 
VolUserDataOperator *PhysicalEquations::returnOpCalculateExternalPressure(
    VectorPtr external_pressure_ptr,
    boost::shared_ptr<ExternalStrainVec> external_strain_vec_ptr,
    std::map<std::string, boost::shared_ptr<ScalingMethod>> smv) {
  return nullptr;
}
 
VolUserDataOperator *PhysicalEquations::returnOpCalculateVarStretchFromStress(
    boost::shared_ptr<DataAtIntegrationPts> data_ptr,
    boost::shared_ptr<PhysicalEquations> physics_ptr) {
  return nullptr;
};
 
} // namespace EshelbianPlasticity
 
#include <impl/EshelbianMatCore.cpp>
#include <impl/HMHStorakers.cpp>
#include <impl/HMHNeohookean.cpp>
#include <impl/HMHHencky.cpp>
namespace EshelbianPlasticity {
 
MoFEMErrorCode EshelbianCore::addMaterial_HMHNeohookean(const double c10,
                                                        const double K) {
  MoFEMFunctionBegin;
  physicalEquations = boost::make_shared<HMHNeohookean>(mField, c10, K);
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode EshelbianCore::addMaterial_HMHStorakers(const double eta,
                                                       const double mu,
                                                       const double beta) {
  MoFEMFunctionBegin;
  physicalEquations = boost::make_shared<HMHStorakers>(mField, eta, mu, beta);
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode EshelbianCore::addMaterial_Hencky(double E, double nu) {
  MoFEMFunctionBegin;
  physicalEquations = boost::make_shared<HMHHencky>(mField, E, nu);
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode EshelbianCore::addMaterial_Core(
    boost::weak_ptr<MatOps::PhysicalEquations> mat_physical_equations_ptr) {
  MoFEMFunctionBegin;
  physicalEquations = boost::make_shared<MatPhysicalEquations>(
      mat_physical_equations_ptr.lock());
  MoFEMFunctionReturn(0);
}
 
}; // namespace EshelbianPlasticity