ObjectManagerBase.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_OBJECTMANAGERBASE_HPP_
#define GEOSX_MANAGERS_OBJECTMANAGERBASE_HPP_

#include "dataRepository/Group.hpp"
#include "common/TimingMacros.hpp"
#include "mpiCommunications/NeighborData.hpp"

namespace geosx
{
class SiloFile;

class ObjectManagerBase : public dataRepository::Group
{
public:
  ObjectManagerBase() = delete;

  explicit ObjectManagerBase( std::string const & name,
                              dataRepository::Group * const parent );

  ~ObjectManagerBase() override;


  using CatalogInterface = dataRepository::CatalogInterface< ObjectManagerBase, std::string const &, dataRepository::Group * const >;

  static CatalogInterface::CatalogType & GetCatalog();

  virtual const string getCatalogName() const = 0;

  using dataRepository::Group::PackSize;
  using dataRepository::Group::Pack;

  virtual localIndex PackSize( string_array const & wrapperNames,
                               arrayView1d< localIndex const > const & packList,
                               integer const recursive,
                               bool on_device = false ) const override;

  virtual localIndex Pack( buffer_unit_type * & buffer,
                           string_array const & wrapperNames,
                           arrayView1d< localIndex const > const & packList,
                           integer const recursive,
                           bool on_device = false )  const override;

  virtual localIndex Unpack( buffer_unit_type const * & buffer,
                             arrayView1d< localIndex > & packList,
                             integer const recursive,
                             bool on_device = false ) override;

  template< bool DOPACK >
  localIndex PackSets( buffer_unit_type * & buffer,
                       arrayView1d< localIndex const > const & packList ) const;

  localIndex UnpackSets( buffer_unit_type const * & buffer );

  virtual void ViewPackingExclusionList( SortedArray< localIndex > & exclusionList ) const;

  virtual localIndex PackGlobalMapsSize( arrayView1d< localIndex const > const & packList,
                                         integer const recursive ) const;

  virtual localIndex PackGlobalMaps( buffer_unit_type * & buffer,
                                     arrayView1d< localIndex const > const & packList,
                                     integer const recursive ) const;

  void SetReceiveLists();

  virtual localIndex PackUpDownMapsSize( arrayView1d< localIndex const > const & packList ) const
  {
    GEOSX_UNUSED_VAR( packList );
    return 0;
  }

  virtual localIndex PackUpDownMaps( buffer_unit_type * & buffer,
                                     arrayView1d< localIndex const > const & packList ) const
  {
    GEOSX_UNUSED_VAR( buffer );
    GEOSX_UNUSED_VAR( packList );
    return 0;
  }

  virtual localIndex UnpackUpDownMaps( buffer_unit_type const * & buffer,
                                       array1d< localIndex > & packList,
                                       bool const overwriteUpMaps,
                                       bool const overwriteDownMaps )
  {
    GEOSX_UNUSED_VAR( buffer );
    GEOSX_UNUSED_VAR( packList );
    GEOSX_UNUSED_VAR( overwriteUpMaps );
    GEOSX_UNUSED_VAR( overwriteDownMaps );
    return 0;
  }

  virtual localIndex UnpackGlobalMaps( buffer_unit_type const * & buffer,
                                       localIndex_array & packList,
                                       integer const recursive );

  localIndex PackParentChildMapsSize( arrayView1d< localIndex const > const & packList ) const
  {
    buffer_unit_type * buffer = nullptr;
    return PackParentChildMapsPrivate< false >( buffer, packList );
  }

  localIndex PackParentChildMaps( buffer_unit_type * & buffer,
                                  arrayView1d< localIndex const > const & packList ) const
  {
    return PackParentChildMapsPrivate< true >( buffer, packList );
  }

