AdolCOps::AdolCVolumeLengthQuality< DIM > Struct Template Reference

Inheritance diagram for AdolCOps::AdolCVolumeLengthQuality< DIM >:

Collaboration diagram for AdolCOps::AdolCVolumeLengthQuality< DIM >:

Public Types
using	A = AdolCElasticImpl< DIM >

Public Member Functions
MoFEMErrorCode	getOptions (MoFEM::Interface *m_field_ptr=nullptr) override
MoFEMErrorCode	setParams (EntityHandle ent, int gg) override
MoFEMErrorCode	recordTape () override
Public Member Functions inherited from AdolCOps::AdolCElasticImpl< DIM >
ForcesAndSourcesCore::UserDataOperator *	createOp (boost::shared_ptr< PhysicalEquations > physical_ptr, bool eval_stress, bool eval_tangent) override
ForcesAndSourcesCore::UserDataOperator *	createOp (boost::shared_ptr< PhysicalEquations > physical_ptr, bool eval_stress, bool eval_tangent)
ForcesAndSourcesCore::UserDataOperator *	createOp (boost::shared_ptr< PhysicalEquations > physical_ptr, bool eval_stress, bool eval_tangent)
	PhysicalEquations ()=delete
	PhysicalEquations (boost::shared_ptr< ADolCData > adolc_data_ptr, int tag, boost::shared_ptr< std::map< int, Range > > tag_vs_range_ptr=nullptr)
Public Member Functions inherited from AdolCOps::PhysicalEquations
	PhysicalEquations ()=delete
	PhysicalEquations (boost::shared_ptr< ADolCData > adolc_data_ptr, int tag, boost::shared_ptr< std::map< int, Range > > tag_vs_range_ptr=nullptr)
virtual	~PhysicalEquations ()=default
MoFEMErrorCode	setActiveContinuousVector ()
MoFEMErrorCode	setDependentContinuousVector ()
MoFEMErrorCode	setDependentDerivativesContinuousVector ()
MoFEMErrorCode	getActiveContinuousVector ()
MoFEMErrorCode	getDependentContinuousVector ()
MoFEMErrorCode	getDependentDerivativesContinuousVector ()

Static Public Attributes
static constexpr std::array< std::array< int, 2 >, 6 >	edgeNodes

Protected Attributes
int	tYpe = BARRIER_AND_QUALITY
double	aLpha = 1.0
double	gAmma = 0.0
std::array< double, 12 >	coordsTet
MoFEM::Interface *	mFieldPtr = nullptr

Additional Inherited Members
Public Attributes inherited from AdolCOps::PhysicalEquations
int	tAg
boost::shared_ptr< std::map< int, Range > >	tagVsRangePtr
std::vector< std::pair< Range, std::vector< double > > >	paramVecByRange
boost::shared_ptr< ADolCData >	adolcDataPtr
std::vector< double >	activeVariables
std::vector< double >	dependentVariables
std::vector< double >	dependentVariablesDerivatives

Detailed Description

template<int DIM>
struct AdolCOps::AdolCVolumeLengthQuality< DIM >

Definition at line 18 of file AdolCVolumeLengthQuality.cpp.

Member Typedef Documentation

A

template<int DIM>

using AdolCOps::AdolCVolumeLengthQuality< DIM >::A = AdolCElasticImpl<DIM>

Definition at line 21 of file AdolCVolumeLengthQuality.cpp.

Member Function Documentation

getOptions()

template<int DIM>

MoFEMErrorCode AdolCOps::AdolCVolumeLengthQuality< DIM >::getOptions ( MoFEM::Interface *  m_field_ptr = nullptr )

inlineoverridevirtual

Implements AdolCOps::PhysicalEquations.

Definition at line 28 of file AdolCVolumeLengthQuality.cpp.

                                                                            {
    MoFEMFunctionBegin;
 
    MOFEM_LOG_CHANNEL("WORLD");
 
    PetscOptionsBegin(PETSC_COMM_WORLD, "",
                      "Get VolumeLengthQuality material options", "none");
    CHKERR PetscOptionsEList(
        "-volume_length_type", "Volume length quality type", "",
        VolumeLengthQualityTypeNames, LASTOP_VOLUMELENGTHQUALITYTYPE,
        VolumeLengthQualityTypeNames[tYpe], &tYpe, PETSC_NULLPTR);
    CHKERR PetscOptionsScalar("-volume_length_alpha",
                              "volume length alpha parameter", "", aLpha,
                              &aLpha, PETSC_NULLPTR);
    CHKERR PetscOptionsScalar("-volume_length_gamma",
                              "volume length parameter (barrier)", "", gAmma,
                              &gAmma, PETSC_NULLPTR);
    PetscOptionsEnd();
 
    MOFEM_TAG_AND_LOG("WORLD", Sev::inform, "VolumeLengthQuality")
        << " type = " << VolumeLengthQualityTypeNames[tYpe]
        << " alpha = " << aLpha << " gamma = " << gAmma;
 
    mFieldPtr = m_field_ptr;
 
    MoFEMFunctionReturn(0);
  };

