FieldFunctions.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _FIELD_FUNCTIONS_H
#define _FIELD_FUNCTIONS_H
 
#include "TensorFunction.h"
#include <string>
 
class Field;
class Fields;
class ASMbase;
class HDF5Reader;
class ProcessAdm;
 
 
class FieldFuncBase
{
public:
  static constexpr int FIXED_LEVEL = 1 << 24; 
 
protected:
  FieldFuncBase() : pidx(0), npch(0) {}
  FieldFuncBase(const FieldFuncBase&) = delete;
  virtual ~FieldFuncBase();
 
  bool setPatch(size_t pIdx);
 
protected:
  std::vector<ASMbase*> patch; 
 
  size_t pidx; 
  size_t npch; 
};
 
 
class FieldFuncHDF5 : public FieldFuncBase
{
protected:
  FieldFuncHDF5() : hasMultipleLevels(false), lastLevel(-1),
                    hdf5(nullptr), pAdm(nullptr)
  {}
  explicit FieldFuncHDF5(const std::string& fileName);
  FieldFuncHDF5(const FieldFuncHDF5&) = delete;
  virtual ~FieldFuncHDF5();
 
  bool load(const std::vector<std::string>& fieldNames,
            const std::string& basisName, int level,
            bool isScalar = false);
 
  int findClosestLevel(double time) const;
 
  virtual void addPatchField(ASMbase* pch,
                             const std::vector<Real>& coefs,
                             int nf, int basis) = 0;
  virtual void clearField() = 0;
 
  bool hasMultipleLevels; 
  mutable int lastLevel; 
 
private:
  HDF5Reader* hdf5; 
  ProcessAdm* pAdm; 
 
  mutable double lastTime;  
};
 
 
class FieldFuncScalarBase : protected FieldFuncHDF5
{
public:
  FieldFuncScalarBase(const std::string& fileName,
                      const std::string& basisName,
                      const std::string& fieldName,
                      int level = 0);
  virtual ~FieldFuncScalarBase() { this->clearFieldInt(); }
 
protected:
  FieldFuncScalarBase() : currentLevel(-1) {}
 
  virtual void addPatchField(ASMbase* pch,
                             const std::vector<Real>& coefs,
                             int, int);
  virtual void clearField() { this->clearFieldInt(); }
 
  void clearFieldInt();
 
  mutable int currentLevel; 
 
  std::string fName; 
  std::string bName; 
 
  std::vector<Field*> field; 
};
 
 
class FieldFunction : public RealFunc, public FieldFuncScalarBase
{
public:
  FieldFunction(const std::string& fileName,
                const std::string& basisName,
                const std::string& fieldName,
                int level = 0);
  FieldFunction(const std::vector<Field*>& fields);
  virtual ~FieldFunction() {}
 
  bool initPatch(size_t pIdx) override { return this->setPatch(pIdx); }
 
  Vec3 gradient(const Vec3& X) const override;
 
  SymmTensor hessian(const Vec3& X) const override;
 
protected:
  Real evaluate(const Vec3& X) const override;
};
 
 
class FieldFuncStream : public RealFunc, private FieldFuncBase
{
public:
  FieldFuncStream(const std::vector<ASMbase*>& patches, std::istream& istr);
  virtual ~FieldFuncStream();
 
  virtual bool initPatch(size_t pIdx) { return this->setPatch(pIdx); }
 
protected:
  virtual Real evaluate(const Vec3& X) const;
 
private:
  std::vector<Field*> field; 
};
 
 
class FieldsFuncBase : public FieldFuncHDF5
{
protected:
  FieldsFuncBase(const std::vector<Fields*>& fields);
 
  FieldsFuncBase(const std::string& fileName,
                 const std::string& basisName,
                 const std::string& fieldName,
                 int level);
  virtual ~FieldsFuncBase() { this->clearField(); }
 
  virtual void addPatchField(ASMbase* pch,
                             const std::vector<Real>& coefs,
                             int nf, int basis);
  virtual void clearField();
 
  std::vector<Real> getValues(const Vec3& X);
 