  localIndex UnpackParentChildMaps( buffer_unit_type const * & buffer,
                                    localIndex_array & packList );

private:
  template< bool DOPACK >
  localIndex PackPrivate( buffer_unit_type * & buffer,
                          string_array const & wrapperNames,
                          arrayView1d< localIndex const > const & packList,
                          integer const recursive,
                          bool on_device ) const;

  template< bool DOPACK >
  localIndex PackGlobalMapsPrivate( buffer_unit_type * & buffer,
                                    arrayView1d< localIndex const > const & packList,
                                    integer const recursive ) const;

  template< bool DOPACK >
  localIndex PackParentChildMapsPrivate( buffer_unit_type * & buffer,
                                         arrayView1d< localIndex const > const & packList ) const;

  //**********************************************************************************************************************
  // functions for compatibility with old data structure
  // TODO Deprecate or modernize all these suckers

public:

  void moveSets( LvArray::MemorySpace const targetSpace );

  localIndex resize( localIndex const newSize,
                     const bool /*assignGlobals*/ )
  {
    dataRepository::Group::resize( newSize );
    return 0;
  }

  using dataRepository::Group::resize;

  void CreateSet( const std::string & newSetName );

  void ConstructSetFromSetAndMap( SortedArrayView< localIndex const > const & inputSet,
                                  const array2d< localIndex > & map,
                                  const std::string & setName );
  void ConstructSetFromSetAndMap( SortedArrayView< localIndex const > const & inputSet,
                                  const array1d< localIndex_array > & map,
                                  const std::string & setName );
  void ConstructSetFromSetAndMap( SortedArrayView< localIndex const > const & inputSet,
                                  ArrayOfArraysView< localIndex const > const & map,
                                  const std::string & setName );

  void ConstructGlobalToLocalMap();

  void ConstructLocalListOfBoundaryObjects( localIndex_array & objectList ) const;

  void ConstructGlobalListOfBoundaryObjects( globalIndex_array & objectList ) const;

  virtual void ExtractMapFromObjectForAssignGlobalIndexNumbers( ObjectManagerBase const * const obj,
                                                                std::vector< std::vector< globalIndex > > & map )
  {
    GEOSX_UNUSED_VAR( obj );
    GEOSX_UNUSED_VAR( map );
  }

  void SetGhostRankForSenders( int const neighborRank )
  {
    arrayView1d< localIndex const > const ghostsToSend = getNeighborData( neighborRank ).ghostsToSend();
    array1d< std::pair< globalIndex, int > > & nonLocalGhosts = getNeighborData( neighborRank ).nonLocalGhosts();
    nonLocalGhosts.clear();

    for( localIndex const index : ghostsToSend )
    {
      integer & owningRank = m_ghostRank[ index ];
      if( owningRank >= 0 )
      {
        nonLocalGhosts.emplace_back( m_localToGlobalMap[ index ], owningRank );
      }
      else
      {
        owningRank = -1;
      }
    }
  }

  localIndex GetNumberOfGhosts() const;

  localIndex GetNumberOfLocalIndices() const;

  integer SplitObject( localIndex const indexToSplit,
                       int const rank,
                       localIndex & newIndex );

  void inheritGhostRankFromParent( std::set< localIndex > const & indices );

  void CopyObject( localIndex const source, localIndex const destination );

  void SetMaxGlobalIndex();

  template< typename TYPE_RELATION >
  static void FixUpDownMaps( TYPE_RELATION & relation,
                             map< localIndex, array1d< globalIndex > > & unmappedIndices,
                             bool const clearIfUnmapped );

  template< typename TYPE_RELATION >
  static void FixUpDownMaps( TYPE_RELATION & relation,
                             map< localIndex, SortedArray< globalIndex > > & unmappedIndices,
                             bool const clearIfUnmapped );

  static void FixUpDownMaps( ArrayOfSets< localIndex > & relation,
                             unordered_map< globalIndex, localIndex > const & globalToLocal,
                             map< localIndex, SortedArray< globalIndex > > & unmappedIndices,
                             bool const clearIfUnmapped );