recordTape()

template<int DIM>

MoFEMErrorCode AdolCOps::AdolCVolumeLengthQuality< DIM >::recordTape ( )

inlineoverridevirtual

Implements AdolCOps::PhysicalEquations.

Definition at line 79 of file AdolCVolumeLengthQuality.cpp.

                                       {
    MoFEMFunctionBegin;
    static_assert(DIM == 3,
                  "AdolCVolumeLengthQuality is implemented for 3D only");
 
    A::adolcDataPtr->insertCommonData("grad", MatrixDouble(DIM * DIM, 1));
    A::adolcDataPtr->insertCommonData("P", MatrixDouble(DIM * DIM, 1));
    A::adolcDataPtr->insertCommonData("P_dF",
                                      MatrixDouble(DIM * DIM, DIM * DIM));
 
    A::adolcDataPtr->insertActiveData("F", MatrixDouble(DIM, DIM));
    A::adolcDataPtr->insertDependentData("P", MatrixDouble(DIM, DIM));
    A::adolcDataPtr->insertDependentDerivativesData(
        "P_dF", MatrixDouble(DIM * DIM, DIM * DIM));
 
    auto t_F = getFTensor2FromPtr<DIM, DIM>(
        A::adolcDataPtr->getActiveDataPtr("F")->data().data());
    auto t_P = getFTensor2FromPtr<DIM, DIM>(
        A::adolcDataPtr->getDependentDataPtr("P")->data().data());
 
    auto t_kd = FTensor::Kronecker_Delta<int>();
 
    FTENSOR_INDEX(DIM, i);
    FTENSOR_INDEX(DIM, j);
    FTENSOR_INDEX(DIM, I);
    FTENSOR_INDEX(DIM, J);
 
    // That assumes that nodal positions are approximated.
    t_F(i, J) = t_kd(i, J);
 
    FTensor::Tensor2<adouble, DIM, DIM> ta_F;
    FTensor::Tensor2<adouble, DIM, DIM> ta_P;
    FTensor::Tensor2<adouble, DIM, DIM> ta_invF;
    FTensor::Tensor2<adouble, DIM, DIM> dX_dChiT;
    FTensor::Tensor2<adouble, DIM, DIM> Q;
    FTensor::Tensor1<adouble, DIM> delta_chi;
    FTensor::Tensor1<adouble, DIM> delta_X;
 
    adouble det_aF;
 
    trace_on(A::tAg);
 
    std::array<adouble, 12> refCoords;
    for (auto dd = 0; dd != 12; ++dd) {
      refCoords[dd] = mkparam(coordsTet[dd]);
    }
 
    ta_F(i, J) <<= t_F(i, J);
    det_aF = determinantTensor(ta_F);
    CHKERR invertTensor(ta_F, det_aF, ta_invF);
 
    const auto x00 = refCoords[0];
    const auto x01 = refCoords[1];
    const auto x02 = refCoords[2];
    const auto x10 = refCoords[3];
    const auto x11 = refCoords[4];
    const auto x12 = refCoords[5];
    const auto x20 = refCoords[6];
    const auto x21 = refCoords[7];
    const auto x22 = refCoords[8];
    const auto x30 = refCoords[9];
    const auto x31 = refCoords[10];
    const auto x32 = refCoords[11];
 
    const auto ax = x10 - x00;
    const auto ay = x11 - x01;
    const auto az = x12 - x02;
 
    const auto bx = x20 - x00;
    const auto by = x21 - x01;
    const auto bz = x22 - x02;
 
    const auto cx = x30 - x00;
    const auto cy = x31 - x01;
    const auto cz = x32 - x02;
 
    const adouble signed_volume =
        (ax * (by * cz - bz * cy) - ay * (bx * cz - bz * cx) +
         az * (bx * cy - by * cx)) /
        6.0;
 
    dX_dChiT(i, J) = 0.0;
 
    adouble lrms_squared = 0.0;
    adouble lrms_squared0 = 0.0;
 
    for (auto ee = 0; ee != 6; ++ee) {
      for (auto dd = 0; dd != DIM; ++dd) {
        delta_chi(dd) =
            refCoords[3 * edgeNodes[ee][0] + dd] -
            refCoords[3 * edgeNodes[ee][1] + dd];
      }
 
      delta_X(i) = ta_F(i, J) * delta_chi(J);
 
      lrms_squared += (1. / 6.) * delta_X(i) * delta_X(i);
      lrms_squared0 += (1. / 6.) * delta_chi(I) * delta_chi(I);
      dX_dChiT(i, I) += delta_X(i) * delta_chi(I);
    }
 
    Q(i, j) = ta_invF(j, i) - 0.5 * dX_dChiT(i, j) / lrms_squared;
 
    const adouble lrms_cubed0 = lrms_squared0 * sqrt(lrms_squared0);
    const adouble b =
        det_aF / (lrms_squared * sqrt(lrms_squared) / lrms_cubed0);
    const adouble current_volume = det_aF * signed_volume;
    const adouble q =
        6. * sqrt(2.) * current_volume / (lrms_squared * sqrt(lrms_squared));
 
    switch (tYpe) {
    case QUALITY:
      ta_P(i, J) = q * Q(i, J);
      break;
    case BARRIER_AND_QUALITY: {
      const adouble t_mp = q / (1.0 - gAmma) - 1.0 / (q - gAmma);
      ta_P(i, J) = t_mp * Q(i, J);
      break;
    }
    case BARRIER_AND_CHANGE_QUALITY: {
      const adouble t_mp = b / (1.0 - gAmma) - 1.0 / (b - gAmma);
      ta_P(i, J) = t_mp * Q(i, J);
      break;
    }
    case BARRIER_AND_CHANGE_QUALITY_SCALED_BY_VOLUME: {
      adouble t_mp = current_volume;
      t_mp *= b / (1.0 - gAmma) - 1.0 / (b - gAmma);
      ta_P(i, J) = t_mp * Q(i, J);
      break;
    }
    default:
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "Unknown volume-length-quality type");
    }
 
    ta_P(i, J) *= aLpha / signed_volume;
    ta_P(i, J) >>= t_P(i, J);
 
    trace_off();
 
    MoFEMFunctionReturn(0);
  }

