SAFunc.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/core/CepsMemory.hpp"
#include "common/containers/CepsMap.hpp"
#include "common/abstract/CepsFunction.hpp"
#include "pde/common/readers/CoeffReader.hpp"
#include "pde/common/DegreeOfFreedom.hpp"
#include "linearAlgebra/DistributedHaloVector.hpp"
 
// namespace ceps
// {
//   /// @brief Extractor from CepsStandardArgs
//   template <CepsFunctionFlag _Flag>
//   auto get (CepsStandardArgs);
 
//   /// @brief Extract t from CepsStandardArgs
//   template <>
//   auto
//   get<CepsFunctionFlag::Time> (CepsStandardArgs args);
 
//   /// @brief Extract x from CepsStandardArgs
//   template <>
//   auto
//   get<CepsFunctionFlag::Space> (CepsStandardArgs args);
 
//   /// @brief Extract u from CepsStandardArgs
//   template <>
//   auto
//   get<CepsFunctionFlag::Solution> (CepsStandardArgs args);
 
//   /// @brief Extract attributes from CepsStandardArgs
//   template <>
//   auto
//   get<CepsFunctionFlag::Attribute> (CepsStandardArgs args);
 
//   /// @brief Extract dofId from CepsStandardArgs
//   template <>
//   auto
//   get<CepsFunctionFlag::DofIndex> (CepsStandardArgs args);
 
//   /// @brief Extract cellId from CepsStandardArgs
//   template <>
//   auto
//   get<CepsFunctionFlag::CellIndex> (CepsStandardArgs args);
 
//   /// @brief Extract nodeId from CepsStandardArgs
//   template <>
//   auto
//   get<CepsFunctionFlag::NodeIndex> (CepsStandardArgs args);
 
//   /// @brief Extract uId from CepsStandardArgs
//   template <>
//   auto
//   get<CepsFunctionFlag::UnknownIndex> (CepsStandardArgs args);
 
//   /// @brief Get the returned type from CepsStandardArgs deduced from the templated flag
//   template <CepsFunctionFlag _Flag>
//   using DeducedTypeFromFlag = decltype (ceps::get<_Flag> ({}));
 
// }  // namespace ceps
 
template <typename _Result>
class SAFunc : public ceps::Function<_Result(CepsStandardArgs)>
{
 
  public:
    using BaseFunction = ceps::Function<_Result(CepsStandardArgs)>;
    using BaseFunction::BaseFunction;
    using BaseFunction::operator=;
 
    SAFunc(const SAFunc&) = default;
 
    SAFunc&
    operator=(const SAFunc&) = default;
 
    CepsEnum 
    virtual getFlags() const = 0;
 
    void
    virtual getLocalData();
 
    void
    virtual releaseLocalData();
 
    CepsBool
    hasOption(CepsFunctionFlag flag);
 
};
 
using ScalarSAFunc = SAFunc<CepsMathScalar>;
using VectorSAFunc = SAFunc<CepsMathVertex>;
using TensorSAFunc = SAFunc<CepsMathTensor>;
 
namespace ceps
{
  template <typename _Fn>
  CepsEnum
  getFlagsOf(_Fn f);
 
  // template <typename _Fn>
  // CepsEnum
  // getFlagsOf(_Fn* f);
  template <typename _Result>
  CepsEnum
  getFlagsOf(Function<_Result(CepsStandardArgs)>* f);
 
}  
 
// =================================================================================================
 
 
template<char _Op, typename _Res1,typename _Res2>
class OperatorSAFunc: public SAFunc<ceps::ResultOfOperation<_Op, _Res1, _Res2>>
{
  
  public:
 
    using Fn1    = SAFunc<_Res1>;
    using Fn2    = SAFunc<_Res2>;
    using Result = ceps::ResultOfOperation<_Op, _Res1, _Res2>;
 
    OperatorSAFunc(Fn1* fn1, Fn2* fn2);
 
    ~OperatorSAFunc() override;
 
    OperatorSAFunc&
    operator=(const OperatorSAFunc&) = default;
 
    CepsEnum 
    getFlags() const override;
 
    void
    getLocalData() override;
 
    void
    releaseLocalData() override;
 
    Result
    eval(CepsStandardArgs) override;
 
    void
    setOwned(CepsBool o1, CepsBool o2);
 
 
  protected:
 
    Fn1* m_fn1; 
    Fn2* m_fn2; 
    CepsBool m_ownedFn1; 
    CepsBool m_ownedFn2; 
 
};
 
template<typename _Res1,typename _Res2>
OperatorSAFunc<'+',_Res1,_Res2>*
newSumSAFunc(SAFunc<_Res1>*,SAFunc<_Res2>*);
 
template<typename _Res1,typename _Res2>
OperatorSAFunc<'-',_Res1,_Res2>*
newDiffSAFunc(SAFunc<_Res1>*,SAFunc<_Res2>*);
 
template<typename _Res1,typename _Res2>
OperatorSAFunc<'*',_Res1,_Res2>*
newProductSAFunc(SAFunc<_Res1>*,SAFunc<_Res2>*);
 
template<typename _Res1,typename _Res2>
OperatorSAFunc<'/',_Res1,_Res2>*
newDivSAFunc(SAFunc<_Res1>*,SAFunc<_Res2>*);
 
// Template definitions
#include "pde/common/functions/SAFunc.tpp"