Tools.h

Go to the documentation of this file.

//
//       ,---.     ,--,    .---.     ,--,    ,---.    .-. .-.
//       | .-'   .' .')   / .-. )  .' .'     | .-'    |  \| |
//       | `-.   |  |(_)  | | |(_) |  |  __  | `-.    |   | |
//       | .-'   \  \     | | | |  \  \ ( _) | .-'    | |\  |
//       |  `--.  \  `-.  \ `-' /   \  `-) ) |  `--.  | | |)|
//       /( __.'   \____\  )---'    )\____/  /( __.'  /(  (_)
//      (__)              (_)      (__)     (__)     (__)
//      Official webSite: https://code-mphi.github.io/ECOGEN/
//
//  This file is part of ECOGEN.
//
//  ECOGEN is the legal property of its developers, whose names
//  are listed in the copyright file included with this source
//  distribution.
//
//  ECOGEN is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published
//  by the Free Software Foundation, either version 3 of the License,
//  or (at your option) any later version.
//
//  ECOGEN is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with ECOGEN (file LICENSE).
//  If not, see <http://www.gnu.org/licenses/>.
 
#ifndef TOOLS_H
#define TOOLS_H
 
#include "Eos/Eos.h"
 
//#define DEBUG

enum Prim
{
  vecPhases,
  vecPhasesO2,
  vecSlopes,
  resume
};

enum Axis
{
  X,
  Y,
  Z
};

enum TypeOutput
{
  GNU,
  VTK,
  VTKHDF
};

enum TypeM
{
  REC,
  UNS,
  AMR
};

enum TypeData
{
  FLOAT,
  DOUBLE,
  INT,
  CHAR
};

enum TypeGO
{
  VERTEX,
  LINE,
  PLAN
};

enum TypeBC
{
  NONREFLECTING     = 1,
  WALL              = 2,
  OUTLETPRESSURE    = 3,
  INLETINJSTAGSTATE = 4,
  INLETTANK         = 5,
  SYMMETRY          = 6,
  INLETINJTEMP      = 7,
  NULLFLUX          = 8,
  OUTLETMASSFLOW    = 9,
  PERIODIC          = 10,
  MOVINGWALL        = 11,
};

enum VarBoundary
{
  p,
  rho,
  velU,
  velV,
  velW,
  SIZE = (velW + 1)
};

enum TypeBCHeat
{
  ADIABATIC   = 0,
  IMPOSEDTEMP = 1,
  IMPOSEDFLUX = 2
};

enum TypeRelax
{
  U    = 0,
  P    = 1,
  PT   = 2,
  PTMU = 3
};

enum TypeGrad
{
  FD,
  GG
};

enum PhaseType
{
  LIQ = 0,
  VAP = 1
};

enum class SimulationOrder
{
  first,
  second
};

enum LimiterType
{
  NONE     = 0,
  MINMOD   = 1,
  SUPERBEE = 2
};

enum class Variable
{
  transport,
  pressure,
  density,
  alpha,
  velocityMag,
  velocityU,
  velocityV,
  velocityW,
  temperature,
  QPA,
  lambda,
  cobaseXX,
  cobaseXY,
  cobaseXZ,
  cobaseYX,
  cobaseYY,
  cobaseYZ,
  cobaseZX,
  cobaseZY,
  cobaseZZ
};

enum class TypeContactAreas
{
  symmetric,
  nonsymmetric
};

template <class Type> using TypeMeshContainer = std::vector<Type>;

template <typename T> int sign(T val) { return (val < T(0)) ? -1 : 1; } //This sign function can take the value -1 or 1
// template <typename T> int sign(T val) { return (T(0) < val) - (val < T(0)); } //This sign function can take the value -1, 1 or 0

template <class T> inline void destroy(T*& p)
{
  delete p;
  p = nullptr;
}

template <class T> inline void destroy_array(T*& p)
{
  delete[] p;
  p = nullptr;
}

class Tools
{
  public:
    Tools(const int& numbPhases, const int& numbSolids, const int& numbTransports);
    ~Tools();

    static void uppercase(std::string& string);

    static void lowercase(std::string& string);

    static void swap(double& a, double& b);

    double returnNonZeroValue(double a);
 
    std::vector<double> ak;
    std::vector<double> Yk;
    std::vector<double> rhok;
    std::vector<double> pk;
    std::vector<double> ek;
    std::vector<double> Ek;
    std::vector<double> akS;
    std::vector<double> rhokS;
    std::vector<double> rhokStar;
    std::vector<double> pkStar;
    std::vector<double> ekStar;
    std::vector<double> EkStar;
    std::vector<double> vkStar;
    std::vector<double> YkStar;
    std::vector<double> Deltapk;       
    std::vector<double> zk;            
    std::vector<double> rho_cIksquare; 
    std::vector<Eos*> eos;
    std::vector<double> Hk0;
    std::vector<double> Yk0;
    std::vector<double> compactionPk_dkappadxi;    
    std::vector<double> compactionPk_dkappadalpha; 
    std::vector<double> dlambda;                   
    std::vector<Tensor> dplast;                    
    std::vector<Tensor> LogCobase;                 
    std::vector<double> LogLambda;                 
    std::vector<bool> alphaNull;                   
    std::vector<bool> relaxSolidPlast;             
 
    //Variables for RK45 solver (visco-plastic relaxation)
    std::vector<double> ak4;
    std::vector<double> ak5;
    std::vector<double> ek4;
    std::vector<double> ek5;
    std::vector<Tensor> LogCobase4; 
    std::vector<Tensor> LogCobase5; 
    std::vector<double> LogLambda4; 
    std::vector<double> LogLambda5; 
    std::vector<Tensor> dLogCobaseDt1;
    std::vector<Tensor> dLogCobaseDt2;
    std::vector<Tensor> dLogCobaseDt3;
    std::vector<Tensor> dLogCobaseDt4;
    std::vector<Tensor> dLogCobaseDt5;
    std::vector<Tensor> dLogCobaseDt6;
    std::vector<double> dLogLambdaDt1;
    std::vector<double> dLogLambdaDt2;
    std::vector<double> dLogLambdaDt3;
    std::vector<double> dLogLambdaDt4;
    std::vector<double> dLogLambdaDt5;
    std::vector<double> dLogLambdaDt6;
    std::vector<double> dakDt1;
    std::vector<double> dakDt2;
    std::vector<double> dakDt3;
    std::vector<double> dakDt4;
    std::vector<double> dakDt5;
    std::vector<double> dakDt6;
    std::vector<double> dekDt1;
    std::vector<double> dekDt2;
    std::vector<double> dekDt3;
    std::vector<double> dekDt4;
    std::vector<double> dekDt5;
    std::vector<double> dekDt6;
 
    static double uselessDouble;
    double physicalTime; 
};
 
extern Tools* TB;
extern SimulationOrder simulationOrder; 
extern int numberPhases;
extern int numberSolids;
extern int numberTransports;
extern bool turbulenceActivated;
extern int turbulenceNumQPA;
extern double sum_u2v2w2;
extern long nCells;
extern double initialSoundSpeed;
extern double initialConductivity;
extern double initialViscosity;
 
#endif // TOOLS_H