grid.h
3.83 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
#ifndef STIM_GRID_H
#define STIM_GRID_H
#include <vector>
#include <string>
#include <sstream>
#include <fstream>
#include <cstdarg>
#include "../math/mathvec.h"
namespace stim{
/**This object describes a generic D-dimensional grid containing data of type T.
Functions are provided for saving and loading binary data.
**/
template<typename T, unsigned int D = 1>
class grid{
protected:
stim::vec<unsigned long> R; //elements in each dimension
stim::vec<float> S;
T* ptr; //pointer to the data (on the GPU or CPU)
///Return the total number of values in the binary file
unsigned long samples(){
unsigned long s = 1;
for(unsigned int d = 0; d < D; d++)
s *= R[d];
return s;
}
///Initializes a grid by allocating the necessary memory and setting all values to zero
void init(){
//calculate the total number of values
unsigned long S = samples();
//allocate memory to store the grid
ptr = (T*)malloc(sizeof(T) * S);
//initialize the memory to zero
memset(ptr, 0, sizeof(T) * S);
}
public:
///Default constructor doesn't do anything
grid(){}
///Constructor used to specify the grid size as a vector
/// @param _R is a vector describing the grid resolution
grid( stim::vec<unsigned long> _R){
//set the grid resolution
R = _R;
init();
}
void
setDim(stim::vec<float> s)
{
S = s;
}
///Constructor used to specify the grid size as a set of parameters
/// @param X0... is a list of values describing the grid size along each dimension
grid( unsigned long X0, ...){
R[0] = X0;
va_list ap;
va_start(ap, X0);
for(unsigned int d = 1; d<D; d++)
R[d] = va_arg(ap, unsigned long);
va_end(ap);
init();
}
///Writes the binary data to disk
/// @param filename is the name of the binary file to be written
void write(std::string filename){
std::fstream file;
//open the file as binary for reading
file.open(filename.c_str(), std::ios::out | std::ios::binary);
//write file to disk
file.write((char *)ptr, samples() * sizeof(T));
}
///Loads a binary file from disk
/// @param filename is the name of the file containing the binary data
/// @param S is the size of the binary file along each dimension
/// @param header is the size of the header in bytes
void read(std::string filename, stim::vec<unsigned long> S, unsigned long header = 0){
R = S; //set the sample resolution
std::fstream file;
//open the file as binary for writing
file.open(filename.c_str(), std::ios::in | std::ios::binary);
//seek past the header
file.seekg(header, std::ios::beg);
//read the data
file.read((char *)ptr, samples() * sizeof(T));
}
///Gets a single value from the grid given a set of coordinates
/// @param x0... is a list of coordinates specifying the desired value
T get(unsigned long x0, ...){
va_list ap;
unsigned long F = 1;
unsigned long p = x0;
va_start(ap, x0);
for(unsigned int d = 1; d<D; d++){
F *= R[d-1];
p += va_arg(ap, unsigned int) * F;
}
va_end(ap);
return ptr[p];
}
///Sets a value in the grid
/// @param value is the grid point value
/// @x0... is the coordinate of the value to be set
void set(T value, unsigned long x0, ...){
va_list ap;
unsigned long F = 1;
unsigned long p = x0;
va_start(ap, x0);
for(unsigned int d = 1; d<D; d++){
F *= R[d-1];
p += va_arg(ap, unsigned int) * F;
}
va_end(ap);
ptr[p] = value;
}
///Outputs grid data as a string
std::string str(){
std::stringstream result;
result<<"stim::grid structure of size [";
for(unsigned int d = 0; d<D; d++){
if(d!=0) result<<", ";
result<<R[d];
}
result<<"]"<<std::endl;
//calculate the number of values to output
unsigned long nV = min((unsigned long long)R[0], (unsigned long long)10);
for(unsigned long v = 0; v<nV; v++){
result<<ptr[v];
if(v != nV-1) result<<", ";
}
return result.str();
}
};
}
#endif