gmpFemNonLinearSolver.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE.
**
************************************************************************/
 
#ifndef _GEMA_PLUGIN_FEM_NONLINEARSOLVER_H_
#define _GEMA_PLUGIN_FEM_NONLINEARSOLVER_H_
 
#include "gmpFemSolver.h"
#include "gmpFemSolverOptions.h"
 
class GmRunProgressStats;
class GmRunProgress;
 
class GMP_FEM_PROCESS_API_EXPORT GmpFemNonLinearSolver : public GmpFemSolver
{
  friend class XfemSolver;
public:
  //constructor
  GmpFemNonLinearSolver(GmElementMesh*, GmSimulationData*, const QVector<GmpFemPhysics*>&, GmNumSolver*,
                 const GmpFemSolverOptions&, const GmLogCategory&);
 
  //destructor
  virtual ~GmpFemNonLinearSolver();
  
  struct solverState
  {
    bool   _equilibrium = false; 
    bool   _iter4new = false;
    double _dt;                  
    double _newdt = 0.0;   
    double _time;                
    double _tolmax = 0.0;   
    double _erMax = 0.0;   
    double _erMax1 = 1e6;   
    double _erMax2 = 1e6;   
    unsigned _iter = 0;     
    GmVector _erL;
    solverState(unsigned ng, double dt, const double t)
      :_erL(ng, arma::fill::zeros), _time(t), _dt(dt)
    {}
  };
 
  void enableFastUpdate(bool mode) { _fastUpdate = mode; }
 
  // initializing Fem NL Solver
  virtual bool init();
 
  virtual bool initResultAttributes(int fatherItemId);
  bool         initReport(GmRunProgressStats* ps);
 
 
  //virtual bool step(double dt, double* newt);
  virtual bool runStep(double dt, double* newt, bool* conv, double* err, int* niter, bool eval=false);
  // Geostatic procedure
  virtual bool geostatic(QString svId = "u", QString gaId = "Em");
  // virtual check time step
  virtual bool checkTimeStep(double dt);
  // Initialize progress stats
  void initializeProgress(solverState& sS, GmRunProgress& ps);
 
protected:
  virtual bool addStateItemsToGroup     (GmStateDump* state, int groupId);
  virtual bool fillStateControlMapData  (QVariantMap* map);
  virtual bool stateControlMapDataLoaded(QVariantMap* map);
  virtual bool stateLoadedCalcDerivedResultsNonLinear();
 
  virtual bool fillStateControlMapDataStaticSolver(QVariantMap* map);
  virtual bool stateControlMapDataLoadedStaticSolver(QVariantMap* map);
  virtual bool fillStateControlMapDataTransientSolver(QVariantMap* map);
  virtual bool stateControlMapDataLoadedTransientSolver(QVariantMap* map);
 
//private:
  // general
  virtual bool initElementSets(GmNumSolver*);
  virtual void setElementSets(bool, bool, bool, bool, bool);
 
  virtual bool prepareNonLinearSolverStep(solverState& sS, GmRunProgress& ps);
 
  virtual bool assembleInitialSystem(const double&);
  virtual bool solveInitialSystem(solverState& sS, GmRunProgress& ps);
 
  virtual bool assembleIterationSystem(const double&);
 
  virtual bool solveNewtonRaphson(GmRunProgress& ps, double& dt, const double& t, double* newt);
 
  virtual bool applyTimeDiscretization() { return true; }
 
  virtual bool applyFixedBoundaryConditions(int*);
  virtual bool intialFixedBoundaryConditions(int*);
  virtual bool applyNonzeroFixedBCsbyModification(int*);
  virtual bool isTransient() const;
  virtual bool isNonlinear() const;
 
  virtual bool convergence() const;
  virtual bool convergenceN (GmVector& erL, GmRunProgress* rp = NULL) const;
  virtual bool convergenceDC(GmVector& er) const;
  virtual void update();
  virtual void restore();
  //Corrector 
  //virtual bool corrector(GmVector& er, GmVector) const;
 
