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();
        void correctionEnergy();
        void sourceTermIntegration(const double& /*dt*/) {};
        void printPhasesMixture(std::ofstream& fileStream) const;
        virtual void completeFulfillState();
        virtual void fulfillState(Prim /*type*/ = vecPhases);
        void fulfillStateRestart();
        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("methode copie non dispo pour 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(int& numQPA) const { 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); 
 
        //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 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
        //-----------------------
        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*/) {};              
        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<int> numeratorDefault;                 
#endif // CELL_H