PLUTO
Functions
write_data.c File Reference

Main output driver. More...

#include "pluto.h"
Include dependency graph for write_data.c:

Go to the source code of this file.

Functions

static void BOV_Header (Output *output, char *fdata)
 
void WriteData (const Data *d, Output *output, Grid *grid)
 
void GetCGSUnits (double *u)
 

Detailed Description

Main output driver.

WriteData() is the main driver for writing data arrays in any of the available formats (binary, VTK, HDF5, etc...).

  • For .dbl, .flt or .vtk file formats, access to binary files is provided by the functions in bin_io.c.
  • HDF5 files are handled by hdf5_io.c.
  • image files are handled by write_img.c
  • tabulated ascii files are handled by write_tab.c

This function also updates the corresponding .out file associated with the output data format.

Authors
A. Mignone (migno.nosp@m.ne@p.nosp@m.h.uni.nosp@m.to.i.nosp@m.t)
G. Muscianisi (g.mus.nosp@m.cian.nosp@m.isi@c.nosp@m.inec.nosp@m.a.it)
Date
Aug 24, 2012

Definition in file write_data.c.

Function Documentation

void BOV_Header ( Output *  output,
char *  fdata 
)
static

Definition at line 590 of file write_data.c.

591 {
592  int nv, nvar;
593  char filename[256];
594  FILE *fp;
595 
596  if (prank != 0) return;
597 
598 /* -- count number of variables -- */
599 
600  nvar = 0;
601  for (nv = 0; nv < output->nvar; nv++){
602  if (!output->dump_var[nv]) continue;
603  nvar++;
604  }
605 
606  sprintf (filename,"data.%04d.bov",output->nfile);
607  fp = fopen (filename, "w");
608  fprintf (fp,"TIME: %f\n",g_time);
609  fprintf (fp,"DATA_FILE: %s\n",fdata);
610  fprintf (fp,"DATA_SIZE: %ld %ld %ld\n", NX1, NX2, NX3);
611  fprintf (fp,"DATA_FORMAT: FLOAT\n");
612  fprintf (fp,"VARIABLE: Density\n");
613  fprintf (fp,"DATA_ENDIAN: LITTLE\n");
614  fprintf (fp,"CENETRING: zonal\n");
615  fprintf (fp,"BRICK_ORIGIN: %f %f %f\n",
616  g_domBeg[IDIR], g_domBeg[JDIR], g_domBeg[KDIR]);
617  fprintf (fp, "BRICK_SIZE: %f %f %f\n",
618  g_domEnd[IDIR]-g_domBeg[IDIR],
619  g_domEnd[JDIR]-g_domBeg[JDIR],
620  g_domEnd[KDIR]-g_domBeg[KDIR]);
621 
622  fprintf (fp,"DATA_COMPONENTS: %d\n", 2);
623 
624  fclose(fp);
625 }
NX1
long int NX1
Number of interior zones in the X1 directions (boundaries excluded) for the local processor...
Definition: globals.h:48
OUTPUT::nfile
int nfile
current number being saved - one per output
Definition: structs.h:237
prank
int prank
Processor rank.
Definition: globals.h:33
KDIR
#define KDIR
Definition: pluto.h:195
NX2
long int NX2
Number of interior zones in the X2 directions (boundaries excluded) for the local processor...
Definition: globals.h:50
IDIR
#define IDIR
Definition: pluto.h:193
OUTPUT::nvar
int nvar
tot.
Definition: structs.h:234
g_domBeg
double g_domBeg[3]
Lower limits of the computational domain.
Definition: globals.h:125
OUTPUT::dump_var
int * dump_var
select vars being written - one per output
Definition: structs.h:240
g_time
double g_time
The current integration time.
Definition: globals.h:117
fp
FILE * fp
Definition: analysis.c:7
g_domEnd
double g_domEnd[3]
Upper limits of the computational domain.
Definition: globals.h:126
JDIR
#define JDIR
Definition: pluto.h:194
NX3
long int NX3
Number of interior zones in the X3 directions (boundaries excluded) for the local processor...
Definition: globals.h:52
void GetCGSUnits ( double *  u)

