| kspaceFirstOrder3D-CUDA 1.1 The CUDA/C++ implementation of the k-wave toolbox for the time-domain simulation of acoustic wave fields in 3D

- Main Page
- Related Pages
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
OutputStreamContainer.cpp
Go to the documentation of this file.
1 /**
2 * @file OutputStreamContainer.cpp
3 *
4 * @author Jiri Jaros & Beau Johnston \n
5 * Faculty of Information Technology \n
6 * Brno University of Technology \n
7 * jarosjir@fit.vutbr.cz
8 *
9 * @brief The implementation file for the output stream container.
10 *
11 * @version kspaceFirstOrder3D 3.4
12 *
13 * @date 04 December 2014, 11:41 (created) \n
14 * 19 July 2016, 17:28 (revised)
15 *
16 * @section License
17 * This file is part of the C++ extension of the k-Wave Toolbox
18 * (http://www.k-wave.org).\n Copyright (C) 2016 Jiri Jaros and Bradley Treeby.
19 *
20 * This file is part of the k-Wave. k-Wave is free software: you can redistribute it and/or modify
21 * it under the terms of the GNU Lesser General Public License as published by the Free Software
22 * Foundation, either version 3 of the License, or (at your option) any later version.
23 *
24 * k-Wave is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
25 * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
26 * General Public License for more details.
27 *
28 * You should have received a copy of the GNU Lesser General Public License along with k-Wave.
29 * If not, see http://www.gnu.org/licenses/. If not, see http://www.gnu.org/licenses/.
30 */
31
32 #include <Parameters/Parameters.h>
33 #include <Containers/OutputStreamContainer.h>
34
35 #include <OutputHDF5Streams/BaseOutputHDF5Stream.h>
36 #include <OutputHDF5Streams/IndexOutputHDF5Stream.h>
37 #include <OutputHDF5Streams/CuboidOutputHDF5Stream.h>
38 #include <OutputHDF5Streams/WholeDomainOutputHDF5Stream.h>
39
40
41 //------------------------------------------------------------------------------------------------//
42 //-------------------------------------- Constants -----------------------------------------------//
43 //------------------------------------------------------------------------------------------------//
44
45
46 //------------------------------------------------------------------------------------------------//
47 //--------------------------------------- Public methods -----------------------------------------//
48 //------------------------------------------------------------------------------------------------//
49
50 /**
51 * Destructor.
52 */
53 TOutputStreamContainer::~TOutputStreamContainer()
54 {
55 outputStreamContainer.clear();
56 }// end of Destructor
57 //--------------------------------------------------------------------------------------------------
58
59 /**
60 * Add all streams in the simulation to the container, set all streams records here! \n
61 * Please note, the Matrix container has to be populated before calling this routine.
62 *
63 * @param [in] matrixContainer - Matrix container to link the steams with sampled matrices and
64 * sensor masks
65 */
66 void TOutputStreamContainer::AddStreams(TMatrixContainer& matrixContainer)
67 {
68 TParameters& params = TParameters::GetInstance();
69
70 //----------------------------------------- pressure ------------------------------------------//
71 if (params.IsStore_p_raw())
72 {
73 outputStreamContainer[p_sensor_raw] = CreateNewOutputStream(matrixContainer,
74 p,
75 p_NAME,
76 TBaseOutputHDF5Stream::NONE);
77 }
78
79 if (params.IsStore_p_rms())
80 {
81 outputStreamContainer[p_sensor_rms] = CreateNewOutputStream(matrixContainer,
82 p,
83 p_rms_NAME,
84 TBaseOutputHDF5Stream::RMS);
85 }
86
87 if (params.IsStore_p_max())
88 {
89 outputStreamContainer[p_sensor_max] = CreateNewOutputStream(matrixContainer,
90 p,
91 p_max_NAME,
92 TBaseOutputHDF5Stream::MAX);
93 }
94
95 if (params.IsStore_p_min())
96 {
97 outputStreamContainer[p_sensor_min] = CreateNewOutputStream(matrixContainer,
98 p,
99 p_min_NAME,
100 TBaseOutputHDF5Stream::MIN);
101 }
102
103 if (params.IsStore_p_max_all())
104 {
105 outputStreamContainer[p_sensor_max_all] =
106 new TWholeDomainOutputHDF5Stream(params.GetOutputFile(),
107 p_max_all_NAME,
108 matrixContainer.GetMatrix<TRealMatrix>(p),
109 TBaseOutputHDF5Stream::MAX);
110 }
111
112 if (params.IsStore_p_min_all())
113 {
114 outputStreamContainer[p_sensor_min_all] =
115 new TWholeDomainOutputHDF5Stream(params.GetOutputFile(),
116 p_min_all_NAME,
117 matrixContainer.GetMatrix<TRealMatrix>(p),
118 TBaseOutputHDF5Stream::MIN);
119 }
120
121 //---------------------------------------- velocity --------------------------------------------//
122 if (params.IsStore_u_raw())
123 {
124 outputStreamContainer[ux_sensor_raw] = CreateNewOutputStream(matrixContainer,
125 ux_sgx,
126 ux_NAME,
127 TBaseOutputHDF5Stream::NONE);
128 outputStreamContainer[uy_sensor_raw] = CreateNewOutputStream(matrixContainer,
129 uy_sgy,
130 uy_NAME,
131 TBaseOutputHDF5Stream::NONE);
132 outputStreamContainer[uz_sensor_raw] = CreateNewOutputStream(matrixContainer,
133 uz_sgz,
134 uz_NAME,
135 TBaseOutputHDF5Stream::NONE);
136 }
137
138 if (params.IsStore_u_non_staggered_raw())
139 {
140 outputStreamContainer[ux_shifted_sensor_raw] = CreateNewOutputStream(matrixContainer,
141 ux_shifted,
142 ux_non_staggered_NAME,
143 TBaseOutputHDF5Stream::NONE);
144 outputStreamContainer[uy_shifted_sensor_raw] = CreateNewOutputStream(matrixContainer,
145 uy_shifted,
146 uy_non_staggered_NAME,
147 TBaseOutputHDF5Stream::NONE);
148 outputStreamContainer[uz_shifted_sensor_raw] = CreateNewOutputStream(matrixContainer,
149 uz_shifted,
150 uz_non_staggered_NAME,
151 TBaseOutputHDF5Stream::NONE);
152 }
153
154 if (params.IsStore_u_rms())
155 {
156 outputStreamContainer[ux_sensor_rms] = CreateNewOutputStream(matrixContainer,
157 ux_sgx,
158 ux_rms_NAME,
159 TBaseOutputHDF5Stream::RMS);
160 outputStreamContainer[uy_sensor_rms] = CreateNewOutputStream(matrixContainer,
161 uy_sgy,
162 uy_rms_NAME,
163 TBaseOutputHDF5Stream::RMS);
164 outputStreamContainer[uz_sensor_rms] = CreateNewOutputStream(matrixContainer,
165 uz_sgz,
166 uz_rms_NAME,
167 TBaseOutputHDF5Stream::RMS);
168 }
169
170 if (params.IsStore_u_max())
171 {
172 outputStreamContainer[ux_sensor_max] = CreateNewOutputStream(matrixContainer,
173 ux_sgx,
174 ux_max_NAME,
175 TBaseOutputHDF5Stream::MAX);
176 outputStreamContainer[uy_sensor_max] = CreateNewOutputStream(matrixContainer,
177 uy_sgy,
178 uy_max_NAME,
179 TBaseOutputHDF5Stream::MAX);
180 outputStreamContainer[uz_sensor_max] = CreateNewOutputStream(matrixContainer,
181 uz_sgz,
182 uz_max_NAME,
183 TBaseOutputHDF5Stream::MAX);
184 }
185
186 if (params.IsStore_u_min())
187 {
188 outputStreamContainer[ux_sensor_min] = CreateNewOutputStream(matrixContainer,
189 ux_sgx,
190 ux_min_NAME,
191 TBaseOutputHDF5Stream::MIN);
192 outputStreamContainer[uy_sensor_min] = CreateNewOutputStream(matrixContainer,
193 uy_sgy,
194 uy_min_NAME,
195 TBaseOutputHDF5Stream::MIN);
196 outputStreamContainer[uz_sensor_min] = CreateNewOutputStream(matrixContainer,
197 uz_sgz,
198 uz_min_NAME,
199 TBaseOutputHDF5Stream::MIN);
200 }
201
202 if (params.IsStore_u_max_all())
203 {
204 outputStreamContainer[ux_sensor_max_all] =
205 new TWholeDomainOutputHDF5Stream(params.GetOutputFile(),
206 ux_max_all_NAME,
207 matrixContainer.GetMatrix<TRealMatrix>(ux_sgx),
208 TBaseOutputHDF5Stream::MAX);
209 outputStreamContainer[uy_sensor_max_all] =
210 new TWholeDomainOutputHDF5Stream(params.GetOutputFile(),
211 uy_max_all_NAME,
212 matrixContainer.GetMatrix<TRealMatrix>(uy_sgy),
213 TBaseOutputHDF5Stream::MAX);
214 outputStreamContainer[uz_sensor_max_all] =
215 new TWholeDomainOutputHDF5Stream(params.GetOutputFile(),
216 uz_max_all_NAME,
217 matrixContainer.GetMatrix<TRealMatrix>(uz_sgz),
218 TBaseOutputHDF5Stream::MAX);
219 }
220
221 if (params.IsStore_u_min_all())
222 {
223 outputStreamContainer[ux_sensor_min_all] =
224 new TWholeDomainOutputHDF5Stream(params.GetOutputFile(),
225 ux_min_all_NAME,
226 matrixContainer.GetMatrix<TRealMatrix>(ux_sgx),
227 TBaseOutputHDF5Stream::MIN);
228 outputStreamContainer[uy_sensor_min_all] =
229 new TWholeDomainOutputHDF5Stream(params.GetOutputFile(),
230 uy_min_all_NAME,
231 matrixContainer.GetMatrix<TRealMatrix>(uy_sgy),
232 TBaseOutputHDF5Stream::MIN);
233 outputStreamContainer[uz_sensor_min_all] =
234 new TWholeDomainOutputHDF5Stream(params.GetOutputFile(),
235 uz_min_all_NAME,
236 matrixContainer.GetMatrix<TRealMatrix>(uz_sgz),
237 TBaseOutputHDF5Stream::MIN);
238 }
239 }// end of AddStreams
240 //--------------------------------------------------------------------------------------------------
241
242 /**
243 * Create all streams.
244 */
245 void TOutputStreamContainer::CreateStreams()
246 {
247 for (const auto& it : outputStreamContainer)
248 {
249 if (it.second)
250 {
251 it.second->Create();
252 }
253 }
254 }// end of CreateStreams
255 //--------------------------------------------------------------------------------------------------
256
257 /**
258 * Reopen all streams after restarting from checkpoint.
259 */
260 void TOutputStreamContainer::ReopenStreams()
261 {
262 for (const auto& it : outputStreamContainer)
263 {
264 if (it.second)
265 {
266 it.second->Reopen();
267 }
268 }
269 }// end of ReopenStreams
270 //--------------------------------------------------------------------------------------------------
271
272
273 /**
274 * Sample all streams.
275 * @warning In the GPU implementation, no data is flushed on disk (just data is sampled)
276 */
277 void TOutputStreamContainer::SampleStreams()
278 {
279 for (const auto& it : outputStreamContainer)
280 {
281 if (it.second)
282 {
283 it.second->Sample();
284 }
285 }
286 }// end of SampleStreams
287 //--------------------------------------------------------------------------------------------------
288
289 /**
290 * Flush stream data to disk.
291 * @warning In GPU implementation, data from raw streams is flushed here. Aggregated streams are
292 * ignored.
293 */
294 void TOutputStreamContainer::FlushRawStreams()
295 {
296 for (const auto& it : outputStreamContainer)
297 {
298 if (it.second)
299 {
300 it.second->FlushRaw();
301 }
302 }
303 }// end of SampleStreams
304 //--------------------------------------------------------------------------------------------------
305
306 /**
307 * Checkpoint streams without post-processing (flush to the file).
308 */
309 void TOutputStreamContainer::CheckpointStreams()
310 {
311 for (const auto& it : outputStreamContainer)
312 {
313 if (it.second)
314 {
315 it.second->Checkpoint();
316 }
317 }
318 }// end of CheckpointStreams
319 //--------------------------------------------------------------------------------------------------
320
321 /**
322 * Post-process all streams and flush them to the file.
323 */
324 void TOutputStreamContainer::PostProcessStreams()
325 {
326 for (const auto& it : outputStreamContainer)
327 {
328 if (it.second)
329 {
330 it.second->PostProcess();
331 }
332 }
333 }// end of CheckpointStreams
334 //--------------------------------------------------------------------------------------------------
335
336
337 /**
338 * Close all streams (apply post-processing if necessary, flush data and close).
339 */
340 void TOutputStreamContainer::CloseStreams()
341 {
342 for (const auto& it : outputStreamContainer)
343 {
344 if (it.second)
345 {
346 it.second->Close();
347 }
348 }
349 }// end of CloseStreams
350 //--------------------------------------------------------------------------------------------------
351
352 /**
353 * Free all streams - destroy them.
354 */
355 void TOutputStreamContainer::FreeStreams()
356 {
357 for (auto& it : outputStreamContainer)
358 {
359 if (it.second)
360 {
361 delete it.second;
362 it.second = nullptr;
363 }
364 }
365 outputStreamContainer.clear();
366 }// end of FreeAllStreams
367 //--------------------------------------------------------------------------------------------------
368
369
370 //------------------------------------------------------------------------------------------------//
371 //-------------------------------------- Protected methods ---------------------------------------//
372 //------------------------------------------------------------------------------------------------//
373
374
375 /**
376 * Create a new output stream.
377 * @param [in] matrixContainer - Name of the HDF5 dataset or group
378 * @param [in] sampledMatrixIdx - Code id of the matrix
379 * @param [in] fileDatasetName - Name of the HDF5 dataset or group
380 * @param [in] reduceOp - Reduce operator
381 *
382 * @return New output stream with defined links
383 *
384 */
385 TBaseOutputHDF5Stream* TOutputStreamContainer::CreateNewOutputStream(TMatrixContainer& matrixContainer,
386 const TMatrixIdx sampledMatrixIdx,
387 const TMatrixName& fileDatasetName,
388 const TBaseOutputHDF5Stream::TReduceOperator reduceOp)
389 {
390 TParameters& params = TParameters::GetInstance();
391
392
393
394 if (params.Get_sensor_mask_type() == TParameters::INDEX)
395 {
396 return (new TIndexOutputHDF5Stream(params.GetOutputFile(),
397 fileDatasetName,
398 matrixContainer.GetMatrix<TRealMatrix>(sampledMatrixIdx),
399 matrixContainer.GetMatrix<TIndexMatrix>(sensor_mask_index),
400 reduceOp)
401 );
402 }
403 else
404 {
405 return (new TCuboidOutputHDF5Stream(params.GetOutputFile(),
406 fileDatasetName,
407 matrixContainer.GetMatrix<TRealMatrix>(sampledMatrixIdx),
408 matrixContainer.GetMatrix<TIndexMatrix>(sensor_mask_corners),
409 reduceOp)
410 );
411 }
412 }// end of CreateNewOutputStream
413 //--------------------------------------------------------------------------------------------------
414
415
416 //------------------------------------------------------------------------------------------------//
417 //--------------------------------------- Private methods ----------------------------------------//
418 //------------------------------------------------------------------------------------------------//
uz_max_NAME
TMatrixName uz_max_NAME
uz_max variable name
Definition: MatrixNames.h:293
TWholeDomainOutputHDF5Stream
Output stream for quantities sampled in the whole domain.
Definition: WholeDomainOutputHDF5Stream.h:44
ux_max_all_NAME
TMatrixName ux_max_all_NAME
ux_max_all variable name
Definition: MatrixNames.h:302
uz_min_all_NAME
TMatrixName uz_min_all_NAME
uz_min_all variable name
Definition: MatrixNames.h:312
BaseOutputHDF5Stream.h
The header file of the class saving RealMatrix data into the output HDF5 file.
TCuboidOutputHDF5Stream
Output stream for quantities sampled by a cuboid corner sensor mask.
Definition: CuboidOutputHDF5Stream.h:49
uy_rms_NAME
TMatrixName uy_rms_NAME
uy_rms variable name
Definition: MatrixNames.h:284
p_rms_NAME
TMatrixName p_rms_NAME
p_rms variable name
Definition: MatrixNames.h:269
TParameters::IsStore_u_min
bool IsStore_u_min() const
Is –u_min specified at the command line?
Definition: Parameters.h:258
TBaseOutputHDF5Stream::RMS
calculate root mean square
Definition: BaseOutputHDF5Stream.h:59
TParameters::GetInstance
static TParameters & GetInstance()
Get instance of the singleton class.
Definition: Parameters.cpp:70
TParameters::IsStore_u_raw
bool IsStore_u_raw() const
Is -u or –u_raw specified at the command line?
Definition: Parameters.h:250
p_max_NAME
TMatrixName p_max_NAME
p_max variable name
Definition: MatrixNames.h:271
TOutputStreamContainer::FreeStreams
void FreeStreams()
Free all streams - destroy them.
Definition: OutputStreamContainer.cpp:355
TMatrixContainer::GetMatrix
T & GetMatrix(const TMatrixIdx matrixIdx)
Get the matrix with a specific type from the container.
Definition: MatrixContainer.h:144
Parameters.h
The header file containing the parameters of the simulation.
TOutputStreamContainer::AddStreams
void AddStreams(TMatrixContainer &matrixContainer)
Add all streams into the container.
Definition: OutputStreamContainer.cpp:66
TMatrixName
const std::string TMatrixName
Datatype for matrix names.
Definition: MatrixNames.h:45
TBaseOutputHDF5Stream::MIN
store minimum
Definition: BaseOutputHDF5Stream.h:63
TOutputStreamContainer::CreateNewOutputStream
TBaseOutputHDF5Stream * CreateNewOutputStream(TMatrixContainer &matrixContainer, const TMatrixIdx sampledMatrixIdx, const TMatrixName &fileDatasetName, const TBaseOutputHDF5Stream::TReduceOperator reduceOp)
Create a new output stream.
Definition: OutputStreamContainer.cpp:385
uy_NAME
TMatrixName uy_NAME
uy variable name
Definition: MatrixNames.h:197
TParameters::IsStore_u_rms
bool IsStore_u_rms() const
Is –u_raw specified at the command line?
Definition: Parameters.h:254
uy_min_all_NAME
TMatrixName uy_min_all_NAME
uy_min_all variable name
Definition: MatrixNames.h:310
TParameters::IsStore_p_raw
bool IsStore_p_raw() const
Is -p or –p_raw specified at the command line?
Definition: Parameters.h:235
TParameters::IsStore_p_rms
bool IsStore_p_rms() const
Is –p_rms specified at the command line?
Definition: Parameters.h:237
TParameters::IsStore_p_min_all
bool IsStore_p_min_all() const
Is –p_min_all specified at the command line?
Definition: Parameters.h:245
TParameters::IsStore_p_min
bool IsStore_p_min() const
Is –p_min specified at the command line?
Definition: Parameters.h:241
TIndexOutputHDF5Stream
Output stream for quantities sampled by an index sensor mask.
Definition: IndexOutputHDF5Stream.h:47
TParameters::IsStore_u_non_staggered_raw
bool IsStore_u_non_staggered_raw() const
Is –u_non_staggered_raw set?
Definition: Parameters.h:252
TParameters::IsStore_u_min_all
bool IsStore_u_min_all() const
Is –u_min_all specified at the command line?
Definition: Parameters.h:262
TParameters
Class storing all parameters of the simulation.
Definition: Parameters.h:49
uz_max_all_NAME
TMatrixName uz_max_all_NAME
uz_max_all variable name
Definition: MatrixNames.h:306
uz_NAME
TMatrixName uz_NAME
uz variable name
Definition: MatrixNames.h:199
WholeDomainOutputHDF5Stream.h
The header file of the class saving whole RealMatrix into the output HDF5 file, e.g. p_max_all.
TOutputStreamContainer::SampleStreams
void SampleStreams()
Sample all streams (only sample, no disk operations).
Definition: OutputStreamContainer.cpp:277
TBaseOutputHDF5Stream::TReduceOperator
TReduceOperator
How to aggregate data.
Definition: BaseOutputHDF5Stream.h:54
uz_rms_NAME
TMatrixName uz_rms_NAME
uz_rms variable name
Definition: MatrixNames.h:286
ux_min_all_NAME
TMatrixName ux_min_all_NAME
ux_min_all variable name
Definition: MatrixNames.h:308
TOutputStreamContainer::ReopenStreams
void ReopenStreams()
Reopen streams after checkpoint file (datasets).
Definition: OutputStreamContainer.cpp:260
TBaseOutputHDF5Stream::NONE
store actual data (time series)
Definition: BaseOutputHDF5Stream.h:57
TMatrixIdx
TMatrixIdx
Matrix identifers of all matrices in the k-space code, names based on the Matlab notation.
Definition: MatrixContainer.h:55
TBaseOutputHDF5Stream
Abstract base class for output data streams (sampled data).
Definition: BaseOutputHDF5Stream.h:46
TMatrixContainer
Class implementing the matrix container.
Definition: MatrixContainer.h:96
TOutputStreamContainer::FlushRawStreams
void FlushRawStreams()
Flush streams to disk - only raw streams.
Definition: OutputStreamContainer.cpp:294
uy_max_all_NAME
TMatrixName uy_max_all_NAME
uy_max_all variable name
Definition: MatrixNames.h:304
TRealMatrix
The class for real matrices.
Definition: RealMatrix.h:45
TOutputStreamContainer::outputStreamContainer
TOutputStreamMap outputStreamContainer
Map with output streams.
Definition: OutputStreamContainer.h:157
uy_max_NAME
TMatrixName uy_max_NAME
uy_max variable name
Definition: MatrixNames.h:291
TParameters::IsStore_p_max_all
bool IsStore_p_max_all() const
Is –p_max_all specified at the command line?
Definition: Parameters.h:243
TOutputStreamContainer::CheckpointStreams
void CheckpointStreams()
Checkpoint streams.
Definition: OutputStreamContainer.cpp:309
TIndexMatrix
The class for 64b unsigned integers (indices). It is used for sensor_mask_index or sensor_corners_mas...
Definition: IndexMatrix.h:46
IndexOutputHDF5Stream.h
The header file of the class saving data based on the index senor mask into the output HDF5 file...
ux_min_NAME
TMatrixName ux_min_NAME
ux_min variable name
Definition: MatrixNames.h:295
TOutputStreamContainer::~TOutputStreamContainer
~TOutputStreamContainer()
Destructor.
Definition: OutputStreamContainer.cpp:53
ux_NAME
TMatrixName ux_NAME
ux variable name
Definition: MatrixNames.h:195
TParameters::IsStore_u_max
bool IsStore_u_max() const
Is –u_max specified at the command line?
Definition: Parameters.h:256
TBaseOutputHDF5Stream::MAX
store maximum
Definition: BaseOutputHDF5Stream.h:61
TParameters::IsStore_u_max_all
bool IsStore_u_max_all() const
Is –u_max_all specified at the command line?
Definition: Parameters.h:260
TParameters::IsStore_p_max
bool IsStore_p_max() const
Is –p_max specified at the command line?
Definition: Parameters.h:239
p_min_NAME
TMatrixName p_min_NAME
p_min variable name
Definition: MatrixNames.h:273
CuboidOutputHDF5Stream.h
The header file of classes responsible for storing output quantities based on the cuboid sensor mask ...
OutputStreamContainer.h
The header file defining the output stream container.
TOutputStreamContainer::CreateStreams
void CreateStreams()
Create all streams - opens the datasets.
Definition: OutputStreamContainer.cpp:245
ux_rms_NAME
TMatrixName ux_rms_NAME
ux_rms variable name
Definition: MatrixNames.h:282
uz_min_NAME
TMatrixName uz_min_NAME
uz_min variable name
Definition: MatrixNames.h:299
uz_non_staggered_NAME
TMatrixName uz_non_staggered_NAME
uz_non_staggered variable name
Definition: MatrixNames.h:213
p_min_all_NAME
TMatrixName p_min_all_NAME
p_min_all variable name
Definition: MatrixNames.h:277
uy_min_NAME
TMatrixName uy_min_NAME
uy_min variable name
Definition: MatrixNames.h:297
TOutputStreamContainer::CloseStreams
void CloseStreams()
Close all streams.
Definition: OutputStreamContainer.cpp:340
p_max_all_NAME
TMatrixName p_max_all_NAME
p_max_all variable name
Definition: MatrixNames.h:275
ux_max_NAME
TMatrixName ux_max_NAME
ux_max variable name
Definition: MatrixNames.h:289
uy_non_staggered_NAME
TMatrixName uy_non_staggered_NAME
uy_non_staggered variable name
Definition: MatrixNames.h:211
TParameters::Get_sensor_mask_type
TSensorMaskType Get_sensor_mask_type() const
Get sensor mask type (linear or corners).
Definition: Parameters.h:166
p_NAME
TMatrixName p_NAME
p variable name
Definition: MatrixNames.h:186
TParameters::GetOutputFile
THDF5_File & GetOutputFile()
Get output file handle.
Definition: Parameters.h:83
ux_non_staggered_NAME
TMatrixName ux_non_staggered_NAME
ux_non_staggered variable name
Definition: MatrixNames.h:209
TOutputStreamContainer::PostProcessStreams
void PostProcessStreams()
Post-process all streams and flush them to the file.
Definition: OutputStreamContainer.cpp:324