ElementRegionManager.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 TotalEnergies
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_MESH_ELEMENTREGIONMANAGER_HPP
#define GEOS_MESH_ELEMENTREGIONMANAGER_HPP
 
#include "constitutive/ConstitutiveManager.hpp"
#include "CellElementRegion.hpp"
#include "CellElementSubRegion.hpp"
#include "mesh/generators/CellBlockManagerABC.hpp"
#include "mesh/ObjectManagerBase.hpp"
#include "dataRepository/ReferenceWrapper.hpp"
#include "SurfaceElementRegion.hpp"
#include "WellElementRegion.hpp"
 
namespace geos
{
 
class MeshManager;
 
class ElementRegionManager : public ObjectManagerBase
{
public:
 
  struct groupKeyStruct : public ObjectManagerBase::groupKeyStruct
  {
    static constexpr auto elementRegionsGroup() { return "elementRegionsGroup"; }
  };
 
  constexpr static int maxNumNodesPerElem = 8;
 
  template< typename VIEWTYPE >
  using ElementViewAccessor = array1d< array1d< VIEWTYPE > >;
 
  template< typename VIEWTYPE >
  using ElementView = typename ElementViewAccessor< VIEWTYPE >::NestedViewType;
 
  template< typename VIEWTYPE >
  using ElementViewConst = typename ElementViewAccessor< VIEWTYPE >::NestedViewTypeConst;
 
  template< typename VIEWTYPE >
  using ElementReferenceAccessor = array1d< array1d< ReferenceWrapper< VIEWTYPE > > >;
 
  template< typename VIEWTYPE >
  using MaterialViewAccessor = array1d< array1d< array1d< VIEWTYPE > > >;
 
  template< typename CONSTITUTIVE_TYPE >
  using ConstitutiveRelationAccessor = array1d< array1d< array1d< CONSTITUTIVE_TYPE * > > >;
 
  static string catalogName()
  { return "ZoneManager"; }
 
  virtual string getCatalogName() const override final
  { return catalogName(); }
 
  ElementRegionManager( string const & name, Group * const parent );
 
  virtual ~ElementRegionManager() override;
 
  template< typename T = ElementSubRegionBase >
  localIndex getNumberOfElements() const
  {
    localIndex numElem = 0;
    this->forElementSubRegions< T >( [&]( ElementSubRegionBase const & elementSubRegion )
    {
      numElem += elementSubRegion.size();
    } );
    return numElem;
  }
 
  void generateMesh( CellBlockManagerABC const & cellBlockManager );
 
  void generateWells( CellBlockManagerABC const & cellBlockManager, MeshLevel & meshLevel );
 
  void buildSets( NodeManager const & nodeManager );
 
  virtual Group * createChild( string const & childKey, string const & childName ) override;
//  virtual void ReadXMLsub( xmlWrapper::xmlNode const & targetNode ) override;
 
  virtual void expandObjectCatalogs() override;
 
  virtual void setSchemaDeviations( xmlWrapper::xmlNode schemaRoot,
                                    xmlWrapper::xmlNode schemaParent,
                                    integer documentationType ) override;
 
  using Group::resize;
 
  void resize( integer_array const & numElements,
               string_array const & regionNames,
               string_array const & elementTypes );
 
  virtual void setMaxGlobalIndex() override final;
 
  subGroupMap const & getRegions() const
  {
    return this->getGroup( groupKeyStruct::elementRegionsGroup() ).getSubGroups();
  }
 
  subGroupMap & getRegions()
  {
    return this->getGroup( groupKeyStruct::elementRegionsGroup() ).getSubGroups();
  }
 
  template< typename T=ElementRegionBase, typename KEY_TYPE=void >
  T const & getRegion( KEY_TYPE const & key ) const
  {
    return this->getGroup( groupKeyStruct::elementRegionsGroup() ).getGroup< T >( key );
  }
 
  template< typename T=ElementRegionBase, typename KEY_TYPE=void >
  T & getRegion( KEY_TYPE const & key )
  {
    return this->getGroup( groupKeyStruct::elementRegionsGroup() ).getGroup< T >( key );
  }
 
  template< typename T=ElementRegionBase >
  bool hasRegion( string const & name ) const
  {
    return this->getGroup( groupKeyStruct::elementRegionsGroup() ).hasGroup< T >( name );
  }
 
  localIndex numRegions() const
  {
    return this->getRegions().size();
  }
 
  array2d< localIndex > getCellBlockToSubRegionMap( CellBlockManagerABC const & cellBlockManager ) const;
 
