BlockParamData Struct Reference

#include <users_modules/multifield_plasticity/src/BasicFeTools.hpp>

Inheritance diagram for BlockParamData:

Collaboration diagram for BlockParamData:

Public Member Functions
MoFEMErrorCode	getOptionsFromCommandLine ()
MoFEMErrorCode	scaleParameters ()
Public Member Functions inherited from CacheParams
	CacheParams ()
virtual MoFEMErrorCode	scaleParameters ()=0
template<typename T1 , typename T2 >
int	getClosestRollerID (Tensor1< T1, 3 > &t_coords, Tensor1< T2, 3 > &t_disp)

Additional Inherited Members
Public Attributes inherited from CacheParams
double	young_modulus
double	young_modulus_inv
double	poisson
double	density
double	sigmaY
double	cn_pl
double	H
double	C1_k
double	Q_inf
double	b_iso
double	visH
double	scale_constraint
MatrixDouble	mtD
double	cn_cont
double	rollers_stop_time
Static Public Attributes inherited from CacheParams
static vector< double >	gravity = vector<double>({0,0,0})
static double	spring_stiffness = 0
static int	closest_roller_id = 0
static double	delta = std::numeric_limits<double>::epsilon()
static Tensor1< double, 3 >	omega
static Tensor2< double, 3, 3 >	Omega
static Tensor4< double, 3, 3, 3, 3 >	Is
static boost::ptr_vector< RigidBodyData >	rollerDataVec
static RigidBodyData *	closest_roller

Detailed Description

Definition at line 103 of file BasicFeTools.hpp.

Member Function Documentation

getOptionsFromCommandLine()

MoFEMErrorCode BlockParamData::getOptionsFromCommandLine ( )

inline

