Commit 4eb181fc authored by Chuck Atkins's avatar Chuck Atkins

Initial ADIOS readers and writers

This is a first pass at readers and writers using the ADIOS library.  It
currently supports writing vtkUnstructuredGrid, vtkImageData, and
vtkPolyData.  The same types are supported for reading into a
vtkMultiPiece dataset. Requires ADIOS version >= 1.7.0.

Currently known issues to be addressed in further branches:
- FindADIOS.cmake was taked directly from the ADIOS source and needs some work
- Setting the writer to WriteMode = OnChange produces output not compatible
  with the reader
- All pieces must currently have the same type of data
- Reader will read all arrays, no way to currently select which arrays to read
- Additional VTK datatypes to be supported

Change-Id: Ib5603d1708a59df923267990ebccc65299fbb6e4
parent 83be7b1b
# - Find ADIOS library, routines for scientific, parallel IO
# https://www.olcf.ornl.gov/center-projects/adios/
#
# Use this module by invoking find_package with the form:
# find_package(ADIOS
# [version] [EXACT] # Minimum or EXACT version, e.g. 1.6.0
# [REQUIRED] # Fail with an error if ADIOS or a required
# # component is not found
# [QUIET] # ...
# [COMPONENTS <...>] # Compiled in components: fortran, readonly,
# sequential (all are case insentative)
# )
#
# Module that finds the includes and libraries for a working ADIOS install.
# This module invokes the `adios_config` script that should be installed with
# the other ADIOS tools.
#
# To provide a hint to the module where to find the ADIOS installation,
# set the ADIOS_ROOT environment variable.
#
# If this variable is not set, make sure that at least the according `bin/`
# directory of ADIOS is in your PATH environment variable.
#
# Set the following CMake variables BEFORE calling find_packages to
# influence this module:
# ADIOS_USE_STATIC_LIBS - Set to ON to force the use of static
# libraries. Default: OFF
#
# This module will define the following variables:
# ADIOS_INCLUDE_DIRS - Include directories for the ADIOS headers.
# ADIOS_LIBRARIES - ADIOS libraries.
# ADIOS_FOUND - TRUE if FindADIOS found a working install
# ADIOS_VERSION - Version in format Major.Minor.Patch
#
# Not used for now:
# ADIOS_DEFINITIONS - Compiler definitions you should add with
# add_definitions(${ADIOS_DEFINITIONS})
#
# Example to find ADIOS (default)
# find_package(ADIOS)
# if(ADIOS_FOUND)
# include_directories(${ADIOS_INCLUDE_DIRS})
# add_executable(foo foo.c)
# target_link_libraries(foo ${ADIOS_LIBRARIES})
# endif()
# Example to find ADIOS using component
# find_package(ADIOS COMPONENTS fortran)
# if(ADIOS_FOUND)
# include_directories(${ADIOS_INCLUDE_DIRS})
# add_executable(foo foo.c)
# target_link_libraries(foo ${ADIOS_LIBRARIES})
# endif()
###############################################################################
#Copyright (c) 2014, Axel Huebl and Felix Schmitt from http://picongpu.hzdr.de
#All rights reserved.
#Redistribution and use in source and binary forms, with or without
#modification, are permitted provided that the following conditions are met:
#1. Redistributions of source code must retain the above copyright notice, this
#list of conditions and the following disclaimer.
#2. Redistributions in binary form must reproduce the above copyright notice,
#this list of conditions and the following disclaimer in the documentation
#and/or other materials provided with the distribution.
#3. Neither the name of the copyright holder nor the names of its contributors
#may be used to endorse or promote products derived from this software without
#specific prior written permission.
#THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
#AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
#IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
#DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
#FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
#DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
#SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
#CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
#OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
#OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
###############################################################################
###############################################################################
# Required cmake version
###############################################################################
cmake_minimum_required(VERSION 2.8.5)
###############################################################################
# ADIOS
###############################################################################
# get flags for adios_config, -l is the default
#-f for fortran, -r for readonly, -s for sequential (nompi)
set(OPTLIST "-l")
if(ADIOS_FIND_COMPONENTS)
foreach(COMP ${ADIOS_FIND_COMPONENTS})
string(TOLOWER ${COMP} comp)
if(comp STREQUAL "fortran")
set(OPTLIST ${OPTLIST} f)
elseif(comp STREQUAL "readonly")
set(OPTLIST ${OPTLIST} r)
elseif(comp STREQUAL "sequential")
set(OPTLIST ${OPTLIST} s)
else()
message("ADIOS component ${COMP} is not supported. Please use fortran, readonly, or sequential")
endif()
endforeach()
endif()
# we start by assuming we found ADIOS and falsify it if some
# dependencies are missing (or if we did not find ADIOS at all)
set(ADIOS_FOUND TRUE)
# find `adios_config` program #################################################
# check the ADIOS_ROOT hint and the normal PATH
find_file(ADIOS_CONFIG
NAME adios_config
PATHS $ENV{ADIOS_ROOT}/bin $ENV{ADIOS_DIR}/bin $ENV{INSTALL_PREFIX}/bin $ENV{PATH})
if(ADIOS_CONFIG)
message(STATUS "Found 'adios_config': ${ADIOS_CONFIG}")
else(ADIOS_CONFIG)
set(ADIOS_FOUND FALSE)
message(STATUS "Can NOT find 'adios_config' - set ADIOS_ROOT, ADIOS_DIR or INSTALL_PREFIX, or check your PATH")
endif(ADIOS_CONFIG)
# check `adios_config` program ################################################
if(ADIOS_FOUND)
execute_process(COMMAND ${ADIOS_CONFIG} ${OPTLIST}
OUTPUT_VARIABLE ADIOS_LINKFLAGS
RESULT_VARIABLE ADIOS_CONFIG_RETURN
OUTPUT_STRIP_TRAILING_WHITESPACE)
if(NOT ADIOS_CONFIG_RETURN EQUAL 0)
set(ADIOS_FOUND FALSE)
message(STATUS "Can NOT execute 'adios_config' - check file permissions")
endif()
# find ADIOS_ROOT_DIR
execute_process(COMMAND ${ADIOS_CONFIG} -d
OUTPUT_VARIABLE ADIOS_ROOT_DIR
OUTPUT_STRIP_TRAILING_WHITESPACE)
if(NOT IS_DIRECTORY "${ADIOS_ROOT_DIR}")
set(ADIOS_FOUND FALSE)
message(STATUS "The directory provided by 'adios_config -d' does not exist: ${ADIOS_ROOT_DIR}")
endif()
endif(ADIOS_FOUND)
# option: use only static libs ################################################
if(ADIOS_USE_STATIC_LIBS)
# carfully: we have to restore the original path in the end
set(_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES})
set(CMAKE_FIND_LIBRARY_SUFFIXES .a)
endif()
# we found something in ADIOS_ROOT_DIR and adios_config works #################
if(ADIOS_FOUND)
# ADIOS headers
list(APPEND ADIOS_INCLUDE_DIRS ${ADIOS_ROOT_DIR}/include)
# check for compiled in dependencies, recomve ";" in ADIOS_LINKFLAGS (from cmake build)
string(REGEX REPLACE ";" " " ADIOS_LINKFLAGS "${ADIOS_LINKFLAGS}")
message(STATUS "ADIOS linker flags (unparsed): ${ADIOS_LINKFLAGS}")
# find all library paths -L
# note: this can cause trouble if some libs are specified twice from
# different sources (quite unlikely)
# http://www.cmake.org/pipermail/cmake/2008-November/025128.html
set(ADIOS_LIBRARY_DIRS "")
string(REGEX MATCHALL "-L([A-Za-z_0-9/\\.-]+)" _ADIOS_LIBDIRS "${ADIOS_LINKFLAGS}")
foreach(_LIBDIR ${_ADIOS_LIBDIRS})
string(REPLACE "-L" "" _LIBDIR ${_LIBDIR})
list(APPEND ADIOS_LIBRARY_DIRS ${_LIBDIR})
endforeach()
# we could append ${CMAKE_PREFIX_PATH} now but that is not really necessary
#message(STATUS "ADIOS DIRS to look for libs: ${ADIOS_LIBRARY_DIRS}")
# parse all -lname libraries and find an absolute path for them
string(REGEX MATCHALL "-l([A-Za-z_0-9\\.-]+)" _ADIOS_LIBS "${ADIOS_LINKFLAGS}")
foreach(_LIB ${_ADIOS_LIBS})
string(REPLACE "-l" "" _LIB ${_LIB})
# find static lib: absolute path in -L then default
find_library(_LIB_DIR NAMES ${_LIB} PATHS ${ADIOS_LIBRARY_DIRS})
# found?
if(_LIB_DIR)
message(STATUS "Found ${_LIB} in ${_LIB_DIR}")
list(APPEND ADIOS_LIBRARIES "${_LIB_DIR}")
else(_LIB_DIR)
set(ADIOS_FOUND FALSE)
message(STATUS "ADIOS: Could NOT find library '${_LIB}'")
endif(_LIB_DIR)
# clean cached var
unset(_LIB_DIR CACHE)
unset(_LIB_DIR)
endforeach()
#add libraries which are already using cmake format
string(REGEX MATCHALL "/([A-Za-z_0-9/\\.-]+)\\.([a|so]+)" _ADIOS_LIBS_SUB "${ADIOS_LINKFLAGS}")
list(APPEND ADIOS_LIBRARIES "${_ADIOS_LIBS_SUB}")
# add the version string
execute_process(COMMAND ${ADIOS_CONFIG} -v
OUTPUT_VARIABLE ADIOS_VERSION
OUTPUT_STRIP_TRAILING_WHITESPACE)
endif(ADIOS_FOUND)
# unset checked variables if not found
if(NOT ADIOS_FOUND)
unset(ADIOS_INCLUDE_DIRS)
unset(ADIOS_LIBRARIES)
endif(NOT ADIOS_FOUND)
# restore CMAKE_FIND_LIBRARY_SUFFIXES if manipulated by this module ###########
if(ADIOS_USE_STATIC_LIBS)
set(CMAKE_FIND_LIBRARY_SUFFIXES ${_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES})
endif()
###############################################################################
# FindPackage Options
###############################################################################
# handles the REQUIRED, QUIET and version-related arguments for find_package
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(ADIOS
REQUIRED_VARS ADIOS_LIBRARIES ADIOS_INCLUDE_DIRS
VERSION_VAR ADIOS_VERSION
)
/*=========================================================================
Program: Visualization Toolkit
Module: ADIOSAttribute.h
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
// .NAME ADIOSAttribute - The utility class wrapping static ADIOS sttributes
#ifndef _ADIOSAttribute_h
#define _ADIOSAttribute_h
#include <string>
#include <vector>
#include <adios_types.h>
struct ADIOSAttributeImpl;
//----------------------------------------------------------------------------
class ADIOSAttribute
{
public:
ADIOSAttribute(ADIOSAttributeImpl *impl);
~ADIOSAttribute(void);
const std::string& GetName(void) const;
int GetId(void) const;
ADIOS_DATATYPES GetType(void) const;
template<typename T>
T GetValue(void) const;
private:
ADIOSAttributeImpl *Impl;
};
#endif // _ADIOSAttribute_h
// VTK-HeaderTest-Exclude: ADIOSAttribute.h
#include "ADIOSDefs.h"
namespace ADIOS
{
const std::string& ToString(TransportMethod method)
{
static const std::string valueMap[] = {
"NULL", "POSIX", "MPI", "MPI_LUSTRE", "MPI_AGGREGATE", "VAR_MERGE",
"Dataspaces", "DIMES", "Flexpath", "PHDF5", "NetCDF4" };
return valueMap[method];
}
const std::string& ToString(Transform xfm)
{
static const std::string valueMap[] = { "", "zlib", "bzlib2", "szip" };
return valueMap[xfm];
}
}
#ifndef __ADIOSDefs_h
#define __ADIOSDefs_h
#include <string>
namespace ADIOS
{
enum TransportMethod
{
TransportMethod_NULL = 0,
TransportMethod_POSIX = 1,
TransportMethod_MPI = 2,
TransportMethod_MPI_LUSTRE = 3,
TransportMethod_MPI_AGGREGATE = 4,
TransportMethod_VAR_MERGE = 5,
TransportMethod_DataSpaces = 6,
TransportMethod_DIMES = 7,
TransportMethod_FlexPath = 8,
TransportMethod_PHDF5 = 9,
TransportMethod_NetCDF4 = 10
};
const std::string& ToString(TransportMethod);
enum Transform
{
Transform_NONE = 0,
Transform_ZLIB = 1,
Transform_BZLIB2 = 2,
Transform_SZIP = 3
};
const std::string& ToString(Transform);
enum ReadMethod
{
ReadMethod_BP = 0,
ReadMethod_BP_AGGREGATE = 1,
ReadMethod_DataSpaces = 3,
ReadMethod_DIMES = 4,
ReadMethod_FlexPath = 5
};
} // end namespace
#endif //__ADIOSDefs_h
// VTK-HeaderTest-Exclude: ADIOSDefs.h
/*=========================================================================
Program: Visualization Toolkit
Module: ADIOSReader.cxx
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#include <cstdlib> // std::free
#include <stdexcept>
#include <map>
#include <utility>
#include "ADIOSReader.h"
#include "ADIOSReaderImpl.h"
#include "ADIOSUtilities.h"
#include <adios_read.h>
#include "ADIOSScalar.h"
typedef std::map<std::string, int> IdMap;
//----------------------------------------------------------------------------
struct ADIOSReader::Context
{
static std::string MethodArgs;
static ADIOS_READ_METHOD Method;
static MPI_Comm Comm;
static int RefCount;
Context()
{
if(this->RefCount == 0)
{
int err;
err = adios_read_init_method(Context::Method, Context::Comm,
Context::MethodArgs.c_str());
ADIOSUtilities::TestReadErrorEq<int>(0, err);
}
++this->RefCount;
}
~Context()
{
--this->RefCount;
if(this->RefCount == 0)
{
int init = 0;
MPI_Initialized(&init);
if(init == 1)
{
MPI_Barrier(Context::Comm);
}
adios_read_finalize_method(Context::Method);
}
}
};
std::string ADIOSReader::Context::MethodArgs("");
ADIOS_READ_METHOD ADIOSReader::Context::Method = ADIOS_READ_METHOD_BP;
MPI_Comm ADIOSReader::Context::Comm = static_cast<MPI_Comm>(NULL);
int ADIOSReader::Context::RefCount = 0;
//----------------------------------------------------------------------------
struct ADIOSAttributeImpl
{
ADIOSAttributeImpl(int id, const char* name, int size, ADIOS_DATATYPES type,
void* data)
: Id(id), Name(name), Size(size), Type(type), Data(data)
{ }
~ADIOSAttributeImpl(void)
{
// Cleanup memory that was previously alocated by ADIOS with malloc
if(this->Data)
{
std::free(this->Data);
}
}
int Id;
std::string Name;
int Size;
ADIOS_DATATYPES Type;
void *Data;
};
ADIOSAttribute::ADIOSAttribute(ADIOSAttributeImpl *impl)
: Impl(impl)
{ }
ADIOSAttribute::~ADIOSAttribute(void)
{ delete this->Impl; }
const std::string& ADIOSAttribute::GetName(void) const
{ return this->Impl->Name; }
int ADIOSAttribute::GetId(void) const
{ return this->Impl->Id; }
ADIOS_DATATYPES ADIOSAttribute::GetType(void) const
{ return this->Impl->Type; }
template<typename TN>
TN ADIOSAttribute::GetValue(void) const
{
if(ADIOSUtilities::TypeNativeToADIOS<TN>::T != this->Impl->Type)
{
throw std::invalid_argument("Wrong type");
}
return *reinterpret_cast<TN*>(this->Impl->Data);
}
// Instantiations for the ADIOSAttribute::GetValue implementation
#define INSTANTIATE(T) template T ADIOSAttribute::GetValue<T>(void) const;
INSTANTIATE(int8_t)
INSTANTIATE(int16_t)
INSTANTIATE(int32_t)
//INSTANTIATE(int64_t)
INSTANTIATE(uint8_t)
INSTANTIATE(uint16_t)
INSTANTIATE(uint32_t)
INSTANTIATE(uint64_t)
INSTANTIATE(vtkIdType)
INSTANTIATE(float)
INSTANTIATE(double)
#undef INSTANTIATE
template<>
const char* ADIOSAttribute::GetValue<const char*>(void) const
{
if(ADIOSUtilities::TypeNativeToADIOS<std::string>::T != this->Impl->Type)
{
throw std::invalid_argument("Wrong type");
}
return reinterpret_cast<char *>(this->Impl->Data);
}
//----------------------------------------------------------------------------
ADIOSReader::ADIOSReader(void)
: ReaderContext(new ADIOSReader::Context), Impl(new ADIOSReaderImpl)
{
}
//----------------------------------------------------------------------------
ADIOSReader::~ADIOSReader(void)
{
if(this->Impl->File != NULL)
{
adios_read_close(this->Impl->File);
}
delete this->ReaderContext;
}
//----------------------------------------------------------------------------
bool ADIOSReader::SetCommunicator(MPI_Comm comm)
{
if(Context::RefCount <= 0) // Not yet initialized, can set whatever we want
{
Context::Comm = comm;
}
else if(Context::Comm != comm) // Already initialized, can't change state
{
return false;
}
return true;
}
//----------------------------------------------------------------------------
bool ADIOSReader::SetReadMethod(ADIOS::ReadMethod method,
const std::string& methodArgs)
{
if(Context::RefCount <= 0) // Not yet initialized, can set whatever we want
{
Context::Method = static_cast<ADIOS_READ_METHOD>(method);
Context::MethodArgs = methodArgs;
}
else if(Context::Method != static_cast<ADIOS_READ_METHOD>(method) ||
Context::MethodArgs != methodArgs)
{
// Already initialized, can't change state
return false;
}
return true;
}
//----------------------------------------------------------------------------
void ADIOSReader::OpenFile(const std::string &fileName)
{
// Make sure we only do this once
if(this->Impl->File)
{
throw std::runtime_error("ADIOSReader already has an open file.");
}
int err;
// Open the file
this->Impl->File = adios_read_open_file(fileName.c_str(),
Context::Method, Context::Comm);
ADIOSUtilities::TestReadErrorNe<void*>(NULL, this->Impl->File);
// Poplulate step information
this->Impl->StepRange.first = this->Impl->File->current_step;
this->Impl->StepRange.second = this->Impl->File->last_step;
// Polulate the attribute information
for(int id = 0; id < this->Impl->File->nattrs; ++id)
{
ADIOS_DATATYPES type;
int size;
void *data;
adios_get_attr(this->Impl->File, this->Impl->File->attr_namelist[id],
&type, &size, &data);
ADIOSAttribute *a = new ADIOSAttribute(
new ADIOSAttributeImpl(id, this->Impl->File->attr_namelist[id], size,
type, data));
this->Impl->Attributes.push_back(a);
}
// Preload the scalar data and cache the array metadata
for(int i = 0; i < this->Impl->File->nvars; ++i)
{
ADIOS_VARINFO *v = adios_inq_var_byid(this->Impl->File, i);
ADIOSUtilities::TestReadErrorNe<void*>(NULL, v);
err = adios_inq_var_stat(this->Impl->File, v, 1, 1);
ADIOSUtilities::TestReadErrorEq<int>(0, err);
err = adios_inq_var_blockinfo(this->Impl->File, v);
ADIOSUtilities::TestReadErrorEq<int>(0, err);
std::string name(this->Impl->File->var_namelist[i]);
// Insert into the appropriate scalar or array map
if(v->ndim == 0)
{
this->Impl->Scalars.push_back(new ADIOSScalar(this->Impl->File, v));
}
else
{
this->Impl->Arrays.push_back(new ADIOSVarInfo(name, v));
this->Impl->ArrayIds.insert(std::make_pair(name, i));
}
}
this->ReadArrays(); // Process all the scheduled scalar reads
}
//----------------------------------------------------------------------------
void ADIOSReader::GetStepRange(int &tS, int &tE) const
{
tS = this->Impl->StepRange.first;
tE = this->Impl->StepRange.second;
}
//----------------------------------------------------------------------------
bool ADIOSReader::IsOpen(void) const
{
return this->Impl->File;
}
//----------------------------------------------------------------------------
const std::vector<ADIOSAttribute*>& ADIOSReader::GetAttributes(void) const
{
return this->Impl->Attributes;
}
//----------------------------------------------------------------------------
const std::vector<ADIOSScalar*>& ADIOSReader::GetScalars(void) const
{
return this->Impl->Scalars;
}
//----------------------------------------------------------------------------
const std::vector<ADIOSVarInfo*>& ADIOSReader::GetArrays(void) const
{
return this->Impl->Arrays;
}
//----------------------------------------------------------------------------
template<typename T>
void ADIOSReader::ScheduleReadArray(const std::string &path, T *data, int step,
int block)
{
IdMap::iterator id = this->Impl->ArrayIds.find(path);
if(id != this->Impl->ArrayIds.end())
{
throw std::runtime_error("Array " + path + " not found");
}
this->ScheduleReadArray<T>(id->second, data, step, block);
}
//----------------------------------------------------------------------------
template<typename T>
void ADIOSReader::ScheduleReadArray(int id, T *data, int step, int block)
{
int err;
ADIOS_SELECTION *sel;
// Use the MPI rank as the block id if not specified
if(block == -1)
{
MPI_Comm_rank(Context::Comm, &block);
}
sel = adios_selection_writeblock(block);
err = adios_schedule_read_byid(this->Impl->File, sel, id,
step, 1, data);
ADIOSUtilities::TestReadErrorEq(0, err);
}
//----------------------------------------------------------------------------
// Instantiations for the ScheduleReadArray implementation
#define INSTANTIATE(T) \
template void ADIOSReader::ScheduleReadArray<T>(const std::string&, T*, int, int); \
template void ADIOSReader::ScheduleReadArray<T>(int, T*, int, int);
INSTANTIATE(int8_t)
INSTANTIATE(int16_t)
INSTANTIATE(int32_t)
INSTANTIATE(int64_t)
INSTANTIATE(uint8_t)
INSTANTIATE(uint16_t)
INSTANTIATE(uint32_t)
INSTANTIATE(uint64_t)
INSTANTIATE(float)
INSTANTIATE(double)
INSTANTIATE(long double)
INSTANTIATE(void)
#undef INSTANTIATE
//----------------------------------------------------------------------------
void ADIOSReader::ReadArrays(void)
{
int err;
err = adios_perform_reads(this->Impl->File, 1);
ADIOSUtilities::TestReadErrorEq(0, err);
}
/*=========================================================================
Program: Visualization Toolkit
Module: ADIOSReader.h
Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
// .NAME ADIOSReader - The utility class performing ADIOS read operations
#ifndef _ADIOSReader_h
#define _ADIOSReader_h
#include <string>
#include <vector>
#include <utility>