  static void CleanUpMap( std::set< localIndex > const & targetIndices,
                          array1d< SortedArray< localIndex > > & upmap,
                          arrayView2d< localIndex const > const & downmap );

  static void CleanUpMap( std::set< localIndex > const & targetIndices,
                          ArrayOfSetsView< localIndex > const & upmap,
                          arrayView2d< localIndex const > const & downmap );

  static void CleanUpMap( std::set< localIndex > const & targetIndices,
                          array1d< SortedArray< localIndex > > & upmap,
                          arrayView1d< arrayView1d< localIndex const > const > const & downmap );
  static void CleanUpMap( std::set< localIndex > const & targetIndices,
                          ArrayOfSetsView< localIndex > const & upmap,
                          arrayView1d< arrayView1d< localIndex const > const > const & downmap );
  static void CleanUpMap( std::set< localIndex > const & targetIndices,
                          ArrayOfSetsView< localIndex > const & upmap,
                          ArrayOfArraysView< localIndex const > const & downmap );

  virtual void enforceStateFieldConsistencyPostTopologyChange( std::set< localIndex > const & targetIndices );

  static localIndex GetParentRecusive( arraySlice1d< localIndex const > const & parentIndices,
                                       localIndex const lookup )
  {
    localIndex rval = lookup;

    while( parentIndices[rval] != -1 )
    {
      rval = parentIndices[rval];
    }

    return rval;
  }

  template< typename MESH_DATA_TRAIT >
  dataRepository::Wrapper< typename MESH_DATA_TRAIT::type > &
  registerExtrinsicData( string const & nameOfRegisteringObject )
  {
    // These are required to work-around the need for instantiation of
    // the static constexpr trait components. This will not be required once
    // we move to c++17.

    //constexpr typename MESH_DATA_TRAIT::DataType defaultValue = MESH_DATA_TRAIT::defaultValue;
    // This is required for the Tensor classes.
    typename MESH_DATA_TRAIT::dataType defaultValue( MESH_DATA_TRAIT::defaultValue );

    return *(this->registerWrapper< typename MESH_DATA_TRAIT::type >( MESH_DATA_TRAIT::key )->
               setApplyDefaultValue( defaultValue )->
               setPlotLevel( MESH_DATA_TRAIT::plotLevel )->
               setRestartFlags( MESH_DATA_TRAIT::restartFlag )->
               setDescription( MESH_DATA_TRAIT::description )->
               setRegisteringObjects( nameOfRegisteringObject ) );
  }

  template< typename MESH_DATA_TRAIT0, typename MESH_DATA_TRAIT1, typename ... MESH_DATA_TRAITS >
  void registerExtrinsicData( string const & nameOfRegisteringObject )
  {
    registerExtrinsicData< MESH_DATA_TRAIT0 >( nameOfRegisteringObject );
    registerExtrinsicData< MESH_DATA_TRAIT1, MESH_DATA_TRAITS... >( nameOfRegisteringObject );
  }

  template< typename MESH_DATA_TRAIT >
  GEOSX_DECLTYPE_AUTO_RETURN getExtrinsicData() const
  {
    return this->getWrapper< typename MESH_DATA_TRAIT::type >( MESH_DATA_TRAIT::key )->reference();
  }

  template< typename MESH_DATA_TRAIT >
  GEOSX_DECLTYPE_AUTO_RETURN getExtrinsicData()
  {
    return this->getWrapper< typename MESH_DATA_TRAIT::type >( MESH_DATA_TRAIT::key )->reference();
  }

