FieldSpecificationManager.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 Total, S.A
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */

#ifndef GEOSX_MANAGERS_FIELDSPECIFICATION_FIELDSPECIFICATIONMANAGER_HPP_
#define GEOSX_MANAGERS_FIELDSPECIFICATION_FIELDSPECIFICATIONMANAGER_HPP_

#include "codingUtilities/StringUtilities.hpp"
#include "managers/FieldSpecification/FieldSpecificationBase.hpp"
#include "common/DataTypes.hpp"
#include "common/TimingMacros.hpp"
#include "managers/ObjectManagerBase.hpp"
#include "managers/DomainPartition.hpp"

namespace geosx
{
namespace dataRepository
{
namespace keys
{
string const boundaryConditionManager( "BoundaryConditionManager" );
}
}

class FieldSpecificationManager : public dataRepository::Group
{
public:


  static FieldSpecificationManager & get();

  virtual Group * CreateChild( string const & childKey, string const & childName ) override;

  virtual void ExpandObjectCatalogs() override;

  template< typename POLICY=parallelHostPolicy >
  void ApplyFieldValue( real64 const time,
                        dataRepository::Group * domain,
                        string const & fieldPath,
                        string const & fieldName ) const
  {
    GEOSX_MARK_FUNCTION;

    ApplyFieldValue< POLICY >( time, domain, fieldPath, fieldName,
                               [&]( FieldSpecificationBase const * const,
                                    SortedArrayView< localIndex const > const & ){} );
  }

  template< typename POLICY=parallelHostPolicy, typename LAMBDA=void >
  void ApplyFieldValue( real64 const time,
                        dataRepository::Group * domain,
                        string const & fieldPath,
                        string const & fieldName,
                        LAMBDA && lambda ) const;

  template< typename POLICY=parallelHostPolicy, typename PRELAMBDA=void, typename POSTLAMBDA=void >
  void ApplyFieldValue( real64 const time,
                        dataRepository::Group * domain,
                        string const & fieldPath,
                        string const & fieldName,
                        PRELAMBDA && preLambda,
                        POSTLAMBDA && postLambda ) const;


  void ApplyInitialConditions( dataRepository::Group * domain ) const;


  template< typename LAMBDA >
  void Apply( real64 const time,
              dataRepository::Group * domain,
              string const & fieldPath,
              string const & fieldName,
              LAMBDA && lambda ) const
  {
    GEOSX_MARK_FUNCTION;
    // loop over all FieldSpecificationBase objects
    for( auto & subGroup : this->GetSubGroups() )
    {
      FieldSpecificationBase const * fs = subGroup.second->group_cast< FieldSpecificationBase const * >();
      int const isInitialCondition = fs->initialCondition();

      if( ( isInitialCondition && fieldPath=="" ) ||
          ( !isInitialCondition && fs->GetObjectPath().find( fieldPath ) != string::npos ) )
      {
        string_array const targetPath = stringutilities::Tokenize( fs->GetObjectPath(), "/" );
        localIndex const targetPathLength = LvArray::integerConversion< localIndex >( targetPath.size());
        string const targetName = fs->GetFieldName();

        if( ( isInitialCondition && fieldName=="" ) ||
            ( !isInitialCondition && time >= fs->GetStartTime() && time < fs->GetEndTime() && targetName==fieldName ) )
        {
          MeshLevel * const meshLevel = domain->group_cast< DomainPartition * >()->
                                          getMeshBody( 0 )->getMeshLevel( 0 );

          dataRepository::Group * targetGroup = meshLevel;

          string processedPath;
          for( localIndex pathLevel=0; pathLevel<targetPathLength; ++pathLevel )
          {
            dataRepository::Group * const elemRegionSubGroup = targetGroup->GetGroup( ElementRegionManager::groupKeyStruct::elementRegionsGroup );
            if( elemRegionSubGroup!=nullptr )
            {
              targetGroup = elemRegionSubGroup;
            }

            dataRepository::Group * const elemSubRegionSubGroup = targetGroup->GetGroup( ElementRegionBase::viewKeyStruct::elementSubRegions );
            if( elemSubRegionSubGroup!=nullptr )
            {
              targetGroup = elemSubRegionSubGroup;
            }

            if( targetPath[pathLevel] == ElementRegionManager::groupKeyStruct::elementRegionsGroup ||
                targetPath[pathLevel] == ElementRegionBase::viewKeyStruct::elementSubRegions )
            {
              continue;
            }

            targetGroup = targetGroup->GetGroup( targetPath[pathLevel] );
            processedPath += "/" + targetPath[pathLevel];

            GEOSX_ERROR_IF( targetGroup == nullptr,
                            "ApplyBoundaryCondition(): Last entry in objectPath ("<<processedPath<<") is not found" );
          }
          ApplyOnTargetRecursive( targetGroup, fs, targetName, lambda );
        }
      }
    }
  }

private:
  FieldSpecificationManager( string const & name, dataRepository::Group * const parent );
  virtual ~FieldSpecificationManager() override;

