SiloFile.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_FILEIO_SILO_SILOFILE_HPP_
#define GEOSX_FILEIO_SILO_SILOFILE_HPP_

#include "common/DataTypes.hpp"
#include "constitutive/solid/SolidBase.hpp"
#include "mpiCommunications/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 geosx
{

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::Comm_rank( MPI_COMM_GEOSX );

    // 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 std::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 * 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 * 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;
  }

private:

  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 const m_siloDirectory = "siloFiles";

  string const m_siloDataSubDirectory = "data";

  string m_fileName;

  string m_baseFileName;

  std::vector< std::string > m_emptyMeshes;
//  string_array m_emptyMaterials;
  std::vector< std::string > m_emptyVariables;

  integer m_writeEdgeMesh;
  integer m_writeFaceMesh;
  integer m_writeCellElementMesh;
  integer m_writeFaceElementMesh;

  dataRepository::PlotLevel m_plotLevel;

  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 )
{
  GEOSX_UNUSED_VAR( dummy );
  return field;
}

template<> inline long int CastField< long int, long int >( const long int & field, int const dummy )
{
  GEOSX_UNUSED_VAR( dummy );
  return field;
}

template<> inline int CastField< int, long int >( const long int & field, int const dummy )
{
  GEOSX_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 )
{
  GEOSX_UNUSED_VAR( dummy );
  return field;
}

template<> inline int CastField< int, long long int >( const long long int & field, int const dummy )
{
  GEOSX_UNUSED_VAR( dummy );
  return LvArray::integerConversion< int >( field );
}

template<> inline real64 CastField< real64, real64 >( const real64 & field, int const dummy )
{
  GEOSX_UNUSED_VAR( dummy );
  return field;
}

template<> inline float CastField< float, real64 >( const real64 & field, int const dummy )
{
  GEOSX_UNUSED_VAR( dummy );
  return static_cast< float >(field);
}

template< typename TYPE >
void SetVariableNames( string const & fieldName, string_array & varnamestring, char const * varnames[] );


}



}
#endif /* GEOSX_FILEIO_SILO_SILOFILE_HPP_ */