mechmat.h

Finite element program for mechanical problem. It can solve various problem in solid problem

#ifndef MECHMAT_H
#define MECHMAT_H


#include <stdio.h>
#include "alias.h"
#include "aepoints.h"
#include "iotools.h"

class intpoints;
class elastisomat;
class elastgmat3d;
class splas1d;
class j2flow;
class j2flow2;
class microM4;
class microSIM;
class microfiber;
class mohrcoulomb;
class mohrcoulombpar;
class boermat;
class drprag;
class camclay;
class shefplast;
class glasgmech;
class glasgowdam;
class creepdam;
class timeswmat;
class svisplas;
class simviscous;
class lemaitre;
class scaldam;
class scaldamcc;
class scaldamtime;
class anisodam;
class aci78;
class cebfip78;
class graphmat;
class graphmattime;
class b3mat;
class rspecmat;
class dplmat;
class creepb;
class consol;
class winpast;
class nonlocmicroM4;
struct matrix;
struct vector;
class therisomat;
class therisomattime;
class nonlocplast;
class nonlocdamg;
class damplast;
class geoelastmat;
class visplast;
class elasttime;
class normmat;
class chen;
class lenjonesmat;
class contactmat;

/**
   class mechmat
   
   it is one of the 5 most important classes of the program
   (probdesc, mechtop, mechmat, mechbclc, mechcrsec)
   
   class mechmat contains data about materials in problem
   
   basic data
   nip (long) - stands for number of all integration points for stiffness matrix computation in problem
   nmt (long) - stands for number of material types
   
   class mechmat creates
   nip objects of class intpoints
   
   JK, TK
*/
class mechmat
{
 public:
  mechmat ();
  ~mechmat ();

  long intpnum (void);
  void intpointalloc ();
  void readip (FILE *in);
  void init_ip_1 (void);
  void init_ip_2 (void);
  void intpointinit ();
  void readmatchar (XFILE *in);
  void readlcsip (FILE *in);
  void read (XFILE *in);

  void matstiff (matrix &d,long ipp,long im=0,long ido=0);
  void elmatstiff (matrix &d,long ipp);
  void elmatcompl (matrix &c,long ipp);
  double give_actual_ym(long ipp, long im=0, long ido=0);
  double give_actual_ft (long ipp, long im=0, long ido=0);
  
  // **********************************************************
  //  plasticity
  // **********************************************************
  double yieldfunction (long ipp, long idpm, matrix &sig, vector &q);
  void dfdsigma (long ipp, long idpm, matrix &sig, vector &q, vector &dfds);
  void dgdsigma (long ipp, long idpm, matrix &sig, vector &q, vector &dgds);
  void dfdsigmadsigma (long ipp, long idpm, matrix &sig, matrix &dfdsds);
  void dgdsigmadsigma (long ipp, long idpm, matrix &sig, matrix &dgdsds);
  void dfdqpar (long ipp, long idpm,matrix &sig,vector &q, vector &dq);
  void dgdqpar (long ipp, long idpm,matrix &sig,vector &q, vector &dq);
  void dfdsigmadq (long ipp, long idpm,matrix &sig,vector &q,matrix &dfdsdq);
  void dgdsigmadq (long ipp, long idpm,matrix &sig,vector &q,matrix &dgdsdq);

  void dhdsigma (long ipp,long idpm,matrix &sigt,vector &q,matrix &dhds);
  void dhdgamma (long ipp,long idpm,vector &epsp,matrix &sig,vector &q,vector &dhdc);
  void dhdqpar (long ipp,long idpm,matrix &sigt,vector &q,matrix &dhdq);
  void hardsoftfunction (long ipp,long idpm,matrix &sigt,vector &q,vector &h);
  //
  //void dfunctdqdq (long ipp, long idpm, matrix &sig, vector &q, matrix &dfdqdq);
  void dhardfdq(long int, long int, long int, double, vector&, matrix&);
  void dqdsigma(long int, long int, matrix&, vector&, matrix&);
  
  //double plasmodscalar(long ipp, long idpm, long ido,matrix &sig, vector &eps, vector &epsp, vector &qtr,double gamma);
  void plasmodscalar(double &denom,long ipp, long idpm, long ido,matrix &sig, vector &eps, vector &epsp, vector &qtr,double gamma);
  //void plasticmoduli (long ipp,long idpm,vector &epsp,matrix &sig,matrix &h);
  void updateq (long ipp, long idpm, long ido, double dgamma, vector &eps, vector &epsp, matrix &sig, vector &q);
  void giveirrstrains(long ipp, long im, long ido, vector &epsirr);
  double givedamage(long ipp, long im, long ido);
  

  
  // **********************************************************
  

  // **********************************************************

  void storestrain (long lcid,long ipp,vector &eps);
  void storestrain (long lcid,long ipp,long fi,vector &eps);
  void storestrain (long lcid,long ipp,long fi,long ncomp,vector &eps);
  void givestrain (long lcid,long ipp,vector &eps);
  void givestrain (long lcid,long ipp,long fi,vector &eps);
  void givestrain (long lcid,long ipp,long fi,long ncomp,vector &eps);
  void cleanstrain ();

