Cell.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 CELL_H
#define CELL_H
 
#include <fstream>
#include "../Models/Phase.h"
#include "../Maths/Coord.h"
#include "../Maths/Tensor.h"
#include "../Transport/Transport.h"
#include "../Transport/GradTransport.h"
 
class Cell; //Predeclaration of class to include following .h
 
#include "../Models/Mixture.h"
#include "../AdditionalPhysics/QuantitiesAddPhys.h"
#include "CellInterface.h"
#include "../Models/Model.h"
#include "../Gradients/Gradient.h"
#include "../Models/Flux.h"
#include "../Meshes/Element.h"
#include "../Geometries/GeometricalDomain.h"
#include "../Symmetries/Symmetry.h"
 
class GradPhase;
class GradMixture;

class Cell
{
  public:
    Cell();
    Cell(int lvl); //Pour AMR
    virtual ~Cell();

    void addCellInterface(CellInterface* cellInterface);
    void deleteCellInterface(CellInterface* cellInterface);

    void associateExtVar(Model* mod, Gradient* grad);
    virtual void allocate(const std::vector<AddPhys*>& addPhys);
    void allocateEos();
    void fill(std::vector<GeometricalDomain*>& domains, const int& /*lvlMax*/);
    virtual void copyPhase(const int& phaseNumber, Phase* phase);
    void copyMixture(Mixture* mixture);
    void setToZeroCons();
    void setToZeroConsGlobal();
    void timeEvolution(const double& dt, Symmetry* symmetry);
    void timeEvolutionAddPhys(const double& dt);
    void buildPrim();
    void buildCons();
    virtual void correctionEnergy(Prim /*type*/ = vecPhases);
    void sourceTermIntegration(const double& /*dt*/) {};
    void printPhasesMixture(std::ofstream& fileStream) const;
    virtual void completeFulfillState();
    virtual void fulfillState(Prim /*type*/ = vecPhases);
    void fulfillStateResume();
    void localProjection(const Coord& normal, const Coord& tangent, const Coord& binormal, Prim /*type*/ = vecPhases);
    virtual void reverseProjection(const Coord& normal, const Coord& tangent, const Coord& binormal);
    virtual void copyInCell(Cell& /*cellSource*/) const { Errors::errorMessage("copyInCell not available for Cell"); };
    void copyVec(Phase** vecPhases, Mixture* mixture, Transport* vecTransports);
    //void printCut1Dde2D(std::ofstream& fileStream, std::string variableConstanteCut, const double& valueCut, const double& dL);    /*!< Write de la cut 1D de la simulation 2D  */
    //void printCut1Dde3D(std::ofstream& fileStream, std::string variableConstanteCut1, std::string variableConstanteCut2, const double& valueCut1, const double& valueCut2, const double& dL1, const double& dL2); /*!< Write de la cut 1D de la simulation 3D  */
    void deleteInterface(const int& b);
 
    //For additional physics
    //----------------------
    void prepareAddPhys();
    Coord selectVector(Variable nameVector, int num = 0, int subscript = -1) const;
    void setVector(Variable nameVector, const Coord& value, int num = 0, int subscript = -1);
 
    const QuantitiesAddPhys* getQPA(const int& numQPA) const
    {
      return m_vecQuantitiesAddPhys[numQPA];
    }; 
    QuantitiesAddPhys* getQPA(const int& numQPA) { return m_vecQuantitiesAddPhys[numQPA]; }; 
 
    const Coord& getGradTk(int& numPhase, int& numAddPhys) const;
    void setGradTk(int& numPhase, int& numAddPhys, double* buffer, int& counter);
    void addNonConsAddPhys(AddPhys& addPhys, Symmetry* symmetry);
 
    void reinitializeColorFunction(const int& numTransport, const int& numPhase); 

    double hatFilterScalar(Variable nameVariable, int num = 0);
 
    //Gradients
    //---------
    void computeGradients(std::vector<Coord>& grads, std::vector<Variable>& nameVariables, std::vector<int>& numPhases);
 
