probdesc.h

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

#ifndef PROBDESC_H
#define PROBDESC_H

#include <stdio.h>
#include "alias.h"
#include "galias.h"
#include "gfunct.h"
#include "timecontr.h"
#include "slesolv.h"
#include "nonlinman.h"
#include "eigvalsol.h"
#include "xfile.h"

class auxdatout;
class gmatrix;

/**
   class probdesc
   
   it is one of the five most important classes of the program
   (probdesc, mechtop, mechmat, mechbclc, mechcrsec)
   
   
   JK, TK
*/

class probdesc
{
 public:
  probdesc ();
  ~probdesc ();
  void read (XFILE *in);
  void print (FILE *out);
  void filename_decomposition (const char *file,char *&pathm,char *&namem,char *&suffixm);
  
  //  for open dx
  long  detnodstrain;

  ///  problem name
  char name[1001];

  ///  type of problem
  problemtype tprob;

  ///  STORAGE TYPES
  ///  type of storage of stiffness matrix
  storagetype tstorsm;
  ///  type of storage of mass matrix
  storagetype tstormm;

  ///  TYPE OF STIFFNESS MATRIX
  ///  stmat=1 - initial elastic stiffness
  ///  stmat=2 - tangent stiffness
  stiffmatrix stmat;
  
  ///  DAMPING
  ///  type of damping
  damping damp;
  ///  mass matrix coefficient
  double dmass;
  ///  stiffness matrix coefficient
  double dstiff;


  ///  time
  double time;
  ///  time controller
  timecontr timecon;
  /// load coefficient
  double lambda;

  
  ///  SOLVER TYPES
  ///  type of eigenvibration solver
  eigvalsol eigsol;
  ///  type of forced vibration solver
  forcedsolver tforvib;
  /// type of earth pressure solver
  epsolvertype tepsol;
  
  ///  data about solver of system of linear equations
  slesolv ssle;
  ///  data about solver of system of nonlinear equations
  nonlinman nlman;
  ///  data about solver of eigenvalues and eigenvectors
  //eigvalsol eig;
  

  ///  threshold for rejection from compressed storages
  double limit;
  ///  computer zero
  double zero;

  

  
  ///  FORCED VIBRATION SOLVER
  ///  coefficients of the Newmark method
  double alphafvn,deltafvn;
  
  

  ///  VISCO-PROBLEM SOLVER
  
  ///  computation phase
  ///  visco-problem solver
  ///  phase=1 - right hand side computation
  ///  phase=2 - stress computation
  ///  nonlocal models
  ///  phase=1 - evaluation of local variables
  ///  phase=2 - evaluation of non-local variables
  long phase;

  ///  variable for computation of internal forces at nodes
  ///  nodeintfor=0 - internal forces are not computed at nodes
  ///  nodeintfor=1 - internal forces are  computed at nodes
  long nodeintfor;

  ///  stress computation
  ///  strcomp=0 - stresses are not computed during evaluation of internal forces
  ///              this is used for initiation of static nonlinear problems
  ///  strcomp=1 - stresses are computed during evaluation of internal forces
  ///              except of the previous case, this is always used
  long strcomp;
  
  
  //  EARTH-PRESSURE SOLVER
  ///  maximum number of increments
  long niep;
  ///  required norm of vector of unbalanced forces
  double errep;
  /// load step size for the load iteration algorithm
  double stepep;
  /// required error of lambda value in the arclength method
  double rlerrep;
  /// number of selected nodes for earth pressure problems, where will be variable supports
  long nselnodep;
  /// selected nodes for earth pressure problems, where will be variable supports
  long *selnodep;
  /// coeficient for static load, which simulates excaving material; number of coef. equals to niep
  double *loadcoef;



  ///  type of material model (local x non-local)
  materialmodel matmodel;
  
