ADOLCPlasticityLargeStrain.hpp

Operators and data structures for large strain plasticity.

Operators and data structures for large strain plasticity

/** \file ADOLCPlasticityLargeStrain.hpp
 * \ingroup adoc_plasticity
 * \example ADOLCPlasticityLargeStrain.hpp
 *
 * \brief Operators and data structures for large strain plasticity
 *
 * \defgroup adoc_plasticity ADOL-C plasticity
 * \ingroup user_modules
 * \defgroup user_modules User modules
 *
**/
 
#include "MoFEM.hpp"
using namespace MoFEM;
 
namespace ADOLCPlasticity {
 
struct OpTransferCommonData : public ForcesAndSourcesCore::UserDataOperator {
  boost::shared_ptr<MatrixDouble> mA;
  boost::shared_ptr<MatrixDouble> mB;
 
  OpTransferCommonData(boost::shared_ptr<MatrixDouble> m_a,
                       boost::shared_ptr<MatrixDouble> m_b)
      : ForcesAndSourcesCore::UserDataOperator(NOSPACE,
                                               UserDataOperator::OPSPACE),
        mA(m_a), mB(m_b) {}
 
  MoFEMErrorCode doWork(int side, EntityType type,
                        DataForcesAndSourcesCore::EntData &data) {
    MoFEMFunctionBegin;
    // Swap mA to mB
    *mA = std::move(*mB);
    MoFEMFunctionReturn(0);
  }
};
 
template <int DIM, IntegrationType I, typename DomainEleOp>
MoFEMErrorCode opFactoryDomainHenckyStrainRhs(
    MoFEM::Interface &m_field, std::string field_name, Pip &pip,
    std::string block_name,
    boost::shared_ptr<ADOLCPlasticity::CommonData> common_data_ptr,
    boost::shared_ptr<ClosestPointProjection> cp_ptr);
 
template <int DIM, IntegrationType I, typename DomainEleOp>
MoFEMErrorCode opFactoryDomainHenckyStrainRhsImpl(
    MoFEM::Interface &m_field, std::string field_name, Pip &pip,
    std::string block_name,
    boost::shared_ptr<ADOLCPlasticity::CommonData> common_data_ptr,
    boost::shared_ptr<ClosestPointProjection> cp_ptr) {
  MoFEMFunctionBegin;
  using namespace HenckyOps;
 
  using P = ADOLCPlasticityIntegrators<DomainEleOp>;
 
  auto common_hencky_ptr = boost::make_shared<HenckyOps::CommonData>();
 
  common_hencky_ptr->matDPtr = boost::make_shared<MatrixDouble>();
  common_hencky_ptr->matGradPtr = boost::make_shared<MatrixDouble>();
 
  using H = HenckyOps::HenckyIntegrators<DomainEleOp>;
 
  pip.push_back(new OpCalculateVectorFieldGradient<DIM, DIM>(
      field_name, common_hencky_ptr->matGradPtr));
  pip.push_back(new typename H::template OpCalculateEigenVals<DIM, I>(
      field_name, common_hencky_ptr));
  pip.push_back(new typename H::template OpCalculateLogC<DIM, I>(
      field_name, common_hencky_ptr));
  pip.push_back(new typename H::template OpCalculateLogC_dC<DIM, I>(
      field_name, common_hencky_ptr));
  pip.push_back(
      new OpTransferCommonData(common_data_ptr->getGradAtGaussPtsPtr(),
                               common_hencky_ptr->getMatLogC()));
 
  CHKERR cp_ptr->addMatBlockOps(m_field, pip, block_name, Sev::inform);
  pip.push_back(getRawPtrOpCalculateStress<DIM, LARGE_STRAIN>(m_field, common_data_ptr,
                                                      cp_ptr, false));
  pip.push_back(
      new OpTransferCommonData(common_hencky_ptr->getMatHenckyStress(),
                               common_data_ptr->getStressMatrixPtr()));
  pip.push_back(new OpTransferCommonData(common_hencky_ptr->matDPtr,
                                         common_data_ptr->getMatTangentPtr()));
 
  // post process stress to first piola kirchhoff stress
  pip.push_back(new typename H::template OpCalculatePiolaStress<DIM, I, 1>(
      field_name, common_hencky_ptr));
  pip.push_back(
      new OpTransferCommonData(common_data_ptr->getStressMatrixPtr(),
                               common_hencky_ptr->getMatFirstPiolaStress()));
  MoFEMFunctionReturn(0);
};
 
template <int DIM, IntegrationType I, typename DomainEleOp>
MoFEMErrorCode opFactoryDomainHenckyStrainRhs(
    MoFEM::Interface &m_field, std::string field_name, Pip &pip,
    std::string block_name,
    boost::shared_ptr<ADOLCPlasticity::CommonData> common_data_ptr,
    boost::shared_ptr<ClosestPointProjection> cp_ptr) {
  return opFactoryDomainHenckyStrainRhsImpl<DIM, I, DomainEleOp>(
      m_field, field_name, pip, block_name, common_data_ptr, cp_ptr);
};
 
template <int DIM, IntegrationType I, typename DomainEleOp>
MoFEMErrorCode opFactoryDomainHenckyStrainLhs(
    MoFEM::Interface &m_field, std::string field_name, Pip &pip,
    std::string block_name,
    boost::shared_ptr<ADOLCPlasticity::CommonData> common_data_ptr,
    boost::shared_ptr<ClosestPointProjection> cp_ptr);
 
template <int DIM, IntegrationType I, typename DomainEleOp>
MoFEMErrorCode opFactoryDomainHenckyStrainLhsImpl(
    MoFEM::Interface &m_field, std::string field_name, Pip &pip,
    std::string block_name,
    boost::shared_ptr<ADOLCPlasticity::CommonData> common_data_ptr,
    boost::shared_ptr<ClosestPointProjection> cp_ptr) {
  MoFEMFunctionBegin;
  using namespace HenckyOps;
 
  auto common_hencky_ptr = boost::make_shared<HenckyOps::CommonData>();
  common_hencky_ptr->matDPtr = boost::make_shared<MatrixDouble>();
  common_hencky_ptr->matGradPtr = boost::make_shared<MatrixDouble>();
 
  using H = HenckyIntegrators<DomainEleOp>;
 
  pip.push_back(new OpCalculateVectorFieldGradient<DIM, DIM>(
      field_name, common_hencky_ptr->matGradPtr));
  pip.push_back(new typename H::template OpCalculateEigenVals<DIM, I>(
      field_name, common_hencky_ptr));
  pip.push_back(new typename H::template OpCalculateLogC<DIM, I>(
      field_name, common_hencky_ptr));
  pip.push_back(new typename H::template OpCalculateLogC_dC<DIM, I>(
      field_name, common_hencky_ptr));
  pip.push_back(
      new OpTransferCommonData(common_data_ptr->getGradAtGaussPtsPtr(),
                               common_hencky_ptr->getMatLogC()));
 
  CHKERR cp_ptr->addMatBlockOps(m_field, pip, block_name, Sev::inform);
  pip.push_back(
      getRawPtrOpCalculateStress<DIM ,LARGE_STRAIN>(m_field, common_data_ptr, cp_ptr, false));
  pip.push_back(
      new OpTransferCommonData(common_hencky_ptr->getMatHenckyStress(),
                               common_data_ptr->getStressMatrixPtr()));
  pip.push_back(new OpTransferCommonData(common_hencky_ptr->matDPtr,
                                         common_data_ptr->getMatTangentPtr()));
  pip.push_back(new typename H::template OpCalculatePiolaStress<DIM, I, 1>(
      field_name, common_hencky_ptr));
 
  pip.push_back(new typename H::template OpHenckyTangent<DIM, I, 1>(
      field_name, common_hencky_ptr));
  pip.push_back(new OpTransferCommonData(common_data_ptr->getMatTangentPtr(),
                                         common_hencky_ptr->getMatTangent()));
  MoFEMFunctionReturn(0);
};
 
template <int DIM, IntegrationType I, typename DomainEleOp>
MoFEMErrorCode opFactoryDomainHenckyStrainLhs(
    MoFEM::Interface &m_field, std::string field_name, Pip &pip,
    std::string block_name,
    boost::shared_ptr<ADOLCPlasticity::CommonData> common_data_ptr,
    boost::shared_ptr<ClosestPointProjection> cp_ptr) {
  return opFactoryDomainHenckyStrainLhsImpl<DIM, I, DomainEleOp>(
      m_field, field_name, pip, block_name, common_data_ptr, cp_ptr);
};
 
 
} // namespace ADOLCPlasticity