    //Accessors
    //---------
    int getCellInterfacesSize() const;
    CellInterface* getCellInterface(const int& b);
    void setCellInterface(const int& b, CellInterface* cellInterface);
    virtual Phase* getPhase(const int& phaseNumber, Prim /*type*/ = vecPhases) const;
    virtual Phase** getPhases(Prim /*type*/ = vecPhases) const;
    virtual Mixture* getMixture(Prim /*type*/ = vecPhases) const;
    Flux* getCons() const;
    void setCons(Flux* cons);
    const Coord& getPosition() const { return m_element->getPosition(); };
    const Coord& getSize() const { return m_element->getSize(); };
    const double& getSizeX() const { return m_element->getSizeX(); };
    const double& getSizeY() const { return m_element->getSizeY(); };
    const double& getSizeZ() const { return m_element->getSizeZ(); };
    void setElement(Element* element, const int& numCell);
    Element* getElement() const;
    virtual void setTransport(double value, int& numTransport, Prim /*type*/ = vecPhases);
    virtual Transport& getTransport(const int& numTransport, Prim /*type*/ = vecPhases) const;
    virtual Transport* getTransports(Prim /*type*/ = vecPhases) const;
    Transport* getConsTransport(const int& numTransport) const;
    void setConsTransport(double value, const int& numTransport);
    std::vector<QuantitiesAddPhys*>& getVecQuantitiesAddPhys();
    const int& getNumberPhases() const;
    const int& getNumberTransports() const;
    double getDensityGradient();
    Model* getModel();
    Coord& getVelocity();
    const Coord& getVelocity() const;
    void setWall(bool wall);
    bool getWall() const { return m_wall; };
    double selectScalar(Variable nameVariable, int num = 0) const;
 
    //Second order (not used for first-order cells)
    //---------------------------------------------
    virtual void allocateSecondOrderBuffersAndGradientVectors(Phase** /*phases*/, Mixture* /*mixture*/) {};

    virtual void computeGradientsO2() {};
    virtual void limitGradientsO2(Limiter& /*globalLimiter*/) {};

    virtual void computeLocalSlopes(CellInterface& /*cellInterfaceRef*/) {};
    virtual void computeLocalSlopes(CellInterface& /*cellInterface*/,
                                    Limiter& /*globalLimiter*/,
                                    Limiter& /*interfaceLimiter*/,
                                    Limiter& /*globalVolumeFractionLimiter*/,
                                    Limiter& /*interfaceVolumeFractionLimiter*/,
                                    double& /*alphaCellAfterOppositeSide*/,
                                    double& /*alphaCell*/,
                                    double& /*alphaCellOtherInterfaceSide*/,
                                    double& /*epsInterface*/) {}; 
    virtual void computeLocalSlopesLimite(CellInterface& /*cellInterface*/,
                                          Limiter& /*globalLimiter*/,
                                          Limiter& /*interfaceLimiter*/,
                                          Limiter& /*globalVolumeFractionLimiter*/,
                                          Limiter& /*interfaceVolumeFractionLimiter*/,
                                          double& /*epsInterface*/) {}; 
    virtual void computeLocalSlopesPeriodic(CellInterface& /*cellInterface*/,
                                            Limiter& /*globalLimiter*/,
                                            Limiter& /*interfaceLimiter*/,
                                            Limiter& /*globalVolumeFractionLimiter*/,
                                            Limiter& /*interfaceVolumeFractionLimiter*/,
                                            double& /*alphaCellAfterOppositeSide*/,
                                            double& /*alphaCell*/,
                                            double& /*alphaCellOtherInterfaceSide*/,
                                            double& /*epsInterface*/) {};           
    virtual Phase* getSlopes() const { return 0; };                                 
    virtual Transport* getSlopesTransport() const { return 0; };                    
    virtual void saveCons() {};                                                     
    virtual void getBackCons() {};                                                  
    virtual void predictionOrdre2(const double& /*dt*/, Symmetry* /*symmetry*/) {}; 
 
