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
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
/* -*- c++ -*- ----------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
Copyright (2003) Sandia Corporation. Under the terms of Contract
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
certain rights in this software. This software is distributed under
the GNU General Public License.
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#ifndef LMP_DUMP_H
#define LMP_DUMP_H
#include "pointers.h" // IWYU pragma: export
namespace LAMMPS_NS {
class Dump : protected Pointers {
public:
char *id; // user-defined name of Dump
char *style; // style of Dump
char *filename; // user-specified file
int igroup,groupbit; // group that Dump is performed on
int first_flag; // 0 if no initial dump, 1 if yes initial dump
int clearstep; // 1 if dump invokes computes, 0 if not
int comm_forward; // size of forward communication (0 if none)
int comm_reverse; // size of reverse communication (0 if none)
#if defined(LMP_QSORT)
// static variable across all Dump objects
static Dump *dumpptr; // holds a ptr to Dump currently being used
#endif
Dump(class LAMMPS *, int, char **);
virtual ~Dump();
void init();
virtual void write();
virtual int pack_forward_comm(int, int *, double *, int, int *) {return 0;}
virtual void unpack_forward_comm(int, int, double *) {}
virtual int pack_reverse_comm(int, int, double *) {return 0;}
virtual void unpack_reverse_comm(int, int *, double *) {}
void modify_params(int, char **);
virtual bigint memory_usage();
protected:
int me,nprocs; // proc info
int compressed; // 1 if dump file is written compressed, 0 no
int binary; // 1 if dump file is written binary, 0 no
int multifile; // 0 = one big file, 1 = one file per timestep
int multiproc; // 0 = proc 0 writes for all,
// else # of procs writing files
int nclusterprocs; // # of procs in my cluster that write to one file
int filewriter; // 1 if this proc writes a file, else 0
int fileproc; // ID of proc in my cluster who writes to file
char *multiname; // filename with % converted to cluster ID
MPI_Comm clustercomm; // MPI communicator within my cluster of procs
int header_flag; // 0 = item, 2 = xyz
int flush_flag; // 0 if no flush, 1 if flush every dump
int sort_flag; // 1 if sorted output
int append_flag; // 1 if open file in append mode, 0 if not
int buffer_allow; // 1 if style allows for buffer_flag, 0 if not
int buffer_flag; // 1 if buffer output as one big string, 0 if not
int padflag; // timestep padding in filename
int pbcflag; // 1 if remap dumped atoms via PBC, 0 if not
int singlefile_opened; // 1 = one big file, already opened, else 0
int sortcol; // 0 to sort on ID, 1-N on columns
int sortcolm1; // sortcol - 1
int sortorder; // ASCEND or DESCEND
int delay_flag; // 1 if delay output until delaystep
bigint delaystep;
int refreshflag; // 1 if dump_modify refresh specified
char *refresh; // compute ID to invoke refresh() on
int irefresh; // index of compute
char boundstr[9]; // encoding of boundary flags
char *format; // format string for the file write
char *format_default; // default format string
char *format_line_user; // user-specified format strings
char *format_float_user;
char *format_int_user;
char *format_bigint_user;
char **format_column_user;
enum{INT,DOUBLE,STRING,BIGINT};
FILE *fp; // file to write dump to
int size_one; // # of quantities for one atom
int nme; // # of atoms in this dump from me
int nsme; // # of chars in string output from me
double boxxlo,boxxhi; // local copies of domain values
double boxylo,boxyhi; // lo/hi are bounding box for triclinic
double boxzlo,boxzhi;
double boxxy,boxxz,boxyz;
int maxfiles; // max number of files created, -1 == infinite
int numfiles; // number of files in names list
int fileidx; // index of file in names list
char **nameslist; // list of history file names
bigint ntotal; // total # of per-atom lines in snapshot
int reorderflag; // 1 if OK to reorder instead of sort
int ntotal_reorder; // # of atoms that must be in snapshot
int nme_reorder; // # of atoms I must own in snapshot
tagint idlo; // lowest ID I own when reordering
int maxbuf; // size of buf
double *buf; // memory for atom quantities
int maxsbuf; // size of sbuf
char *sbuf; // memory for atom quantities in string format
int maxids; // size of ids
int maxsort; // size of bufsort, idsort, index
int maxproc; // size of proclist
tagint *ids; // list of atom IDs, if sorting on IDs
double *bufsort;
tagint *idsort;
int *index,*proclist;
double **xpbc,**vpbc;
imageint *imagepbc;
int maxpbc;
class Irregular *irregular;
virtual void init_style() = 0;
virtual void openfile();
virtual int modify_param(int, char **) {return 0;}
virtual void write_header(bigint) = 0;
virtual int count();
virtual void pack(tagint *) = 0;
virtual int convert_string(int, double *) {return 0;}
virtual void write_data(int, double *) = 0;
void pbc_allocate();
void sort();
#if defined(LMP_QSORT)
static int idcompare(const void *, const void *);
static int bufcompare(const void *, const void *);
static int bufcompare_reverse(const void *, const void *);
#else
static int idcompare(const int, const int, void *);
static int bufcompare(const int, const int, void *);
static int bufcompare_reverse(const int, const int, void *);
#endif
};
}
#endif
/* ERROR/WARNING messages:
E: Dump file MPI-IO output not allowed with % in filename
This is because a % signifies one file per processor and MPI-IO
creates one large file for all processors.
E: Cannot dump sort when multiple dump files are written
In this mode, each processor dumps its atoms to a file, so
no sorting is allowed.
E: Cannot dump sort on atom IDs with no atom IDs defined
Self-explanatory.
E: Dump sort column is invalid
Self-explanatory.
E: Too many atoms to dump sort
Cannot sort when running with more than 2^31 atoms.
E: Dump could not find refresh compute ID
UNDOCUMENTED
E: Too much per-proc info for dump
Number of local atoms times number of columns must fit in a 32-bit
integer for dump.
E: Too much buffered per-proc info for dump
The size of the buffered string must fit in a 32-bit integer for a
dump.
E: Cannot open gzipped file
LAMMPS was compiled without support for reading and writing gzipped
files through a pipeline to the gzip program with -DLAMMPS_GZIP.
E: Cannot open dump file
Self-explanatory.
E: Illegal ... command
Self-explanatory. Check the input script syntax and compare to the
documentation for the command. You can use -echo screen as a
command-line option when running LAMMPS to see the offending line.
E: Dump_modify buffer yes not allowed for this style
Self-explanatory.
E: Cannot use dump_modify fileper without % in dump file name
Self-explanatory.
E: Cannot use dump_modify nfile without % in dump file name
Self-explanatory.
*/