  template< typename REGIONTYPE = ElementRegionBase, typename ... REGIONTYPES, typename LAMBDA >
  void forElementRegions( LAMBDA && lambda )
  {
    this->getGroup( groupKeyStruct::elementRegionsGroup() ).forSubGroups< REGIONTYPE, REGIONTYPES... >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename REGIONTYPE = ElementRegionBase, typename ... REGIONTYPES, typename LAMBDA >
  void forElementRegions( LAMBDA && lambda ) const
  {
    this->getGroup( groupKeyStruct::elementRegionsGroup() ).forSubGroups< REGIONTYPE, REGIONTYPES... >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename REGIONTYPE = ElementRegionBase, typename ... REGIONTYPES, typename LOOKUP_CONTAINER, typename LAMBDA >
  void forElementRegions( LOOKUP_CONTAINER const & targetRegions, LAMBDA && lambda )
  {
    this->getGroup( groupKeyStruct::elementRegionsGroup() ).forSubGroups< REGIONTYPE, REGIONTYPES... >( targetRegions, std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename REGIONTYPE = ElementRegionBase, typename ... REGIONTYPES, typename LOOKUP_CONTAINER, typename LAMBDA >
  void forElementRegions( LOOKUP_CONTAINER const & targetRegions, LAMBDA && lambda ) const
  {
    this->getGroup( groupKeyStruct::elementRegionsGroup() ).forSubGroups< REGIONTYPE, REGIONTYPES... >( targetRegions, std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename LAMBDA >
  void forElementRegionsComplete( LAMBDA lambda ) const
  {
    forElementRegionsComplete< CellElementRegion, SurfaceElementRegion,
                               WellElementRegion >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename LAMBDA >
  void forElementRegionsComplete( LAMBDA lambda )
  {
    forElementRegionsComplete< CellElementRegion, SurfaceElementRegion,
                               WellElementRegion >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename REGIONTYPE, typename ... REGIONTYPES, typename LAMBDA >
  void forElementRegionsComplete( LAMBDA lambda )
  {
    for( localIndex er=0; er<this->numRegions(); ++er )
    {
      ElementRegionBase & elementRegion = this->getRegion( er );
 
      Group::applyLambdaToContainer< REGIONTYPE, REGIONTYPES... >( elementRegion, [&]( auto & castedRegion )
      {
        lambda( er, castedRegion );
      } );
    }
  }
 
  template< typename REGIONTYPE, typename ... REGIONTYPES, typename LAMBDA >
  void forElementRegionsComplete( LAMBDA lambda ) const
  {
    for( localIndex er=0; er<this->numRegions(); ++er )
    {
      ElementRegionBase const & elementRegion = this->getRegion( er );
 
      Group::applyLambdaToContainer< REGIONTYPE, REGIONTYPES... >( elementRegion, [&]( auto const & castedRegion )
      {
        lambda( er, castedRegion );
      } );
    }
  }
 
  template< typename LOOKUP_CONTAINER, typename LAMBDA >
  void forElementRegionsComplete( LOOKUP_CONTAINER const & targetRegions, LAMBDA lambda ) const
  {
    forElementRegionsComplete< CellElementRegion, SurfaceElementRegion,
                               WellElementRegion >( targetRegions, std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename LOOKUP_CONTAINER, typename LAMBDA >
  void forElementRegionsComplete( LOOKUP_CONTAINER const & targetRegions, LAMBDA lambda )
  {
    forElementRegionsComplete< CellElementRegion, SurfaceElementRegion,
                               WellElementRegion >( targetRegions, std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename REGIONTYPE, typename ... REGIONTYPES, typename LOOKUP_CONTAINER, typename LAMBDA >
  void forElementRegionsComplete( LOOKUP_CONTAINER const & targetRegions, LAMBDA lambda )
  {
    forElementRegions< REGIONTYPE, REGIONTYPES... >( targetRegions, [&] ( localIndex const targetIndex,
                                                                          auto & elementRegion )
    {
      lambda( targetIndex, elementRegion.getIndexInParent(), elementRegion );
    } );
  }
 
  template< typename REGIONTYPE, typename ... REGIONTYPES, typename LOOKUP_CONTAINER, typename LAMBDA >
  void forElementRegionsComplete( LOOKUP_CONTAINER const & targetRegions, LAMBDA lambda ) const
  {
    forElementRegions< REGIONTYPE, REGIONTYPES... >( targetRegions, [&] ( localIndex const targetIndex,
                                                                          auto const & elementRegion )
    {
      lambda( targetIndex, elementRegion.getIndexInParent(), elementRegion );
    } );
  }
 
  template< typename LAMBDA >
  void forElementSubRegions( LAMBDA && lambda )
  {
    forElementSubRegions< CellElementSubRegion, FaceElementSubRegion, EmbeddedSurfaceSubRegion,
                          WellElementSubRegion >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename LAMBDA >
  void forElementSubRegions( LAMBDA && lambda ) const
  {
    forElementSubRegions< CellElementSubRegion, FaceElementSubRegion, EmbeddedSurfaceSubRegion,
                          WellElementSubRegion >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename LOOKUP_CONTAINER, typename LAMBDA >
  void forElementSubRegions( LOOKUP_CONTAINER const & targetRegions, LAMBDA && lambda )
  {
    forElementSubRegions< CellElementSubRegion, FaceElementSubRegion, EmbeddedSurfaceSubRegion,
                          WellElementSubRegion >( targetRegions, std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename LOOKUP_CONTAINER, typename LAMBDA >
  void forElementSubRegions( LOOKUP_CONTAINER const & targetRegions, LAMBDA && lambda ) const
  {
    forElementSubRegions< CellElementSubRegion, FaceElementSubRegion, EmbeddedSurfaceSubRegion,
                          WellElementSubRegion >( targetRegions, std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename SUBREGIONTYPE, typename ... SUBREGIONTYPES, typename LAMBDA >
  void forElementSubRegions( LAMBDA && lambda )
  {
    forElementSubRegionsComplete< SUBREGIONTYPE, SUBREGIONTYPES... >(
      [lambda = std::forward< LAMBDA >( lambda )]( localIndex const,
                                                   localIndex const,
                                                   ElementRegionBase &,
                                                   auto & subRegion )
    {
      lambda( subRegion );
    }
      );
  }
 
  template< typename SUBREGIONTYPE, typename ... SUBREGIONTYPES, typename LAMBDA >
  void forElementSubRegions( LAMBDA && lambda ) const
  {
    forElementSubRegionsComplete< SUBREGIONTYPE, SUBREGIONTYPES... >(
      [lambda = std::forward< LAMBDA >( lambda )]( localIndex const,
                                                   localIndex const,
                                                   ElementRegionBase const &,
                                                   auto const & subRegion )
    {
      lambda( subRegion );
    } );
  }
 
  template< typename SUBREGIONTYPE, typename ... SUBREGIONTYPES, typename LOOKUP_CONTAINER, typename LAMBDA >
  void forElementSubRegions( LOOKUP_CONTAINER const & targetRegions, LAMBDA && lambda )
  {
    forElementSubRegionsComplete< SUBREGIONTYPE, SUBREGIONTYPES... >( targetRegions,
                                                                      [lambda = std::forward< LAMBDA >( lambda )]( localIndex const targetIndex,
                                                                                                                   localIndex const,
                                                                                                                   localIndex const,
                                                                                                                   ElementRegionBase &,
                                                                                                                   auto & subRegion )
    {
      lambda( targetIndex, subRegion );
    } );
  }
 
  template< typename SUBREGIONTYPE, typename ... SUBREGIONTYPES, typename LOOKUP_CONTAINER, typename LAMBDA >
  void forElementSubRegions( LOOKUP_CONTAINER const & targetRegions, LAMBDA && lambda ) const
  {
    forElementSubRegionsComplete< SUBREGIONTYPE, SUBREGIONTYPES... >( targetRegions,
                                                                      [lambda = std::forward< LAMBDA >( lambda )]( localIndex const targetIndex,
                                                                                                                   localIndex const,
                                                                                                                   localIndex const,
                                                                                                                   ElementRegionBase const &,
                                                                                                                   auto const & subRegion )
    {
      lambda( targetIndex, subRegion );
    } );
  }
 
  template< typename LAMBDA >
  void forElementSubRegionsComplete( LAMBDA && lambda ) const
  {
    forElementSubRegionsComplete< CellElementSubRegion, FaceElementSubRegion, EmbeddedSurfaceSubRegion,
                                  WellElementSubRegion >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename LAMBDA >
  void forElementSubRegionsComplete( LAMBDA && lambda )
  {
    forElementSubRegionsComplete< CellElementSubRegion, FaceElementSubRegion, EmbeddedSurfaceSubRegion,
                                  WellElementSubRegion >( std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename LOOKUP_CONTAINER, typename LAMBDA >
  void forElementSubRegionsComplete( LOOKUP_CONTAINER const & targetRegions, LAMBDA && lambda )
  {
    forElementSubRegionsComplete< CellElementSubRegion, FaceElementSubRegion, EmbeddedSurfaceSubRegion, WellElementSubRegion >( targetRegions,
                                                                                                                                std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename LOOKUP_CONTAINER, typename LAMBDA >
  void forElementSubRegionsComplete( LOOKUP_CONTAINER const & targetRegions, LAMBDA && lambda ) const
  {
    forElementSubRegionsComplete< CellElementSubRegion, FaceElementSubRegion, EmbeddedSurfaceSubRegion, WellElementSubRegion >( targetRegions,
                                                                                                                                std::forward< LAMBDA >( lambda ) );
  }
 
  template< typename SUBREGIONTYPE, typename ... SUBREGIONTYPES, typename LAMBDA >
  void forElementSubRegionsComplete( LAMBDA && lambda )
  {
    for( localIndex er=0; er<this->numRegions(); ++er )
    {
      ElementRegionBase & elementRegion = this->getRegion( er );
 
      for( localIndex esr=0; esr<elementRegion.numSubRegions(); ++esr )
      {
        ElementSubRegionBase & subRegion = elementRegion.getSubRegion( esr );
 
        Group::applyLambdaToContainer< SUBREGIONTYPE, SUBREGIONTYPES... >( subRegion, [&]( auto & castedSubRegion )
        {
          lambda( er, esr, elementRegion, castedSubRegion );
        } );
      }
    }
  }
 
  template< typename SUBREGIONTYPE, typename ... SUBREGIONTYPES, typename LAMBDA >
  void forElementSubRegionsComplete( LAMBDA && lambda ) const
  {
    for( localIndex er=0; er<this->numRegions(); ++er )
    {
      ElementRegionBase const & elementRegion = this->getRegion( er );
 
      for( localIndex esr=0; esr<elementRegion.numSubRegions(); ++esr )
      {
        ElementSubRegionBase const & subRegion = elementRegion.getSubRegion( esr );
 
        Group::applyLambdaToContainer< SUBREGIONTYPE, SUBREGIONTYPES... >( subRegion, [&]( auto const & castedSubRegion )
        {
          lambda( er, esr, elementRegion, castedSubRegion );
        } );
      }
    }
  }
 
  template< typename SUBREGIONTYPE, typename ... SUBREGIONTYPES, typename LOOKUP_CONTAINER, typename LAMBDA >
  void forElementSubRegionsComplete( LOOKUP_CONTAINER const & targetRegions, LAMBDA && lambda )
  {
    forElementRegions( targetRegions, [&] ( localIndex const targetIndex, ElementRegionBase & elementRegion )
    {
      localIndex const er = elementRegion.getIndexInParent();
 
      if( er>-1 )
      {
        for( localIndex esr=0; esr<elementRegion.numSubRegions(); ++esr )
        {
          ElementSubRegionBase & subRegion = elementRegion.getSubRegion( esr );
 
          Group::applyLambdaToContainer< SUBREGIONTYPE, SUBREGIONTYPES... >( subRegion, [&]( auto & castedSubRegion )
          {
            lambda( targetIndex, er, esr, elementRegion, castedSubRegion );
          } );
        }
      }
    } );
  }
 
  template< typename SUBREGIONTYPE, typename ... SUBREGIONTYPES, typename LOOKUP_CONTAINER, typename LAMBDA >
  void forElementSubRegionsComplete( LOOKUP_CONTAINER const & targetRegions, LAMBDA && lambda ) const
  {
    forElementRegions( targetRegions, [&] ( localIndex const targetIndex, ElementRegionBase const & elementRegion )
    {
      localIndex const er = elementRegion.getIndexInParent();
 
      if( er>-1 )
      {
        for( localIndex esr=0; esr<elementRegion.numSubRegions(); ++esr )
        {
          ElementSubRegionBase const & subRegion = elementRegion.getSubRegion( esr );
 
          Group::applyLambdaToContainer< SUBREGIONTYPE, SUBREGIONTYPES... >( subRegion, [&]( auto const & castedSubRegion )
          {
            lambda( targetIndex, er, esr, elementRegion, castedSubRegion );
          } );
        }
      }
    } );
  }
 
 
  template< typename FIELD_TRAIT >
  ElementViewAccessor< traits::ViewTypeConst< typename FIELD_TRAIT::type > >
  constructFieldAccessor( string const & neighborName = string() ) const;
 
  template< typename VIEWTYPE, typename LHS=VIEWTYPE >
  ElementViewAccessor< LHS >
  constructViewAccessor( string const & name, string const & neighborName = string() ) const;
 
  template< typename VIEWTYPE, typename LHS=VIEWTYPE >
  ElementViewAccessor< LHS >
  constructViewAccessor( string const & name, string const & neighborName = string() );
 
  template< typename T, int NDIM, typename PERM = defaultLayout< NDIM > >
  ElementViewAccessor< ArrayView< T const, NDIM, getUSD< PERM > > >
  constructArrayViewAccessor( string const & name, string const & neighborName = string() ) const;
 
  template< typename VIEWTYPE >
  ElementViewAccessor< ReferenceWrapper< VIEWTYPE > >
  constructReferenceAccessor( string const & viewName, string const & neighborName = string() ) const;
 
  template< typename VIEWTYPE >
  ElementViewAccessor< ReferenceWrapper< VIEWTYPE > >
  constructReferenceAccessor( string const & viewName, string const & neighborName = string() );
 
  template< typename VIEWTYPE, typename LHS=VIEWTYPE >
  MaterialViewAccessor< LHS >
  constructFullMaterialViewAccessor( string const & viewName,
                                     constitutive::ConstitutiveManager const & cm ) const;
 
  template< typename VIEWTYPE, typename LHS=VIEWTYPE >
  MaterialViewAccessor< LHS >
  constructFullMaterialViewAccessor( string const & viewName,
                                     constitutive::ConstitutiveManager const & cm );
 
  template< typename FIELD_TRAIT >
  ElementViewAccessor< traits::ViewTypeConst< typename FIELD_TRAIT::type > >
  constructMaterialFieldAccessor( arrayView1d< string const > const & regionNames,
                                  arrayView1d< string const > const & materialNames,
                                  bool const allowMissingViews = false ) const;
 
  template< typename MATERIAL_TYPE, typename FIELD_TRAIT >
  ElementViewAccessor< traits::ViewTypeConst< typename FIELD_TRAIT::type > >
  constructMaterialFieldAccessor( bool const allowMissingViews = false ) const;
 
 
  template< typename VIEWTYPE, typename LHS=VIEWTYPE >
  ElementViewAccessor< LHS >
  constructMaterialViewAccessor( string const & viewName,
                                 arrayView1d< string const > const & regionNames,
                                 string const & materialKeyName,
                                 bool const allowMissingViews = false ) const;
 
  template< typename VIEWTYPE, typename LHS=VIEWTYPE >
  ElementViewAccessor< LHS >
  constructMaterialViewAccessor( string const & viewName,
                                 arrayView1d< string const > const & regionNames,
                                 string const & materialKeyName,
                                 bool const allowMissingViews = false );
 
  template< typename T, int NDIM, typename PERM = defaultLayout< NDIM > >
  ElementViewAccessor< ArrayView< T const, NDIM, getUSD< PERM > > >
  constructMaterialArrayViewAccessor( string const & viewName,
                                      arrayView1d< string const > const & regionNames,
                                      string const & materialKeyName,
                                      bool const allowMissingViews = false ) const;
 
  template< typename MATERIALTYPE, typename VIEWTYPE, typename LHS=VIEWTYPE >
  ElementViewAccessor< LHS >
  constructMaterialViewAccessor( string const & viewName ) const;
 
  template< typename MATERIALTYPE, typename T, int NDIM, typename PERM = defaultLayout< NDIM > >
  ElementViewAccessor< ArrayView< T const, NDIM, getUSD< PERM > > >
  constructMaterialArrayViewAccessor( string const & viewName ) const;
 
  template< typename CONSTITUTIVE_TYPE >
  ConstitutiveRelationAccessor< CONSTITUTIVE_TYPE >
  constructFullConstitutiveAccessor( constitutive::ConstitutiveManager const & cm ) const;
 
 
  template< typename CONSTITUTIVE_TYPE >
  ConstitutiveRelationAccessor< CONSTITUTIVE_TYPE >
  constructFullConstitutiveAccessor( constitutive::ConstitutiveManager const & cm );
 
  using Group::packSize;
  using Group::pack;
  using ObjectManagerBase::packGlobalMapsSize;
  using ObjectManagerBase::packGlobalMaps;
  using ObjectManagerBase::unpackGlobalMaps;
  using ObjectManagerBase::packUpDownMapsSize;
  using ObjectManagerBase::packUpDownMaps;
  using ObjectManagerBase::unpackUpDownMaps;
 
  int packSize( ElementViewAccessor< arrayView1d< localIndex > > const & packList ) const;
 
  int pack( buffer_unit_type * & buffer,
            ElementViewAccessor< arrayView1d< localIndex > > const & packList ) const;
 
  using ObjectManagerBase::unpack;
 
  int unpack( buffer_unit_type const * & buffer,
              ElementViewAccessor< arrayView1d< localIndex > > & packList );
 
  int unpack( buffer_unit_type const * & buffer,
              ElementReferenceAccessor< array1d< localIndex > > & packList );
 
  int packGlobalMapsSize( ElementViewAccessor< arrayView1d< localIndex > > const & packList ) const;
 
  int packGlobalMaps( buffer_unit_type * & buffer,
                      ElementViewAccessor< arrayView1d< localIndex > > const & packList ) const;
 
  int unpackGlobalMaps( buffer_unit_type const * & buffer,
                        ElementViewAccessor< ReferenceWrapper< localIndex_array > > & packList );
 
  int packUpDownMapsSize( ElementViewAccessor< arrayView1d< localIndex > > const & packList ) const;
 
  int packUpDownMapsSize( ElementReferenceAccessor< array1d< localIndex > > const & packList ) const;
 
  int packUpDownMaps( buffer_unit_type * & buffer,
                      ElementViewAccessor< arrayView1d< localIndex > > const & packList ) const;
 
  int packUpDownMaps( buffer_unit_type * & buffer,
                      ElementReferenceAccessor< array1d< localIndex > > const & packList ) const;
 
  int unpackUpDownMaps( buffer_unit_type const * & buffer,
                        ElementReferenceAccessor< localIndex_array > & packList,
                        bool const overwriteMap );
 
  int packFracturedElementsSize( ElementViewAccessor< arrayView1d< localIndex > > const & packList,
                                 string const fractureRegionName ) const;
 
  int packFracturedElements( buffer_unit_type * & buffer,
                             ElementViewAccessor< arrayView1d< localIndex > > const & packList,
                             string const fractureRegionName ) const;
 
  int unpackFracturedElements( buffer_unit_type const * & buffer,
                               ElementReferenceAccessor< localIndex_array > & packList,
                               string const fractureRegionName );
 
 
private:
 
  template< bool DO_PACKING >
  int packImpl( buffer_unit_type * & buffer,
                ElementViewAccessor< arrayView1d< localIndex > > const & viewAccessor ) const;
 
  template< bool DO_PACKING >
  int packGlobalMapsImpl( buffer_unit_type * & buffer,
                          ElementViewAccessor< arrayView1d< localIndex > > const & viewAccessor ) const;
 
  template< bool DO_PACKING, typename T >
  int
  packUpDownMapsImpl( buffer_unit_type * & buffer,
                      T const & packList ) const;
  template< typename T >
  int unpackImpl( buffer_unit_type const * & buffer,
                  T & packList );
 
  template< bool DO_PACKING >
  int packFracturedElementsImpl( buffer_unit_type * & buffer,
                                 ElementViewAccessor< arrayView1d< localIndex > > const & packList,
                                 string const fractureRegionName ) const;
 
  ElementRegionManager( const ElementRegionManager & );
 
  ElementRegionManager & operator=( const ElementRegionManager & );
 
 
};
 
 
template< typename VIEWTYPE, typename LHS >
ElementRegionManager::ElementViewAccessor< LHS >
ElementRegionManager::constructViewAccessor( string const & viewName, string const & neighborName ) const
{
  ElementViewAccessor< LHS > viewAccessor;
  viewAccessor.resize( numRegions() );
  for( typename dataRepository::indexType kReg=0; kReg<numRegions(); ++kReg )
  {
    ElementRegionBase const & elemRegion = getRegion( kReg );
    viewAccessor[kReg].resize( elemRegion.numSubRegions() );
 
    for( typename dataRepository::indexType kSubReg = 0; kSubReg < elemRegion.numSubRegions(); ++kSubReg )
    {
      Group const * group = &elemRegion.getSubRegion( kSubReg );
 
      if( !neighborName.empty() )
      {
        group = &group->getGroup( ObjectManagerBase::groupKeyStruct::neighborDataString() ).getGroup( neighborName );
      }
 
      dataRepository::Wrapper< VIEWTYPE > const * const wrapper = group->getWrapperPointer< VIEWTYPE >( viewName );
      if( wrapper )
      {
        viewAccessor[kReg][kSubReg] = wrapper->reference();
      }
    }
  }
  return viewAccessor;
}
 
 
template< typename VIEWTYPE, typename LHS >
ElementRegionManager::ElementViewAccessor< LHS >
ElementRegionManager::
  constructViewAccessor( string const & viewName, string const & neighborName )
{
  ElementViewAccessor< LHS > viewAccessor;
  viewAccessor.resize( numRegions() );
  for( typename dataRepository::indexType kReg=0; kReg<numRegions(); ++kReg )
  {
    ElementRegionBase & elemRegion = getRegion( kReg );
    viewAccessor[kReg].resize( elemRegion.numSubRegions() );
 
    for( typename dataRepository::indexType kSubReg = 0; kSubReg < elemRegion.numSubRegions(); ++kSubReg )
    {
      Group * group = &elemRegion.getSubRegion( kSubReg );
 
      if( !neighborName.empty() )
      {
        group = &group->getGroup( ObjectManagerBase::groupKeyStruct::neighborDataString() ).getGroup( neighborName );
      }
 
      dataRepository::Wrapper< VIEWTYPE > * const wrapper = group->getWrapperPointer< VIEWTYPE >( viewName );
      if( wrapper )
      {
        viewAccessor[kReg][kSubReg] = wrapper->reference();
      }
    }
  }
  return viewAccessor;
}
 
template< typename FIELD_TRAIT >
ElementRegionManager::ElementViewAccessor< traits::ViewTypeConst< typename FIELD_TRAIT::type > >
ElementRegionManager::constructFieldAccessor( string const & neighborName ) const
{
  return constructViewAccessor< typename FIELD_TRAIT::type,
                                traits::ViewTypeConst< typename FIELD_TRAIT::type > >( FIELD_TRAIT::key(), neighborName );
}
 
 
template< typename T, int NDIM, typename PERM >
ElementRegionManager::ElementViewAccessor< ArrayView< T const, NDIM, getUSD< PERM > > >
ElementRegionManager::
  constructArrayViewAccessor( string const & name, string const & neighborName ) const
{
  return constructViewAccessor< Array< T, NDIM, PERM >,
                                ArrayView< T const, NDIM, getUSD< PERM > >
                                >( name, neighborName );
}
 
template< typename VIEWTYPE >
ElementRegionManager::ElementViewAccessor< ReferenceWrapper< VIEWTYPE > >
ElementRegionManager::
  constructReferenceAccessor( string const & viewName, string const & neighborName ) const
{
  ElementViewAccessor< ReferenceWrapper< VIEWTYPE > > viewAccessor;
  viewAccessor.resize( numRegions() );
  for( typename dataRepository::indexType kReg=0; kReg<numRegions(); ++kReg )
  {
    ElementRegionBase const & elemRegion = getRegion( kReg );
    viewAccessor[kReg].resize( elemRegion.numSubRegions() );
 
    for( typename dataRepository::indexType kSubReg=0; kSubReg<elemRegion.numSubRegions(); ++kSubReg )
    {
      Group const * group = &elemRegion.getSubRegion( kSubReg );
 
      if( !neighborName.empty() )
      {
        group = &group->getGroup( ObjectManagerBase::groupKeyStruct::neighborDataString() ).getGroup( neighborName );
      }
 
      if( group->hasWrapper( viewName ) )
      {
        viewAccessor[kReg][kSubReg].set( group->getReference< VIEWTYPE >( viewName ) );
      }
    }
  }
  return viewAccessor;
}
 
template< typename VIEWTYPE >
ElementRegionManager::ElementViewAccessor< ReferenceWrapper< VIEWTYPE > >
ElementRegionManager::constructReferenceAccessor( string const & viewName,
                                                  string const & neighborName )
{
  ElementViewAccessor< ReferenceWrapper< VIEWTYPE > > viewAccessor;
  viewAccessor.resize( numRegions() );
  for( typename dataRepository::indexType kReg = 0; kReg < numRegions(); ++kReg )
  {
    ElementRegionBase & elemRegion = getRegion( kReg );
    viewAccessor[kReg].resize( elemRegion.numSubRegions() );
 
    for( typename dataRepository::indexType kSubReg = 0; kSubReg < elemRegion.numSubRegions(); ++kSubReg )
    {
      Group * group = &elemRegion.getSubRegion( kSubReg );
 
      if( !neighborName.empty() )
      {
        group = &group->getGroup( ObjectManagerBase::groupKeyStruct::neighborDataString() ).getGroup( neighborName );
      }
 
      if( group->hasWrapper( viewName ) )
      {
        viewAccessor[kReg][kSubReg].set( group->getReference< VIEWTYPE >( viewName ) );
      }
    }
  }
  return viewAccessor;
}
 
template< typename VIEWTYPE, typename LHS >
ElementRegionManager::MaterialViewAccessor< LHS >
ElementRegionManager::
  constructFullMaterialViewAccessor( string const & viewName,
                                     constitutive::ConstitutiveManager const & cm ) const
{
  MaterialViewAccessor< LHS > accessor;
  accessor.resize( numRegions() );
  for( localIndex kReg=0; kReg<numRegions(); ++kReg )
  {
    ElementRegionBase const & elemRegion = getRegion( kReg );
    accessor[kReg].resize( elemRegion.numSubRegions() );
 
    for( localIndex kSubReg=0; kSubReg<elemRegion.numSubRegions(); ++kSubReg )
    {
      ElementSubRegionBase const & subRegion = elemRegion.getSubRegion( kSubReg );
      dataRepository::Group const & constitutiveGroup = subRegion.getConstitutiveModels();
 
      accessor[kReg][kSubReg].resize( cm.numSubGroups() );
 
      for( localIndex matIndex=0; matIndex<cm.numSubGroups(); ++matIndex )
      {
        string const & constitutiveName = cm.getGroup( matIndex ).getName();
        dataRepository::Group const * const constitutiveRelation = constitutiveGroup.getGroupPointer( constitutiveName );
        if( constitutiveRelation != nullptr )
        {
          dataRepository::Wrapper< VIEWTYPE > const * const wrapper = constitutiveRelation->getWrapperPointer< VIEWTYPE >( viewName );
          if( wrapper )
          {
            accessor[kReg][kSubReg][matIndex] = wrapper->reference();
          }
        }
      }
    }
  }
  return accessor;
}
 
template< typename VIEWTYPE, typename LHS >
ElementRegionManager::MaterialViewAccessor< LHS >
ElementRegionManager::
  constructFullMaterialViewAccessor( string const & viewName,
                                     constitutive::ConstitutiveManager const & cm )
{
  MaterialViewAccessor< LHS > accessor;
  accessor.resize( numRegions() );
  for( localIndex kReg=0; kReg<numRegions(); ++kReg )
  {
    ElementRegionBase & elemRegion = getRegion( kReg );
    accessor[kReg].resize( elemRegion.numSubRegions() );
 
    for( localIndex kSubReg=0; kSubReg<elemRegion.numSubRegions(); ++kSubReg )
    {
      ElementSubRegionBase & subRegion = elemRegion.getSubRegion( kSubReg );
      dataRepository::Group & constitutiveGroup = subRegion.getConstitutiveModels();
 
      accessor[kReg][kSubReg].resize( cm.numSubGroups() );
 
      for( localIndex matIndex=0; matIndex<cm.numSubGroups(); ++matIndex )
      {
        string const & constitutiveName = cm.getGroup( matIndex ).getName();
        dataRepository::Group * const constitutiveRelation = constitutiveGroup.getGroupPointer( constitutiveName );
        if( constitutiveRelation != nullptr )
        {
          dataRepository::Wrapper< VIEWTYPE > * const wrapper = constitutiveRelation->getWrapperPointer< VIEWTYPE >( viewName );
          if( wrapper )
          {
            accessor[kReg][kSubReg][matIndex] = wrapper->reference();
          }
        }
      }
    }
  }
  return accessor;
}
 
template< typename VIEWTYPE, typename LHS >
ElementRegionManager::ElementViewAccessor< LHS >
ElementRegionManager::constructMaterialViewAccessor( string const & viewName,
                                                     arrayView1d< string const > const & regionNames,
                                                     string const & materialKeyName,
                                                     bool const allowMissingViews ) const
{
  ElementViewAccessor< LHS > accessor;
 
  // Resize the accessor to all regions and subregions
  accessor.resize( numRegions() );
  for( localIndex kReg = 0; kReg < numRegions(); ++kReg )
  {
    accessor[kReg].resize( getRegion( kReg ).numSubRegions() );
  }
 
  subGroupMap const & regionMap = getRegions();
 
  // Loop only over regions named and populate according to given material names
  for( localIndex k = 0; k < regionNames.size(); ++k )
  {
    localIndex const er = regionMap.getIndex( regionNames[k] );
    if( er >=0 )
    {
      GEOS_ERROR_IF_EQ_MSG( er, subGroupMap::KeyIndex::invalid_index, "Region not found: " << regionNames[k] );
      ElementRegionBase const & region = getRegion( er );
 
      region.forElementSubRegionsIndex( [&]( localIndex const esr,
                                             ElementSubRegionBase const & subRegion )
      {
        string const & materialName = subRegion.getReference< string >( materialKeyName );
        dataRepository::Group const & constitutiveRelation = subRegion.getConstitutiveModel( materialName );
 
        dataRepository::Wrapper< VIEWTYPE > const * const wrapper = constitutiveRelation.getWrapperPointer< VIEWTYPE >( viewName );
        if( wrapper )
        {
          accessor[er][esr] = wrapper->reference();
        }
        else
        {
          GEOS_ERROR_IF( !allowMissingViews,
                         subRegion.getDataContext() <<
                         ": Material " << constitutiveRelation.getDataContext() <<
                         " does not contain " << viewName );
        }
      } );
    }
  }
  return accessor;
}
 
template< typename VIEWTYPE, typename LHS >
ElementRegionManager::ElementViewAccessor< LHS >
ElementRegionManager::constructMaterialViewAccessor( string const & viewName,
                                                     arrayView1d< string const > const & regionNames,
                                                     string const & materialKeyName,
                                                     bool const allowMissingViews )
{
  ElementViewAccessor< LHS > accessor;
 
  // Resize the accessor to all regions and subregions
  accessor.resize( numRegions() );
  for( localIndex kReg = 0; kReg < numRegions(); ++kReg )
  {
    accessor[kReg].resize( getRegion( kReg ).numSubRegions() );
  }
 
  subGroupMap const & regionMap = getRegions();
 
  // Loop only over regions named and populate according to given material names
  for( localIndex k = 0; k < regionNames.size(); ++k )
  {
    localIndex const er = regionMap.getIndex( regionNames[k] );
    if( er >=0 )
    {
      GEOS_ERROR_IF_EQ_MSG( er, subGroupMap::KeyIndex::invalid_index, "Region not found: " << regionNames[k] );
      ElementRegionBase & region = getRegion( er );
 
      region.forElementSubRegionsIndex( [&]( localIndex const esr, ElementSubRegionBase & subRegion )
      {
        string const & materialName = subRegion.getReference< string >( materialKeyName );
        dataRepository::Group const & constitutiveRelation = subRegion.getConstitutiveModel( materialName );
 
        dataRepository::Wrapper< VIEWTYPE > * const wrapper = constitutiveRelation.getWrapperPointer< VIEWTYPE >( viewName );
        if( wrapper )
        {
          accessor[er][esr] = wrapper->reference();
        }
        else
        {
          GEOS_ERROR_IF( !allowMissingViews, region.getDataContext() << ": Material " << materialName
                                                                     << " does not contain " << viewName );
        }
      } );
    }
  }
  return accessor;
}
 
template< typename FIELD_TRAIT >
ElementRegionManager::ElementViewAccessor< traits::ViewTypeConst< typename FIELD_TRAIT::type > >
ElementRegionManager::constructMaterialFieldAccessor( arrayView1d< string const > const & regionNames,
                                                      arrayView1d< string const > const & materialNames,
                                                      bool const allowMissingViews ) const
{
  return constructMaterialViewAccessor< typename FIELD_TRAIT::type,
                                        traits::ViewTypeConst< typename FIELD_TRAIT::type > >( FIELD_TRAIT::key(),
                                                                                               regionNames,
                                                                                               materialNames,
                                                                                               allowMissingViews );
}
 
template< typename MATERIAL_TYPE, typename FIELD_TRAIT >
ElementRegionManager::ElementViewAccessor< traits::ViewTypeConst< typename FIELD_TRAIT::type > >
ElementRegionManager::constructMaterialFieldAccessor( bool const allowMissingViews ) const
{
  GEOS_UNUSED_VAR( allowMissingViews );
  return constructMaterialViewAccessor< MATERIAL_TYPE, typename FIELD_TRAIT::type,
                                        traits::ViewTypeConst< typename FIELD_TRAIT::type > >( FIELD_TRAIT::key() );
}
 
 
template< typename T, int NDIM, typename PERM >
ElementRegionManager::ElementViewAccessor< ArrayView< T const, NDIM, getUSD< PERM > > >
ElementRegionManager::
  constructMaterialArrayViewAccessor( string const & viewName,
                                      arrayView1d< string const > const & regionNames,
                                      string const & materialKeyName,
                                      bool const allowMissingViews ) const
{
  return constructMaterialViewAccessor< Array< T, NDIM, PERM >, ArrayView< T const, NDIM, getUSD< PERM > > >( viewName,
                                                                                                              regionNames,
                                                                                                              materialKeyName,
                                                                                                              allowMissingViews );
}
 
template< typename MATERIALTYPE, typename VIEWTYPE, typename LHS >
ElementRegionManager::ElementViewAccessor< LHS >
ElementRegionManager::constructMaterialViewAccessor( string const & viewName ) const
{
  ElementViewAccessor< LHS > accessor( numRegions() );
 
  // Resize the accessor to all regions and subregions
  for( localIndex er = 0; er < numRegions(); ++er )
  {
    accessor[er].resize( getRegion( er ).numSubRegions() );
  }
 
  // Loop only over regions named and populate according to given material names
  for( localIndex er = 0; er < numRegions(); ++er )
  {
    ElementRegionBase const & region = getRegion( er );
 
    region.forElementSubRegionsIndex( [&]( localIndex const esr,
                                           ElementSubRegionBase const & subRegion )
    {
      dataRepository::Group const & constitutiveGroup = subRegion.getConstitutiveModels();
 
      string materialName;
      constitutiveGroup.forSubGroups< MATERIALTYPE >( [&]( MATERIALTYPE const & constitutiveRelation )
      {
        materialName = constitutiveRelation.getName();
        if( constitutiveRelation.template hasWrapper( viewName ) )  //NOTE (matteo): I have added this check to allow for the view to be
                                                                    // missing. I am not sure this is the default behaviour we want though.
        {
          accessor[er][esr] = constitutiveRelation.template getReference< VIEWTYPE >( viewName );
        }
      } );
    } );
  }
  return accessor;
}
 
template< typename MATERIALTYPE, typename T, int NDIM, typename PERM >
ElementRegionManager::ElementViewAccessor< ArrayView< T const, NDIM, getUSD< PERM > > >
ElementRegionManager::constructMaterialArrayViewAccessor( string const & viewName ) const
{
  return constructMaterialViewAccessor< MATERIALTYPE, Array< T, NDIM, PERM >, ArrayView< T const, NDIM, getUSD< PERM > > >( viewName );
}
 
template< typename CONSTITUTIVE_TYPE >
ElementRegionManager::ConstitutiveRelationAccessor< CONSTITUTIVE_TYPE >
ElementRegionManager::constructFullConstitutiveAccessor( constitutive::ConstitutiveManager const & cm ) const
{
  ConstitutiveRelationAccessor< CONSTITUTIVE_TYPE > accessor;
  accessor.resize( numRegions() );
  for( localIndex kReg=0; kReg<numRegions(); ++kReg )
  {
    ElementRegionBase const & elemRegion = getRegion( kReg );
    accessor[kReg].resize( elemRegion.numSubRegions() );
 
    for( localIndex kSubReg=0; kSubReg<elemRegion.numSubRegions(); ++kSubReg )
    {
      ElementSubRegionBase const & subRegion = elemRegion.getSubRegion( kSubReg );
      dataRepository::Group const & constitutiveGroup = subRegion.getConstitutiveModels();
      accessor[kReg][kSubReg].resize( cm.numSubGroups() );
 
      for( localIndex matIndex=0; matIndex<cm.numSubGroups(); ++matIndex )
      {
        string const & constitutiveName = cm.getGroup( matIndex ).getName();
 
        CONSTITUTIVE_TYPE * const
        constitutiveRelation = constitutiveGroup.getGroupPointer< CONSTITUTIVE_TYPE >( constitutiveName );
        if( constitutiveRelation != nullptr )
        {
          accessor[kReg][kSubReg][matIndex] = constitutiveRelation;
        }
      }
    }
  }
  return accessor;
}
 
template< typename CONSTITUTIVE_TYPE >
ElementRegionManager::ConstitutiveRelationAccessor< CONSTITUTIVE_TYPE >
ElementRegionManager::constructFullConstitutiveAccessor( constitutive::ConstitutiveManager const & cm )
{
  ConstitutiveRelationAccessor< CONSTITUTIVE_TYPE > accessor;
  accessor.resize( numRegions() );
  for( localIndex kReg=0; kReg<numRegions(); ++kReg )
  {
    ElementRegionBase & elemRegion = getRegion( kReg );
    accessor[kReg].resize( elemRegion.numSubRegions() );
 
    for( localIndex kSubReg=0; kSubReg<elemRegion.numSubRegions(); ++kSubReg )
    {
      ElementSubRegionBase & subRegion = elemRegion.getSubRegion( kSubReg );
      dataRepository::Group & constitutiveGroup = subRegion.getConstitutiveModels();
      accessor[kReg][kSubReg].resize( cm.numSubGroups() );
 
      for( localIndex matIndex=0; matIndex<cm.numSubGroups(); ++matIndex )
      {
        string const & constitutiveName = cm.getGroup( matIndex ).getName();
 
        CONSTITUTIVE_TYPE * const
        constitutiveRelation = constitutiveGroup.getGroupPointer< CONSTITUTIVE_TYPE >( constitutiveName );
        if( constitutiveRelation != nullptr )
        {
          accessor[kReg][kSubReg][matIndex] = constitutiveRelation;
        }
      }
    }
  }
  return accessor;
}
 
}
#endif /* GEOS_MESH_ELEMENTREGIONMANAGER_HPP */