AbstractPdeProblem.hpp

Go to the documentation of this file.

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   This file is part of CEPS.
 
   CEPS 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.
 
   CEPS 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 CEPS (see file LICENSE at root of project).
   If not, see <https://www.gnu.org/licenses/>.
 
 
   Copyright 2019-2024 Inria, Universite de Bordeaux
 
   Authors, in alphabetical order:
 
     Pierre-Elliott BECUE, Florian CARO, Yves COUDIERE(*), Andjela DAVIDOVIC, 
     Charlie DOUANLA-LONTSI, Marc FUENTES, Mehdi JUHOOR, Michael LEGUEBE(*), 
     Pauline MIGERDITICHAN, Valentin PANNETIER(*), Nejib ZEMZEMI.
     * : currently active authors
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#pragma once
 
#include "common/CepsCommon.hpp"
#include "geometry/Geometry.hpp"
#include "pde/common/Unknown.hpp"
#include "pde/common/AbstractDiscretization.hpp"
#include "pde/solver/AbstractPdeSolver.hpp"
#include "pde/common/functions/BoundaryConditionManager.hpp"
#include "pde/common/functions/SourceTermManager.hpp"
 
class AbstractPdeProblem : public CepsObject
{
 
  public :
 
    using ScalarFunction = ceps::Function<CepsReal(CepsStandardArgs)>;
 
 
  public :
 
    explicit AbstractPdeProblem(
      Geometry*        geom, 
      InputParameters* params = nullptr
    );
 
    virtual ~AbstractPdeProblem();
 
    AbstractPdeProblem(const AbstractPdeProblem& that) = delete;
 
    AbstractPdeProblem&
    operator=(const AbstractPdeProblem& that) = delete;
 
    InputParameters*
    getParameters() const;
 
    virtual void
    setupWithParameters(InputParameters* params);
 
    virtual void
    run();
 
    void
    setProblemName(const CepsString& name);
 
    CepsString 
    getProblemName() const;
 
    // ---------------------------------------------------------------------------------------
    // LINKS
 
    Geometry*
    getGeometry() const;
 
    AbstractDiscretization*
    getSpatialDiscretization() const;
 
    void
    setSpatialDiscretization(AbstractDiscretization* discr);
 
    void
    createSpatialDiscretization();
 
    // ---------------------------------------------------------------------------------------
    // UNKNOWNS
    
    virtual void 
    defineUnknowns() = 0;
 
    const CepsVector<Unknown*>&
    getUnknowns() const;
 
    Unknown*
    getUnknown(const CepsString& label) const;
 
    Unknown*
    getUnknown(CepsUnknownIndex uid) const;
 
    CepsVector<Unknown*>
    getSpatialUnknowns() const;
 
    CepsVector<Unknown*>
    getZeroDUnknowns() const;
 
    const CepsVector<UnknownInteraction*>&
    getUnknownsInteractions() const;
 
    CepsBool
    unknownsInteract(
      Unknown* u1, 
      Unknown* u2, 
      const CepsSet<CepsAttribute>& attrs = {CepsUniversal}
    ) const;
 
    CepsBool
    ignoreZeroDUnknownsForError() const;
 
    // ---------------------------------------------------------------------------------------
    // Functions, source terms, bcs
 
    CepsBool
    hasAnalyticSolution() const;
 
    ScalarFunction*
    getAnalyticSolution() const;
 
    virtual void
    defineAnalyticSolution();
 
    void
    setReferenceSolution(const CepsString& baseFiles, CepsReal snapDt);
 
    CepsBool
    usesReferenceSolution() const;
 
    CepsReal
    getReferenceSolutionOutputPeriod() const;
 
    FunctionDictionary*
    getFunctionDictionary() const;
  
    void 
    setFunctionDictionary(FunctionDictionary*);
  
    virtual void
    defineBoundaryConditions();
 
    BoundaryConditionManager*
    getBoundaryConditionManager() const;
  
    void
    setBoundaryConditionManager(BoundaryConditionManager* bcm);
    
    virtual void
    defineSourceTerms();
 
    SourceTermManager*
    getSourceTermManager() const;
    
    void 
    setSourceTermManager(SourceTermManager* stm);
 
    virtual void
    initializeEquation();
 
    // ---------------------------------------------------------------------------------------
    // outputs
 
    CepsString
    getOutputFileBase() const;
 
    void 
    setOutputFileBase(CepsString fileName);
 
    CepsOutputFormat
    getOutputFormat() const;
 
    void 
    setOutputFormat(CepsOutputFormat opt);
 
    CepsBool
    writesGlobalIndices() const;
 
    void 
    writeGlobalIndices(CepsBool opt);
 
    CepsVector<CepsReal3D>
    getProbePoints() const;
 
    CepsReal
    virtual getStartTime() const;
 
    CepsReal
    virtual getEndTime() const;
 
    CepsReal
    virtual getSnapshotTime() const;
 
 
  protected : 
 
    void
    addUnknown(const CepsString& label, CepsSet<CepsAttribute> attrs = {}, 
               CepsLocationFlag flag = CepsLocationFlag::Point, const CepsString& unit = "");
 
    void
    addZeroDUnknown(CepsString label, const CepsString& unit = "");
 
    void
    addUnknownInteraction(CepsString label1, CepsString label2, CepsSet<CepsAttribute> attrs = {});
 
 
  protected:
 
    CepsString m_name; 
 
    Geometry*               m_geom;       
    InputParameters*        m_parameters; 
    AbstractDiscretization* m_discr;      
    CepsBool                m_ownedDiscr; 
 
    CepsVector<Unknown*>            m_unknowns;             
    CepsVector<UnknownInteraction*> m_unknownsInteractions; 
 
    ScalarFunction*           m_analyticSolution;   
    CepsBool                  m_ownedRefSol;        
    CepsString                m_refSolFiles;        
    CepsReal                  m_refSolSnapDt;       
    FunctionDictionary*       m_functions;          
    BoundaryConditionManager* m_boundaryConditions; 
    SourceTermManager*        m_sourceTerms;        
 
    CepsBool m_ownedFunctions; 
    CepsBool m_ownedBCs;       
    CepsBool m_ownedSrcs;      
 
    CepsString             m_outputFileBase;   
    CepsOutputFormat       m_outputFormat;     
    CepsBool               m_writeGlobalIDs;   
    CepsVector<CepsReal3D> m_probePoints;      
    CepsBool               m_ignoreZeroDError; 
 
};