Group.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_DATAREPOSITORY_GROUP_HPP_
#define GEOSX_DATAREPOSITORY_GROUP_HPP_

#include "InputFlags.hpp"
#include "dataRepository/ObjectCatalog.hpp"
#include "MappedVector.hpp"
#include "RestartFlags.hpp"
#include "Wrapper.hpp"
#include "xmlWrapper.hpp"

#include <iostream>

#ifndef NOCHARTOSTRING_KEYLOOKUP
#define NOCHARTOSTRING_KEYLOOKUP 0
#endif

// Forward declaration of conduit::Node
namespace conduit
{
class Node;
}


namespace geosx
{

namespace dataRepository
{

//START_SPHINX_INCLUDE_00
using keyType = string;

using indexType = localIndex;
//END_SPHINX_INCLUDE_00

class Group
{
public:
  //START_SPHINX_INCLUDE_01
  using subGroupMap = MappedVector< Group, Group *, keyType, indexType >;

  using wrapperMap = MappedVector< WrapperBase, WrapperBase *, keyType, indexType >;
  //END_SPHINX_INCLUDE_01


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


  Group( Group && source );

  virtual ~Group();

  Group() = delete;

  Group( Group const & ) = delete;

  Group( Group const && ) = delete;

  Group & operator=( Group const & ) = delete;

  Group & operator=( Group && ) = delete;




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

  static CatalogInterface::CatalogType & GetCatalog();



  virtual const std::type_info & get_typeid() const
  {
    return typeid(*this);
  }

  bool CheckTypeID( std::type_info const & typeToCheck ) const
  {
    return typeToCheck == get_typeid();
  }

  void PrintDataHierarchy( integer indent = 0 );

  string dumpInputOptions() const;


  //START_SPHINX_INCLUDE_REGISTER_GROUP

  template< typename T = Group >
  T * RegisterGroup( std::string const & name, std::unique_ptr< T > newObject );

  template< typename T = Group >
  T * RegisterGroup( std::string const & name,
                     T * newObject );

  template< typename T = Group >
  T * RegisterGroup( std::string const & name )
  {
    return RegisterGroup< T >( name, std::move( std::make_unique< T >( name, this )) );
  }

  template< typename T = Group >
  T * RegisterGroup( subGroupMap::KeyIndex const & keyIndex )
  {
    T * rval = RegisterGroup< T >( keyIndex.Key(), std::move( std::make_unique< T >( keyIndex.Key(), this )) );
    keyIndex.setIndex( this->m_subGroups.getIndex( keyIndex.Key()) );
    return rval;
  }

  template< typename T = Group, typename TBASE = Group >
  T * RegisterGroup( std::string const & name, std::string const & catalogName )
  {
    std::unique_ptr< TBASE > newGroup = TBASE::CatalogInterface::Factory( catalogName, name, this );
    return RegisterGroup< T >( name, std::move( newGroup ) );
  }

  void deregisterGroup( std::string const & name );

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


  //END_SPHINX_INCLUDE_REGISTER_GROUP


  template< typename T >
  static T group_cast( Group * group )
  {
    return dynamicCast< T >( group );
  }

  template< typename T >
  static T group_cast( Group const * group )
  {
    return dynamicCast< T >( group );
  }

  template< typename T >
  T group_cast()
  {
    return dynamicCast< T >( this );
  }

  template< typename T >
  T group_cast() const
  {
    return dynamicCast< T >( this );
  }


  //START_SPHINX_INCLUDE_GET_GROUP

  template< typename T = Group >
  T * GetGroup( localIndex index )
  {
    return group_cast< T * >( m_subGroups[index] );
  }

  template< typename T = Group >
  T const * GetGroup( localIndex index ) const
  {
    return group_cast< T const * >( m_subGroups[index] );
  }

  template< typename T = Group >
  T * GetGroup( string const & name )
  {
    return group_cast< T * >( m_subGroups[name] );
  }

  template< typename T = Group >
  T const * GetGroup( string const & name ) const
  { return group_cast< T const * >( m_subGroups[name] ); }

  template< typename T = Group >
  T & getGroupReference( string const & key )
  { return dynamicCast< T & >( *m_subGroups[ key ] ); }

  template< typename T = Group >
  T const & getGroupReference( string const & key ) const
  { return dynamicCast< T const & >( *m_subGroups[ key ] ); }

  template< typename T = Group >
  T & GetGroupReference( subGroupMap::KeyIndex const & key )
  { return dynamicCast< T & >( *m_subGroups[key] ); }