Compute an array of c.g.s units

Parameters
[in]uan array containing the c.g.s units of the primitive variables, e.g., u[RHO] will be in gr/cm^3, u[VX1] will be in cm/s, etc...

Definition at line 557 of file write_data.c.

566 {
567  int nv;
568  double unit_velocity = UNIT_VELOCITY;
569  double unit_pressure = UNIT_DENSITY*UNIT_VELOCITY*UNIT_VELOCITY;
570  double unit_mag = UNIT_VELOCITY*sqrt(4.0*CONST_PI*UNIT_DENSITY);
571 
572  #if PHYSICS == RHD || PHYSICS == RMHD
573  unit_velocity = CONST_c;
574  #endif
575 
576  u[RHO] = UNIT_DENSITY;
577  EXPAND(u[VX1] = unit_velocity; ,
578  u[VX2] = unit_velocity; ,
579  u[VX3] = unit_velocity;)
580  #if PHYSICS == MHD || PHYSICS == RMHD
581  EXPAND(u[BX1] = unit_mag; ,
582  u[BX2] = unit_mag; ,
583  u[BX3] = unit_mag;)
584  #endif
585  #if HAVE_ENERGY
586  u[PRS] = unit_pressure;
587  #endif
588 }
UNIT_DENSITY
#define UNIT_DENSITY
Unit density in gr/cm^3.
Definition: pluto.h:369
VX2
#define VX2
Definition: mod_defs.h:29
RHO
#define RHO
Definition: mod_defs.h:19
CONST_c
#define CONST_c
Speed of Light.
Definition: pluto.h:255
VX1
#define VX1
Definition: mod_defs.h:28
UNIT_VELOCITY
#define UNIT_VELOCITY
Unit velocity in cm/sec.
Definition: pluto.h:377
PHYSICS
#define PHYSICS
Definition: definitions_01.h:1
MHD
#define MHD
Definition: pluto.h:111
BX3
#define BX3
Definition: mod_defs.h:27
BX1
#define BX1
Definition: mod_defs.h:25
VX3
#define VX3
Definition: mod_defs.h:30
CONST_PI
#define CONST_PI
.
Definition: pluto.h:269
BX2
#define BX2
Definition: mod_defs.h:26
RMHD
#define RMHD
Definition: pluto.h:112
HAVE_ENERGY
#define HAVE_ENERGY
Definition: pluto.h:395

Here is the caller graph for this function:

void WriteData ( const Data *  d,
Output *  output,
Grid *  grid 
)

Write data to disk using any of the available formats.

Parameters
[in]dpointer to PLUTO Data structre
[in]outputthe output structure corresponding to a given format
[in]gridpointer to an array of Grid structures
  • DBL output: Double-precision data files can be written using single or multiple file mode.
    • for single file, serial: we open the file just once before the main variable loop, dump variables and then close.
    • for single file, parallel the distributed array descriptor sz is different for cell-centered or staggered data type and we thus have to open and close the file after each variable has been dumped.
    • when writing multiple files we open, write to and close the file one each loop cycle.
      Note
      In all cases, the pointer to the data array that has to be written must be cast into (void *) and the starting index of the array must be zero.
  • VTK output: in order to enable parallel writing, files must be closed and opened again for scalars, since the distributed array descriptors used by ArrayLib (Float_Vect) and (float) are different. This is done using the AL_Get_offset() and AL_Set_offset() functions.

Definition at line 29 of file write_data.c.