    //Methods for distance to an other object (Cell or CellInterface)
    //---------------------------------------------------------------
    double distance(Cell* c);           
    double distanceX(Cell* c);          
    double distanceY(Cell* c);          
    double distanceZ(Cell* c);          
    double distance(CellInterface* b);  
    double distanceX(CellInterface* b); 
    double distanceY(CellInterface* b); 
    double distanceZ(CellInterface* b); 
 
    bool traverseObjet(const GeometricObject& objet) const;
 
    //Printing
    //--------
    void printInfo() const;
    double getPsat();
    bool printGnuplotAMR(std::ofstream& fileStream, const int& dim, GeometricObject* objet = 0, bool recordPsat = false);
    void computeVolumePhaseK(double& integration, const int& numPhase);
    void computeMass(double& mass, double& alphaRef);
    void computeTotalMass(double& mass);
    void computeTotalEnergy(double& totalEnergy);
    void lookForPmax(double* pMax, double* pMaxWall);
 
    //Specific for AMR method
    //-----------------------
    // clang-format off
    void setToZeroXi();                                                         
    void setToZeroConsXi();                                                     
    void timeEvolutionXi();                                                     
    void chooseRefine(const double& xiSplit,
                      const int& nbCellsY,
                      const int& nbCellsZ,
                      const std::vector<AddPhys*>& addPhys,
                      int& nbCellsTotalAMR);                                    
    void chooseUnrefine(const double& xiJoin, int& nbCellsTotalAMR);            
    void refineCellAndCellInterfaces(const int& nbCellsY,
                                     const int& nbCellsZ,
                                     const std::vector<AddPhys*>& addPhys,
                                     const bool& refineExternalCellInterfaces); 
    virtual void createChildCell(const int& lvl);                               
    void unrefineCellAndCellInterfaces();                                       
    void averageChildrenInParent();                                             
    bool lvlNeighborTooHigh();                                                  
    bool lvlNeighborTooLow();                                                   
    void buildLvlCellsAndLvlInternalCellInterfacesArrays(
      std::vector<Cell*>* cellsLvl,
      std::vector<CellInterface*>* cellInterfacesLvl);                          
    const int& getLvl() const { return m_lvl; };                                
    const bool& getSplit() const { return m_split; };                           
    const double& getXi() const { return m_xi; };                               
    void setXi(double value);                                                   
    void addFluxXi(double value);                                               
    int getNumberCellsChildren();                                               
    Cell* getCellChild(const int& num);                                         
    std::vector<Cell*>* getChildVector();                                       
 
    //For parallel computing (no AMR)
    //-------------------------------
    virtual void pushBackSlope() {};                                            
    virtual void popBackSlope() {};                                             
    virtual int getRankOfNeighborCPU() const { return -1; };
    virtual void setRankOfNeighborCPU(int /*rank*/) {};                         
    // clang-format on
    void fillBufferPrimitives(double* buffer, int& counter, const int& lvl, const int& neighbour, Prim type = vecPhases) const;
    void getBufferPrimitives(double* buffer, int& counter, const int& lvl, Eos** eos, Prim type = vecPhases);
    void fillBufferVector(
      double* buffer, int& counter, const int& lvl, const int& neighbour, const int& dim, Variable nameVector, int num = 0, int index = -1) const;
    void getBufferVector(double* buffer, int& counter, const int& lvl, const int& dim, Variable nameVector, int num = 0, int index = -1);
    void fillBufferTransports(double* buffer, int& counter, const int& lvl, const int& neighbour) const;
    void getBufferTransports(double* buffer, int& counter, const int& lvl);
    virtual void fillBufferSlopes(double* /*buffer*/, int& /*counter*/, const int& /*lvl*/, const int& /*neighbour*/) const
    {
      Errors::errorMessage("fillBufferSlopes not available for Cell");
    }; 
    virtual void getBufferSlopes(double* /*buffer*/, int& /*counter*/, const int& /*lvl*/)
    {
      Errors::errorMessage("getBufferSlopes not available for Cell");
    }; 
    virtual bool isCellGhost() const { return false; };
    bool hasNeighboringGhostCellOfCPUneighbour(const int& neighbour) const;      
    int numberOfNeighboringGhostCellsOfCPUneighbour(const int& neighbour) const; 
    virtual GradPhase* getGradPhase(const int& /*phaseNumber*/) const
    {
      Errors::errorMessage("getGradPhase not available for Cell");
      return nullptr;
    };
    virtual GradMixture* getGradMixture() const
    {
      Errors::errorMessage("getGradMixture not available for Cell");
      return nullptr;
    };
    virtual GradTransport* getGradTransport(const int& /*transportNumber*/) const
    {
      Errors::errorMessage("getGradTransport not available for Cell");
      return nullptr;
    };
 
