FiniteElements.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 "pde/common/AbstractDiscretization.hpp"
#include "pde/finiteElements/FEBase.hpp"
#include "pde/finiteElements/FENode.hpp"
#include "pde/finiteElements/ReferenceFE.hpp"
 
class FiniteElements : public AbstractDiscretization
{
 
  public:
    //------------------------------------------------------------------------------
    // Constructors
  
    FiniteElements() = delete;
  
    FiniteElements(AbstractPdeProblem* problem, CepsUInt order);
  
    FiniteElements(const FiniteElements&) = delete;
  
    ~FiniteElements() override;
 
    //------------------------------------------------------------------------------
    // FiniteElements shortcuts
  
    ReferenceFE*
    getReferenceElementOfDim(CepsCellType type, CepsUInt dim) const;
  
    CepsVector<FEBase*>&
    getFiniteElements();
  
    CepsVector<FEBase*>&
    getBoundaryFiniteElements();
  
    CepsUInt
    getNumberOfHaloFENodes() const;
  
    CepsUInt
    getNumberOfOwnedFENodes() const;
  
    const CepsVector<FENode*>&
    getOwnedFENodes();
  
    const CepsVector<FENode*>&
    getHaloFENodes();
  
    FENode*
    getFENode(CepsGlobalIndex nID);
  
    CepsBool
    isOwnedFENode(CepsGlobalIndex globalID) const;
  
    CepsBool
    isHaloFENode(CepsGlobalIndex globalID) const;
 
    CepsVector<DegreeOfFreedom*>
    getDofsOnElement(FEBase* elem);
 
    CepsVector<DegreeOfFreedom*>
    getDofsOnElementForUnknowns(FEBase* elem, const CepsVector<Unknown*>& us);
 
    CepsIndex
    getDofSpatialId(const DegreeOfFreedom* dof) const override;
 
    // ========== Access to matrices======================================================
 
    DMatPtr
    getMassMatrix() const;
 
    DMatPtr
    getStiffnessMatrix() const;
 
    // ========== METRICS ================================================================
 
    CepsReal
    dotProduct(
      DHVecPtr                      u,
      DHVecPtr                      v,
      CepsBool                      boundary = false,
      const CepsSet<CepsAttribute>& attrs    = {},
      const CepsVector<Unknown*>&   unknowns = {}
    ) final;
 
    CepsReal
    stiffProduct(
      DHVecPtr                      u,
      DHVecPtr                      v,
      CepsBool                      boundary = false,
      const CepsSet<CepsAttribute>& attrs    = {},
      const CepsVector<Unknown*>&   unknowns = {}
    );
 
    CepsReal
    h1Norm(
      DHVecPtr                      v,
      CepsBool                      boundary = false,
      const CepsSet<CepsAttribute>& attrs    = {},
      const CepsVector<Unknown*>&   unknowns = {}
    ) override;
 
    void
    extractValuesForUnknown(
      const CepsUnknownIndex& uId,
      DVecPtr                 vec,
      CepsVector<CepsIndex>&  indices,
      CepsVector<CepsReal>&   values,
      CepsBool                sendToMaster = false,
      CepsBool                returnGeomIndices = false
    ) override;
 
  protected:
    void
    initializeRefElements();
  
    void
    buildElements();
 
    void
    buildElements(Mesh* mesh, CepsBool onBoundary);
  
    void
    checkNeighborsBeforeAssign(
      FEBase*   fElem,
      FEBase*   nElem,
      CepsUInt  nID,
      CepsBool  boundary,
      CepsBool& foundSameDof
    );
  
    void
    createNewNode(FEBase* el, CepsUInt indexDof, CepsBool isBoundary, Mesh* mesh);
  
    void
    computeNeighbors();
  
    CepsHash3
    getNodeHash(const FENode* n) const;
  
    void 
    buildDofsTree() override;
 
    void
    setSpatialUnknownsDofsInteractions() override;
 
  protected:
 
    CepsUInt m_order;
    CepsMap<CepsCellType,CepsArray4<ReferenceFE*>> m_refElems;
    DistributedInfos<FENode*,CepsHash3>* m_nodes;
    DistributedInfos<FEBase*>* m_volElems;
    DistributedInfos<FEBase*>* m_bdrElems;
    CepsUInt m_maxValidDim;
    DMatPtr m_mass;
    DMatPtr m_stiff;
 
 
};
 
CepsReal
getDomainMeasure(
  const CepsVector<FEBase*>&    cells,
  const CepsSet<CepsAttribute>& attributes,
  CepsBool                      onlyOfThisProc = false
);
 
CepsReal
getDomainMeasure(const CepsVector<FEBase*>& cells, CepsBool onlyOfThisProc = false);