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,
    transientLinear,
    transientSolver,
    transientNonlinearDc,
    transientAutomaticTimeStep,
    staticAutomaticStep,
    hydraulicFract,
    transientIterative,
    dynamicLinear,
    dynamicSolver,
    state,
    //-----------------------------------
    // IMPORTANT: When adding entries or CHANGING enum order, please remember 
    //            to also change solverTypeOptions()
  };

  enum ConvergenceCriterion
  {
    load,
    displacement,
    velocity,
        flux,
    //-----------------------------------
    // IMPORTANT: When adding entries or CHANGING enum order, please remember 
    //            to also change convergenceCriterionOptions()  
  };

  enum 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 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 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 options
  unsigned _printOptions;     
  int      _printFieldWidth;  
  char     _printFormat;      
  int      _printPrecision;   

  // Multi threaded options used when traversing elements
  int                                  _mtnWorkers; 
  int                                  _mtnTasks;   
  GmTaskManager::CellPartitionStrategy _mtStrategy; 

  // Assembler option. 
  AssemblerMode     _assemblerDofMode;  

  // User defined prefix for result attributes
  QString           _resultAttributePrefix; 

  // Analysis type and other strategy definitions
  SolverType        _type;                       
  IncrementStrategy _incrementStrategy;
  IterationStrategy _iterationStrategy;
  NewtonRaphsonMode _newtonRaphsonMode;
  GeostaticType     _geostaticType;
  CouplingStrategy  _couplingStrategy;
  ReductionMethod   _reductionMethod;
  LinearTransientMethods _linearTransientMethod;
  TimeIncrementMethod    _timeIncrementMethod;
  AccurateMethod        _Order; 

  // Load step and iteration options
  unsigned          _stepsMax;                   
  unsigned          _attemptsMax;                
  unsigned          _iterationsMax;              
  unsigned          _iterationsDesired;          
  
  // Tolerances & convergence criteria
  unsigned          _convergenceCriterion;
  QVector<double>   _tolerance;                  
  
  // 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;       

private:
  const char** asssemblerModeOptions();
  const char** solverTypeOptions();
  const char** newtonRaphsonModeOptions();
  const char** incrementStrategyOptions();
  const char** iterationStrategyOptions();
  const char** integrationSchemeOptions();
  const char** geostaticTypeOptions();
  const char** couplingStrategyOptions();
  const char** convergenceCriterionOptions();
  const char** transientLinearOptions();
  const char** reductionMethodOptions();
  const char** timeIncrementAdaptativeOptions();
  const char** AccurateMethodOptions();


  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 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