  //Iterative Error
  virtual bool loadError(GmVector& er)const;
  virtual bool dispError(GmVector& er) const;
  virtual bool velocityError(GmVector& er)const;
  virtual bool fluxError(GmVector& er) const;
  virtual bool fluxMagnitude(GmVector& qa) const;
 
  virtual bool convergenceStep(unsigned& attempt, unsigned& incT, double, double);
  virtual bool maxErr(GmVector, double& ermax, double &tolmax);
  virtual bool maxVal(GmVector& array,  const GmVector&) const;
  virtual bool phygroupName(int & kgroup,  QString var) const;
  virtual bool divergingIncrement(unsigned iter, double tolmax, double ermax, double& ermax_1, double& ermax_2);
  virtual bool adaptativeTimeAbqs(bool conv, unsigned iter, double dt, double& newdt, double errmax, unsigned inc, bool iter4);
  virtual bool adaptativeTime(bool conv, int iter, double dt, double& newdt, double err, double tol);
  virtual void saveInternalForceAttributes(GmVector& dv);
 
  virtual void setLoad();
  virtual void setTime();
  virtual void setState();
  virtual void setTransientSystem(double);
 
  virtual bool getLinearSystem(double dt);
  virtual bool getSystemRHSVector(double dt);
  virtual bool getSystemResidualVector(double dt);
  virtual bool solveLinearSystem();
  bool applyDirichletBoundaryConditions();
 
  virtual GmpFemPhysics::FemResultType updateResidualForceAndStiffnessMatrix(double l);
  virtual GmpFemPhysics::FemResultType fillStiffnessMatrixBroyden();
 
 
  virtual double evalLocalError(GmVector, GmVector);
 
  virtual double evalTimeIncrementSize(unsigned, double, double, GmVector&);
 
  // Solvers
 
  //virtual bool staticSolver(double step, double* newt, bool* conv, double* err, int* niter, bool eval);
  virtual bool transientSolver(double dt, double* newt, bool* conv, double* err, int* niter, bool eval);
  virtual bool transientLocalSolver(double dt, double* newt, bool* conv, double* err, int* niter, bool eval);
  virtual bool iterativeSolver(double dt, double* newt, bool* conv, double* err, int* niter, bool eval);
  
  // To check
  virtual bool stepStandardDc(double dt, double* newt, bool* conv, double* err, int* niter, bool eval);
  //virtual bool stepTransientNonlinearAut(double dt, double* newt);
 
  // atributtes
  double     _dl;
  double     _dl0;
  double     _ddl;
  double     _Lold;
  double     _tin;
  // double     _ts;                
  double     _dt;
  double     _oldIter;
  double     _hlast;
 
  // controls time incrementation
  unsigned   _attempt = 0;
  unsigned   _ninc = 0;          
  unsigned   _incT = 0;          
  bool       _iter4old = false;  
 
 
 
  GmVector   _v;
  GmVector   _dx;
  GmVector   _dv;
  GmVector   _xold;
  GmVector   _vold;
  GmVector   _dxt;
  GmVector   _ddx;
  GmVector   _ddxt;
  GmVector   _ddxr;
  GmVector   _FeGs;
  GmVector   _r0;
  // controls fluxe
  GmVector   _qta;      
  GmVector   _qtamax;   
 
 
  QVector<int> _fixedDof;
 
  bool _fastUpdate; 
  bool _hasUnanamedDofs; 
 
 
  struct TrackItemState
  {
    bool _geostatic = false; // Is this a geostatic step?
    int _femItem    = -1;   
    int _femNlItem  = -1;   
    int _solverItem = -1;   
 
    int _incAttr         = -1; 
    int _attemptAttr     = -1; 
    int _convAttr        = -1; 
    int _nlIterAttr      = -1; 
    int _simTimeAttr     = -1; 
    int _simStepAttr     = -1; 
    int _solverCallsAttr = -1; 
 
    int _nlErrorAttr     = -1;     
 
    int _solverFemExecTimeAttr = -1; 
    int _solverFemNumIterAttr  = -1; 
    int _prepareExecTimeAttr   = -1; 
  };
 
  TrackItemState _td; 
  
};
 
#endif