38 {
39  int i, j, k, nv;
40  int single_file;
41  size_t dsize;
42  char filename[512], sline[512];
43  static int last_computed_var = -1;
44  double units[MAX_OUTPUT_VARS];
45  float ***Vpt3;
46  void *Vpt;
47  FILE *fout, *fbin;
48  time_t tbeg, tend;
49  long long offset;
50 
51 /* -----------------------------------------------------------
52  Increment the file number and initialize units
53  ----------------------------------------------------------- */
54 
55  output->nfile++;
56 
57  print1 ("> Writing file #%d (%s) to disk...", output->nfile, output->ext);
58 
59  #ifdef PARALLEL
60  MPI_Barrier (MPI_COMM_WORLD);
61  if (prank == 0) time(&tbeg);
62  #endif
63 
64  for (nv = 0; nv < MAX_OUTPUT_VARS; nv++) units[nv] = 1.0;
65  if (output->cgs) GetCGSUnits(units);
66 
67 /* --------------------------------------------------------
68  Get user var if necessary
69  -------------------------------------------------------- */
70 
71  if (last_computed_var != g_stepNumber && d->Vuser != NULL) {
72  ComputeUserVar (d, grid);
73  last_computed_var = g_stepNumber;
74  }
75 
76 /* --------------------------------------------------------
77  Select the output type
78  -------------------------------------------------------- */
79 
80  if (output->type == DBL_OUTPUT) {
81 
82  /* ------------------------------------------------------------------- */
83  /*! - \b DBL output:
84  Double-precision data files can be written using single or
85  multiple file mode.
86  - for single file, serial: we open the file just once before
87  the main variable loop, dump variables and then close.
88  - for single file, parallel the distributed array descriptor sz is
89  different for cell-centered or staggered data type and we
90  thus have to open and close the file after each variable
91  has been dumped.
92  - when writing multiple files we open, write to and close the
93  file one each loop cycle.
94  \note In all cases, the pointer to the data array that has to be
95  written must be cast into (void *) and the starting index of
96  the array must be zero.
97  */
98  /* ------------------------------------------------------------------- */
99 
100  int sz;
101  single_file = strcmp(output->mode,"single_file") == 0;
102  dsize = sizeof(double);
103 
104  if (single_file){ /* -- single output file -- */
105 
106  sprintf (filename, "%s/data.%04d.%s", output->dir,output->nfile,
107  output->ext);
108  offset = 0;
109  #ifndef PARALLEL
110  fbin = OpenBinaryFile (filename, 0, "w");
111  #endif
112  for (nv = 0; nv < output->nvar; nv++) {
113  if (!output->dump_var[nv]) continue;
114 
115  if (output->stag_var[nv] == -1) { /* -- cell-centered data -- */
116  sz = SZ;
117  Vpt = (void *)output->V[nv][0][0];
118  } else if (output->stag_var[nv] == 0) { /* -- x-staggered data -- */
119  sz = SZ_stagx;
120  Vpt = (void *)(output->V[nv][0][0]-1);
121  } else if (output->stag_var[nv] == 1) { /* -- y-staggered data -- */
122  sz = SZ_stagy;
123  Vpt = (void *)output->V[nv][0][-1];
124  } else if (output->stag_var[nv] == 2) { /* -- z-staggered data -- */
125  sz = SZ_stagz;
126  Vpt = (void *)output->V[nv][-1][0];
127  }
128  #ifdef PARALLEL
129  fbin = OpenBinaryFile (filename, sz, "w");
130  AL_Set_offset(sz, offset);
131  #endif
132  WriteBinaryArray (Vpt, dsize, sz, fbin, output->stag_var[nv]);
133  #ifdef PARALLEL
134  offset = AL_Get_offset(sz);
135  CloseBinaryFile(fbin, sz);
136  #endif
137  }
138  #ifndef PARALLEL
139  CloseBinaryFile(fbin, sz);
140  #endif
141 
142  }else{ /* -- multiple files -- */
143 
144  for (nv = 0; nv < output->nvar; nv++) {
145  if (!output->dump_var[nv]) continue;
146  sprintf (filename, "%s/%s.%04d.%s", output->dir, output->var_name[nv],
147  output->nfile, output->ext);
148 
149  if (output->stag_var[nv] == -1) { /* -- cell-centered data -- */
150  sz = SZ;
151  Vpt = (void *)output->V[nv][0][0];
152  } else if (output->stag_var[nv] == 0) { /* -- x-staggered data -- */
153  sz = SZ_stagx;
154  Vpt = (void *)(output->V[nv][0][0]-1);
155  } else if (output->stag_var[nv] == 1) { /* -- y-staggered data -- */
156  sz = SZ_stagy;
157  Vpt = (void *)output->V[nv][0][-1];
158  } else if (output->stag_var[nv] == 2) { /* -- z-staggered data -- */
159  sz = SZ_stagz;
160  Vpt = (void *)output->V[nv][-1][0];
161  }
162  fbin = OpenBinaryFile (filename, sz, "w");
163  WriteBinaryArray (Vpt, dsize, sz, fbin, output->stag_var[nv]);
164  CloseBinaryFile (fbin, sz);
165  }
166  }
167 
168  } else if (output->type == FLT_OUTPUT) {
169 
170  /* ----------------------------------------------------------
171  FLT output for cell-centered data
172  ---------------------------------------------------------- */
173 
174  single_file = strcmp(output->mode,"single_file") == 0;
175 
176  if (single_file){ /* -- single output file -- */
177  sprintf (filename, "%s/data.%04d.%s", output->dir, output->nfile,
178  output->ext);
179  fbin = OpenBinaryFile (filename, SZ_float, "w");
180  for (nv = 0; nv < output->nvar; nv++) {
181  if (!output->dump_var[nv]) continue;
182 /* Vpt = (void *)(Convert_dbl2flt(output->V[nv],0))[0][0]; */
183  Vpt3 = Convert_dbl2flt(output->V[nv], units[nv],0);
184  Vpt = (void *)Vpt3[0][0];
185  WriteBinaryArray (Vpt, sizeof(float), SZ_float, fbin,
186  output->stag_var[nv]);
187  }
188  CloseBinaryFile(fbin, SZ_float);
189 /*
190 BOV_Header(output, filename);
191 */
192  }else{ /* -- multiple files -- */
193 
194  for (nv = 0; nv < output->nvar; nv++) {
195  if (!output->dump_var[nv]) continue;
196  sprintf (filename, "%s/%s.%04d.%s", output->dir, output->var_name[nv],
197  output->nfile, output->ext);
198 
199  fbin = OpenBinaryFile (filename, SZ_float, "w");
200 /* Vpt = (void *)(Convert_dbl2flt(output->V[nv],0))[0][0]; */
201  Vpt3 = Convert_dbl2flt(output->V[nv], units[nv],0);
202  Vpt = (void *)Vpt3[0][0];
203  WriteBinaryArray (Vpt, sizeof(float), SZ_float, fbin,
204  output->stag_var[nv]);
205  CloseBinaryFile (fbin, SZ_float);
206  }
207  }
208 
209  }else if (output->type == DBL_H5_OUTPUT || output->type == FLT_H5_OUTPUT){
210 
211  /* ------------------------------------------------------
212  HDF5 (static grid) output (single/double precision)
213  ------------------------------------------------------ */
214 
215  #ifdef USE_HDF5
216  single_file = YES;
217  WriteHDF5 (output, grid);
218  #else
219  print1 ("! WriteData: HDF5 library not available\n");
220  return;
221  #endif
222 
223  }else if (output->type == VTK_OUTPUT) {
224 
225  /* ------------------------------------------------------------------- */
226  /*! - \b VTK output:
227  in order to enable parallel writing, files must be closed and
228  opened again for scalars, since the distributed array descriptors
229  used by ArrayLib (Float_Vect) and (float) are different. This is
230  done using the AL_Get_offset() and AL_Set_offset() functions. */
231  /* ------------------------------------------------------------------- */
232 
233  single_file = strcmp(output->mode,"single_file") == 0;
234  sprintf (filename, "%s/data.%04d.%s", output->dir, output->nfile,
235  output->ext);
236 
237  if (single_file){ /* -- single output file -- */
238 
239  fbin = OpenBinaryFile(filename, SZ_Float_Vect, "w");
240  WriteVTK_Header(fbin, grid);
241  for (nv = 0; nv < output->nvar; nv++) { /* -- write vectors -- */
242  if (output->dump_var[nv] != VTK_VECTOR) continue;
243  WriteVTK_Vector (fbin, output->V + nv, units[nv],
244  output->var_name[nv], grid);
245  }
246 
247  #ifdef PARALLEL
248  offset = AL_Get_offset(SZ_Float_Vect);
249  CloseBinaryFile(fbin, SZ_Float_Vect);
250  fbin = OpenBinaryFile(filename, SZ_float, "w");
251  AL_Set_offset(SZ_float, offset);
252  #endif
253 
254  for (nv = 0; nv < output->nvar; nv++) { /* -- write scalars -- */
255  if (output->dump_var[nv] != YES) continue;
256  WriteVTK_Scalar (fbin, output->V[nv], units[nv],
257  output->var_name[nv], grid);
258  }
259  CloseBinaryFile(fbin, SZ_float);
260 
261  }else{ /* -- multiple output files -- */
262 
263  for (nv = 0; nv < output->nvar; nv++) { /* -- write vectors -- */
264  if (output->dump_var[nv] != VTK_VECTOR) continue;
265  if (strcmp(output->var_name[nv],"vx1") == 0) {
266  sprintf (filename, "%s/vfield.%04d.%s", output->dir, output->nfile,
267  output->ext);
268  }else if (strcmp(output->var_name[nv],"bx1") == 0) {
269  sprintf (filename, "%s/bfield.%04d.%s", output->dir, output->nfile,
270  output->ext);
271  }else{
272  print1 ("! WriteData: unknown vector type in VTK output\n");
273  QUIT_PLUTO(1);
274  }
275 
276  fbin = OpenBinaryFile(filename, SZ_Float_Vect, "w");
277  WriteVTK_Header(fbin, grid);
278  WriteVTK_Vector(fbin, output->V + nv, units[nv],
279  output->var_name[nv], grid);
280  CloseBinaryFile(fbin, SZ_Float_Vect);
281  }
282 
283  for (nv = 0; nv < output->nvar; nv++) { /* -- write scalars -- */
284  if (output->dump_var[nv] != YES) continue;
285  sprintf (filename, "%s/%s.%04d.%s", output->dir, output->var_name[nv],
286  output->nfile, output->ext);
287  fbin = OpenBinaryFile(filename, SZ_Float_Vect, "w");
288  WriteVTK_Header(fbin, grid);
289  #ifdef PARALLEL
290  offset = AL_Get_offset(SZ_Float_Vect);
291  CloseBinaryFile(fbin, SZ_Float_Vect);
292  fbin = OpenBinaryFile(filename, SZ_float, "w");
293  AL_Set_offset(SZ_float, offset);
294  #endif
295  WriteVTK_Scalar(fbin, output->V[nv], units[nv],
296  output->var_name[nv], grid);
297  CloseBinaryFile (fbin, SZ_float);
298  }
299  }
300 
301  }else if (output->type == TAB_OUTPUT) {
302 
303  /* ------------------------------------------------------
304  Tabulated (ASCII) output
305  ------------------------------------------------------ */
306 
307  single_file = YES;
308  sprintf (filename,"%s/data.%04d.%s", output->dir, output->nfile,
309  output->ext);
310  WriteTabArray (output, filename, grid);
311 
312  }else if (output->type == PPM_OUTPUT) {
313 
314  /* ------------------------------------------------------
315  PPM output
316  ------------------------------------------------------ */
317 
318  single_file = NO;
319  for (nv = 0; nv < output->nvar; nv++) {
320  if (!output->dump_var[nv]) continue;
321  sprintf (filename, "%s/%s.%04d.%s", output->dir, output->var_name[nv],
322  output->nfile, output->ext);
323  WritePPM (output->V[nv], output->var_name[nv], filename, grid);
324  }
325 
326  }else if (output->type == PNG_OUTPUT) {
327 
328  /* ------------------------------------------------------
329  PNG output
330  ------------------------------------------------------ */
331 
332  #ifdef USE_PNG
333  single_file = NO;
334  for (nv = 0; nv < output->nvar; nv++) {
335  if (!output->dump_var[nv]) continue;
336  sprintf (filename, "%s/%s.%04d.%s", output->dir, output->var_name[nv],
337  output->nfile, output->ext);
338  WritePNG (output->V[nv], output->var_name[nv], filename, grid);
339  }
340  #else
341  print1 ("! PNG library not available\n");
342  return;
343  #endif
344 
345  }
346 
347 /* -------------------------------------------------------------
348  Update corresponding ".out" file
349  ------------------------------------------------------------- */
350 
351  sprintf (filename,"%s/%s.out",output->dir, output->ext);
352 
353  if (prank == 0) {
354  if (output->nfile == 0) {
355  fout = fopen (filename, "w");
356  }else {
357  fout = fopen (filename, "r+");
358  for (nv = 0; nv < output->nfile; nv++) fgets (sline, 512, fout);
359  fseek (fout, ftell(fout), SEEK_SET);
360  }
361 
362  /* -- write a multi-column file -- */
363 
364  fprintf (fout, "%d %12.6e %12.6e %ld ",
365  output->nfile, g_time, g_dt, g_stepNumber);
366 
367  if (single_file) fprintf (fout,"single_file ");
368  else fprintf (fout,"multiple_files ");
369 
370  if (IsLittleEndian()) fprintf (fout, "little ");
371  else fprintf (fout, "big ");
372 
373  for (nv = 0; nv < output->nvar; nv++) {
374  if (output->dump_var[nv]) fprintf (fout, "%s ", output->var_name[nv]);
375  }
376 
377  fprintf (fout,"\n");
378  fclose (fout);
379  }
380 
381  #ifdef PARALLEL
382  MPI_Barrier (MPI_COMM_WORLD);
383  if (prank == 0){
384  time(&tend);
385  print1 (" [%5.2f sec]",difftime(tend,tbeg));
386  }
387  #endif
388  print1 ("\n");
389 
390 }
WritePNG
void WritePNG(double ***, char *, char *, Grid *)
FLT_H5_OUTPUT
#define FLT_H5_OUTPUT
Definition: pluto.h:83
PPM_OUTPUT
#define PPM_OUTPUT
Definition: pluto.h:85
OUTPUT::V
double *** V[64]
pointer to arrays being written - same for all
Definition: structs.h:247
AL_Get_offset
long long AL_Get_offset(int sz_ptr)
Definition: al_io.c:327
VTK_VECTOR
#define VTK_VECTOR
Definition: pluto.h:88
print1
void print1(const char *fmt,...)
Definition: amrPluto.cpp:511
OpenBinaryFile
FILE * OpenBinaryFile(char *filename, int sz, char *mode)
Definition: bin_io.c:31
OUTPUT::nfile
int nfile
current number being saved - one per output
Definition: structs.h:237
SZ_float
int SZ_float
Definition: globals.h:27
YES
#define YES
Definition: pluto.h:25
GetCGSUnits
void GetCGSUnits(double *u)
Definition: write_data.c:557
g_dt
double g_dt
The current integration time step.
Definition: globals.h:118
AL_Set_offset
int AL_Set_offset(int sz_ptr, long long offset)
Definition: al_io.c:342
WriteVTK_Scalar
void WriteVTK_Scalar(FILE *, double ***, double, char *, Grid *)
Definition: write_vtk.c:341
WriteHDF5
void WriteHDF5(Output *output, Grid *grid)
Definition: hdf5_io.c:45
OUTPUT::dir
char dir[256]
output directory name
Definition: structs.h:244
WriteVTK_Vector
void WriteVTK_Vector(FILE *, Data_Arr, double, char *, Grid *)
Definition: write_vtk.c:259
prank
int prank
Processor rank.
Definition: globals.h:33
WriteVTK_Header
void WriteVTK_Header(FILE *, Grid *)
Definition: write_vtk.c:91
Convert_dbl2flt
float *** Convert_dbl2flt(double ***Vdbl, double unit, int swap_endian)
Definition: bin_io.c:216
OUTPUT::cgs
int cgs
when set to 1 saves data in c.g.s units
Definition: structs.h:236
SZ_stagx
int SZ_stagx
Definition: globals.h:24
SZ_stagy
int SZ_stagy
Definition: globals.h:25
OUTPUT::ext
char ext[8]
output extension
Definition: structs.h:243
SZ_Float_Vect
int SZ_Float_Vect
Definition: globals.h:29
ComputeUserVar
void ComputeUserVar(const Data *, Grid *)
Definition: userdef_output.c:4
SZ
struct szz SZ
g_stepNumber
long int g_stepNumber
Gives the current integration step number.
Definition: globals.h:97
VTK_OUTPUT
#define VTK_OUTPUT
Definition: pluto.h:81
DBL_H5_OUTPUT
#define DBL_H5_OUTPUT
Definition: pluto.h:82
WritePPM
void WritePPM(double ***, char *, char *, Grid *)
Definition: write_img.c:10
j
int j
Definition: analysis.c:2
IsLittleEndian
int IsLittleEndian(void)
Definition: tools.c:40
SZ_stagz
int SZ_stagz
Definition: globals.h:26
k
int k
Definition: analysis.c:2
OUTPUT::nvar
int nvar
tot.
Definition: structs.h:234
OUTPUT::dump_var
int * dump_var
select vars being written - one per output
Definition: structs.h:240
TAB_OUTPUT
#define TAB_OUTPUT
Definition: pluto.h:84
FLT_OUTPUT
#define FLT_OUTPUT
Definition: pluto.h:80
MAX_OUTPUT_VARS
#define MAX_OUTPUT_VARS
Definition: pluto.h:96
i
int i
Definition: analysis.c:2
g_time
double g_time
The current integration time.
Definition: globals.h:117
DBL_OUTPUT
#define DBL_OUTPUT
Definition: pluto.h:79
OUTPUT::mode
char mode[32]
single or multiple files - one per output
Definition: structs.h:241
OUTPUT::type
int type
output format (DBL, FLT, ...) - one per output
Definition: structs.h:233
OUTPUT::stag_var
int * stag_var
centered or staggered variable - same for all
Definition: structs.h:239
WriteTabArray
void WriteTabArray(Output *, char *, Grid *)
Definition: write_tab.c:31
DATA::Vuser
double **** Vuser
Array storing user-defined supplementary variables written to disk.
Definition: structs.h:49
CloseBinaryFile
int CloseBinaryFile(FILE *fbin, int sz)
Definition: bin_io.c:78
QUIT_PLUTO
#define QUIT_PLUTO(e_code)
Definition: macros.h:125
WriteBinaryArray
void WriteBinaryArray(void *V, size_t dsize, int sz, FILE *fl, int istag)
Definition: bin_io.c:98
PNG_OUTPUT
#define PNG_OUTPUT
Definition: pluto.h:86
OUTPUT::var_name
char ** var_name
variable names - same for all
Definition: structs.h:242
NO
#define NO
Definition: pluto.h:26

Here is the call graph for this function:

Here is the caller graph for this function: