gmpFemTransientNonLinearSolver.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_TRANSIENTNONLINEARSOLVER_H_
#define _GEMA_PLUGIN_FEM_TRANSIENTNONLINEARSOLVER_H_
 
#include "gmpFemNonLinearSolver.h"
#include "gmpFemSolverOptions.h"
 
class GmRunProgressStats;
class GmRunProgress;
 
class GMP_FEM_PROCESS_API_EXPORT GmpFemTransientNonLinearSolver : public GmpFemNonLinearSolver
{
public:
  //constructor
  GmpFemTransientNonLinearSolver(GmElementMesh*, GmSimulationData*, const QVector<GmpFemPhysics*>&, GmNumSolver*,
                 const GmpFemSolverOptions&, const GmLogCategory&);
 
  //destructor
  virtual ~GmpFemTransientNonLinearSolver();
  
  void enableFastUpdate(bool mode) { _fastUpdate = mode; }
 
  //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");
 
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 void setElementDiscretizedSystem(bool RHS, bool LHS);
  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&);
 
 
  // To check
  virtual bool stepStandardDc(double dt, double* newt, bool* conv, double* err, int* niter, bool eval);
  virtual bool stepTransientNonlinearAut(double dt, double* newt);
 
 
#if 0
  double     _dl0;
  
  double     _Lold;
  
  // 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 // 0
 
};
 
#endif