    //For parallel AMR computing
    //--------------------------
    void chooseRefineDeraffineGhost(
      const int& nbCellsY,
      const int& nbCellsZ,
      const std::vector<AddPhys*>& addPhys,
      std::vector<Cell*>* cellsLvlGhost); 
    void
    refineCellAndCellInterfacesGhost(const int& nbCellsY,
                                     const int& nbCellsZ,
                                     const std::vector<AddPhys*>& addPhys); 
    void unrefineCellAndCellInterfacesGhost(); 
    void fillBufferXi(double* buffer, int& counter, const int& lvl, const int& neighbour) const;
    void getBufferXi(double* buffer, int& counter, const int& lvl);
    void fillBufferSplit(bool* buffer, int& counter, const int& lvl, const int& neighbour) const;
    void getBufferSplit(bool* buffer, int& counter, const int& lvl);
    void fillNumberElementsToSendToNeighbour(int& numberElementsToSendToNeighbor,
                                             int& numberSlopesToSendToNeighbor,
                                             const int& lvl,
                                             const int& neighbour,
                                             int numberNeighboursOfCPUneighbour);
    void fillDataToSend(std::vector<double>& dataToSend, std::vector<int>& dataSplitToSend, const int& lvl) const;
    void getDataToReceiveAndRefine(std::vector<double>& dataToReceive,
                                   std::vector<int>& dataSplitToReceive,
                                   const int& lvl,
                                   Eos** eos,
                                   int& counter,
                                   int& counterSplit,
                                   const int& nbCellsY,
                                   const int& nbCellsZ,
                                   const std::vector<AddPhys*>& addPhys);
    void computeLoad(double& load, int lvl) const;
    void computeLvlMax(int& lvlMax) const;
    void clearExternalCellInterfaces(const int& nbCellsY, const int& nbCellsZ);
    void updatePointersInternalCellInterfaces();
    void updateNbCellsTotalAMR(int& nbCellsTotalAMR);
 
  protected:
    bool m_wall;                                            
    Phase** m_vecPhases;                                    
    Mixture* m_mixture;                                     
    Transport* m_vecTransports;                             
    Flux* m_cons;                                           
    Transport* m_consTransports;                            
    Element* m_element;                                     
    std::vector<CellInterface*> m_cellInterfaces;           
    std::vector<QuantitiesAddPhys*> m_vecQuantitiesAddPhys; 
 
    //Attributs pour methode AMR
    int m_lvl;                                                    
    double m_xi;                                                  
    double m_consXi;                                              
    bool m_split;                                                 
    std::vector<Cell*> m_childrenCells;                           
    std::vector<CellInterface*> m_childrenInternalCellInterfaces; 
 
  private:
};
 
extern Model* model;                           
extern Gradient* gradient;                     
extern std::vector<Coord> gradRho;             
extern std::vector<Variable> variableDensity;  
extern std::vector<Coord> gradVelocityX;       
extern std::vector<Variable> variableVelocity; 
extern std::vector<int> numeratorDefault;      
 
#endif // CELL_H