8#ifndef __VOLUME_LENGTH_QUALITY_HPP__ 
    9#define __VOLUME_LENGTH_QUALITY_HPP__ 
   12#error "MoFEM need to be compiled with ADOL-C" 
   24    "QUALITY", 
"BARRIER_AND_QUALITY", 
"BARRIER_AND_CHANGE_QUALITY",
 
   25    "BARRIER_AND_CHANGE_QUALITY_SCALED_BY_VOLUME"};
 
 
   31template <
typename TYPE>
 
   49    CHKERRABORT(PETSC_COMM_WORLD, 
ierr);
 
 
   54    PetscOptionsBegin(PETSC_COMM_WORLD, 
"",
 
   55                      "Get VolumeLengthQuality material options", 
"none");
 
   57        "-volume_length_type", 
"Volume length quality type", 
"",
 
   60    CHKERR PetscOptionsScalar(
"-volume_length_alpha",
 
   61                              "volume length alpha parameter", 
"", 
aLpha,
 
   62                              &
aLpha, PETSC_NULLPTR);
 
   63    CHKERR PetscOptionsScalar(
"-volume_length_gamma",
 
   64                              "volume length parameter (barrier)", 
"", 
gAmma,
 
   65                              &
gAmma, PETSC_NULLPTR);
 
 
   74  ublas::vector<TYPE> 
deltaX;
 
   86                &coordsEdges[0 * 3 * 2 + 0], 1);
 
   88                &coordsEdges[0 * 3 * 2 + 3], 1);
 
   90                &coordsEdges[1 * 3 * 2 + 0], 1);
 
   92                &coordsEdges[1 * 3 * 2 + 3], 1);
 
   94                &coordsEdges[2 * 3 * 2 + 0], 1);
 
   96                &coordsEdges[2 * 3 * 2 + 3], 1);
 
   98                &coordsEdges[3 * 3 * 2 + 0], 1);
 
  100                &coordsEdges[3 * 3 * 2 + 3], 1);
 
  102                &coordsEdges[4 * 3 * 2 + 0], 1);
 
  104                &coordsEdges[4 * 3 * 2 + 3], 1);
 
  106                &coordsEdges[5 * 3 * 2 + 0], 1);
 
  108                &coordsEdges[5 * 3 * 2 + 3], 1);
 
 
  137    for (
int ee = 0; ee < 6; ee++) {
 
  138      for (
int dd = 0; dd < 3; dd++) {
 
  142      for (
int ii = 0; ii != 3; ++ii)
 
  143        for (
int jj = 0; jj != 3; ++jj)
 
  146      for (
int dd = 0; dd < 3; dd++) {
 
  150      for (
int ii = 0; ii != 3; ++ii)
 
  151        for (
int jj = 0; jj != 3; ++jj)
 
 
  173    Q.resize(3, 3, 
false);
 
 
  206      boost::shared_ptr<const NumeredEntFiniteElement> fe_ptr) {
 
  210    detF = determinantTensor3by3(this->
F);
 
  211    if (this->
invF.size1() != 3)
 
  212      this->
invF.resize(3, 3);
 
  214    CHKERR invertTensor3by3(this->
F, detF, this->
invF);
 
  224    if (this->
P.size1() != 3)
 
  225      this->
P.resize(3, 3);
 
  230      noalias(this->
P) = q * 
Q;
 
  235      noalias(this->
P) = tMp * 
Q;
 
  240      noalias(this->
P) = tMp * 
Q;
 
  247      noalias(this->
P) = tMp * 
Q;
 
 
static PetscErrorCode ierr
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
VectorDouble & getCoords()
nodal coordinates
double getVolume() const
element volume (linear geometry)
data for calculation heat conductivity and heat capacity elements
Implementation of elastic (non-linear) St. Kirchhoff equation.
FunctionsToCalculatePiolaKirchhoffI()
FTensor::Tensor2< FTensor::PackPtr< TYPE *, 0 >, 3, 3 > t_invF
MoFEM::VolumeElementForcesAndSourcesCore::UserDataOperator * opPtr
pointer to finite element tetrahedral operator
MatrixBoundedArray< TYPE, 9 > invF
MatrixBoundedArray< TYPE, 9 > F
MatrixBoundedArray< TYPE, 9 > P
structure grouping operators and data used for calculation of nonlinear elastic element
FTensor::Index< 'k', 3 > k
MoFEMErrorCode calculateQ()
Calculate Q.
ublas::vector< TYPE > deltaX
FTensor::Index< 'j', 3 > j
VolumeLengthQuality(VolumeLengthQualityType type, double alpha, double gamma)
FTensor::Index< 'i', 3 > i
MoFEMErrorCode getEdgesFromElemCoords()
MoFEMErrorCode getMaterialOptions()
MoFEMErrorCode calculateLrms()
Calculate mean element edge length.
virtual MoFEMErrorCode calculateP_PiolaKirchhoffI(const NonlinearElasticElement::BlockData block_data, boost::shared_ptr< const NumeredEntFiniteElement > fe_ptr)
Volume Length Quality.
ublas::matrix< TYPE > dXdChiT
@ LASTOP_VOLUMELENGTHQUALITYTYPE
@ BARRIER_AND_CHANGE_QUALITY_SCALED_BY_VOLUME
@ BARRIER_AND_CHANGE_QUALITY
static const char * VolumeLengthQualityTypeNames[]