WrapperBase.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_DATAREPOSITORY_WRAPPERBASE_HPP_
#define GEOS_DATAREPOSITORY_WRAPPERBASE_HPP_
 
#include "common/DataTypes.hpp"
#include "common/GEOS_RAJA_Interface.hpp"
#include "common/Span.hpp"
#include "InputFlags.hpp"
#include "xmlWrapper.hpp"
#include "RestartFlags.hpp"
#include "HistoryDataSpec.hpp"
#include "DataContext.hpp"
 
#if defined(GEOSX_USE_PYGEOSX)
#include "LvArray/src/python/python.hpp"
#endif
 
#include <string>
#include <memory>
#include <set>
 
namespace conduit
{
class Node;
}
 
 
namespace geos
{
namespace dataRepository
{
 
class Group;
 
class WrapperBase
{
public:
 
 
  explicit WrapperBase( string const & name,
                        Group & parent,
                        string const & rtTypeName );
 
  WrapperBase() = delete;
  WrapperBase( WrapperBase const & ) = delete;
  WrapperBase( WrapperBase && ) = delete;
  WrapperBase & operator=( WrapperBase const & ) = delete;
  WrapperBase & operator=( WrapperBase && ) = delete;
 
  virtual ~WrapperBase();
 
 
 
  virtual localIndex size() const = 0;
 
  virtual void const * voidPointer() const = 0;
 
  virtual localIndex elementByteSize() const = 0;
 
  virtual size_t bytesAllocated() const = 0;
 
 
  virtual void resize( int num_dims, localIndex const * const dims ) = 0;
 
  virtual void reserve( localIndex const newCapacity ) = 0;
 
  virtual localIndex capacity() const = 0;
 
  virtual void resize( localIndex newsize ) = 0;
 
  void resize();
 
  virtual void copy( localIndex const sourceIndex, localIndex const destIndex ) = 0;
 
  virtual void erase( std::set< localIndex > const & indicesToErase ) = 0;
 
  virtual void move( LvArray::MemorySpace const space, bool const touch ) const = 0;
 
  virtual Regex const & getTypeRegex() const = 0;
 
  string const & getRTTypeName() const
  { return m_rtTypeName; }
 
  WrapperBase & setRTTypeName( string_view rtTypeName )
  {
    m_rtTypeName = rtTypeName;
    return *this;
  }
 
 
  virtual bool hasDefaultValue() const = 0;
 
  virtual string getDefaultValueString() const = 0;
 
  virtual bool processInputFile( xmlWrapper::xmlNode const & targetNode,
                                 xmlWrapper::xmlNodePos const & nodePos ) = 0;
 
  virtual void addBlueprintField( conduit::Node & fields,
                                  string const & name,
                                  string const & topology,
                                  std::vector< string > const & componentNames = {} ) const = 0;
 
  virtual void populateMCArray( conduit::Node & node, std::vector< string > const & componentNames = {} ) const = 0;
 
  virtual std::unique_ptr< WrapperBase > averageOverSecondDim( string const & name, Group & group ) const = 0;
 
 
  virtual void registerToWrite() const = 0;
 
  virtual void finishWriting() const = 0;
 
  virtual bool loadFromConduit() = 0;
 
 
  virtual HistoryMetadata getHistoryMetadata( localIndex const packCount ) const = 0;
 
 
  virtual bool isPackable( bool onDevice ) const = 0;
 
  template< bool DO_PACKING >
  localIndex pack( buffer_unit_type * & buffer,
                   bool withMetadata,
                   bool onDevice,
                   parallelDeviceEvents & events ) const
  {
    return DO_PACKING ? packPrivate( buffer, withMetadata, onDevice, events ) : packSizePrivate( withMetadata, onDevice, events );
  }
 
  template< bool DO_PACKING >
  localIndex packByIndex( buffer_unit_type * & buffer,
                          arrayView1d< localIndex const > const & packList,
                          bool withMetadata,
                          bool onDevice,
                          parallelDeviceEvents & events ) const
  {
    return DO_PACKING ? packByIndexPrivate( buffer, packList, withMetadata, onDevice, events ) : packByIndexSizePrivate( packList, withMetadata, onDevice, events );
  }
 
  virtual localIndex unpack( buffer_unit_type const * & buffer,
                             bool withMetadata,
                             bool onDevice,
                             parallelDeviceEvents & events ) = 0;
 
  virtual localIndex unpackByIndex( buffer_unit_type const * & buffer,
                                    arrayView1d< localIndex const > const & unpackIndices,
                                    bool withMetadata,
                                    bool onDevice,
                                    parallelDeviceEvents & events,
                                    MPI_Op op=MPI_REPLACE ) = 0;
 
 
 