  template< typename MESH_DATA_TRAIT >
  bool hasExtrinsicData() const
  {
    // FIXME c++17 We copy paste the Group::hasWrapper implementation for linking reasons
    //             (the key needs to be defined/declared).
    //             C++17 introduces inline variables and should remove this problem.
    return this->wrappers()[MESH_DATA_TRAIT::key] != nullptr;
  }

#if 0
  template< typename MESH_DATA_TRAIT >
  dataRepository::Wrapper< typename MESH_DATA_TRAIT::Type > &
  registerExtrinsicData( string const & nameOfRegisteringObject,
                         MESH_DATA_TRAIT const & extrinisicDataTrait )
  {
    // These are required to work-around the need for instantiation of
    // the static constexpr trait components. This will not be required once
    // we move to c++17.

    //constexpr typename MESH_DATA_TRAIT::DataType defaultValue = MESH_DATA_TRAIT::defaultValue;
    constexpr dataRepository::PlotLevel plotLevel = MESH_DATA_TRAIT::plotLevel;
    string const description = MESH_DATA_TRAIT::description;

    // This is required for the Tensor classes.
    typename MESH_DATA_TRAIT::DataType defaultValue( MESH_DATA_TRAIT::defaultValue );

    return *(this->registerWrapper< typename MESH_DATA_TRAIT::Type >( extrinisicDataTrait.viewKey )->
               setApplyDefaultValue( defaultValue )->
               setPlotLevel( plotLevel )->
               setDescription( description )->
               setRegisteringObjects( nameOfRegisteringObject ) );
  }

  template< typename MESH_DATA_TRAIT0, typename MESH_DATA_TRAIT1, typename ... MESH_DATA_TRAITS >
  void registerExtrinsicData( string const & nameOfRegisteringObject,
                              MESH_DATA_TRAIT0 const & extrinisicDataTrait0,
                              MESH_DATA_TRAIT1 const & extrinisicDataTrait1,
                              MESH_DATA_TRAITS && ... extrinisicDataTraits )
  {
    registerExtrinsicData< MESH_DATA_TRAIT0 >( nameOfRegisteringObject, extrinisicDataTrait0 );
    registerExtrinsicData< MESH_DATA_TRAIT1,
                           MESH_DATA_TRAITS... >( nameOfRegisteringObject,
                                                  extrinisicDataTrait1,
                                                  std::forward< MESH_DATA_TRAITS >( extrinisicDataTraits )... );
  }

  template< typename MESH_DATA_TRAIT >
  auto const & getExtrinsicData( MESH_DATA_TRAIT const & extrinisicDataTrait ) const
  {
    return this->getWrapper< typename MESH_DATA_TRAIT::Type >( extrinisicDataTrait.viewKey )->referenceAsView();
  }

  template< typename MESH_DATA_TRAIT >
  auto & getExtrinsicData( MESH_DATA_TRAIT const & extrinisicDataTrait )
  {
    return this->getWrapper< typename MESH_DATA_TRAIT::Type >( extrinisicDataTrait.viewKey )->referenceAsView();
  }
#endif

  //**********************************************************************************************************************

  struct viewKeyStruct
  {
    static constexpr auto adjacencyListString = "adjacencyList";
    static constexpr auto domainBoundaryIndicatorString = "domainBoundaryIndicator";
    static constexpr auto externalSetString = "externalSet";
    static constexpr auto ghostRankString = "ghostRank";
    static constexpr auto ghostsToReceiveString = "ghostsToReceive";
    static constexpr auto globalToLocalMapString = "globalToLocalMap";
    static constexpr auto isExternalString = "isExternal";
    static constexpr auto localToGlobalMapString = "localToGlobalMap";

    dataRepository::ViewKey externalSet = { externalSetString };
    dataRepository::ViewKey ghostRank = { ghostRankString };
    dataRepository::ViewKey globalToLocalMap = { globalToLocalMapString };
    dataRepository::ViewKey localToGlobalMap = { localToGlobalMapString };
  }
  m_ObjectManagerBaseViewKeys;

  struct groupKeyStruct
  {
    static constexpr auto setsString = "sets";
    static constexpr auto neighborDataString = "neighborData";
    dataRepository::GroupKey sets = { setsString };
  }
  m_ObjectManagerBaseGroupKeys;