  void storestress (long lcid,long ipp,vector &sig);
  void storestress (long lcid,long ipp,long fi,vector &sig);
  void storestress (long lcid,long ipp,long fi,long ncomp,vector &sig);
  void givestress (long lcid,long ipp,vector &sig);
  void givestress (long lcid,long ipp,long fi,vector &sig);
  void givestress (long lcid,long ipp,long fi,long ncomp,vector &sig);

  void storeeigstrain (long ipp,vector &eps);
  void storeeigstrain (long ipp,long fi,long ncomp,vector &eps);
  void giveeigstrain (long ipp,vector &eps);
  void giveeigstrain (long ipp,long fi,long ncomp,vector &eps);

  void storeeigstress (long ipp,vector &sig);
  void storeeigstress (long ipp,long fi,long ncomp,vector &sig);
  void giveeigstress (long ipp,vector &sig);
  void giveeigstress (long ipp,long fi,long ncomp,vector &sig);
  
  void storeeqother (long ipp,long fi,long ncomp,double *comp);
  void giveeqother (long ipp,long fi,long ncomp,double *comp);
  
  // **********************************************************



  long give_num_interparam (long ipp,long idpm);
  void give_interparam (long ipp,long im,long ido,vector &q);
  void store_interparam (long ipp,long im,long ido,vector &q);


  long givencompother (long ipp,long im);
  long givencompeqother (long ipp,long im);


  void compute_averstrains ();
  void temprstrains (long lcid);


  void transformstrain ();

  void computenlstresses (long ipp, long im=0, long ido=0);
  void compnonloc_nlstresses (long ipp, long im=0, long ido=0);

  void cutting_plane (long ipp,long im,long ido,double &gamma,vector &epsn,vector &epsp,vector &q,long ni,double err);
  void mult_surf_cutting_plane (long ipp,vector &epsn,vector &epsp,vector &gamma,vector &q);
  void newton_stress_return (long ipp,long im,long ido,double &gamma,vector &epsn,vector &epsp,vector &q,long ni,double err);
  void newton_stress_return_2 (long ipp,long im,long ido,double &gamma,vector &epsn,vector &epsp,vector &q,long ni,double err);
  

  void damfuncpar(long ipp, long im, vector &eps, vector &kappa);
  double damfunction(long ipp, long im, long ido,vector &kappa, vector &eps);
  double epsefunction(long ipp, long idem);
  double scal_dam_sol (long ipp,long im,long ido,vector &eps,vector &kappa, vector &sigma);
  void stiff_deps_vispl (long ipp,long im,long ido,vector &sig,vector &q,double dt);
  void stiff_deps_creep (long ipp, long im,vector &epscr,long ncomp,long ncomph);
  void stiff_eps (long ipp);

  double nonlocradius (long ipp,long im=0);
  void matdilat (matrix &d,long ipp);
  void updateipval (void);
  void updateipvalmat (long ipp,long im,long ido);
  void initvalues (long ipp,long im,long ido);

  void nonlocaverage(long ipp,long im=0);

  //  void visc_cutting_plane (long ipp,double &gamma,vector &epsn,vector &epsp,vector &q,
  //double gt,double gdt);
  //  void visc_closest_point_proj (long ipp,vector &epsn,vector &epsp,double &gamma,vector &q);

  double give_consparam (long ipp, long im=0, long ido=0);
  void refresh_plast (long im=0, long ido=0);
  
  void storeipvol (long ipp,double vol);
  
  void alloceigstrains ();
  void alloceigstresses ();
  void alloctempstrains ();
  void eigstrmod ();
  void totstrains ();
  void totstrains (long ipp);
  void tempstr_eigstr();
  
  void clean_ip ();
  void save_intpoints (FILE *aux, long ido1, long ncompo);
  void restore_intpoints (FILE *aux, long ido1, long ncompo);

  double give_dampar (long ipp,long im,long ido);

  void alloc_tempr ();

  /************************************/
  //part for creep
  void creep_matstiff (matrix &d, long ipp,long im,long ido);
  double creep_matstiffchange (long ipp,long im,long ido);
  void creep_updateval(long ipp,long im,long ido);
  void creep_phase1 (long ipp,long im,long ido);
  void creep_phase2 (long ipp,long im,long ido);
  void creep_hidden_strains (matrix &screep,vector sig,vector emu, double mi, long n_ret_times, vector ret_times, double actualtime, double dt,strastrestate ss);
  void creep_giveirrstrains (long ipp, long ido, vector &epscr);
  long creep_number_rettimes(long ipp,long im);
  long creep_ncompo (long ipp,long im);
  /************************************/
  
  double give_first_derivative (long ipp,double r);
  double give_second_derivative (long ipp,double r);
  
  
  ///  indicator of plastic regime in domain
  long plast;
  
  ///  type of eigstrain
  eigstraintype est;
  