  int sizedFromParent() const
  {
    return m_sizedFromParent;
  }
 
  WrapperBase & setSizedFromParent( int val )
  {
    m_sizedFromParent = val;
    return *this;
  }
 
  RestartFlags getRestartFlags() const { return m_restart_flags; }
 
  WrapperBase & setRestartFlags( RestartFlags flags )
  {
    m_restart_flags = flags;
    return *this;
  }
 
  PlotLevel getPlotLevel() const { return m_plotLevel; }
 
  WrapperBase & setPlotLevel( PlotLevel const flag )
  {
    m_plotLevel = flag;
    return *this;
  }
 
  string const & getName() const
  {
    return m_name;
  }
 
  string getPath() const;
 
  DataContext const & getDataContext() const
  { return *m_dataContext; }
 
  Group & getParent()
  { return *m_parent; }
 
  Group const & getParent() const
  { return *m_parent; }
 
  WrapperBase & setInputFlag( InputFlags const input )
  {
    if( input == InputFlags::OPTIONAL || input == InputFlags::REQUIRED )
    {
      this->setSizedFromParent( 0 );
      m_restart_flags = RestartFlags::WRITE;
    }
    m_inputFlag = input;
 
    return *this;
  }
 
  InputFlags getInputFlag() const
  {
    return m_inputFlag;
  }
 
  bool getSuccessfulReadFromInput() const
  {
    return m_successfulReadFromInput;
  }
 
  WrapperBase & setDescription( string const & description )
  {
    m_description = description;
    return *this;
  }
 
  string const & getDescription() const
  {
    return m_description;
  }
 
  string dumpInputOptions( bool const outputHeader ) const;
 
 
  std::set< string > const & getRegisteringObjects() const
  {
    return m_registeringObjects;
  }
 
  WrapperBase & setRegisteringObjects( string const & objectName )
  {
    m_registeringObjects.insert( objectName );
    return *this;
  }
 
 
 
  virtual void copyWrapperAttributes( WrapperBase const & source );
 
  virtual std::unique_ptr< WrapperBase > clone( string const & name, Group & parent ) = 0;
 
  virtual void copyData( WrapperBase const & source ) = 0;
 
  virtual void copyWrapper( WrapperBase const & source ) = 0;
 
  virtual std::type_info const & getTypeId() const = 0;
 
  virtual int numArrayDims() const = 0;
 
  virtual localIndex numArrayComp() const = 0;
 
  virtual WrapperBase & setDimLabels( integer dim, Span< string const > labels ) = 0;
 
  virtual Span< string const > getDimLabels( integer dim ) const = 0;
 
 
#if defined(USE_TOTALVIEW_OUTPUT)
  virtual string totalviewTypeName() const = 0;
 
  virtual int setTotalviewDisplay() const;
//  static int TV_ttf_display_type( const WrapperBase * wrapper);
#endif
 
#if defined(GEOSX_USE_PYGEOSX)
  virtual PyObject * createPythonObject( ) = 0;
#endif
 
protected:
 
 
  conduit::Node & getConduitNode()
  {
    return m_conduitNode;
  }
 
 
  void createDataContext( xmlWrapper::xmlNode const & targetNode,
                          xmlWrapper::xmlNodePos const & nodePos );
 
protected:
 
  string m_name;
 
  Group * m_parent;
 
  int m_sizedFromParent;
 
  RestartFlags m_restart_flags;
 
  PlotLevel m_plotLevel;
 
  InputFlags m_inputFlag;
 
  bool m_successfulReadFromInput;
 
  string m_description;
 
  string m_rtTypeName;
 
  std::set< string > m_registeringObjects;
 
  conduit::Node & m_conduitNode;
 
  std::unique_ptr< DataContext > m_dataContext;
 
private:
 
  virtual localIndex packPrivate( buffer_unit_type * & buffer, bool withMetadata, bool onDevice, parallelDeviceEvents & events ) const = 0;
 
  virtual localIndex packSizePrivate( bool withMetadata, bool onDevice, parallelDeviceEvents & events ) const = 0;
 
 
  virtual localIndex packByIndexPrivate( buffer_unit_type * & buffer,
                                         arrayView1d< localIndex const > const & packList,
                                         bool withMetadata,
                                         bool onDevice,
                                         parallelDeviceEvents & events ) const = 0;
 
  virtual localIndex packByIndexSizePrivate( arrayView1d< localIndex const > const & packList,
                                             bool withMetadata,
                                             bool onDevice,
                                             parallelDeviceEvents & events ) const = 0;
};
 
} 
} 
 
#endif /* GEOS_DATAREPOSITORY_WRAPPERBASE_HPP_ */