  template< typename T = Group >
  T const & GetGroupReference( subGroupMap::KeyIndex const & key ) const
  { return dynamicCast< T const & >( *m_subGroups[key] ); }

  template< typename T = Group >
  T * GetGroup( subGroupMap::KeyIndex const & key )
  {
    return group_cast< T * >( m_subGroups[key] );
  }

  template< typename T = Group >
  T const * GetGroup( subGroupMap::KeyIndex const & key ) const
  {
    return group_cast< T const * >( m_subGroups[key] );
  }

  template< typename T = Group >
  T * GetGroupByPath( string const & path )
  {
    return const_cast< T * >(const_cast< Group const * >(this)->GetGroupByPath< T >( path ));
  }

  template< typename T = Group >
  T const * GetGroupByPath( string const & path ) const;

  //END_SPHINX_INCLUDE_GET_GROUP

  subGroupMap & GetSubGroups()
  {
    return m_subGroups;
  }

  subGroupMap const & GetSubGroups() const
  {
    return m_subGroups;
  }

  localIndex numSubGroups() const { return m_subGroups.size(); }

  bool hasGroup( std::string const & name ) const
  {
    return (m_subGroups[name] != nullptr);
  }



  template< typename CASTTYPE, typename CONTAINERTYPE, typename LAMBDA >
  static bool applyLambdaToContainer( CONTAINERTYPE & container, LAMBDA && lambda )
  {
    using T = std::conditional_t< std::is_const< CONTAINERTYPE >::value, CASTTYPE const, CASTTYPE >;
    T * const castedContainer = dynamic_cast< T * >( &container );

    if( castedContainer != nullptr )
    {
      lambda( *castedContainer );
      return true;
    }

    return false;
  }
  template< typename T0, typename T1, typename ... CASTTYPES, typename CONTAINERTYPE, typename LAMBDA >
  static bool applyLambdaToContainer( CONTAINERTYPE & container, LAMBDA && lambda )
  {
    using T = std::conditional_t< std::is_const< CONTAINERTYPE >::value, T0 const, T0 >;
    T * const castedContainer = dynamic_cast< T * >( &container );

    if( castedContainer != nullptr )
    {
      lambda( *castedContainer );
      return true;
    }

    return applyLambdaToContainer< T1, CASTTYPES... >( container, std::forward< LAMBDA >( lambda ) );
  }


  //START_SPHINX_INCLUDE_LOOP_INTERFACE

  template< typename GROUPTYPE = Group, typename ... GROUPTYPES, typename LAMBDA >
  void forSubGroups( LAMBDA lambda )
  {
    for( auto & subGroupIter : m_subGroups )
    {
      applyLambdaToContainer< GROUPTYPE, GROUPTYPES... >( *subGroupIter.second, [&]( auto & castedSubGroup )
      {
        lambda( castedSubGroup );
      } );
    }
  }

  template< typename GROUPTYPE = Group, typename ... GROUPTYPES, typename LAMBDA >
  void forSubGroups( LAMBDA lambda ) const
  {
    for( auto const & subGroupIter : m_subGroups )
    {
      applyLambdaToContainer< GROUPTYPE, GROUPTYPES... >( *subGroupIter.second, [&]( auto const & castedSubGroup )
      {
        lambda( castedSubGroup );
      } );
    }
  }

  template< typename GROUPTYPE = Group, typename ... GROUPTYPES, typename LOOKUP_CONTAINER, typename LAMBDA >
  void forSubGroups( LOOKUP_CONTAINER const & subGroupKeys, LAMBDA lambda )
  {
    localIndex counter = 0;
    for( auto const & subgroup : subGroupKeys )
    {
      applyLambdaToContainer< GROUPTYPE, GROUPTYPES... >( *GetGroup( subgroup ), [&]( auto & castedSubGroup )
      {
        lambda( counter, castedSubGroup );
      } );
      ++counter;
    }
  }

  template< typename GROUPTYPE = Group, typename ... GROUPTYPES, typename LOOKUP_CONTAINER, typename LAMBDA >
  void forSubGroups( LOOKUP_CONTAINER const & subGroupKeys, LAMBDA lambda ) const
  {
    localIndex counter = 0;
    for( auto const & subgroup : subGroupKeys )
    {
      applyLambdaToContainer< GROUPTYPE, GROUPTYPES... >( *GetGroup( subgroup ), [&]( auto const & castedSubGroup )
      {
        lambda( counter, castedSubGroup );
      } );
      ++counter;
    }
  }