  virtual viewKeyStruct & viewKeys() { return m_ObjectManagerBaseViewKeys; }

  virtual viewKeyStruct const & viewKeys() const { return m_ObjectManagerBaseViewKeys; }
  virtual groupKeyStruct & groupKeys() { return m_ObjectManagerBaseGroupKeys; }
  virtual groupKeyStruct const & groupKeys() const { return m_ObjectManagerBaseGroupKeys; }

  Group & sets()
  { return m_sets; }

  Group const & sets() const
  { return m_sets; }

  SortedArray< localIndex > & externalSet()
  { return m_sets.getReference< SortedArray< localIndex > >( m_ObjectManagerBaseViewKeys.externalSet ); }

  SortedArrayView< localIndex const > externalSet() const
  { return m_sets.getReference< SortedArray< localIndex > >( m_ObjectManagerBaseViewKeys.externalSet ); }

  void updateGlobalToLocalMap( localIndex const lid )
  {
    globalIndex const gid = m_localToGlobalMap[ lid ];
    m_localMaxGlobalIndex = std::max( m_localMaxGlobalIndex, gid );
    m_globalToLocalMap[ gid ] = lid;
  }

  arrayView1d< globalIndex > localToGlobalMap()
  { return m_localToGlobalMap; }

  arrayView1d< globalIndex const > localToGlobalMap() const
  { return m_localToGlobalMap; }

  unordered_map< globalIndex, localIndex > const & globalToLocalMap() const
  { return m_globalToLocalMap; }

  localIndex globalToLocalMap( globalIndex const gid ) const
  { return m_globalToLocalMap.at( gid ); }

  array1d< integer > const & isExternal()
  { return this->m_isExternal; }

  arrayView1d< integer const > isExternal() const
  { return this->m_isExternal; }

  array1d< integer > const & ghostRank()
  { return this->m_ghostRank; }

  arrayView1d< integer const > ghostRank() const
  { return this->m_ghostRank; }

  NeighborData & getNeighborData( int const rank )
  { return m_neighborData.at( rank ); }

  NeighborData const & getNeighborData( int const rank ) const
  { return m_neighborData.at( rank ); }

  void addNeighbor( int const rank )
  {
    std::string const & rankString = std::to_string( rank );
    m_neighborData.emplace( std::piecewise_construct, std::make_tuple( rank ), std::make_tuple( rankString, &m_neighborGroup ) );
    m_neighborGroup.RegisterGroup( rankString, &getNeighborData( rank ) );
  }

  void removeNeighbor( int const rank )
  {
    m_neighborGroup.deregisterGroup( getNeighborData( rank ).getName() );
    m_neighborData.erase( rank );
  }

  globalIndex maxGlobalIndex() const
  { return m_maxGlobalIndex; }

  arrayView1d< integer > getDomainBoundaryIndicator()
  {
    return m_domainBoundaryIndicator.toView();
  }

  arrayView1d< integer const > getDomainBoundaryIndicator() const
  {
    return m_domainBoundaryIndicator.toViewConst();
  }

protected:
  Group m_sets;

  Group m_neighborGroup;

  array1d< globalIndex > m_localToGlobalMap;

  unordered_map< globalIndex, localIndex > m_globalToLocalMap;

  array1d< integer > m_isExternal;

  array1d< integer > m_domainBoundaryIndicator;

  array1d< integer > m_ghostRank;

  unordered_map< int, NeighborData > m_neighborData;

  real64 m_overAllocationFactor = 1.1;

  globalIndex m_maxGlobalIndex = -1;

  globalIndex m_localMaxGlobalIndex = -1;
};


template< typename TYPE_RELATION >
void ObjectManagerBase::FixUpDownMaps( TYPE_RELATION & relation,
                                       map< localIndex, array1d< globalIndex > > & unmappedIndices,
                                       bool const )
{
  GEOSX_MARK_FUNCTION;

  bool allValuesMapped = true;
  unordered_map< globalIndex, localIndex > const & globalToLocal = relation.RelatedObjectGlobalToLocal();
  for( map< localIndex, array1d< globalIndex > >::iterator iter = unmappedIndices.begin();
       iter != unmappedIndices.end();
       ++iter )
  {
    localIndex const li = iter->first;
    array1d< globalIndex > const & globalIndices = iter->second;
    for( localIndex a=0; a<globalIndices.size(); ++a )
    {
      if( globalIndices[a] != unmappedLocalIndexValue )
      {
        if( relation[li][a] == unmappedLocalIndexValue )
        {
          relation[li][a] = globalToLocal.at( globalIndices[a] );
        }
        else
        {
          allValuesMapped = false;
        }
      }
      GEOSX_ERROR_IF( relation[li][a]==unmappedLocalIndexValue, "Index not set" );
    }
  }
  GEOSX_ERROR_IF( !allValuesMapped, "some values of unmappedIndices were not used" );
  unmappedIndices.clear();
}


template< typename TYPE_RELATION >
void ObjectManagerBase::FixUpDownMaps( TYPE_RELATION & relation,
                                       map< localIndex, SortedArray< globalIndex > > & unmappedIndices,
                                       bool const clearIfUnmapped )
{
  GEOSX_MARK_FUNCTION;

  unordered_map< globalIndex, localIndex > const & globalToLocal = relation.RelatedObjectGlobalToLocal();
  for( map< localIndex, SortedArray< globalIndex > >::iterator iter = unmappedIndices.begin();
       iter != unmappedIndices.end();
       ++iter )
  {
    localIndex const li = iter->first;
    if( clearIfUnmapped )
    {
      relation[li].clear();
    }
    else
    {
      SortedArray< globalIndex > const & globalIndices = iter->second;
      for( auto const newGlobalIndex : globalIndices )
      {
        // NOTE: This simply ignores if newGlobalIndex is not found. This is OK if this function is
        // used for an upmap and the object shouldn't exist on this rank. There should be a better
        // way to check this.
        auto iterG2L = globalToLocal.find( newGlobalIndex );
        if( iterG2L != globalToLocal.end() )
        {
          relation[li].insert( iterG2L->second );
        }
      }
    }
  }
  unmappedIndices.clear();
}

inline
void ObjectManagerBase::FixUpDownMaps( ArrayOfSets< localIndex > & relation,
                                       unordered_map< globalIndex, localIndex > const & globalToLocal,
                                       map< localIndex, SortedArray< globalIndex > > & unmappedIndices,
                                       bool const clearIfUnmapped )
{
  GEOSX_MARK_FUNCTION;

  for( map< localIndex, SortedArray< globalIndex > >::iterator iter = unmappedIndices.begin();
       iter != unmappedIndices.end();
       ++iter )
  {
    localIndex const li = iter->first;
    if( clearIfUnmapped )
    {
      relation.clearSet( li );
    }
    else
    {
      SortedArray< globalIndex > const & globalIndices = iter->second;
      for( globalIndex const newGlobalIndex : globalIndices )
      {
        // NOTE: This simply ignores if newGlobalIndex is not found. This is OK if this function is
        // used for an upmap and the object shouldn't exist on this rank. There should be a better
        // way to check this.
        auto iterG2L = globalToLocal.find( newGlobalIndex );
        if( iterG2L != globalToLocal.end() )
        {
          relation.insertIntoSet( li, iterG2L->second );
        }
      }
    }
  }
  unmappedIndices.clear();
}

} /* namespace geosx */


typedef geosx::ObjectManagerBase ObjectDataStructureBaseT;

#endif /* GEOSX_MANAGERS_OBJECTMANAGERBASE_HPP_ */