FieldSpecificationManager.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_FIELDSPECIFICATIONMANAGER_HPP_
#define GEOS_FIELDSPECIFICATION_FIELDSPECIFICATIONMANAGER_HPP_
 
#include "FieldSpecificationBase.hpp"
 
#include "common/format/StringUtilities.hpp"
#include "common/DataTypes.hpp"
#include "common/TimingMacros.hpp"
 
namespace geos
{
namespace dataRepository
{
namespace keys
{
string const boundaryConditionManager( "BoundaryConditionManager" );
}
}
 
class FieldSpecificationManager : public dataRepository::Group
{
public:
 
  FieldSpecificationManager( string const & name, dataRepository::Group * const parent );
 
  virtual ~FieldSpecificationManager() override;
 
  static FieldSpecificationManager & getInstance();
 
  virtual Group * createChild( string const & childKey, string const & childName ) override;
 
  virtual void expandObjectCatalogs() override;
 
  template< typename POLICY=parallelHostPolicy >
  void applyFieldValue( real64 const time,
                        MeshLevel & mesh,
                        string const & fieldName ) const
  {
    GEOS_MARK_FUNCTION;
 
    applyFieldValue< POLICY >( time, mesh, fieldName,
                               [&]( FieldSpecificationBase const &,
                                    SortedArrayView< localIndex const > const & ){} );
  }
 
  template< typename POLICY=parallelHostPolicy, typename LAMBDA=void >
  void applyFieldValue( real64 const time,
                        MeshLevel & mesh,
                        string const & fieldName,
                        LAMBDA && lambda ) const;
 
  template< typename POLICY=parallelHostPolicy, typename PRELAMBDA=void, typename POSTLAMBDA=void >
  void applyFieldValue( real64 const time,
                        MeshLevel & mesh,
                        string const & fieldName,
                        PRELAMBDA && preLambda,
                        POSTLAMBDA && postLambda ) const;
 
 
  void applyInitialConditions( MeshLevel & mesh ) const;
 
  void validateBoundaryConditions( MeshLevel & mesh ) const;
 
 
  template< typename OBJECT_TYPE=dataRepository::Group,
            typename BCTYPE = FieldSpecificationBase,
            typename LAMBDA >
  void apply( real64 const time,
              MeshLevel & mesh,
              string const & fieldName,
              LAMBDA && lambda ) const
  {
    GEOS_MARK_FUNCTION;
 
    string const meshBodyName = mesh.getParent().getParent().getName();
    string const meshLevelName = mesh.getName();
 
    // loop over all FieldSpecificationBase objects
    this->forSubGroups< BCTYPE >( [&] ( BCTYPE const & fs )
    {
      integer const isInitialCondition = fs.initialCondition();
      if( ( isInitialCondition && fieldName=="") || // this only use case for this line is in the unit test for field specification
          ( !isInitialCondition && time >= fs.getStartTime() && time < fs.getEndTime() && fieldName == fs.getFieldName() ) )
      {
        fs.template apply< OBJECT_TYPE, BCTYPE, LAMBDA >( mesh, std::forward< LAMBDA >( lambda ) );
      }
    } );
  }
 
  void setIsSurfaceGenerationCase( bool isSurfaceGenerationCase )
  {
    m_isSurfaceGenerationCase = isSurfaceGenerationCase;
  }
 
private:
  static FieldSpecificationManager * m_instance;
  bool m_isSurfaceGenerationCase = false;
 
};
 
template< typename POLICY, typename LAMBDA >
void
FieldSpecificationManager::
  applyFieldValue( real64 const time,
                   MeshLevel & mesh,
                   string const & fieldName,
                   LAMBDA && lambda ) const
{
  GEOS_MARK_FUNCTION;
 
  apply( time, mesh, fieldName,
         [&]( FieldSpecificationBase const & fs,
              string const &,
              SortedArrayView< localIndex const > const & targetSet,
              Group & targetGroup,
              string const & targetField )
  {
    fs.applyFieldValue< FieldSpecificationEqual, POLICY >( targetSet, time, targetGroup, targetField );
    lambda( fs, targetSet );
  } );
}
 
template< typename POLICY, typename PRELAMBDA, typename POSTLAMBDA >
void
FieldSpecificationManager::
  applyFieldValue( real64 const time,
                   MeshLevel & mesh,
                   string const & fieldName,
                   PRELAMBDA && preLambda,
                   POSTLAMBDA && postLambda ) const
{
  GEOS_MARK_FUNCTION;
 
  apply( time, mesh, fieldName,
         [&]( FieldSpecificationBase const & fs,
              string const &,
              SortedArrayView< localIndex const > const & targetSet,
              Group & targetGroup,
              string const & targetField )
  {
    preLambda( fs, targetSet );
    fs.applyFieldValue< FieldSpecificationEqual, POLICY >( targetSet, time, targetGroup, targetField );
    postLambda( fs, targetSet );
  } );
}
 
} /* namespace geos */
 
#endif /* GEOS_FIELDSPECIFICATION_FIELDSPECIFICATIONMANAGER_HPP_ */