  template< typename LAMBDA >
  void forWrappers( LAMBDA lambda )
  {
    for( auto & wrapperIter : m_wrappers )
    {
      lambda( *wrapperIter.second );
    }
  }

  template< typename LAMBDA >
  void forWrappers( LAMBDA lambda ) const
  {
    for( auto const & wrapperIter : m_wrappers )
    {
      lambda( *wrapperIter.second );
    }
  }

  template< typename TYPE, typename ... TYPES, typename LAMBDA >
  void forWrappers( LAMBDA lambda )
  {
    for( auto & wrapperIter : m_wrappers )
    {
      applyLambdaToContainer< Wrapper< TYPE >, Wrapper< TYPES >... >( *wrapperIter.second,
                                                                      std::forward< LAMBDA >( lambda ));
    }
  }

  template< typename TYPE, typename ... TYPES, typename LAMBDA >
  void forWrappers( LAMBDA lambda ) const
  {
    for( auto const & wrapperIter : m_wrappers )
    {
      applyLambdaToContainer< Wrapper< TYPE >, Wrapper< TYPES >... >( *wrapperIter.second,
                                                                      std::forward< LAMBDA >( lambda ));
    }
  }

  //END_SPHINX_INCLUDE_LOOP_INTERFACE


  void Initialize( Group * const group );

  virtual void InitializationOrder( string_array & order );


  void InitializePostInitialConditions( Group * const group );

  void postRestartInitializationRecursive( Group * const domain );

  void ProcessInputFileRecursive( xmlWrapper::xmlNode & targetNode );

  void PostProcessInputRecursive();


  //START_SPHINX_INCLUDE_REGISTER_WRAPPER

  template< typename T, typename TBASE=T >
  Wrapper< TBASE > * registerWrapper( std::string const & name,
                                      wrapperMap::KeyIndex::index_type * const rkey = nullptr );

  template< typename T, typename TBASE=T >
  Wrapper< TBASE > * registerWrapper( Group::wrapperMap::KeyIndex const & viewKey );

  template< typename T >
  Wrapper< T > * registerWrapper( std::string const & name,
                                  std::unique_ptr< T > newObject );

  template< typename T >
  Wrapper< T > * registerWrapper( std::string const & name,
                                  T * newObject );

  WrapperBase * registerWrapper( string const & name,
                                 std::unique_ptr< WrapperBase > wrapper );

  void deregisterWrapper( string const & name );

  //END_SPHINX_INCLUDE_REGISTER_WRAPPER


  void GenerateDataStructureSkeleton( integer const level )
  {
    ExpandObjectCatalogs();
    std::string indent( level*2, ' ' );

    for( auto const & subGroupIter : m_subGroups )
    {
      std::cout << indent << subGroupIter.second->getName() << std::endl;
      subGroupIter.second->GenerateDataStructureSkeleton( level + 1 );
    }
  }

  virtual void ExpandObjectCatalogs() {}

  virtual void SetSchemaDeviations( xmlWrapper::xmlNode schemaRoot,
                                    xmlWrapper::xmlNode schemaParent,
                                    integer documentationType );



  virtual void RegisterDataOnMeshRecursive( Group * const meshBodies );

  virtual void RegisterDataOnMesh( Group * const meshBodies );



  virtual localIndex PackSize( string_array const & wrapperNames,
                               integer const recursive,
                               bool on_device = false ) const;

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

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

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

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


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

  //START_SPHINX_INCLUDE_GET_WRAPPER

  WrapperBase const * getWrapperBase( indexType const index ) const
  { return m_wrappers[index]; }

  WrapperBase * getWrapperBase( indexType const index )
  { return m_wrappers[index]; }

  WrapperBase const * getWrapperBase( std::string const & name ) const
  { return m_wrappers[name]; }

  WrapperBase * getWrapperBase( std::string const & name )
  { return m_wrappers[name]; }

  WrapperBase const * getWrapperBase( wrapperMap::KeyIndex const & keyIndex ) const
  { return m_wrappers[keyIndex]; }

  WrapperBase * getWrapperBase( wrapperMap::KeyIndex const & keyIndex )
  { return m_wrappers[keyIndex]; }

  indexType getWrapperIndex( std::string const & name ) const
  {
    return m_wrappers.getIndex( name );
  }

  wrapperMap const & wrappers() const
  {
    return m_wrappers;
  }