Definition at line 105 of file BasicFeTools.hpp.

                                             {
    MoFEMFunctionBegin;
 
    // CHKERR PetscOptionsInsertString(NULL, default_options);
    CHKERR PetscOptionsInsertString(
        NULL, "-mat_mumps_icntl_14 1200 -mat_mumps_icntl_24 1 "
              "-mat_mumps_icntl_13 1 -mat_mumps_icntl_20 0");
 
    CHKERR PetscOptionsBegin(PETSC_COMM_WORLD, "", "", "none");
 
    int nb_ent_grav = 3;
    CHKERR PetscOptionsGetRealArray(NULL, NULL, "-gravity", gravity.data(),
                                    &nb_ent_grav, PETSC_NULL);
    // for elastic
    CHKERR PetscOptionsScalar("-young", "Young's modulus", "", young_modulus,
                              &young_modulus, PETSC_NULL);
 
    CHKERR PetscOptionsScalar("-poisson", "Poisson ratio", "", poisson,
                              &poisson, PETSC_NULL);
    CHKERR PetscOptionsScalar("-density", "Density", "", density, &density,
                              PETSC_NULL);
 
    PetscBool with_contact = PETSC_FALSE;
    CHKERR PetscOptionsBool("-with_contact", "run calculations with contact",
                            "", with_contact, &with_contact, PETSC_NULL);
 
    double rot_vec[3] = {0, 0, 1};
    int nb_ent = 3;
    PetscBool is_rotating;
    // get rotation velocity vector
    CHKERR PetscOptionsGetRealArray(NULL, NULL, "-rot_omega", rot_vec, &nb_ent,
                                    &is_rotating);
    if (nb_ent < 3 && is_rotating) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "provide an appropriate number of entries for omega vector (3)");
    }
    {
      Tensor1<double, 3> t1_omega(rot_vec[0], rot_vec[1], rot_vec[2]);
      omega(i) = t1_omega(i);
      Omega(i, k) = levi_civita<double>(i, j, k) * t1_omega(j);
    }
 
    if (poisson >= 0.5)
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "poisson ratio value not supported");
 
    CHKERR PetscOptionsScalar("-sigmaY", "SigmaY - limit stress", "", sigmaY,
                              &sigmaY, PETSC_NULL);
    CHKERR PetscOptionsScalar("-H", "Hardening modulus", "", H, &H, PETSC_NULL);
    CHKERR PetscOptionsScalar("-cn_pl",
                              "cn_pl parameter for active set constrains", "",
                              cn_pl, &cn_pl, PETSC_NULL);
    CHKERR PetscOptionsScalar("-scale_constraint", "constraint scale", "",
                              scale_constraint, &scale_constraint, PETSC_NULL);
    CHKERR PetscOptionsScalar("-C1_k", "1st Backstress", "", C1_k, &C1_k,
                              PETSC_NULL);
    CHKERR PetscOptionsScalar("-Q_inf", "Saturation stress", "", Q_inf, &Q_inf,
                              PETSC_NULL);
    CHKERR PetscOptionsScalar("-b_iso", "Isotropic exponent", "", b_iso, &b_iso,
                              PETSC_NULL);
    CHKERR PetscOptionsScalar("-visH", "viscous hardening", "", visH, &visH,
                              PETSC_NULL);
    // for contact
    CHKERR PetscOptionsScalar("-spring",
                              "Springs stiffness on the boundary (contact)", "",
                              spring_stiffness, &spring_stiffness, PETSC_NULL);
 
    CHKERR PetscOptionsScalar("-cn_cont",
                              "cn_cont parameter for active set constrains", "",
                              cn_cont, &cn_cont, PETSC_NULL);
    CHKERR PetscOptionsScalar(
        "-rollers_stop", "Time at which rollers will stop moving", "",
        rollers_stop_time, &rollers_stop_time, PETSC_NULL);
 
    constexpr int MAX_NB_OF_ROLLERS = 10;
    // if (with_contact) {
 
    const char *body_list[] = {"plane", "sphere", "cylinder", "cone",
                               "torus", "roller", "stl",      "nurbs"};
    for (int ii = 0; ii < MAX_NB_OF_ROLLERS; ++ii) {
      int nb_coord = 3;
      int nb_disp = 3;
      int nb_dirs = 3;
      VectorDouble center_coords({0, 0, 0});
      VectorDouble disp({0, 0, 0});
 
      PetscBool flg = PETSC_FALSE;
      PetscBool rflg;
      string param = "-body" + to_string(ii);
      // char mesh_file_name[255];
      // CHKERR PetscOptionsString(param.c_str(), "file name", "", "mesh.vtk",
      //                           mesh_file_name, 255, &flg);
      int body_type_id = LASTBODY;
      CHKERR PetscOptionsGetEList(PETSC_NULL, NULL, param.c_str(), body_list,
                                  LASTBODY, &body_type_id, &flg);
 
      param = "-coords" + to_string(ii);
      CHKERR PetscOptionsGetRealArray(NULL, NULL, param.c_str(),
                                      &center_coords(0), &nb_coord, &rflg);
      param = "-move" + to_string(ii);
      CHKERR PetscOptionsGetRealArray(NULL, NULL, param.c_str(), &disp(0),
                                      &nb_disp, &rflg);
      if (flg) {
        switch (body_type_id) {
        case PLANE:
          rollerDataVec.push_back(new PlaneRigidBody(center_coords, disp, ii));
          break;
        case SPHERE:
          rollerDataVec.push_back(new SphereRigidBody(center_coords, disp, ii));
          break;
        case CYLINDER:
          rollerDataVec.push_back(
              new CylinderRigidBody(center_coords, disp, ii));
          break;
        case CONE:
          rollerDataVec.push_back(new ConeRigidBody(center_coords, disp, ii));
          break;
        case TORUS:
          rollerDataVec.push_back(new TorusRigidBody(center_coords, disp, ii));
          break;
        case ROLLER:
          rollerDataVec.push_back(new RollerRigidBody(center_coords, disp, ii));
          break;
        case STL:
          rollerDataVec.push_back(new STLRigidBody(center_coords, disp, ii));
          break;
        case NURBS:
          // code to be executed if
          break;
        default:
          //  SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
          //     "this type of rigid body is not supported, check spelling "
          //     "(plane, sphere, cylinder, torus, superquadric, stl, nurbs)");
          break;
        }
        auto &rol = rollerDataVec.back();
        CHKERR rol.getBodyOptions();
 
        char pos_data_file[255];
        PetscBool ctg_flag = PETSC_FALSE;
        param = "-position_data" + to_string(ii);
        CHKERR PetscOptionsString(param.c_str(), "", "", "", pos_data_file, 255,
                                  &ctg_flag);
        if (ctg_flag) {
          rol.methodOpForRollerPosition =
              boost::make_shared<TimeAccelerogram>(string(param));
          rol.originCoords.clear();
          rol.rollerDisp.clear();
        }
 
        param = "-direction_data" + to_string(ii);
        CHKERR PetscOptionsString(param.c_str(), "", "", "", pos_data_file, 255,
                                  &ctg_flag);
        if (ctg_flag) {
          rol.methodOpForRollerDirection =
              boost::make_shared<TimeAccelerogram>(string(param));
          rol.BodyDirectionScaled = VectorDouble({0, 0, 0});
        }
 
      }
    }
 
    if (with_contact && rollerDataVec.empty()) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "provide at least one body data for contact (-body1 "
              "sphere    -radius r and opional -move x,y) ");
    }
    // }
 
    ierr = PetscOptionsEnd();
    CHKERRQ(ierr);
 
    MoFEMFunctionReturn(0);
  }

scaleParameters()

MoFEMErrorCode BlockParamData::scaleParameters ( )

inlinevirtual

Implements CacheParams.

Definition at line 280 of file BasicFeTools.hpp.

                                   {
    MoFEMFunctionBeginHot;
 
    young_modulus_inv = 1. / young_modulus;
    young_modulus = 1;
    sigmaY *= young_modulus_inv;
    H *= young_modulus_inv;
    Q_inf *= young_modulus_inv;
    C1_k *= young_modulus_inv;
    visH *= young_modulus_inv;
    
    gravity[0] *= young_modulus_inv;
    gravity[1] *= young_modulus_inv;
    gravity[2] *= young_modulus_inv;
    // cn_cont = 1; // perhaps these should be always assigned by user
    // cn_pl = 1;
 
    MoFEMFunctionReturnHot(0);
  }

---

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

• users_modules/multifield_plasticity/src/BasicFeTools.hpp