MeshFields.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 Total, S.A
 * 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_MESH_FIELDS_HPP_
#define GEOS_MESH_FIELDS_HPP_
 
#include "codingUtilities/traits.hpp"
#include "dataRepository/RestartFlags.hpp"
#include "common/DataTypes.hpp"
 
#define DECLARE_FIELD( NAME, \
                       KEY, \
                       TYPE, \
                       DEFAULT, \
                       PLOTLEVEL, \
                       RESTARTFLAG, \
                       DESCRIPTION ) \
 \
 \
  struct NAME \
  { \
 \
    static constexpr char const * key() \
    { return KEY; } \
 \
    using type = TYPE; \
 \
    using dataType = internal::typeHelper_t< TYPE >; \
 \
    static constexpr dataType defaultValue() \
    { return DEFAULT; } \
 \
    static constexpr dataRepository::PlotLevel plotLevel = dataRepository::PlotLevel::PLOTLEVEL; \
 \
    static constexpr dataRepository::RestartFlags restartFlag = dataRepository::RestartFlags::RESTARTFLAG; \
 \
    static constexpr char const * description = DESCRIPTION; \
  }
 
namespace geos
{
namespace fields
{
 
namespace internal
{
template< typename TYPE, bool HAS_TYPE = std::enable_if_t< traits::HasAlias_value_type< TYPE >, std::true_type >::value >
struct typeHelper
{
  using type = typename TYPE::value_type;
};
 
template< typename TYPE >
struct typeHelper< TYPE, false >
{
  using type = TYPE;  //typename std::enable_if< std::is_fundamental<TYPE>::value, TYPE>::type;
};
 
template< typename T >
using typeHelper_t = typename typeHelper< T >::type;
}
 
DECLARE_FIELD( ghostRank,
               "ghostRank",
               array1d< integer >,
               -2,
               LEVEL_0,
               WRITE_AND_READ,
               "Ghost rank." );
 
DECLARE_FIELD( elementVolume,
               "elementVolume",
               array1d< real64 >,
               0,
               LEVEL_1,
               WRITE_AND_READ,
               "Element volume." );
 
DECLARE_FIELD( elementAperture,
               "elementAperture",
               array1d< real64 >,
               1e-5,
               LEVEL_0,
               WRITE_AND_READ,
               "Element aperture." );
 
DECLARE_FIELD( elementArea,
               "elementArea",
               array1d< real64 >,
               0,
               LEVEL_0,
               WRITE_AND_READ,
               "Element area." );
 
DECLARE_FIELD( parentIndex,
               "parentIndex",
               array1d< localIndex >,
               -1,
               LEVEL_2,
               WRITE_AND_READ,
               "Index of parent within the mesh object it is registered on." );
 
DECLARE_FIELD( parentEdgeIndex,
               "parentEdgeIndex",
               array1d< localIndex >,
               -1,
               LEVEL_2,
               WRITE_AND_READ,
               "Index of parent edge within the mesh object it is registered on." );
 
DECLARE_FIELD( childIndex,
               "childIndex",
               array1d< localIndex >,
               -1,
               LEVEL_2,
               WRITE_AND_READ,
               "Index of child within the mesh object it is registered on." );
 
DECLARE_FIELD( ruptureTime,
               "ruptureTime",
               array1d< real64 >,
               1.0e9,
               LEVEL_0,
               WRITE_AND_READ,
               "Time that the object was ruptured/split." );
 
DECLARE_FIELD( normalVector,
               "normalVector",
               array2d< real64 >,
               0.0,
               LEVEL_0,
               WRITE_AND_READ,
               "Unit normal vector to the surface." );
 
DECLARE_FIELD( tangentVector1,
               "tangentVector1",
               array2d< real64 >,
               0.0,
               LEVEL_0,
               WRITE_AND_READ,
               "Unit vector in the first tangent direction to the surface." );
 
DECLARE_FIELD( tangentVector2,
               "tangentVector2",
               array2d< real64 >,
               0.0,
               LEVEL_0,
               WRITE_AND_READ,
               "Unit vector in the second tangent direction to the surface." );
 
 
} // namespace fields
} // namespace geos
 
#endif /* GEOS_MESH_FIELDS_HPP_ */