  wrapperMap & wrappers()
  {
    return m_wrappers;
  }



  template< typename LOOKUP_TYPE >
  bool hasWrapper( LOOKUP_TYPE const & lookup ) const
  {
    return (m_wrappers[lookup] != nullptr);
  }

  template< typename T, typename LOOKUP_TYPE >
  Wrapper< T > const * getWrapper( LOOKUP_TYPE const & index ) const
  {
    return dynamicCast< Wrapper< T > const * >( m_wrappers[index] );
  }

  template< typename T, typename LOOKUP_TYPE >
  Wrapper< T > * getWrapper( LOOKUP_TYPE const & index )
  { return const_cast< Wrapper< T > * >( const_cast< Group const * >(this)->getWrapper< T >( index ) ); }

  template< typename T >
  Wrapper< T > const * getWrapper( char const * const key ) const
  { return getWrapper< T >( string( key ) ); }

  template< typename T >
  Wrapper< T > * getWrapper( char const * const key )
  { return getWrapper< T >( string( key ) ); }



  template< typename T, typename LOOKUP_TYPE >
  GEOSX_DECLTYPE_AUTO_RETURN
  getReference( LOOKUP_TYPE const & lookup ) const
  {
    Wrapper< T > const * const wrapper = getWrapper< T >( lookup );
    if( wrapper == nullptr )
    {
      if( hasWrapper( lookup ) )
      {
        GEOSX_ERROR( "call to getWrapper results in nullptr but a view exists. Most likely given the incorrect type. lookup : " << lookup );
      }
      GEOSX_ERROR( "call to getWrapper results in nullptr and a view does not exist. lookup : " << lookup );
    }

    return wrapper->reference();
  }

  template< typename T, typename LOOKUP_TYPE >
  T &
  getReference( LOOKUP_TYPE const & lookup )
  {
    Wrapper< T > * const wrapper = getWrapper< T >( lookup );
    if( wrapper == nullptr )
    {
      if( hasWrapper( lookup ) )
      {
        GEOSX_ERROR( "call to getWrapper results in nullptr but a view exists. Most likely given the incorrect type. lookup : " << lookup );
      }
      GEOSX_ERROR( "call to getWrapper results in nullptr and a view does not exist. lookup : " << lookup );
    }

    return wrapper->reference();
  }

  template< typename T >
  GEOSX_DECLTYPE_AUTO_RETURN
  getReference( char const * const name ) const
  { return getReference< T >( string( name ) ); }

  template< typename T >
  T & getReference( char const * const name )
  { return getReference< T >( string( name ) ); }

  //END_SPHINX_INCLUDE_GET_WRAPPER



  virtual void resize( localIndex const newSize );

  virtual void reserve( indexType const newsize );

  inline localIndex capacity() const
  {
    return m_capacity;
  }

  inline localIndex size() const
  {
    return m_size;
  }



  inline const string getName() const
  {
    return m_name;
  }

  Group * getParent()             { return m_parent; }

  Group const * getParent() const { return m_parent; }

  localIndex getIndexInParent() const
  {
    return m_parent->GetSubGroups().getIndex( this->m_name );
  }

  integer sizedFromParent() const
  {
    return m_sizedFromParent;
  }

  Group * setSizedFromParent( int val )
  {
    m_sizedFromParent = val;
    return this;
  }
  RestartFlags getRestartFlags() const { return m_restart_flags; }

  void setRestartFlags( RestartFlags flags ) { m_restart_flags = flags; }

  InputFlags getInputFlags() const { return m_input_flags; }

  void setInputFlags( InputFlags flags ) { m_input_flags = flags; }



  conduit::Node & getConduitNode()
  {
    return m_conduitNode;
  }

  void prepareToWrite();

  void finishWriting();

  void loadFromConduit();

  void enableLogLevelInput();

  integer getLogLevel() const { return m_logLevel; }

protected:


  virtual void PostProcessInput() {}

  virtual void InitializePreSubGroups( Group * const group )
  {
    GEOSX_UNUSED_VAR( group );
  }

  virtual void InitializePostSubGroups( Group * const group )
  {
    GEOSX_UNUSED_VAR( group );
  }

  virtual void InitializePostInitialConditions_PreSubGroups( Group * const group )
  {
    GEOSX_UNUSED_VAR( group );
  }

  virtual void InitializePostInitialConditions_PostSubGroups( Group * const group )
  {
    GEOSX_UNUSED_VAR( group );
  }