setParams()

template<int DIM>

MoFEMErrorCode AdolCOps::AdolCVolumeLengthQuality< DIM >::setParams ( EntityHandle  ent, int  gg  )

inlineoverridevirtual

Implements AdolCOps::PhysicalEquations.

Definition at line 56 of file AdolCVolumeLengthQuality.cpp.

                                                              {
    MoFEMFunctionBegin;
    (void)gg;
 
    if (mFieldPtr == nullptr) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "MoFEM interface pointer not set");
    }
 
    const EntityHandle *conn = nullptr;
    int num_nodes = 0;
    CHKERR mFieldPtr->get_moab().get_connectivity(ent, conn, num_nodes, true);
    if (PetscUnlikely(num_nodes != 4)) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "VolumeLengthQuality is implemented for 4-node tetrahedra only");
    }
 
    CHKERR mFieldPtr->get_moab().get_coords(conn, num_nodes, coordsTet.data());
    set_param_vec(A::tAg, coordsTet.size(), coordsTet.data());
 
    MoFEMFunctionReturn(0);
  }

Member Data Documentation

aLpha

template<int DIM>

double AdolCOps::AdolCVolumeLengthQuality< DIM >::aLpha = 1.0

protected

Definition at line 223 of file AdolCVolumeLengthQuality.cpp.

coordsTet

template<int DIM>

std::array<double, 12> AdolCOps::AdolCVolumeLengthQuality< DIM >::coordsTet

protected

Initial value:

= {
 
      0.0, 0.0, 0.0,
 
      1.0, 0.0, 0.0,
 
      0.0, 1.0, 0.0,
 
      0.0, 0.0, 1.0}

Definition at line 225 of file AdolCVolumeLengthQuality.cpp.

                                   {
 
      0.0, 0.0, 0.0,
 
      1.0, 0.0, 0.0,
 
      0.0, 1.0, 0.0,
 
      0.0, 0.0, 1.0};

edgeNodes

template<int DIM>

constexpr std::array<std::array<int, 2>, 6> AdolCOps::AdolCVolumeLengthQuality< DIM >::edgeNodes

inlinestaticconstexpr

Initial value:

= {
      std::array<int, 2>{0, 1}, std::array<int, 2>{0, 2},
      std::array<int, 2>{0, 3}, std::array<int, 2>{1, 2},
      std::array<int, 2>{1, 3}, std::array<int, 2>{2, 3}}

Definition at line 23 of file AdolCVolumeLengthQuality.cpp.

                                                                    {
      std::array<int, 2>{0, 1}, std::array<int, 2>{0, 2},
      std::array<int, 2>{0, 3}, std::array<int, 2>{1, 2},
      std::array<int, 2>{1, 3}, std::array<int, 2>{2, 3}};

gAmma

template<int DIM>

double AdolCOps::AdolCVolumeLengthQuality< DIM >::gAmma = 0.0

protected

Definition at line 224 of file AdolCVolumeLengthQuality.cpp.

mFieldPtr

template<int DIM>

MoFEM::Interface* AdolCOps::AdolCVolumeLengthQuality< DIM >::mFieldPtr = nullptr

protected

Definition at line 234 of file AdolCVolumeLengthQuality.cpp.

tYpe

template<int DIM>

int AdolCOps::AdolCVolumeLengthQuality< DIM >::tYpe = BARRIER_AND_QUALITY

protected

Definition at line 222 of file AdolCVolumeLengthQuality.cpp.

---

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

• src/adolc/impl/AdolCVolumeLengthQuality.cpp