SiloFile.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_FILEIO_SILO_SILOFILE_HPP_
#define GEOS_FILEIO_SILO_SILOFILE_HPP_
 
#include "common/DataTypes.hpp"
#include "constitutive/solid/SolidBase.hpp"
#include "common/MpiWrapper.hpp"
#include "mesh/ElementRegionManager.hpp"
#include "mesh/CellElementSubRegion.hpp"
#include "mesh/FaceElementSubRegion.hpp"
#include "mesh/InterObjectRelation.hpp"
 
#include "silo.h"
 
struct _PMPIO_baton_t;
 
typedef _PMPIO_baton_t PMPIO_baton_t;
 
namespace geos
{
 
class DomainPartition;
class MeshLevel;
 
namespace constitutive
{
class ConstitutiveManager;
}
 
// *********************************************************************************************************************
// *********************************************************************************************************************
class SiloFile
{
 
public:
 
  SiloFile();
 
  virtual ~SiloFile();
 
  void makeSiloDirectories();
 
  void initialize( int const numGroups=1 );
 
  void finish();
 
  int groupRank( int const i ) const;
 
  void waitForBatonWrite( int const domainNumber,
                          int const cycleNum,
                          integer const eventCounter,
                          bool const isRestart );
 
  void waitForBaton( int const domainNumber, string const & restartFileName );
 
  void handOffBaton();
 
 
  void makeSubDirectory( string const & subdir, string const & rootdir )
  {
    int const rank = MpiWrapper::commRank( MPI_COMM_GEOS );
 
    // char dirname[100];
    if( rank == 0 )
    {
//      DBGetDir(m_dbBaseFilePtr, dirname );
      DBMkDir( m_dbBaseFilePtr, rootdir.c_str());
    }
 
//    DBGetDir (m_dbFilePtr, dirname );
    DBMkDir( m_dbFilePtr, subdir.c_str());
  }
 
  void writeMeshObject( string const & meshName,
                        const localIndex nnodes,
                        real64 * coords[3],
                        const globalIndex * globalNodeNum,
                        char const * const ghostNodeName,
                        char const * const ghostZoneName,
                        int const numShapes,
                        int const * shapecnt,
                        const localIndex * const * const meshConnectivity,
                        const globalIndex * const * const globalElementNum,
                        int const * const shapetype,
                        int const * const shapesize,
                        int const cycleNumber,
                        real64 const problemTime );
 
  void writePolygonMeshObject( const string & meshName,
                               const localIndex nnodes,
                               real64 * coords[3],
                               const globalIndex * dummy1,
                               const int numRegions,
                               const int * shapecnt,
                               const localIndex * const * const meshConnectivity,
                               const globalIndex * const * const globalElementNum,
                               const int * const * const dummy2,
                               const int * const shapetype,
                               const int * const shapesize,
                               const int cycleNumber,
                               const real64 problemTime,
                               const int lnodelist );
 
  void writeDomainPartition( DomainPartition const & domain,
                             int const cycleNum,
                             real64 const problemTime,
                             bool const isRestart );
 
  void writeElementMesh( ElementRegionBase const & elementRegion,
                         NodeManager const & nodeManager,
                         string const & meshName,
                         const localIndex nnodes,
                         real64 * coords[3],
                         globalIndex const * const globalNodeNum,
                         char const * const ghostNodeFlag,
                         int const cycleNumber,
                         real64 const problemTime,
                         bool & writeArbitraryPolygon );
 
  void writeMeshLevel( MeshLevel const & meshLevel,
                       int const cycleNum,
                       real64 const problemTime,
                       bool const isRestart );
 
  void writePointMesh( string const & meshName,
                       const localIndex numPoints,
                       real64 * coords[3],
                       int const cycleNumber,
                       real64 const problemTime );
 
  void writeBeamMesh( string const & meshName,
                      const localIndex nnodes,
                      real64 * coords[3],
                      const localIndex_array & node1,
                      const localIndex_array & node2,
                      int const cycleNumber,
                      real64 const problemTime );
 
  void writeBeamMesh( string const & meshName,
                      const localIndex nnodes,
                      real64 * coords[3],
                      integer_array & nodelist,
                      int const cycleNumber,
                      real64 const problemTime );
 
