gmpFemSolverOptions.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_SOLVER_OPTIONS_H_
#define _GEMA_PLUGIN_FEM_SOLVER_OPTIONS_H_
 
#include <QString>
#include <QVector>
 
#include "gmpFemProcessConfig.h"
 
#include <gmTaskManager.h>
#include <luaEnv.h>
 
class LuaTable;
class GmSimulationData;
 
class GMP_FEM_PROCESS_API_EXPORT GmpFemSolverOptions
{
public:
 
  enum AssemblerMode
  {
    automatic,
    noDofHandling,
    removeDof,
    //-----------------------------------
    // IMPORTANT: When adding entries or CHANGING enum order, please remember 
    //            to also change assemblerModeOptions()
  };
 
  enum SolverType
  {
    staticLinear,
    staticSolver,
    transientSolver,
    transientLocalSolver,
    transientNonlinearDc,
    transientAutomaticTimeStep,
    transientIterative,
 
    //-----------------------------------
    // IMPORTANT: When adding entries or CHANGING enum order, please remember 
    //            to also change solverTypeOptions()
  };
 
  enum ConvergenceCriterion
  {
    load,
    displacement,
    velocity,
    flux,
    absDisplacement,
    //-----------------------------------
    // IMPORTANT: When adding entries or CHANGING enum order, please remember 
    //            to also change convergenceCriterionOptions()  
  };
 
  enum NonlinearScheme
  {
      newton,
      picard,
      //-----------------------------------
      // IMPORTANT: When adding entries or CHANGING enum order, please remember 
      //            to also change nonlinearSchemeOptions()  
  };
 
  enum class IncrementStrategy
  {
    loadControlIncrement,
    displacementControlIncrement,
    cylindricalArcLengthIncrement,
    sphericalArcLengthIncrement,
    dissipatedEnergyIncrement,
    combinedArcDissipatedEnergyIncrement,
    strainControlIncrement,
    elementControlIncrement,
    externalWorkIncrement,
    prescribedDisplacementIncrement,
    //-----------------------------------
    // IMPORTANT: When adding entries or CHANGING enum order, please remember 
    //            to also change incrementStrategyOptions()    
  };
 
  enum class IterationStrategy
  {
    loadControl,
    displacementControl,
    linearArcLength,
    cylindricalArcLength,
    sphericalArcLength,
    dissipatedEnergy,
    combinedArcDissipatedEnergy,
    elementControl,
    strainControl,
    minimalNorm,
    orthogonalResidue,
    prescribedDisplacement,
    //-----------------------------------
    // IMPORTANT: When adding entries or CHANGING enum order, please remember 
    //            to also change iterationStrategyOptions()    
  };
 
  enum NewtonRaphsonMode
  {
    full,
    modified,
    broyden,
    bfgs,
 
    //-----------------------------------
    // IMPORTANT: When adding entries or CHANGING enum order, please remember 
    //            to also change newtonRaphsonModeOptions()
  };
 
  enum GeostaticType
  {
    none,
    fixedNode,
    selfWeight,
    //-----------------------------------
    // IMPORTANT: When adding entries or CHANGING enum order, please remember 
    //            to also change geostaticTypeOptions()
  };
 
  enum CouplingStrategy
  {
    fully,
    iterative,
 
    //-----------------------------------
    // IMPORTANT: When adding entries or CHANGING enum order, please remember 
    //            to also change couplingStrategyOptions()
  };
  
 
  /* Linear Transient Methods Type*/
  enum LinearTransientMethods {
    Implicit,
          RK2,
          RK4,
          RK6,
  };
 
  enum ReductionMethod {
    NoReduction,
          GuyanReduction,
  };
 
  enum TimeIncrementMethod {
          userDefined,
          rate_based,
          maxIncrementTransientVar,
  };
 
  enum PrintOptions
  {
    printElementMatrices   = 0x0001,  
    printElementVectors    = 0x0002,  
    printElementDofMapping = 0x0004,  
    printEqMatrix          = 0x0008,  
    printEqVector          = 0x0010,  
    printGlobalMatrices    = 0x0020,  
    printGlobalVectors     = 0x0040,  
    printLinearMatrix      = 0x0080,  
    printLinearVector      = 0x0100,  
    printLinearResult      = 0x0200,  
    saveLinearMatrix       = 0x0400,  
    saveLinearVector       = 0x0800,  
    saveLinearResult       = 0x1000,  
  };
 
  enum ElementSaveOptions {
    saveIteration     = 0x0001,  
    savePhysicsId     = 0x0002,  
    savePhysicsHeader = 0x0004,  
    saveDofMap        = 0x0008,  
    saveDofValues     = 0x0010,  
    saveFeVector      = 0x0020,  
    saveFiVector      = 0x0040,  
    saveKMatrix       = 0x0080,  
    saveCMatrix       = 0x0100,  
    saveMMatrix       = 0x0200,  
  };
 
  enum AccurateMethod {
          firstOrder,
          secondOrder,   
        //-----------------------------------
        // IMPORTANT: When adding entries or CHANGING enum order, please remember 
        //            to also change AccurateMethodOptions()   
  };
 