  std::vector<Real> getGradient(const Vec3& X) const;
 
  std::vector<Real> getHessian(const Vec3& X) const;
 
private:
  mutable int currentLevel; 
 
protected:
  std::vector<std::string> fName; 
  std::string              bName; 
 
  std::vector<Fields*> field; 
};
 
 
class VecFieldFunction : public VecFunc, private FieldsFuncBase
{
public:
  VecFieldFunction(const std::string& fileName,
                   const std::string& basisName,
                   const std::string& fieldName,
                   int level = 0);
 
  VecFieldFunction(const std::vector<Fields*>& fields);
 
  virtual ~VecFieldFunction() {}
 
  bool initPatch(size_t pIdx) override { return this->setPatch(pIdx); }
 
protected:
  Vec3 evaluate(const Vec3& X) const override;
 
  std::vector<Real> evalGradient(const Vec3& X) const override
  { return this->getGradient(X); }
  std::vector<Real> evalHessian(const Vec3& X) const override
  { return this->getHessian(X); }
};
 
 
class TensorFieldFunction : public TensorFunc, private FieldsFuncBase
{
public:
  TensorFieldFunction(const std::string& fileName,
                      const std::string& basisName,
                      const std::string& fieldName,
                      int level = 0);
  virtual ~TensorFieldFunction() {}
 
  virtual bool initPatch(size_t pIdx) { return this->setPatch(pIdx); }
 
protected:
  virtual Tensor evaluate(const Vec3& X) const;
};
 
 
class ScalarGradFieldFunction : public VecFunc, private FieldFuncScalarBase
{
public:
  ScalarGradFieldFunction(const std::string& fileName,
                          const std::string& basisName,
                          const std::string& fieldName,
                          int level = 0);
 
  ScalarGradFieldFunction(const std::vector<Field*>& fields, int dim);
 
  virtual ~ScalarGradFieldFunction() {}
 
  virtual bool initPatch(size_t pIdx) { return this->setPatch(pIdx); }
 
protected:
  virtual Vec3 evaluate(const Vec3& X) const;
};
 
 
class ScalarLaplacianFieldFunction : public VecFunc, private FieldFuncScalarBase
{
public:
  ScalarLaplacianFieldFunction(const std::string& fileName,
                               const std::string& basisName,
                               const std::string& fieldName,
                               int level = 0);
  virtual ~ScalarLaplacianFieldFunction() {}
 
  virtual bool initPatch(size_t pIdx) { return this->setPatch(pIdx); }
 
protected:
  virtual Vec3 evaluate(const Vec3& X) const;
};
 
 
class VecGradFieldFunction : public TensorFunc, private FieldsFuncBase
{
public:
  VecGradFieldFunction(const std::string& fileName,
                       const std::string& basisName,
                       const std::string& fieldName,
                       int level = 0);
  virtual ~VecGradFieldFunction() {}
 
  virtual bool initPatch(size_t pIdx) { return this->setPatch(pIdx); }
 
protected:
  virtual Tensor evaluate(const Vec3& X) const;
};
 
 
class VecLaplacianFieldFunction : public TensorFunc, private FieldsFuncBase
{
public:
  VecLaplacianFieldFunction(const std::string& fileName,
                            const std::string& basisName,
                            const std::string& fieldName,
                            int level = 0);
  virtual ~VecLaplacianFieldFunction() {}
 
  virtual bool initPatch(size_t pIdx) { return this->setPatch(pIdx); }
 
protected:
  virtual Tensor evaluate(const Vec3& X) const;
};
 
 
class STensorFieldFunction : public STensorFunc, private FieldsFuncBase
{
public:
  STensorFieldFunction(const std::string& fileName,
                       const std::string& basisName,
                       const std::string& fieldName,
                       int level = 0);
  virtual ~STensorFieldFunction() {}
 
  virtual bool initPatch(size_t pIdx) { return this->setPatch(pIdx); }
 
protected:
  virtual SymmTensor evaluate(const Vec3& X) const;
};
 
#endif