FieldSpecification.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_FIELDSPECIFICATION_FIELDSPECIFICATION_HPP
#define GEOS_FIELDSPECIFICATION_FIELDSPECIFICATION_HPP
 
 
#include "common/DataTypes.hpp"
#include "common/format/EnumStrings.hpp"
#include "dataRepository/Group.hpp"
#include "mesh/MeshObjectPath.hpp"
 
namespace geos
{
class Function;
 
 
class FieldSpecification : public dataRepository::Group
{
public:
 
  using CatalogInterface = dataRepository::CatalogInterface< FieldSpecification,
                                                             string const &,
                                                             dataRepository::Group * const >;
  enum class SetErrorMode : integer
  {
    silent,
    error,
    warning
  };
 
  static CatalogInterface::CatalogType & getCatalog();
 
  static string catalogName() { return "FieldSpecification"; }
 
  virtual const string getCatalogName() const
  { return FieldSpecification::catalogName(); }
 
  FieldSpecification( string const & name, dataRepository::Group * parent );
 
  virtual ~FieldSpecification() override;
 
 
  FieldSpecification( FieldSpecification const & ) = delete;
 
  FieldSpecification( FieldSpecification && ) = default;
 
  FieldSpecification & operator=( FieldSpecification const & ) = delete;
 
  FieldSpecification & operator=( FieldSpecification && ) = delete;
 
  struct viewKeyStruct
  {
    constexpr static char const * setNamesString() { return "setNames"; }
    constexpr static char const * constitutivePathString() { return "constitutivePath"; }
    constexpr static char const * objectPathString() { return "objectPath"; }
    constexpr static char const * fieldNameString() { return "fieldName"; }
    constexpr static char const * dataTypeString() { return "dataType"; }
    constexpr static char const * componentString() { return "component"; }
    constexpr static char const * directionString() { return "direction"; }
    constexpr static char const * bcApplicationTableNameString() { return "bcApplicationTableName"; }
    constexpr static char const * scaleString() { return "scale"; }
    constexpr static char const * functionNameString() { return "functionName"; }
    constexpr static char const * initialConditionString() { return "initialCondition"; }
    constexpr static char const * beginTimeString() { return "beginTime"; }
    constexpr static char const * endTimeString() { return "endTime"; }
    constexpr static char const * errorSetModeString() { return "errorSetMode"; }
  };
 
  string const & getFunctionName() const
  { return m_functionName; }
 
  virtual const string & getObjectPath() const
  { return m_objectPath; }
 
  virtual const string & getFieldName() const
  { return m_fieldName; }
 
  virtual int getComponent() const
  { return m_component; }
 
  virtual R1Tensor const & getDirection() const
  { return m_direction; }
 
  real64 getStartTime() const
  { return m_beginTime; }
 
  real64 getEndTime() const
  { return m_endTime; }
 
  string_array const & getSetNames() const
  { return m_setNames; }
 
  int initialCondition() const
  { return m_initialCondition; }
 
  real64 getScale() const
  { return m_scale; }
 
  void setFieldName( string const & fieldName )
  { m_fieldName = fieldName; }
 
  void setObjectPath( string const & objectPath )
  { m_objectPath = objectPath; }
 
  void setScale( real64 const & scale )
  { m_scale = scale; }
 
  void initialCondition( bool isInitialCondition )
  { m_initialCondition = isInitialCondition; }
 
  void addSetName( string const & setName )
  { m_setNames.emplace_back( setName ); }
 
  void setMeshObjectPath( Group const & meshBodies );
 
  MeshObjectPath const & getMeshObjectPaths() const
  { return *(m_meshObjectPaths.get()); }
 
 
protected:
 
 
private:
 
 
  string_array m_setNames;
 
  string m_objectPath;
 
  std::unique_ptr< MeshObjectPath > m_meshObjectPaths;
 
  string m_fieldName;
 
 
  int m_component;
 
  R1Tensor m_direction;
 
  int m_initialCondition;
 
  string m_functionName;
 
  real64 m_scale;
 
  real64 m_beginTime;
 
  real64 m_endTime;
 
  string m_bcApplicationFunctionName;
 
  SetErrorMode m_emptySetErrorMode;
};
 
ENUM_STRINGS( FieldSpecification::SetErrorMode,
              "silent",
              "error",
              "warning" );
 
}
 
#endif //GEOS_FIELDSPECIFICATION_FIELDSPECIFICATION_HPP