  ///  number of material types
  long nmt;
  ///  total number of all integration points
  long tnip;
  ///  integration points
  intpoints *ip;
  ///  integration point - element correspondation
  ///  elip[number of int point] = number of element
  long *elip;

  ///  pointers to local coordinate systems in integration points
  long *lcsip;
  ///  array containing local coordinate system basis for integration points
  double **lcsbase;

  /// array with initial conditions at integration points (allocated at mechbclc::readinic)
  double **ic;
  
  ///  array containing volume appropriate to integration points
  double *ipv;
  /// maximum number of component of strain/stress arrays at nodes
  long max_ncompstrn;
  /// maximum number of component of strain/stress array on elements
  long max_ncompstre;
  /// maximum number of component of other array at nodes
  long max_nncompo;
  /// maximum number of component of eqother array on elements
  long max_encompo;

  ///  array containing eigenstrains
  ///  the array is allocated only for several problems
  ///  eigstrains[number of int. point][number of component]
  ///  the array is allocated in function mechbclc::read
  double **eigstrains;
  ///  array containing eigenstresses
  ///  the array is allocated only for several problems
  ///  eigstresses[number of int. point][number of component]
  double **eigstresses;
  ///  array containing strains caused by temperature
  ///  tempstrains[number of int. point][number of component]
  double **tempstrains;
    

  ///  array containing temperatures at integration points
  ///  temp[number of integ. point] - temperature at the required integration point
  double *tempr;
  ///  array containing moistures at integration points
  ///  moist[number of integ. point] - moisture at the required integration point
  double *moist;
  
  
  
  
  ///  elastic isotropic linear material
  elastisomat *eliso;
  ///  elastic general 3D material
  elastgmat3d *elgm3d;

  ///  simple plastic 1D material
  splas1d *spl1d;
  ///  J2 flow material
  j2flow *j2f;
  j2flow2 *j2f2;
  ///  Mohr-Coulomb material
  mohrcoulomb *mcoul;
  ///  Prabolic Mohr-Coulomb material
  mohrcoulombpar *mcpar;
  ///  Boer model of plasticity
  boermat *boerm;
  ///  Drucker-Prager model of plasticity
  drprag *drprm;
  ///  modified cam-clay model
  camclay *cclay;
  ///  Sheffield plasticity model
  shefplast *shpl;
  /// Glasgow scalar damage with a thermal influence  
  glasgmech *glasgmat;
  /// Glasgow damage model
  glasgowdam *glasgdam;
  ///  artificial model for combination of damage and creep model
  creepdam *crdam;
  ///  artificial model for combination of several time dependent material models switched on in the given time 
  timeswmat *tswmat;
  
  
  ///  microplane M4
  microM4 *mpM4;
  ///
  microSIM *mpSIM;
  ///
  microfiber *mpfib;
  
  ///  simple model of viscosity
  simviscous *svis;
  ///  simple visco-plastic material
  svisplas *svipl;
  ///  Lemaitre visco-plastic model
  lemaitre *lmtr;

  ///  isotropic damage material model
  scaldam *scdam;

  ///  simple damage 3D material with crack closure
  scaldamcc *scdamcc;

  /// scalar damage for time dependent problems
  scaldamtime *scdamtime;
  ///  anisotropic damage material model
  anisodam *anidam;
  ///  aci78 model for creep and shrinkage
  aci78 *aci78mod;
  ///  cebfip78 model for creep and shrinkage
  cebfip78 *cebfip78mod;

  /// material with explicit prescribed diagram force/displacement
  graphmat *grmat;

  /// material with explicit prescribed diagram force/displacement or stiffness/displacement
  graphmattime *grmattime;
  
  /// combination of plasticity and special kind of elasticity (different loading and unloading modulus)
  geoelastmat *geoel;

  ///  B3 model of creep based on Bazant theory
  b3mat *crb3;
  ///  retardation spectrum
  rspecmat *crrs;
  ///  Double power law model of creep based on Bazant theory
  dplmat *crdpl;
  ///  model of creep based on Bazant theory
  creepb *crbaz;
  ///  consolidation model
  consol *csol;
  ///  Winkler-Pasternak material model of subsoil
  winpast *wpast;

  nonlocmicroM4 *nmpM4;

  ///  thermal isotropic dilatancy model
  therisomat *tidilat;

  ///  thermal isotropic dilatancy model with time dependent temperature
  therisomattime *tidilattime;

  /// nonlocal plasticity models
  nonlocplast *nlplast;

  /// nonlocal damage models
  nonlocdamg *nldamg;

  ///  artificial model for combination of damage and plasticity model
  damplast * dampl;
  ///
  visplast *visplas;
  ///  artificial model for time dependent problem
  elasttime *eltimemat;
  
  ///  material model based on Eurocode
  normmat *normm;
  
  ///  Chen model of plasticity of concrete
  chen *chplast;

  ///  strain/stress points
  aepoints stra,stre;
  
  ///  Lennard-Jones interatomic potential
  lenjonesmat *lenjon;

  ///  material model for contact problems
  contactmat *conmat;

};

#endif