QMCPACK
IOVar.h
Go to the documentation of this file.
1 //////////////////////////////////////////////////////////////////////////////////////
2 // This file is distributed under the University of Illinois/NCSA Open Source License.
3 // See LICENSE file in top directory for details.
4 //
5 // Copyright (c) 2016 Jeongnim Kim and QMCPACK developers.
6 //
7 // File developed by: Paul R. C. Kent, kentpr@ornl.gov, Oak Ridge National Laboratory
8 // Mark A. Berrill, berrillma@ornl.gov, Oak Ridge National Laboratory
9 //
10 // File created by: Paul R. C. Kent, kentpr@ornl.gov, Oak Ridge National Laboratory
11 //////////////////////////////////////////////////////////////////////////////////////
12 
13 
14 // http://pathintegrals.info //
15 /////////////////////////////////////////////////////////////
16 
17 #ifndef IO_VAR_H
18 #define IO_VAR_H
19 
20 #include "IOVarASCII.h"
21 
22 #include "Blitz.h"
23 
24 namespace IO
25 {
26 template<typename T>
27 bool IOVarBase::Read(T& val)
28 {
29  if (GetFileType() == ASCII_TYPE)
30  {
31  IOVarASCII<T, 0>* newVar = dynamic_cast<IOVarASCII<T, 0>*>(this);
32  if (newVar == NULL)
33  {
34  std::cerr << "Error in dynamic cast to IOVarASCII.\n";
35  abort();
36  }
37  return newVar->VarRead(val);
38  }
39  else
40  {
41  std::cerr << "Error: unknown type in IOVarBase::Read().\n";
42  abort();
43  }
44 }
45 
46 template<typename T, int LEN>
47 bool IOVarBase::Read(TinyVector<T, LEN>& val)
48 {
49  if (GetFileType() == ASCII_TYPE)
50  {
51  IOVarASCII<T, 1>* newVar = dynamic_cast<IOVarASCII<T, 1>*>(this);
52  if (newVar == NULL)
53  {
54  std::cerr << "Error in dynamic cast to IOVarASCII.\n";
55  abort();
56  }
57  Array<T, 1> aVal;
58  bool success = newVar->VarRead(aVal);
59  if (!success)
60  return false;
61  else if (aVal.size() == LEN)
62  for (int i = 0; i < LEN; i++)
63  val[i] = aVal(i);
64  else
65  return false;
66  return true;
67  }
68  else
69  {
70  std::cerr << "Error: unknown type in IOVarBase::Read().\n";
71  abort();
72  }
73 }
74 
75 template<typename T, int RANK>
76 bool IOVarBase::Read(Array<T, RANK>& val)
77 {
78  if (GetFileType() == ASCII_TYPE)
79  {
80  IOVarASCII<T, RANK>* newVar = dynamic_cast<IOVarASCII<T, RANK>*>(this);
81  if (newVar == NULL)
82  {
83  std::cerr << "Error in dynamic cast to IOVarASCII.\n";
84  abort();
85  }
86  return newVar->VarRead(val);
87  }
88  else
89  {
90  std::cerr << "Error: unknown type in IOVarBase::Read().\n";
91  abort();
92  }
93 }
94 
95 
96 template<typename T,
97  int RANK,
98  typename T0,
99  typename T1,
100  typename T2,
101  typename T3,
102  typename T4,
103  typename T5,
104  typename T6,
105  typename T7,
106  typename T8,
107  typename T9,
108  typename T10>
109 bool IOVarBase::Read(Array<T, RANK>& val,
110  T0 s0,
111  T1 s1,
112  T2 s2,
113  T3 s3,
114  T4 s4,
115  T5 s5,
116  T6 s6,
117  T7 s7,
118  T8 s8,
119  T9 s9,
120  T10 s10)
121 {
122  static const int numSlices = SliceCheck<T0>::isSlice + SliceCheck<T1>::isSlice + SliceCheck<T2>::isSlice +
123  SliceCheck<T3>::isSlice + SliceCheck<T4>::isSlice + SliceCheck<T5>::isSlice + SliceCheck<T6>::isSlice +
124  SliceCheck<T7>::isSlice + SliceCheck<T8>::isSlice + SliceCheck<T9>::isSlice + SliceCheck<T10>::isSlice;
125 
126  /// The rank of the array must be the rank of the IO variable minus
127  /// the number of slices by integer singlet ranges.
128  static const int varRank = numSlices + RANK;
129 
130  if (GetFileType() == ASCII_TYPE)
131  {
132  IOVarASCII<T, varRank>* newVar = dynamic_cast<IOVarASCII<T, varRank>*>(this);
133  if (newVar == NULL)
134  {
135  std::cerr << "Error in dynamic cast to IOVarHDF5.\n";
136  abort();
137  }
138  return newVar->Slice(s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10).VarRead(val);
139  }
140 }
141 
142 
143 template<typename T,
144  int RANK,
145  typename T0,
146  typename T1,
147  typename T2,
148  typename T3,
149  typename T4,
150  typename T5,
151  typename T6,
152  typename T7,
153  typename T8,
154  typename T9,
155  typename T10>
156 bool IOVarBase::Write(const Array<T, RANK>& val,
157  T0 s0,
158  T1 s1,
159  T2 s2,
160  T3 s3,
161  T4 s4,
162  T5 s5,
163  T6 s6,
164  T7 s7,
165  T8 s8,
166  T9 s9,
167  T10 s10)
168 {
169  static const int numSlices = SliceCheck<T0>::isSlice + SliceCheck<T1>::isSlice + SliceCheck<T2>::isSlice +
170  SliceCheck<T3>::isSlice + SliceCheck<T4>::isSlice + SliceCheck<T5>::isSlice + SliceCheck<T6>::isSlice +
171  SliceCheck<T7>::isSlice + SliceCheck<T8>::isSlice + SliceCheck<T9>::isSlice + SliceCheck<T10>::isSlice;
172 
173  /// The rank of the array must be the rank of the IO variable minus
174  /// the number of slices by integer singlet ranges.
175  static const int varRank = numSlices + RANK;
176 
177  if (GetFileType() == ASCII_TYPE)
178  {
179  IOVarASCII<T, varRank>* newVar = dynamic_cast<IOVarASCII<T, varRank>*>(this);
180  if (newVar == NULL)
181  {
182  std::cerr << "Error in dynamic cast to IOVarASCII.\n";
183  abort();
184  }
185  return newVar->Slice(s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10).VarWrite(val);
186  }
187 }
188 
189 template<typename T>
190 bool IOVarBase::Append(const T val)
191 {
192  assert(GetRank() == 1);
193  int n = GetExtent(0);
194  Resize(n + 1);
195  Array<T, 1> v(1);
196  v(0) = val;
197  return Write(v, Range(n, n));
198 }
199 
200 // template<typename T, int RANK> bool
201 // IOVarBase::Append(Array<T,RANK> &val)
202 // {
203 // assert (GetRank() == (RANK+1));
204 // int n = GetExtent(0);
205 // for (int i=0; i<RANK; i++)
206 // assert (val.extent(i) == GetExtent(i+1));
207 
208 // if (GetFileType() == HDF5_TYPE) {
209 // IOVarHDF5<T,RANK+1>* newVar = dynamic_cast<IOVarHDF5<T,RANK+1>*>(this);
210 // if (newVar == NULL) {
211 // cerr << "Error in dynamic cast to IOVarHDF5.\n";
212 // abort();
213 // }
214 // newVar->Resize(n+1);
215 // return newVar->Slice(n, n0, n0, n0, n0, n0, n0, n0, n0, n0, n0).VarWrite(val);
216 // }
217 // else if (GetFileType() == ASCII_TYPE) {
218 // IOVarASCII<T,RANK+1>* newVar = dynamic_cast<IOVarASCII<T,RANK+1>*>(this);
219 // if (newVar == NULL) {
220 // cerr << "Error in dynamic cast to IOVarASCII.\n";
221 // abort();
222 // }
223 // newVar->Resize(n+1);
224 // return newVar->Slice(n, n0, n0, n0, n0, n0, n0, n0, n0, n0, n0).VarWrite(val);
225 // }
226 // }
227 
228 template<class T>
229 bool IOVarBase::Append(const Array<T, 1>& val)
230 {
231  assert(GetRank() == 2);
232  int n = GetExtent(0);
233  assert(val.extent(0) == GetExtent(1));
234  Resize(n + 1);
235  return Write(val, n, Range::all());
236 }
237 
238 template<class T>
239 bool IOVarBase::Append(const Array<T, 2>& val)
240 {
241  assert(GetRank() == 3);
242  int n = GetExtent(0);
243  assert(val.extent(0) == GetExtent(1));
244  assert(val.extent(1) == GetExtent(2));
245  Resize(n + 1);
246  return Write(val, n, Range::all(), Range::all());
247 }
248 
249 template<class T>
250 bool IOVarBase::Append(const Array<T, 3>& val)
251 {
252  assert(GetRank() == 4);
253  int n = GetExtent(0);
254  assert(val.extent(0) == GetExtent(1));
255  assert(val.extent(1) == GetExtent(2));
256  assert(val.extent(2) == GetExtent(3));
257  Resize(n + 1);
258  return Write(val, n, Range::all(), Range::all(), Range::all());
259 }
260 
261 template<class T>
262 bool IOVarBase::Append(const Array<T, 4>& val)
263 {
264  assert(GetRank() == 5);
265  int n = GetExtent(0);
266  assert(val.extent(0) == GetExtent(1));
267  assert(val.extent(1) == GetExtent(2));
268  assert(val.extent(2) == GetExtent(3));
269  assert(val.extent(3) == GetExtent(4));
270  Resize(n + 1);
271  return Write(val, n, Range::all(), Range::all(), Range::all(), Range::all());
272 }
273 
274 
275 } // namespace IO
276 
277 
278 #endif /// Ends ifndef IO_VAR_H
IO::IOVarBase::Write
bool Write(const Array< T, RANK > &val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7, T8 s8, T9 s9, T10 s10)
Write functions ///.
Definition: IOVar.h:156
Array::extent
std::ptrdiff_t extent(int d) const
Definition: Blitz.h:77
IO::SliceCheck
The following is a template trick for counting how many /// dimension reductions we have made to a da...
Definition: IOVarBase.h:46
IO::IOVarBase::GetExtent
virtual int GetExtent(int dim)=0
IO
Definition: IO.h:24
IO::IOVarBase::GetFileType
virtual IOFileType GetFileType()=0
Array::size
size_t size() const
Definition: OhmmsArray.h:57
IO::IOVarASCII::Slice
ASCIISliceMaker< T, RANK, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 >::SliceType Slice(T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7, T8 s8, T9 s9, T10 s10)
Definition: IOVarASCII.h:452
Range::all
static auto all()
Definition: Blitz.h:176
Range
Definition: Blitz.h:173
IO::IOVarBase::Append
bool Append(const T val)
Definition: IOVar.h:190
IO::IOVarBase::Read
bool Read(T &val)
Read functions ///.
Definition: IOVar.h:27
IO::IOVarASCII::VarRead
bool VarRead(Array< T, RANK > &val)
Definition: IOVarASCII.h:357
IO::IOVarBase::GetRank
virtual int GetRank()=0
IO::IOVarBase::Resize
virtual void Resize(int n)=0
Resizes the first dimension of the variable.