  void writeMaterialMapsFullStorage( ElementRegionBase const & elementRegion,
                                     string const & meshName,
                                     string_array const & regionMaterialList,
                                     int const cycleNumber,
                                     real64 const problemTime );
  void writeGroupSilo( dataRepository::Group const & group,
                       string const & siloDirName,
                       string const & meshname,
                       int const centering,
                       int const cycleNum,
                       real64 const problemTime,
                       bool const isRestart,
                       const localIndex_array & mask );
 
  void writeElementRegionSilo( ElementRegionBase const & elemRegion,
                               string const & siloDirName,
                               string const & meshName,
                               int const cycleNum,
                               real64 const problemTime,
                               bool const isRestart );
  template< typename OUTPUTTYPE >
  void writeWrappersToSilo( string const & meshname,
                            const dataRepository::Group::wrapperMap & wrappers,
                            int const centering,
                            int const cycleNum,
                            real64 const problemTime,
                            bool const isRestart,
                            string const & multiRoot,
                            const localIndex_array & mask );
 
  template< typename OUTTYPE, typename TYPE >
  void writeDataField( string const & meshName,
                       string const & fieldName,
                       arrayView1d< TYPE const > const & field,
                       int const centering,
                       int const cycleNumber,
                       real64 const problemTime,
                       string const & multiRoot );
 
  template< typename OUTTYPE, typename TYPE, int USD >
  void writeDataField( string const & meshName,
                       string const & fieldName,
                       arrayView2d< TYPE const, USD > const & field,
                       int const centering,
                       int const cycleNumber,
                       real64 const problemTime,
                       string const & multiRoot );
 
  template< typename OUTTYPE, typename TYPE, int USD >
  void writeDataField( string const & meshName,
                       string const & fieldName,
                       arrayView3d< TYPE const, USD > const & field,
                       int const centering,
                       int const cycleNumber,
                       real64 const problemTime,
                       string const & multiRoot );
 
  template< typename OUTTYPE, typename TYPE, int NDIM, int USD >
  void writeDataField( string const & meshName,
                       string const & fieldName,
                       ArrayView< TYPE const, NDIM, USD > const & field,
                       int const siloTensorRank,
                       int const centering,
                       int const cycleNumber,
                       real64 const problemTime,
                       string const & multiRoot );
 
  template< typename OUTTYPE, typename TYPE >
  void writeMaterialDataField( string const & meshName,
                               string const & fieldName,
                               array1d< array1d< arrayView2d< TYPE const > > > const & field,
                               ElementRegionBase const & elemRegion,
                               int const centering,
                               int const cycleNumber,
                               real64 const problemTime,
                               string const & multiRoot,
                               string_array const & materialNames );
 
  template< typename OUTTYPE, typename TYPE >
  void writeMaterialDataField2d( string const & meshName,
                                 string const & fieldName,
                                 ElementRegionBase const & elemRegion,
                                 int const centering,
                                 int const cycleNumber,
                                 real64 const problemTime,
                                 string const & multiRoot,
                                 string_array const & materialNames );
 
  template< typename OUTTYPE, typename TYPE >
  void writeMaterialDataField3d( string const & meshName,
                                 string const & fieldName,
                                 ElementRegionBase const & elemRegion,
                                 int const centering,
                                 int const cycleNumber,
                                 real64 const problemTime,
                                 string const & multiRoot,
                                 string_array const & materialNames );
 
  template< typename OUTTYPE, typename TYPE >
  void writeMaterialDataField4d( string const & meshName,
                                 string const & fieldName,
                                 ElementRegionBase const & elemRegion,
                                 int const centering,
                                 int const cycleNumber,
                                 real64 const problemTime,
                                 string const & multiRoot,
                                 string_array const & materialNames );
 
  void writeMaterialVarDefinition( string const & subDir,
                                   string const & matDir,
                                   localIndex const matIndex,
                                   string const & fieldName );
 
  void writeStressVarDefinition( string const & MatDir );
 
  void writeVectorVarDefinition( string const & fieldName,
                                 string const & subDirectory );
 
  int getMeshType( string const & meshName ) const;
 
  template< typename CBF >
  void writeMultiXXXX( const DBObjectType type, CBF DBPutMultiCB,
                       int const centering, string const name, int const cycleNumber,
                       string const & multiRoot, const DBoptlist * optlist = nullptr );
 
 
  void clearEmptiesFromMultiObjects( int const cycleNum );
 