  GmpFemSolverOptions();
 
  void loadFromTable(LuaTable& optionsTable, GmSimulationData* simData);
 
  // Print & save options
  unsigned        _printOptions;     
  int             _printFieldWidth;  
  char            _printFormat;      
  int             _printPrecision;   
  QString         _saveBaseName;     
  QString         _saveFilterAttr;   
  QVector<double> _saveFilterValues; 
 
  // Multi threaded options used when traversing elements
  int                                  _mtnWorkers; 
  int                                  _mtnTasks;   
  GmTaskManager::CellPartitionStrategy _mtStrategy; 
 
  // Assembler option. 
  AssemblerMode     _assemblerDofMode;  
 
  // Analysis type and other strategy definitions
  SolverType        _type;                       
  IncrementStrategy _incrementStrategy;
  IterationStrategy _iterationStrategy;
  NewtonRaphsonMode _newtonRaphsonMode;
  GeostaticType     _geostaticType;
  QString           _physicsType;       
  CouplingStrategy  _couplingStrategy;
  ReductionMethod   _reductionMethod;
  LinearTransientMethods _linearTransientMethod;
  TimeIncrementMethod    _timeIncrementMethod;
  AccurateMethod        _Order; 
  NonlinearScheme          _nonlinearScheme;
 
  // Load step and iteration options
  unsigned          _stepsMax;                   
  unsigned          _attemptsMax;                
  unsigned          _iterationsMax;              
  unsigned          _iterationsDesired;          
  
  // Tolerances & convergence criteria
  unsigned          _convergenceCriterion;
  QVector<double>   _tolerance;                  
  QStringList       _toleranceQuotedGroupNames;  
  bool              _updateNumSolverTol;         
 
  // displacement control Data & dof index
  QVector<int>     _dispControlData;            
 
  // Static solver options
  double            _loadOld;                    
  double            _loadNew;                    
  double            _loadMax;                    
  double            _loadIncrement;              
  double            _loadMinIncrement;           
  double            _loadMaxIncrement;           
  bool              _loadAdjustStep;             
  double            _minDissipatedEnergy;        
  double            _initialEnergyIncrement;     
  bool              _normalFlow;                 
  bool              _crackTracking;              
   
  // Transient solver options
  double            _timeOld;
  double            _timeNew;
  double            _timeMax;                    
  double            _timeIncrement;              
  double            _timeMinIncrement;           
  double            _timeMaxIncrement;           
  double            _integrationScheme;          
  bool              _timeAdjustStep;
  double            _iterationTolerance;         
  double            _integrationTolerance;       
  double            _transientVariableChange;    
  bool              _skipLocalError;             
  bool              _resetDisplacement;          
  
  // controls time incrementation
  unsigned          _iterationsL;                
  unsigned          _iterationsG;                
  bool              _timeControl;                 
  unsigned          _incrementsT;                 
  double            _DeltaG;                      
  double            _DeltaM;                      
  double            _DeltaB;                      
  double            _DeltaF;                      
  // Element saving options
  bool     _saveElementData;          
  QString  _saveElementDataFileMask;  
  unsigned _saveElementOptions;       
 
  // Report options
  bool    _report;            
  QString _reportFile;        
  QString _reportId;          
  bool    _reportDetailed;    
 
 
  const char** asssemblerModeOptions();
  const char** solverTypeOptions();
  const char** newtonRaphsonModeOptions();
  const char** incrementStrategyOptions();
  const char** iterationStrategyOptions();
  const char** integrationSchemeOptions();
  const char** nonlinearSchemeOptions();
  const char** geostaticTypeOptions();
  const char** couplingStrategyOptions();
  const char** convergenceCriterionOptions();
  const char** transientLinearOptions();
  const char** reductionMethodOptions();
  const char** timeIncrementAdaptativeOptions();
  const char** AccurateMethodOptions();
 
private:
  void setAsssemblerMode   (int index) { _assemblerDofMode  = (AssemblerMode)index;     }
  void setSolverType       (int index) { _type              = (SolverType)index;        }
  void setNewtonRaphsonMode(int index) { _newtonRaphsonMode = (NewtonRaphsonMode)index; }
  void setIncrementStrategy(int index) { _incrementStrategy = (IncrementStrategy)index; }
  void setIterationStrategy(int index) { _iterationStrategy = (IterationStrategy)index; }
  void setIntegrationScheme(int index);
  void setNonlinearScheme  (int index) { _nonlinearScheme   = (NonlinearScheme)index;   }
  void setGeostaticType    (int index) { _geostaticType     = (GeostaticType)index;     }
  void setCouplingStrategy (int index) { _couplingStrategy  = (CouplingStrategy)index;  }
  void setLinearTransient  (int index) {_linearTransientMethod = (LinearTransientMethods)index;}
  void setReductionMethod  (int index) {_reductionMethod    = (ReductionMethod)index; }
  void setTimeIncrementStrategy(int index) { _timeIncrementMethod = (TimeIncrementMethod)index; }
  void setAccurateMethod   (int index) { _Order = (AccurateMethod)index; }
};
 
#endif