QMCPACK
IOVarASCII.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_ASCII_H
18 #define IO_VAR_ASCII_H
19 
20 #include "IOVarBase.h"
21 #include <fstream>
22 
23 namespace IO
24 {
25 template<typename T, int RANK>
26 class IOVarASCII;
27 
28 // template<typename T, typename T0, typename T1, typename T2, typename T3, typename T4,
29 // typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
30 // class ASCIISliceMaker
31 // {
32 // public:
33 // static const int rank = ArraySectionInfo<T0>::rank + ArraySectionInfo<T1>::rank +
34 // ArraySectionInfo<T2>::rank + ArraySectionInfo<T3>::rank + ArraySectionInfo<T4>::rank +
35 // ArraySectionInfo<T5>::rank + ArraySectionInfo<T6>::rank + ArraySectionInfo<T7>::rank +
36 // ArraySectionInfo<T8>::rank + ArraySectionInfo<T9>::rank + ArraySectionInfo<T10>::rank;
37 
38 // using SliceType = IOVarASCII<T,rank>;
39 // };
40 
41 template<typename T,
42  int RANK,
43  typename T0,
44  typename T1,
45  typename T2,
46  typename T3,
47  typename T4,
48  typename T5,
49  typename T6,
50  typename T7,
51  typename T8,
52  typename T9,
53  typename T10>
54 class ASCIISliceMaker
55 {
56 public:
57  static const int rank = RANK -
58  (SliceCheck<T0>::isSlice + SliceCheck<T1>::isSlice + SliceCheck<T2>::isSlice + SliceCheck<T3>::isSlice +
59  SliceCheck<T4>::isSlice + SliceCheck<T5>::isSlice + SliceCheck<T6>::isSlice + SliceCheck<T7>::isSlice +
60  SliceCheck<T8>::isSlice + SliceCheck<T9>::isSlice + SliceCheck<T10>::isSlice);
61 
62  using SliceType = IOVarASCII<T, rank>;
63  using T_slice = Array<T, rank>;
64 };
65 
66 template<typename T, int RANK>
67 class IOVarASCII : public IOVarBase
68 {
69 public:
70  Array<T, RANK> ArrayValue;
71  template<typename T0,
72  typename T1,
73  typename T2,
74  typename T3,
75  typename T4,
76  typename T5,
77  typename T6,
78  typename T7,
79  typename T8,
80  typename T9,
81  typename T10>
82  typename ASCIISliceMaker<T, RANK, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::SliceType Slice(T0 s0,
83  T1 s1,
84  T2 s2,
85  T3 s3,
86  T4 s4,
87  T5 s5,
88  T6 s6,
89  T7 s7,
90  T8 s8,
91  T9 s9,
92  T10 s10);
93 
94  int GetRank() override;
95  IODataType GetType() override;
96  IOFileType GetFileType() override;
97 
98  void Print(std::ofstream& out) override;
99 
100  int GetExtent(int dim) override;
101  void Resize(int n) override;
102 
103  bool VarRead(Array<T, RANK>& val);
104  template<class TT>
105  bool VarRead(Array<TT, 1>& val)
106  {
107  assert(0);
108  return false;
109  }
110 
111  template<typename T0,
112  typename T1,
113  typename T2,
114  typename T3,
115  typename T4,
116  typename T5,
117  typename T6,
118  typename T7,
119  typename T8,
120  typename T9,
121  typename T10>
122  bool VarRead(typename SliceInfo<T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::T_slice& val,
123  T0 s0,
124  T1 s1,
125  T2 s2,
126  T3 s3,
127  T4 s4,
128  T5 s5,
129  T6 s6,
130  T7 s7,
131  T8 s8,
132  T8 s9,
133  T10 s10);
134 
135  bool VarWrite(const Array<T, RANK>& val);
136  template<typename T0,
137  typename T1,
138  typename T2,
139  typename T3,
140  typename T4,
141  typename T5,
142  typename T6,
143  typename T7,
144  typename T8,
145  typename T9,
146  typename T10>
147  bool VarWrite(const typename SliceInfo<T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::T_slice& val,
148  T0 s0,
149  T1 s1,
150  T2 s2,
151  T3 s3,
152  T4 s4,
153  T5 s5,
154  T6 s6,
155  T7 s7,
156  T8 s8,
157  T8 s9,
158  T10 s10);
159 
160  /// Assignment operator
161  IOVarASCII<T, RANK>& operator=(const IOVarASCII<T, RANK>& var)
162  {
163  /// This references var's value.
164  ArrayValue.reference(var.ArrayValue);
165  }
166 
167  IOVarASCII(std::string name, const Array<T, RANK>& val)
168  {
169  Name = name;
170  ArrayValue.resize(val.shape());
171  ArrayValue = val;
172  }
173  /// Default constructor
174  IOVarASCII(std::string name) { Name = name; }
175  /// Copy constructor
176  IOVarASCII(const IOVarASCII<T, RANK>& var) : ArrayValue(var.ArrayValue)
177  {
178  /// This references the arguments array value.
179  }
180 };
181 
182 template<>
183 class IOVarASCII<double, 0> : public IOVarBase
184 {
185 public:
186  double Value;
187 
188  int GetRank() override;
189  IODataType GetType() override;
190  IOFileType GetFileType() override;
191 
192  int GetExtent(int dim) override;
193  void Resize(int n) override;
194 
195  bool VarRead(double& val)
196  {
197  val = Value;
198  return true;
199  }
200  bool VarWrite(double& val);
201  IOVarASCII(std::string name, double val)
202  {
203  Name = name;
204  Value = val;
205  }
206  /// Default constructor
207  IOVarASCII(std::string name) { Name = name; }
208 };
209 
210 template<>
211 class IOVarASCII<int, 0> : public IOVarBase
212 {
213 public:
214  int Value;
215 
216  int GetRank() override;
217  IODataType GetType() override;
218  IOFileType GetFileType() override;
219 
220  int GetExtent(int dim) override;
221  void Resize(int n) override;
222 
223  bool VarRead(int& val)
224  {
225  val = Value;
226  return true;
227  }
228  bool VarWrite(int& val);
229  IOVarASCII(std::string name, int val)
230  {
231  Name = name;
232  Value = val;
233  }
234  /// Default constructor
235  IOVarASCII(std::string name) { Name = name; }
236 };
237 
238 template<>
239 class IOVarASCII<std::string, 0> : public IOVarBase
240 {
241 public:
242  std::string Value;
243 
244  int GetRank() override;
245  IODataType GetType() override;
246  IOFileType GetFileType() override;
247 
248  int GetExtent(int dim) override;
249  void Resize(int n) override;
250 
251  bool VarRead(std::string& val);
252  bool VarWrite(std::string val);
253  IOVarASCII(std::string name, std::string val)
254  {
255  Name = name;
256  Value = val;
257  }
258  /// Default constructor
259  IOVarASCII(std::string name) { Name = name; }
260 };
261 
262 template<>
263 class IOVarASCII<bool, 0> : public IOVarBase
264 {
265 public:
266  bool Value;
267 
268  int GetRank() override;
269  IODataType GetType() override;
270  IOFileType GetFileType() override;
271 
272  int GetExtent(int dim) override;
273  void Resize(int n) override;
274 
275  bool VarRead(bool& val)
276  {
277  val = Value;
278  return true;
279  }
280  bool VarWrite(bool& val);
281  IOVarASCII(std::string name, bool val)
282  {
283  Name = name;
284  Value = val;
285  }
286  /// Default constructor
287  IOVarASCII(std::string name) { Name = name; }
288 };
289 
290 
291 template<>
292 class IOVarASCII<std::complex<double>, 0> : public IOVarBase
293 {
294 public:
295  std::complex<double> Value;
296 
297  int GetRank() override;
298  IODataType GetType() override;
299  IOFileType GetFileType() override;
300 
301  int GetExtent(int dim) override;
302  void Resize(int n) override;
303 
304  bool VarRead(std::complex<double>& val)
305  {
306  val = Value;
307  return true;
308  }
309  bool VarWrite(std::complex<double>& val);
310  IOVarASCII(std::string name, std::complex<double> val)
311  {
312  Name = name;
313  Value = val;
314  }
315  /// Default constructor
316  IOVarASCII(std::string name) { Name = name; }
317 };
318 
319 
320 template<typename T, int RANK>
321 inline int IOVarASCII<T, RANK>::GetRank()
322 {
323  return RANK;
324 }
325 
326 template<typename T, int RANK>
327 inline IODataType IOVarASCII<T, RANK>::GetType()
328 {
329  return TypeConvert<T>::Type;
330 }
331 
332 template<typename T, int RANK>
333 inline IOFileType IOVarASCII<T, RANK>::GetFileType()
334 {
335  return ASCII_TYPE;
336 }
337 
338 
339 template<typename T, int RANK>
340 inline int IOVarASCII<T, RANK>::GetExtent(int dim)
341 {
342  return ArrayValue.extent(dim);
343 }
344 
345 
346 template<typename T, int RANK>
347 inline void IOVarASCII<T, RANK>::Resize(int n)
348 {
349  // TinyVector<int, RANK>
350  auto dims = ArrayValue.shape();
351  std::get<0>(dims) = n;
352  // dims[0] = n;
353  ArrayValue.resizeAndPreserve(dims);
354 }
355 
356 template<typename T, int RANK>
357 bool IOVarASCII<T, RANK>::VarRead(Array<T, RANK>& val)
358 {
359  val.resize(ArrayValue.shape());
360  val = ArrayValue;
361  return true;
362 }
363 
364 template<typename T, int RANK>
365 template<typename T0,
366  typename T1,
367  typename T2,
368  typename T3,
369  typename T4,
370  typename T5,
371  typename T6,
372  typename T7,
373  typename T8,
374  typename T9,
375  typename T10>
376 inline bool IOVarASCII<T, RANK>::VarRead(
377  typename SliceInfo<T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::T_slice& val,
378  T0 s0,
379  T1 s1,
380  T2 s2,
381  T3 s3,
382  T4 s4,
383  T5 s5,
384  T6 s6,
385  T7 s7,
386  T8 s8,
387  T8 s9,
388  T10 s10)
389 {
390  val.resize(ArrayValue(s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10).shape());
391  val = ArrayValue(s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10);
392  return true;
393 }
394 
395 template<typename T, int RANK>
396 bool IOVarASCII<T, RANK>::VarWrite(const Array<T, RANK>& val)
397 {
398  bool mustReshape = false;
399  for (int i = 0; i < RANK; i++)
400  if (ArrayValue.extent(i) != val.extent(i))
401  mustReshape = true;
402  if (mustReshape)
403  ArrayValue.resize(val.shape());
404  ArrayValue = val;
405  return true;
406 }
407 
408 template<typename T, int RANK>
409 template<typename T0,
410  typename T1,
411  typename T2,
412  typename T3,
413  typename T4,
414  typename T5,
415  typename T6,
416  typename T7,
417  typename T8,
418  typename T9,
419  typename T10>
420 inline bool IOVarASCII<T, RANK>::VarWrite(
421  const typename SliceInfo<T, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::T_slice& val,
422  T0 s0,
423  T1 s1,
424  T2 s2,
425  T3 s3,
426  T4 s4,
427  T5 s5,
428  T6 s6,
429  T7 s7,
430  T8 s8,
431  T8 s9,
432  T10 s10)
433 {
434  ArrayValue(s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10) = val;
435  return true;
436 }
437 
438 
439 template<class T, int RANK>
440 template<typename T0,
441  typename T1,
442  typename T2,
443  typename T3,
444  typename T4,
445  typename T5,
446  typename T6,
447  typename T7,
448  typename T8,
449  typename T9,
450  typename T10>
451 typename ASCIISliceMaker<T, RANK, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::SliceType IOVarASCII<T, RANK>::
452  Slice(T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7, T8 s8, T9 s9, T10 s10)
453 {
454  using newSliceType = typename ASCIISliceMaker<T, RANK, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::SliceType;
455  newSliceType newVar(Name);
456  newVar.ArrayValue.reference(ArrayValue(s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10));
457  return newVar;
458 }
459 
460 template<class T, int RANK>
461 void IOVarASCII<T, RANK>::Print(std::ofstream& out)
462 {
463  T a;
464  if (GetRank() == 0)
465  {
466  out << TypeString(a) << " " << Name << " = " << std::endl;
467  }
468  else
469  {
470  out << "Array<" << TypeString(a) << "," << GetRank() << ">(";
471  for (int i = 0; i < RANK; i++)
472  {
473  out << ArrayValue.extent(i);
474  if (i < (RANK - 1))
475  out << ",";
476  }
477  out << ") = [ ";
478  for (int i = 0; i < ArrayValue.size(); i++)
479  {
480  out << *(ArrayValue.data() + i);
481  if (i < (ArrayValue.size() - 1))
482  out << ", ";
483  }
484  out << " ];" << std::endl;
485  }
486 }
487 
488 } // namespace IO
489 
490 #endif
IO::IOVarASCII::Print
void Print(std::ofstream &out) override
Definition: IOVarASCII.h:461
IO::IOVarASCII::GetRank
int GetRank() override
Definition: IOVarASCII.h:321
IO::IOVarASCII< bool, 0 >::IOVarASCII
IOVarASCII(std::string name, bool val)
Definition: IOVarASCII.h:281
IO::ASCIISliceMaker::rank
static const int rank
Definition: IOVarASCII.h:57
IO::IOVarASCII< double, 0 >::VarRead
bool VarRead(double &val)
Definition: IOVarASCII.h:195
IO::IOVarASCII::GetExtent
int GetExtent(int dim) override
Definition: IOVarASCII.h:340
IO::IOVarASCII::GetFileType
IOFileType GetFileType() override
Definition: IOVarASCII.h:333
IO::IOVarASCII::GetType
IODataType GetType() override
Definition: IOVarASCII.h:327
IO::IOVarASCII< int, 0 >::IOVarASCII
IOVarASCII(std::string name, int val)
Definition: IOVarASCII.h:229
IO::IOVarASCII::ArrayValue
Array< T, RANK > ArrayValue
Definition: IOVarASCII.h:70
IO::IOVarASCII< double, 0 >::IOVarASCII
IOVarASCII(std::string name)
Default constructor.
Definition: IOVarASCII.h:207
IO::TypeConvert
The following are template tricks for converting a C++ type /// into an enumerated type variable...
Definition: IOVarBase.h:354
IO::IODataType
IODataType
Definition: IOVarBase.h:26
IO::IOVarBase::Name
std::string Name
Definition: IOVarBase.h:65
IO::IOVarASCII< double, 0 >::IOVarASCII
IOVarASCII(std::string name, double val)
Definition: IOVarASCII.h:201
IO::IOVarASCII< int, 0 >::IOVarASCII
IOVarASCII(std::string name)
Default constructor.
Definition: IOVarASCII.h:235
Array::resize
void resize(const std::array< SIZET, D > &dims)
Resize the container.
Definition: OhmmsArray.h:65
Array::extent
std::ptrdiff_t extent(int d) const
Definition: Blitz.h:77
IO::IOVarASCII::operator=
IOVarASCII< T, RANK > & operator=(const IOVarASCII< T, RANK > &var)
Assignment operator.
Definition: IOVarASCII.h:161
IO::IOFileType
IOFileType
Definition: IOVarBase.h:35
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::IOVarASCII::Resize
void Resize(int n) override
Resizes the first dimension of the variable.
Definition: IOVarASCII.h:347
IO
Definition: IO.h:24
IO::IOVarASCII< bool, 0 >::VarRead
bool VarRead(bool &val)
Definition: IOVarASCII.h:275
IO::IOVarASCII< int, 0 >::VarRead
bool VarRead(int &val)
Definition: IOVarASCII.h:223
IO::IOVarASCII::VarWrite
bool VarWrite(const Array< T, RANK > &val)
Definition: IOVarASCII.h:396
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
IO::IOVarASCII::VarRead
bool VarRead(Array< TT, 1 > &val)
Definition: IOVarASCII.h:105
IO::IOVarASCII< bool, 0 >::IOVarASCII
IOVarASCII(std::string name)
Default constructor.
Definition: IOVarASCII.h:287
IO::IOVarASCII::IOVarASCII
IOVarASCII(std::string name, const Array< T, RANK > &val)
Definition: IOVarASCII.h:167
IO::IOVarASCII< std::complex< double >, 0 >::IOVarASCII
IOVarASCII(std::string name, std::complex< double > val)
Definition: IOVarASCII.h:310
qmcplusplus::dims
std::vector< int > dims
Definition: test_ObservableHelper.cpp:51
Array
A D-dimensional Array class based on PETE.
Definition: OhmmsArray.h:25
IO::TypeString
std::string TypeString(T &val)
Definition: IOVarBase.h:397
IO::IOVarASCII< std::complex< double >, 0 >::VarRead
bool VarRead(std::complex< double > &val)
Definition: IOVarASCII.h:304
Array::shape
const std::array< size_t, D > & shape() const
Definition: OhmmsArray.h:56
IO::IOVarASCII::IOVarASCII
IOVarASCII(std::string name)
Default constructor.
Definition: IOVarASCII.h:174
IO::IOVarASCII< std::string, 0 >::IOVarASCII
IOVarASCII(std::string name)
Default constructor.
Definition: IOVarASCII.h:259
IO::IOVarASCII< std::string, 0 >::IOVarASCII
IOVarASCII(std::string name, std::string val)
Definition: IOVarASCII.h:253
IO::IOVarASCII::IOVarASCII
IOVarASCII(const IOVarASCII< T, RANK > &var)
Copy constructor.
Definition: IOVarASCII.h:176
IO::IOVarASCII::VarRead
bool VarRead(Array< T, RANK > &val)
Definition: IOVarASCII.h:357
IO::IOVarASCII< std::complex< double >, 0 >::IOVarASCII
IOVarASCII(std::string name)
Default constructor.
Definition: IOVarASCII.h:316