  void setNumGroups( int const numGroups )
  {
    m_numGroups = numGroups;
  }
 
  void setPlotLevel( int const plotLevel )
  {
    m_plotLevel = dataRepository::toPlotLevel( plotLevel );
  }
 
  void setWriteEdgeMesh( int const val )
  {
    m_writeEdgeMesh = val;
  }
 
  void setWriteFaceMesh( int const val )
  {
    m_writeFaceMesh = val;
  }
 
  void setWriteCellElementMesh( int const val )
  {
    m_writeCellElementMesh = val;
  }
 
  void setWriteFaceElementMesh( int const val )
  {
    m_writeFaceElementMesh = val;
  }
 
  void setPlotFileRoot( string const & fileRoot )
  {
    m_plotFileRoot = fileRoot;
  }
 
  void setOutputDirectory( string const & path )
  {
    m_siloDirectory = joinPath( path, "siloFiles" );
  }
 
  void setOnlyPlotSpecifiedFieldNamesFlag( integer const onlyPlotSpecifiedFieldNames )
  {
    m_onlyPlotSpecifiedFieldNames = onlyPlotSpecifiedFieldNames;
  }
 
  void setFieldNames( arrayView1d< string const > const & fieldNames )
  {
    m_fieldNames.insert( fieldNames.begin(), fieldNames.end() );
  }
 
private:
 
  bool isFieldPlotEnabled( dataRepository::WrapperBase const & wrapper ) const;
 
  DBfile * m_dbFilePtr;
 
  DBfile * m_dbBaseFilePtr;
 
  int m_numGroups;
 
  PMPIO_baton_t *m_baton;
 
  int const m_driver;
 
  string m_plotFileRoot;
 
  string m_restartFileRoot;
 
  string m_siloDirectory;
 
  string const m_siloDataSubDirectory = "data";
 
  string m_fileName;
 
  string m_baseFileName;
 
  std::vector< string > m_emptyMeshes;
//  string_array m_emptyMaterials;
  std::vector< string > m_emptyVariables;
 
  integer m_writeEdgeMesh;
  integer m_writeFaceMesh;
  integer m_writeCellElementMesh;
  integer m_writeFaceElementMesh;
 
  dataRepository::PlotLevel m_plotLevel;
 
  integer m_onlyPlotSpecifiedFieldNames;
 
  bool m_requireFieldRegistrationCheck;
 
  std::set< string > m_fieldNames;
 
 
  bool m_ghostFlags;
};
 
namespace siloFileUtilities
{
template< typename OUTTYPE >
int DB_TYPE();
 
template< typename TYPE >
int GetNumberOfVariablesInField();
 
template< typename TYPE >
int GetTensorRank();
 
template< typename OUTTYPE, typename TYPE >
OUTTYPE CastField( const TYPE & field, int const i = 0 );     // avoids compiler
                                                              // warning
template<> inline real64 CastField( R1Tensor const & field, int const i )
{
  return field[i];
}
 
template<> inline int CastField< int, int >( const int & field, int const dummy )
{
  GEOS_UNUSED_VAR( dummy );
  return field;
}
 
template<> inline long int CastField< long int, long int >( const long int & field, int const dummy )
{
  GEOS_UNUSED_VAR( dummy );
  return field;
}
 
template<> inline int CastField< int, long int >( const long int & field, int const dummy )
{
  GEOS_UNUSED_VAR( dummy );
  return LvArray::integerConversion< int >( field );
}
 
template<> inline long long int CastField< long long int, long long int >( const long long int & field, int const dummy )
{
  GEOS_UNUSED_VAR( dummy );
  return field;
}
 
template<> inline int CastField< int, long long int >( const long long int & field, int const dummy )
{
  GEOS_UNUSED_VAR( dummy );
  return LvArray::integerConversion< int >( field );
}
 
template<> inline real64 CastField< real64, real64 >( const real64 & field, int const dummy )
{
  GEOS_UNUSED_VAR( dummy );
  return field;
}
 
template<> inline float CastField< float, real64 >( const real64 & field, int const dummy )
{
  GEOS_UNUSED_VAR( dummy );
  return static_cast< float >(field);
}
 
template< typename TYPE >
void SetVariableNames( string const & fieldName, string_array & varnamestring, char const * varnames[] );
 
 
}
 
 
 
}
#endif /* GEOS_FILEIO_SILO_SILOFILE_HPP_ */