  virtual void postRestartInitialization( Group * const domain )
  {
    GEOSX_UNUSED_VAR( domain );
  }


private:
  virtual void ProcessInputFile( xmlWrapper::xmlNode const & targetNode );

  //START_SPHINX_INCLUDE_02
  Group * m_parent = nullptr;

  integer m_sizedFromParent;

  wrapperMap m_wrappers;

  subGroupMap m_subGroups;

  indexType m_size;

  indexType m_capacity;

  string m_name;

  integer m_logLevel;
  //END_SPHINX_INCLUDE_02

  RestartFlags m_restart_flags;

  InputFlags m_input_flags;

  conduit::Node & m_conduitNode;

};

using GroupKey = Group::subGroupMap::KeyIndex;

using ViewKey = Group::wrapperMap::KeyIndex;



template< typename T >
T * Group::RegisterGroup( std::string const & name,
                          std::unique_ptr< T > newObject )
{
  newObject->m_parent = this;
  return dynamicCast< T * >( m_subGroups.insert( name, newObject.release(), true ) );
}


template< typename T >
T * Group::RegisterGroup( std::string const & name,
                          T * newObject )
{
  return dynamicCast< T * >( m_subGroups.insert( name, newObject, false ) );
}

// Doxygen bug - sees this as a separate function
template< typename T, typename TBASE >
Wrapper< TBASE > * Group::registerWrapper( std::string const & name,
                                           ViewKey::index_type * const rkey )
{
  std::unique_ptr< TBASE > newObj = std::make_unique< T >();
  m_wrappers.insert( name,
                     new Wrapper< TBASE >( name, this, std::move( newObj ) ),
                     true );

  if( rkey != nullptr )
  {
    *rkey = m_wrappers.getIndex( name );
  }

  Wrapper< TBASE > * const rval = getWrapper< TBASE >( name );
  if( rval->sizedFromParent() == 1 )
  {
    rval->resize( this->size());
  }
  return rval;
}

template< typename T, typename TBASE >
Wrapper< TBASE > * Group::registerWrapper( ViewKey const & viewKey )
{
  ViewKey::index_type index;
  Wrapper< TBASE > * const rval = registerWrapper< T, TBASE >( viewKey.Key(), &index );
  viewKey.setIndex( index );

  return rval;
}


template< typename T >
Wrapper< T > * Group::registerWrapper( std::string const & name,
                                       std::unique_ptr< T > newObject )
{
  m_wrappers.insert( name,
                     new Wrapper< T >( name, this, std::move( newObject ) ),
                     true );

  Wrapper< T > * const rval = getWrapper< T >( name );
  if( rval->sizedFromParent() == 1 )
  {
    rval->resize( this->size());
  }
  return rval;
}



template< typename T >
Wrapper< T > * Group::registerWrapper( std::string const & name,
                                       T * newObject )
{
  m_wrappers.insert( name,
                     new Wrapper< T >( name, this, newObject ),
                     true );

  Wrapper< T > * const rval = getWrapper< T >( name );
  if( rval->sizedFromParent() == 1 )
  {
    rval->resize( this->size());
  }
  return rval;
}

template< typename T >
T const * Group::GetGroupByPath( string const & path ) const
{
  // needed for getting root correctly with GetGroupByPath("/");
  if( path.empty())
  {
    return group_cast< T const * >( this );
  }

  size_t directoryMarker = path.find( '/' );

  if( directoryMarker == std::string::npos )
  {
    // Target should be a child of this group
    return this->GetGroup< T >( path );
  }
  else
  {
    // Split the path
    string const child = path.substr( 0, directoryMarker );
    string const subPath = path.substr( directoryMarker+1, path.size());

    if( directoryMarker == 0 )            // From root
    {
      if( this->getParent() == nullptr )  // At root
      {
        return this->GetGroupByPath< T >( subPath );
      }
      else                               // Not at root
      {
        return this->getParent()->GetGroupByPath< T >( path );
      }
    }
    else if( child[0] == '.' )
    {
      if( child[1] == '.' )               // '../' = Reverse path
      {
        return this->getParent()->GetGroupByPath< T >( subPath );
      }
      else                               // './' = This path
      {
        return this->GetGroupByPath< T >( subPath );
      }
    }
    else
    {
      return m_subGroups[child]->GetGroupByPath< T >( subPath );
    }
  }
}

} /* end namespace dataRepository */
} /* end namespace geosx */

#endif /* GEOSX_DATAREPOSITORY_GROUP_HPP_ */