  ///  compute strains
  ///  straincomp=0 - strains are not computed
  ///  straincomp=1 - strains are computed
  long straincomp;
  ///  strain averaging
  ///  strainaver=0 - values are not averaged
  ///  strainaver=1 - values are averaged
  long strainaver;
  ///  state of strain computation
  ///  strainstate = 0 - strains at integration points have not been computed
  ///  strainstate = 1 - strains at integration points have been computed
  long strainstate;
  ///  position where strains are computed
  ///  strainpos = 1 - integration points
  ///  strainpos = 2 - nodes, values are copied from the closest integration point
  ///  strainpos = 3 - nodes, values are computed at nodes
  long strainpos;

  ///  compute stresses
  ///  stresscomp=0 - stresses are not computed
  ///  stresscomp=1 - stresses are computed
  long stresscomp;
  ///  stress averaging
  ///  stressaver=0 - values are not averaged
  ///  stressaver=1 - values are averaged
  long stressaver;
  ///  state of stress computation
  ///  stressstate = 0 - stresses at integration points have not been computed
  ///  stressstate = 1 - stresses at integration points have been computed
  long stressstate;
  ///  position where stresses are computed
  ///  stresspos = 1 - integration points
  ///  stresspos = 2 - nodes, values are copied from the closest integration point
  ///  stresspos = 3 - nodes, values are computed at nodes
  long stresspos;

  ///  compute other values
  ///  othercomp=0 - components of other array are not computed
  ///  othercomp=1 - components of other array are computed
  long othercomp;
  ///  other values averaging
  ///  otheraver=0 - components of other array are not averaged
  ///  otheraver=1 - components of other array are averaged
  long otheraver;
  ///  state of other computation
  ///  otherstate = 0 - other components have not been computed
  ///  otherstate = 1 - other components have been computed
  long otherstate;
  ///  position where components of array other are computed
  ///  otherpos = 1 - integration points
  ///  otherpos = 2 - nodes, values are copied from the closest integration point
  long otherpos;

  ///  compute reactions
  ///  reactcomp=0 - reactions are not computed
  ///  reactcomp=1 - reactions are computed
  long reactcomp;



  ///  ADAPTIVITY COMPUTATION
  long adaptivity;
  char *path;
  char *filename;
  char *suffix;
  long diagonalization;
  //  
  long adaptflag;
  ///  required accuracy in adaptivity analysis
  double adapt_accuracy;
  
  ///  variables for adaptivity
  double corr;
  double limf;
  double clos;
  double plra;
  
  
  
  ///  stochastic calculation indicator
  ///  stochasticcalc=0 - deterministic computation
  ///  stochasticcalc=1 - stochastic/fuzzy computation, data are read all at once
  ///  stochasticcalc=2 - stochastic/fuzzy computation, data are read sequentially
  ///  stochasticcalc=3 - stochastic/fuzzy computation, data are generated in the code
  long stochasticcalc;
  
  ///  indicator of eigenstrains
  long eigstrains;
  
  ///  indicator of temperature
  ///  temperature=0 - problem without influence of temperature
  ///  temperature=1 - problem with influence of defined temperature
  ///  temperature=2 - problem with influence of computed temperature
  long temperature;
  
  ///  type of layered problem
  long tlm;

  ///  number of simulation
  long ns;
  
  ///  definition of homogenization
  ///  homog = 0 - homogenization is switched off
  ///  homog = 1 - homogenization is switched on
  long homog;
  
  
  ///  number of particles in one cell describing molecular structure
  ///  it has similar meaning as number nodes on one finite element
  long mcnne;
  
  ///  dimension of solved problem
  long dim;
  
  ///  estimated number of rigid body motions
  long ense;
  
  ///  number of iterations in method of variable stiffness
  long nivsm;
  
  
  //  number of increments in floating subdomain problems
  long nincr;


    
  //  NEWTON-RAPHSON METHOD
  ///  maximum number of iterations in inner loop
  ///  maximum number of iterations in one increment
  long niilnr;
  ///  required norm of vector of unbalanced forces
  double errnr;
  
  ///  type of fully coupled solver
  ///  nrsolv = 1 - full newton method (matrices are recomputed in all internal loops)
  ///  nrsolv = 2 - modified Newton method (matrices are recomputed only in new increment)
  nonlintimesolvertype nrsolv;
 

  ///  type of time printing
  timetypeprin tpr;
};

#endif