From fa6f99147385917c08ec54d23af6ab0519e3a361 Mon Sep 17 00:00:00 2001 From: Olivier Parcollet Date: Sun, 3 Nov 2013 18:56:19 +0100 Subject: [PATCH] arrays: clean h5 code - c++11 cleaning, more doc. - clean the array_stack and its doc. --- triqs/arrays/h5/array_stack.hpp | 260 +++++++++++++------------ triqs/arrays/h5/simple_read_write.hpp | 261 +++++++++++++------------- triqs/h5/group.hpp | 13 +- 3 files changed, 273 insertions(+), 261 deletions(-) diff --git a/triqs/arrays/h5/array_stack.hpp b/triqs/arrays/h5/array_stack.hpp index aa290fa3..349c0eaf 100644 --- a/triqs/arrays/h5/array_stack.hpp +++ b/triqs/arrays/h5/array_stack.hpp @@ -2,7 +2,7 @@ * * TRIQS: a Toolbox for Research in Interacting Quantum Systems * - * Copyright (C) 2011 by O. Parcollet + * Copyright (C) 2011-2013 by O. Parcollet * * TRIQS is free software: you can redistribute it and/or modify it under the * terms of the GNU General Public License as published by the Free Software @@ -24,134 +24,144 @@ #include #include "./simple_read_write.hpp" -namespace triqs { namespace arrays { - - namespace h5_stack_details { // to be replaced by ellipsis - template array_view slice0( array & A, size_t ind); -#define AUX(z,p,unused) BOOST_PP_COMMA_IF(p) range() -#define IMPL(z, NN, unused) \ - template array_view slice0( array & A, size_t ind) {\ - return A(ind,BOOST_PP_REPEAT(BOOST_PP_INC(NN),AUX,nil));} - BOOST_PP_REPEAT(ARRAY_NRANK_MAX , IMPL, nil); -#undef IMPL -#undef AUX - template T & slice0( array & A, size_t ind) { return A(ind);} - - template struct get_value_type { typedef B type; static const size_t rank = 0;}; - template struct get_value_type >::type > { - typedef typename B::value_type type;static const size_t rank = B::rank;}; - - } +namespace triqs { +namespace arrays { /** - * \brief Hdf5 array stack - * \tparam BaseElementType The type of the base element of the stack. Can be an array/matrix/vector or a scalar. - * If it in a scalar, the array_stack will write an hdf5 array of dimension 1 - * If it in an array/matrix/vector, the array_stack will write an hdf5 array of dimension BaseElementType::rank +1 - * + * The implementation class */ - template< typename BaseElementType> - class array_stack { - typedef BaseElementType base_element_type; - static_assert( (is_amv_value_class::value || is_scalar::value), "BaseElementType must be an array/matrix/vector or a simple number"); - typedef typename h5_stack_details::get_value_type::type T; - static const size_t dim = h5_stack_details::get_value_type::rank; - static const bool base_is_array = dim >0; - size_t bufsize_, step, _size; - static const bool T_is_complex = boost::is_complex::value; - static const unsigned int RANK = dim + 1 + (T_is_complex ? 1 : 0); - utility::mini_vector dims, offset, maxdims, dim_chunk, buffer_dim, zero; - H5::DataSet dataset; - array buffer; + template class array_stack_impl { + static const size_t dim = R; + static const bool base_is_array = dim > 0; + size_t bufsize_, step, _size; + static const bool T_is_complex = boost::is_complex::value; + static const unsigned int RANK = dim + 1 + (T_is_complex ? 1 : 0); + utility::mini_vector dims, offset, maxdims, dim_chunk, buffer_dim, zero; + H5::DataSet dataset; + array buffer; - template - void construct_delegate ( FileGroupType g, std::string const & name, mini_vector const & a_dims, size_t bufsize) { - mini_vector dim_chunk; - bufsize_ = bufsize; step = 0; _size =0; - for (size_t i =1; i<=dim; ++i) { dims[i] = a_dims[i-1];} - if (T_is_complex) { dims[RANK-1] =2; } - maxdims = dims; buffer_dim = dims; dim_chunk = dims; - dims[0] = 0; maxdims[0] = H5S_UNLIMITED; dim_chunk[0]=1; buffer_dim[0] = bufsize_; - mini_vector s; for (size_t i =0; i<=dim; ++i) {s[i] = buffer_dim[i];} - buffer.resize(s); - H5::DataSpace mspace1( RANK, dims.ptr(), maxdims.ptr()); - H5::DSetCreatPropList cparms; cparms.setChunk( RANK, dim_chunk.ptr() ); // Modify dataset creation properties, i.e. enable chunking. - try { - dataset = g.create_dataset(name,h5::native_type_from_C(typename h5::remove_complex::type()), mspace1, cparms ); - if (boost::is_complex::value) h5::write_string_attribute(&dataset,"__complex__","1"); - } - TRIQS_ARRAYS_H5_CATCH_EXCEPTION; - } - - public : - - /** - * \brief Constructor - * \param g The h5 file or group, of type FileGroupType - * \param name The name of the hdf5 array in the file/group where the stack will be stored - * \param base_element_shape The shape of the base array/matrix/vector [or mini_vector() for a scalar] - * \param bufsize The size of the bufferThe name of the hdf5 array in the file/group where the stack will be stored - * \exception The HDF5 exceptions will be caught and rethrown as TRIQS_RUNTIME_ERROR (with stackstrace, cf doc). - */ - template - array_stack( FileGroupType g, std::string const & name, mini_vector const & base_element_shape, size_t bufsize) { - construct_delegate ( g, name, base_element_shape, bufsize); - } - - /** - * \brief Constructor : valid only if the base is a scalar - * \param g The h5 file or group, of type FileGroupType - * \param name The name of the hdf5 array in the file/group where the stack will be stored - * \param bufsize The size of the bufferThe name of the hdf5 array in the file/group where the stack will be stored - * \exception The HDF5 exceptions will be caught and rethrown as TRIQS_RUNTIME_ERROR (with stackstrace, cf doc). - */ - template - array_stack( FileGroupType g, std::string const & name, size_t bufsize) { - static_assert( (is_scalar::value), "This constructor is only available for a scalar BaseElementType"); - construct_delegate ( g, name,mini_vector() , bufsize); - } - - /// - ~array_stack() {flush();} - - /// The type of the base of the stack (a view or a reference) - typedef typename boost::mpl::if_c< base_is_array , array_view, T &>::type slice_type; - - /** - * \return A view (for an array/matrix/vector base) or a reference (for a scalar base) to the top of the stack - * i.e. the next element to be assigned to - */ - slice_type operator() () { return h5_stack_details::slice0(buffer, step); } - - /// Advance the stack by one - void operator++() { ++step; ++_size; if (step==bufsize_) flush(); } - - /// Flush the buffer to the disk. Automatically called at destruction. - void flush() { save_buffer(); step=0;} - - /** - * \brief Add a element onto the stack and advance it by one. - * S << A is equivalent to S() = A; ++S; - */ - template void operator << ( AType const & A) { (*this)() = A; ++(*this);} - - /// Current size of the stack - size_t size() const { return _size;} - - private: - void save_buffer () { - if (step==0) return; - dims[0] += step; - buffer_dim[0] = step; - dataset.extend(dims.ptr()); - H5::DataSpace fspace1 = dataset.getSpace (), mspace = h5_impl::data_space(buffer); - fspace1.selectHyperslab( H5S_SELECT_SET, buffer_dim.ptr(), offset.ptr() ); - mspace.selectHyperslab( H5S_SELECT_SET, buffer_dim.ptr(), zero.ptr() ); - try { dataset.write( h5_impl::get_array_data_ptr(buffer), h5::data_type_memory(), mspace, fspace1 ); } - TRIQS_ARRAYS_H5_CATCH_EXCEPTION; - offset [0] += step; + public: + array_stack_impl(h5::group g, std::string const &name, mini_vector const &base_element_shape, size_t bufsize) { + mini_vector dim_chunk; + bufsize_ = bufsize; + step = 0; + _size = 0; + for (size_t i = 1; i <= dim; ++i) { + dims[i] = base_element_shape[i - 1]; } - }; -}} // namespace + if (T_is_complex) { + dims[RANK - 1] = 2; + } + maxdims = dims; + buffer_dim = dims; + dim_chunk = dims; + dims[0] = 0; + maxdims[0] = H5S_UNLIMITED; + dim_chunk[0] = 1; + buffer_dim[0] = bufsize_; + mini_vector s; + for (size_t i = 0; i <= dim; ++i) { + s[i] = buffer_dim[i]; + } + buffer.resize(s); + H5::DataSpace mspace1(RANK, dims.ptr(), maxdims.ptr()); + H5::DSetCreatPropList cparms; + cparms.setChunk(RANK, dim_chunk.ptr()); // Modify dataset creation properties, i.e. enable chunking. + try { + dataset = g.create_dataset(name, h5::native_type_from_C(typename h5::remove_complex::type()), mspace1, cparms); + if (boost::is_complex::value) h5::write_string_attribute(&dataset, "__complex__", "1"); + } + TRIQS_ARRAYS_H5_CATCH_EXCEPTION; + } + + /// + ~array_stack_impl() { flush(); } + +#ifdef TRIQS_DOXYGEN + /// A view (for an array/matrix/vector base) or a reference (for a scalar base) to the top of the stack i.e. the next element to be assigned to + auto operator()() { return buffer(step, ellipsis()); } + + /// A view (for an array/matrix/vector base) or a reference (for a scalar base) to the top of the stack i.e. the next element to be assigned to + auto operator()() const { return buffer(step, ellipsis()); } +#else + auto operator()() DECL_AND_RETURN(buffer(step, ellipsis())); + auto operator()() const DECL_AND_RETURN(buffer(step, ellipsis())); +#endif + + /// Advance the stack by one + void operator++() { + ++step; + ++_size; + if (step == bufsize_) flush(); + } + + /// Flush the buffer to the disk. Automatically called at destruction. + void flush() { + save_buffer(); + step = 0; + } + + /** + * \brief Add a element onto the stack and advance it by one. + * S << A is equivalent to S() = A; ++S; + */ + template void operator<<(AType const &A) { + (*this)() = A; + ++(*this); + } + + /// Current size of the stack + size_t size() const { return _size; } + + private: + void save_buffer() { + if (step == 0) return; + dims[0] += step; + buffer_dim[0] = step; + dataset.extend(dims.ptr()); + H5::DataSpace fspace1 = dataset.getSpace(), mspace = h5_impl::data_space(buffer); + fspace1.selectHyperslab(H5S_SELECT_SET, buffer_dim.ptr(), offset.ptr()); + mspace.selectHyperslab(H5S_SELECT_SET, buffer_dim.ptr(), zero.ptr()); + try { + dataset.write(h5_impl::__get_array_data_ptr(buffer), h5::data_type_memory(), mspace, fspace1); + } + TRIQS_ARRAYS_H5_CATCH_EXCEPTION; + offset[0] += step; + } + }; + + // ------------------------- User classes ------------------------------ + + // The simple case, 1d + template class array_stack : public array_stack_impl { + static_assert((is_scalar::value), "Only available for a scalar type"); + public: + /** + * \brief Constructor + * \param g The h5 group + * \param name The name of the hdf5 array in the file/group where the stack will be stored + * \param bufsize The size of the buffer + * \exception The HDF5 exceptions will be caught and rethrown as TRIQS_RUNTIME_ERROR (with stackstrace, cf doc). + */ + array_stack(h5::group g, std::string const &name, size_t bufsize) + : array_stack_impl{g, name, mini_vector{}, bufsize} {} + }; + + // Specialisation for The simple case, 1d + template class array_stack> : public array_stack_impl { + public: + /** + * \brief Constructor + * \param g The h5 group + * \param name The name of the hdf5 array in the file/group where the stack will be stored + * \param base_element_shape The shape of the base array of the stack. + * \param bufsize The size of the buffer + * \exception The HDF5 exceptions will be caught and rethrown as TRIQS_RUNTIME_ERROR (with stackstrace, cf doc). + */ + array_stack(h5::group g, std::string const &name, mini_vector const &base_element_shape, size_t bufsize) + : array_stack_impl{g, name, base_element_shape, bufsize} {} + }; +} +} // namespace #endif diff --git a/triqs/arrays/h5/simple_read_write.hpp b/triqs/arrays/h5/simple_read_write.hpp index c544d855..d5d85bdb 100644 --- a/triqs/arrays/h5/simple_read_write.hpp +++ b/triqs/arrays/h5/simple_read_write.hpp @@ -25,174 +25,175 @@ #include #include "../cache.hpp" -namespace triqs { namespace arrays { +namespace triqs { +namespace arrays { namespace h5_impl { - template const void * get_array_data_cptr ( array_const_view const & A) { return h5::get_data_ptr(&(A.storage()[0]));} - template const void * get_array_data_cptr ( array_view const & A) { return h5::get_data_ptr(&(A.storage()[0]));} - template const void * get_array_data_cptr ( array const & A) { return h5::get_data_ptr(&(A.storage()[0]));} - //template void * get_array_data_ptr ( array_view & A) { return h5::get_data_ptr(&(A.storage()[0]));} - //template void * get_array_data_ptr ( array & A) { return h5::get_data_ptr(&(A.storage()[0]));} + template const void* __get_array_data_cptr(A const& a) { return h5::get_data_ptr(&(a.storage()[0])); } + template void* __get_array_data_ptr(A& x) { return h5::get_data_ptr(&(x.storage()[0])); } - template ENABLE_IF(is_amv_value_or_view_class) * - get_array_data_ptr (A & x) { return h5::get_data_ptr(&(x.storage()[0]));} - // the dataspace corresponding to the array. Contiguous data only... - template - H5::DataSpace data_space ( ArrayType const & A) { - static const unsigned int R = ArrayType::rank; - mini_vector S; - mini_vector const & S1 ( A.indexmap().strides() ); - for (size_t u=0; u::value; - return h5::dataspace_from_LS ( A.indexmap().domain().lengths(),A.indexmap().domain().lengths(), S); + template H5::DataSpace data_space(ArrayType const& A) { + if (!A.indexmap().is_contiguous()) TRIQS_RUNTIME_ERROR << " h5 : internal error : array not contiguous"; + static const unsigned int R = ArrayType::rank; + mini_vector S; + auto const& S1(A.indexmap().strides()); + for (int u = 0; u < R; ++u) { + if (S1[u] <= 0) TRIQS_RUNTIME_ERROR << " negative strides not permitted in h5"; + S[u] = 1; } + static const bool is_complex = boost::is_complex::value; + return h5::dataspace_from_LS(A.indexmap().domain().lengths(), A.indexmap().domain().lengths(), S); + } /******************** resize or check the size ****************************************************/ - template ENABLE_IF(is_amv_value_class) - resize_or_check ( A & a, mini_vector const & dimsf ) { a.resize( indexmaps::cuboid::domain_t( dimsf)); } + template ENABLE_IF(is_amv_value_class) resize_or_check(A& a, mini_vector const& dimsf) { + a.resize(indexmaps::cuboid::domain_t(dimsf)); + } - template ENABLE_IF(is_amv_view_class) - resize_or_check ( A const & a, mini_vector const & dimsf ) { - if (a.indexmap().domain().lengths() != dimsf) TRIQS_RUNTIME_ERROR<<"Dimension error : the view can not be resized : " - << "\n in file : "<< dimsf.to_string() - << "\n in view : "< ENABLE_IF(is_amv_view_class) resize_or_check(A const& a, mini_vector const& dimsf) { + if (a.indexmap().domain().lengths() != dimsf) + TRIQS_RUNTIME_ERROR << "Dimension error : the view can not be resized : " + << "\n in file : " << dimsf.to_string() + << "\n in view : " << a.indexmap().domain().lengths().to_string(); + } /*********************************** WRITE array ****************************************************************/ - /** - * \brief Write an array or a view into an hdf5 file - * \tparam - * \param f The h5 file or group of type H5::H5File or H5::Group - * \param name The name of the hdf5 array in the file/group where the stack will be stored - * \param A The array to be stored - * \param C_reorder bool If true [default] the data will be stored in C order in the hdf5, hence making a temporary + /* + * Write an array or a view into an hdf5 file + * + * f The h5 file or group of type H5::H5File or H5::Group + * name The name of the hdf5 array in the file/group where the stack will be stored + * A The array to be stored + * C_reorder bool If true [default] the data will be stored in C order in the hdf5, hence making a temporary * cache of the data to reorder them in memory. * If false, the array is stored as it [if you know what you are doing] - * \exception The HDF5 exceptions will be caught and rethrown as TRIQS_RUNTIME_ERROR (with a full stackstrace, cf triqs doc). + * The HDF5 exceptions will be caught and rethrown as TRIQS_RUNTIME_ERROR (with a full stackstrace, cf triqs doc). */ template - void write_array (h5::group g, std::string const & name, array_const_view const & A, bool C_reorder = true) { - static_assert( !std::is_base_of::value, " Not implemented");// 1d is below - if (C_reorder) { write_array(g,name, make_const_cache(A).view(),false); return; } - try { - H5::DataSet ds = g.create_dataset(name, h5::data_type_file(), data_space(A) ); - ds.write( get_array_data_cptr(A), h5::data_type_memory(), data_space(A) ); - // if complex, to be python compatible, we add the __complex__ attribute - if (boost::is_complex::value) h5::write_string_attribute(&ds,"__complex__","1"); - } - TRIQS_ARRAYS_H5_CATCH_EXCEPTION; + void write_array_impl(h5::group g, std::string const& name, array_const_view A, bool C_reorder) { + static_assert(!std::is_base_of::value, " Not implemented"); // 1d is below + if (C_reorder) { + write_array_impl(g, name, make_const_cache(A).view(), false); + return; } - - template - void write_array (h5::group g, std::string const & name, array const & A, bool C_reorder = true) { write_array(g,name,A(),C_reorder);} - template - void write_array (h5::group g, std::string const & name, array_view const & A, bool C_reorder = true) { write_array(g,name,A(),C_reorder);} - + try { + H5::DataSet ds = g.create_dataset(name, h5::data_type_file(), data_space(A)); + ds.write(__get_array_data_cptr(A), h5::data_type_memory(), data_space(A)); + // if complex, to be python compatible, we add the __complex__ attribute + if (boost::is_complex::value) h5::write_string_attribute(&ds, "__complex__", "1"); + } + TRIQS_ARRAYS_H5_CATCH_EXCEPTION; + } + + template void write_array(h5::group g, std::string const& name, A const& a, bool C_reorder = true) { + write_array_impl(g, name, typename A::const_view_type{a}, C_reorder); + } + /*********************************** READ array ****************************************************************/ - /** - * \brief Read an array or a view from an hdf5 file - * \tparam ArrayType The type of the array/matrix/vector, etc.. - * \param f The h5 file or group of type H5::H5File or H5::Group - * \param name The name of the hdf5 array in the file/group where the stack will be stored - * \param A The array to be stored - * \param C_reorder bool If true [default] the data will be stored in C order in the hdf5, hence making a temporary + /* + * Read an array or a view from an hdf5 file + * ArrayType The type of the array/matrix/vector, etc.. + * f The h5 file or group of type H5::H5File or H5::Group + * name The name of the hdf5 array in the file/group where the stack will be stored + * A The array to be stored + * C_reorder bool If true [default] the data will be stored in C order in the hdf5, hence making a temporary * cache of the data to reorder them in memory. If false, the array is stored as it [if you know what you are doing] - * \exception The HDF5 exceptions will be caught and rethrown as TRIQS_RUNTIME_ERROR (with a full stackstrace, cf triqs doc). + * The HDF5 exceptions will be caught and rethrown as TRIQS_RUNTIME_ERROR (with a full stackstrace, cf triqs doc). */ - template - void read_array (h5::group g, std::string const & name, ArrayType1 && A, bool C_reorder = true) { - typedef typename std::remove_reference::type ArrayType; - static_assert( !std::is_base_of::value, " Not implemented");// 1d is below - typedef typename ArrayType::value_type V; - try { - H5::DataSet ds = g.open_dataset(name); - H5::DataSpace dataspace = ds.getSpace(); - static const unsigned int Rank = ArrayType::rank + (boost::is_complex::value ? 1 : 0); - int rank = dataspace.getSimpleExtentNdims(); - if (rank != Rank) TRIQS_RUNTIME_ERROR << "triqs::array::h5::read. Rank mismatch : the array has rank = " - <::value ? 1 : 0); + int rank = dataspace.getSimpleExtentNdims(); + if (rank != Rank) + TRIQS_RUNTIME_ERROR << "triqs::array::h5::read. Rank mismatch : the array has rank = " << Rank + << " while the array stored in the hdf5 file has rank = " << rank; + mini_vector dims_out; + dataspace.getSimpleExtentDims(&dims_out[0], NULL); + mini_vector d2; + for (size_t u = 0; u < ArrayType::rank; ++u) d2[u] = dims_out[u]; + resize_or_check(A, d2); + if (C_reorder) { + read_array(g, name, cache(A).view(), false); + } else + ds.read(__get_array_data_ptr(A), h5::data_type_memory(), data_space(A), dataspace); } + TRIQS_ARRAYS_H5_CATCH_EXCEPTION; + } // overload : special treatment for arrays of strings (one dimension only). - inline void write_array (h5::group f, std::string const & name, vector_const_view V) { - h5::detail::write_1darray_vector_of_string_impl(f,name,V); + inline void write_array(h5::group f, std::string const& name, vector_const_view V) { + h5::detail::write_1darray_vector_of_string_impl(f, name, V); } - inline void write_array (h5::group f, std::string const & name, array_const_view V) { - write_array(f,name,vector_const_view(V)); + inline void write_array(h5::group f, std::string const& name, array_const_view V) { + write_array(f, name, vector_const_view(V)); } - inline void read_array (h5::group f, std::string const & name, arrays::vector & V) { - h5::detail::read_1darray_vector_of_string_impl(f,name,V); + inline void read_array(h5::group f, std::string const& name, arrays::vector& V) { + h5::detail::read_1darray_vector_of_string_impl(f, name, V); } // I can not use the generic code, just because the resize of the array take a shape, not a size_t as std::vector and vector - // Ok, speed is no issue here... - inline void read_array (h5::group f, std::string const & name, arrays::array & V) { - arrays::vector res; read_array(f,name,res); V = res; + inline void read_array(h5::group f, std::string const& name, arrays::array& V) { + arrays::vector res; + read_array(f, name, res); + V = res; } - }// namespace h5impl - - //template struct is_amv_value_or_view_class_no_string : - // boost::mpl::and_, boost::mpl::not_ > > {}; - - template struct has_scalar_or_string_value_type : std::false_type{}; - template struct has_scalar_or_string_value_type()))> : - boost::mpl::or_,std::is_base_of>{}; + } // namespace h5impl + // a trait to detect if A::value_type exists and is a scalar or a string + // used to exclude array> + template struct has_scalar_or_string_value_type : std::false_type {}; + template + struct has_scalar_or_string_value_type< + A, decltype(nop(std::declval< + typename A::value_type>()))> : std::integral_constant::value || + std::is_base_of::value> {}; + // get_triqs_hdf5_data_scheme template - TYPE_ENABLE_IFC(std::string,is_amv_value_or_view_class::value) - get_triqs_hdf5_data_scheme(ArrayType const&) { - using triqs::get_triqs_hdf5_data_scheme;// for the basic types, not found by ADL - std::stringstream fs; - fs<<"array<"<"; - return fs.str(); - } + TYPE_ENABLE_IFC(std::string, is_amv_value_or_view_class::value) get_triqs_hdf5_data_scheme(ArrayType const&) { + using triqs::get_triqs_hdf5_data_scheme; // for the basic types, not found by ADL + std::stringstream fs; + fs << "array<" << get_triqs_hdf5_data_scheme(typename ArrayType::value_type()) << "," << ArrayType::rank << ">"; + return fs.str(); + } - /** - * \brief Read an array or a view from an hdf5 file - * \tparam ArrayType The type of the array/matrix/vector, etc.. - * \param fg The h5 file or group of type H5::H5File or H5::Group - * \param name The name of the hdf5 array in the file/group where the stack will be stored - * \param A The array to be stored - * \exception The HDF5 exceptions will be caught and rethrown as TRIQS_RUNTIME_ERROR (with a full stackstrace, cf triqs doc). + /* + * Read an array or a view from an hdf5 file + * ArrayType The type of the array/matrix/vector, etc.. + * g The h5 group + * name The name of the hdf5 array in the file/group where the stack will be stored + * A The array to be stored + * The HDF5 exceptions will be caught and rethrown as TRIQS_RUNTIME_ERROR (with a full stackstrace, cf triqs doc). */ template - //ENABLE_IF(is_amv_value_or_view_class) - ENABLE_IFC(is_amv_value_or_view_class::value && has_scalar_or_string_value_type::value) - h5_read (h5::group fg, std::string const & name, ArrayType & A) { h5_impl::read_array(fg,name, A);} + ENABLE_IFC(is_amv_value_or_view_class::value&& has_scalar_or_string_value_type::value) + h5_read(h5::group g, std::string const& name, ArrayType& A) { + h5_impl::read_array(g, name, A); + } - /** - * \brief Write an array or a view into an hdf5 file - * \tparam ArrayType The type of the array/matrix/vector, etc.. - * \param fg The h5 file or group of type H5::H5File or H5::Group - * \param name The name of the hdf5 array in the file/group where the stack will be stored - * \param A The array to be stored - * \exception The HDF5 exceptions will be caught and rethrown as TRIQS_RUNTIME_ERROR (with a full stackstrace, cf triqs doc). + /* + * Write an array or a view into an hdf5 file + * ArrayType The type of the array/matrix/vector, etc.. + * g The h5 group + * name The name of the hdf5 array in the file/group where the stack will be stored + * A The array to be stored + * The HDF5 exceptions will be caught and rethrown as TRIQS_RUNTIME_ERROR (with a full stackstrace, cf triqs doc). */ template - //ENABLE_IF(is_amv_value_or_view_class) - ENABLE_IFC(is_amv_value_or_view_class::value && has_scalar_or_string_value_type::value) - h5_write (h5::group fg, std::string const & name, ArrayType const & A) { h5_impl::write_array(fg,name, array_const_view(A));} - -}} + ENABLE_IFC(is_amv_value_or_view_class::value&& has_scalar_or_string_value_type::value) + h5_write(h5::group g, std::string const& name, ArrayType const& A) { + h5_impl::write_array(g, name, array_const_view(A)); + } +} +} #endif diff --git a/triqs/h5/group.hpp b/triqs/h5/group.hpp index 0e03654a..d26a63f6 100644 --- a/triqs/h5/group.hpp +++ b/triqs/h5/group.hpp @@ -29,11 +29,11 @@ namespace triqs { namespace h5 { class group { H5::Group _g, _parent; std::string _name_in_parent; + group(H5::Group g, H5::Group parent, std::string name_in_parent) : _g(g), _parent(parent), _name_in_parent(name_in_parent) {} public: group() = default; group(group const &) = default; group(H5::Group g) : _g(g) {} - group(H5::Group g, H5::Group parent, std::string name_in_parent) : _g(g), _parent(parent), _name_in_parent(name_in_parent) {} /// Takes the "/" group at the top of the file. group (H5::H5File f) : _g(f.openGroup("/")) {} // can not fail, right ? @@ -75,8 +75,8 @@ namespace triqs { namespace h5 { } /** * \brief Create a subgroup. - * \param key : the name of the subgroup - * \param delete_if_exists : unlink the group if it exists + * \param key The name of the subgroup + * \param delete_if_exists Unlink the group if it exists */ group create_group(std::string const & key, bool delete_if_exists = true) const { unlink_key_if_exists(key); @@ -84,9 +84,10 @@ namespace triqs { namespace h5 { } /** * \brief Create a dataset. - * \param key : the name of the subgroup - * \param all others are forwarded to H5::Group - * It unlinks the dataset if it exists. + * \param key The name of the subgroup + * \param args Other parameters are forwarded to H5::Group + * + * NB : It unlinks the dataset if it exists. */ template H5::DataSet create_dataset(std::string const & key, Args && ... args) const {