FunctionDictionary.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 "linearAlgebra/DistributedVector.hpp"
#include "pde/common/functions/AllFunctors.hpp"
 
class FunctionDictionary : public CepsObject
{
 
  public:
  
    template <class _Result>
    using Entry       = SAFunc<_Result>*;
    using ScalarEntry = Entry<CepsMathScalar>;
    using VectorEntry = Entry<CepsMathVertex>;
    using TensorEntry = Entry<CepsMathTensor>;
  
    template <class _Result>
    using Map       = CepsMap<CepsString, Entry<_Result>>;
    using ScalarMap = Map<CepsMathScalar>;
    using VectorMap = Map<CepsMathVertex>;
    using TensorMap = Map<CepsMathTensor>;
  
    FunctionDictionary();
  
    ~FunctionDictionary();
  
    void
    add(const CepsString& label, const CepsString& params, Geometry* geom = nullptr);
  
    // -----------------------------------------------------------------
  
    void
    addConstant(const CepsString& label, const CepsString& params);
  
    template <class _Constant>
    void
    addConstant(const CepsString& label, _Constant value);
  
    // -----------------------------------------------------------------
  
    void
    addCstPiecewise(const CepsString& label, const CepsString& params);
  
    void
    addFctPiecewise (const CepsString& label, const CepsString& params);
  
    // -----------------------------------------------------------------
  
    void
    addFromFile (
      const CepsString& label, 
      const CepsString& params, 
      Geometry*         geom, 
      CepsBool          neverMind = false
    );
  
    // -----------------------------------------------------------------
  
    void
    addFunction(const CepsString& label, const CepsString& params);
  
    // -----------------------------------------------------------------
  
    void
    addOperator(const CepsString& label, const CepsString &params);
  
    template <class _Obj1, class _Obj2>
    void
    addOperator(const CepsString& label, _Obj1 *a, const CepsChar& op, _Obj2 *b);
  
    // ------------------------------------------------------------------
  
    void 
    addAlias(const CepsString& label, const CepsString& params);
  
    // -----------------------------------------------------------------
    // Generic Add function
    // -----------------------------------------------------------------
  
    void
    addEntry (const CepsString& label, ScalarEntry func);
  
    void
    addEntry (const CepsString& label, VectorEntry func);
  
    void
    addEntry (const CepsString& label, TensorEntry func);
  
    // -----------------------------------------------------------------
    // Has function
    // -----------------------------------------------------------------
  
    CepsBool
    hasScalar (const CepsString& label) const;
  
    CepsBool
    hasVector (const CepsString& label) const;
  
    CepsBool
    hasTensor (const CepsString& label) const;
  
    // -----------------------------------------------------------------
    // Get functions 
    // -----------------------------------------------------------------
  
    const ScalarMap&
    getScalars() const;
  
    const VectorMap&
    getVectors() const;
  
    const TensorMap&
    getTensors() const;
  
    const ScalarEntry
    getScalar(const CepsString& label) const;
  
    const VectorEntry
    getVector(const CepsString& label) const;
  
    const TensorEntry
    getTensor(const CepsString& label) const;
  
    const ScalarEntry
    getScalar(const CepsString& label, const ScalarEntry def) const;
  
    const VectorEntry
    getVector(const CepsString& label, const VectorEntry def) const;
  
    const TensorEntry
    getTensor(const CepsString& label, const TensorEntry def) const;
  
    void
    deleteScalar(const CepsString& label);
  
    void
    deleteVector(const CepsString& label);
  
    void
    deleteTensor(const CepsString& label);
  
  
  private:
  
    ScalarEntry
    parseFunction (const CepsString &params);
  
    ScalarEntry
    parseTimeFunction (const CepsVector<CepsString> &params);
  
    ScalarEntry
    parseSpatialFunction (const CepsVector<CepsString> &params);
  
    void
    checkParam(const CepsVector<CepsString>& words, const CepsVector<CepsString>& keys,
               const CepsVector<CepsUInt>& nToRead={}) const;
  
    template <class _Result>
    void
    addInternal(const CepsString& label, Entry<_Result> func,
                 Map<_Result>& map, const CepsString& name);
  
    template <class _Result>
    static CepsBool
    hasInternal(const CepsString &key, const Map<_Result> &map);
 
    template <CepsUInt n, typename Reals>
    void
    addInterpolationTable(const CepsString& label, std::ifstream& ifs, const CepsString& fileName, CepsBool time);
 
 
  protected:
  
    ScalarMap m_scalars; 
    VectorMap m_vectors; 
    TensorMap m_tensors; 
  
    CepsSet<CepsString> m_doNotDelete; 
  
    CepsString m_address = "   See https://carmen.gitlabpages.inria.fr/ceps/syntax.html for details on syntax";
  
};
 
// template definitions
 
template <class _Constant>
void
FunctionDictionary::addConstant(const CepsString &label,_Constant value)
{
  return addEntry(label,newConstantSAFunc(value));
}
 
template <class _Obj1, class _Obj2>
void
FunctionDictionary::addOperator(const CepsString &label, _Obj1 *a, const CepsChar &op, _Obj2 *b)
{
  if (op == '+')
    return addEntry(label,newSumSAFunc(a,b));
  if (op == '-')
    return addEntry(label,newDiffSAFunc(a,b));
  if (op == '*')
    return addEntry(label,newProductSAFunc(a,b));
  if (op == '/')
    return addEntry(label,newDivSAFunc(a,b));
 
  CEPS_ABORT("Operator '" << op << "' between functions is not implemented (target " << label << ")");
}
 
template <class _Result>
void
FunctionDictionary::addInternal(
  const CepsString& label, 
  Entry<_Result>    func,
  Map<_Result>&     map,
  const CepsString& name
)
{
  if (map.contains(ceps::toKey(label)))
  {
    CEPS_WARNS (
      "dictionary already contains an object with the label " << label << 
      "\n   of type '" << name << "'. Ignoring"
    );
    ceps::destroyObject(func);
    return;
  }
  map.insert(std::make_pair(ceps::toKey(label),func));
  return;
}
 
template <class _Result>
CepsBool
FunctionDictionary::hasInternal(const CepsString& label, const Map<_Result>& map)
{
  return map.contains(ceps::toKey(label));
}
 
template <CepsUInt n, typename Reals>
void
FunctionDictionary::addInterpolationTable(
  const CepsString& label, 
  std::ifstream&    ifs,
  const CepsString& fileName,
  CepsBool          time
)
{
  ifs.seekg(0,std::ios::beg);
  Reals                   value;
  CepsReal                x{0.};
  CepsUInt                lc = 1;
  CepsString              line;
  CepsMap<CepsReal,Reals> itpMap;
  while(std::getline(ifs,line))
  {
    std::istringstream iss(line);
    CepsString         errmsg(fileName+", line "+std::to_string(lc)+": cannot read real ");
    x     = ceps::readReal(iss,errmsg+"in first column");
    value = ceps::convertReal<Reals>(ceps::readReals<n>(iss,errmsg).data());
    itpMap[x] = value;
    lc++;
  }
  ScalarSAFunc* selector = nullptr;
  if (time)
    selector = getScalar("dicofunc_time_selector");
  return addEntry(label,new CoeffInterpolatorSAFunc(itpMap,selector));   
 
}
 
// ===================================================================
 
class DicoFuncTimeSelector : public ScalarSAFunc
{
  CepsEnum
  getFlags() const override;
 
  CepsReal
  eval(CepsStandardArgs) override;
};