  template< typename LAMBDA >
  void ApplyOnTargetRecursive( Group * target,
                               FieldSpecificationBase const * fs,
                               string const & targetName,
                               LAMBDA && lambda
                               ) const
  {
    if( ( target->getParent()->getName() == ElementRegionBase::viewKeyStruct::elementSubRegions
          || target->getName() == "nodeManager"
          || target->getName() == "FaceManager"
          || target->getName() == "edgeManager" ) // TODO these 3 strings are harcoded because for the moment, there are
                                                  // inconsistencies with the name of the Managers...
        && target->getName() != ObjectManagerBase::groupKeyStruct::setsString
        && target->getName() != ObjectManagerBase::groupKeyStruct::neighborDataString )
    {
      dataRepository::Group const * setGroup = target->GetGroup( ObjectManagerBase::groupKeyStruct::setsString );
      string_array setNames = fs->GetSetNames();
      for( auto & setName : setNames )
      {
        dataRepository::Wrapper< SortedArray< localIndex > > const * const setWrapper = setGroup->getWrapper< SortedArray< localIndex > >( setName );
        if( setWrapper != nullptr )
        {
          SortedArrayView< localIndex const > const & targetSet = setWrapper->reference();
          lambda( fs, setName, targetSet, target, targetName );
        }
      }
    }
    else
    {
      target->forSubGroups( [&]( Group & subTarget )
      {
        ApplyOnTargetRecursive( &subTarget, fs, targetName, lambda );
      } );
    }
  }
};

template< typename POLICY, typename LAMBDA >
void
FieldSpecificationManager::
  ApplyFieldValue( real64 const time,
                   dataRepository::Group * domain,
                   string const & fieldPath,
                   string const & fieldName,
                   LAMBDA && lambda ) const
{
  GEOSX_MARK_FUNCTION;

  Apply( time, domain, fieldPath, fieldName,
         [&]( FieldSpecificationBase const * const fs,
              string const &,
              SortedArrayView< localIndex const > const & targetSet,
              Group * const 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,
                   dataRepository::Group * domain,
                   string const & fieldPath,
                   string const & fieldName,
                   PRELAMBDA && preLambda,
                   POSTLAMBDA && postLambda ) const
{
  GEOSX_MARK_FUNCTION;

  Apply( time, domain, fieldPath, fieldName,
         [&]( FieldSpecificationBase const * const fs,
              string const &,
              SortedArrayView< localIndex const > const & targetSet,
              Group * const targetGroup,
              string const & targetField )
  {
    preLambda( fs, targetSet );
    fs->ApplyFieldValue< FieldSpecificationEqual, POLICY >( targetSet, time, targetGroup, targetField );
    postLambda( fs, targetSet );
  } );
}

} /* namespace geosx */

#endif /* GEOSX_MANAGERS_FIELDSPECIFICATION_FIELDSPECIFICATIONMANAGER_HPP_ */