Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F86995031
dump_custom.cpp
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Wed, Oct 9, 21:16
Size
80 KB
Mime Type
text/x-c
Expires
Fri, Oct 11, 21:16 (1 d, 21 h)
Engine
blob
Format
Raw Data
Handle
21517110
Attached To
rLAMMPS lammps
dump_custom.cpp
View Options
/* ----------------------------------------------------------------------
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.
------------------------------------------------------------------------- */
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "dump_custom.h"
#include "atom.h"
#include "force.h"
#include "domain.h"
#include "region.h"
#include "group.h"
#include "input.h"
#include "variable.h"
#include "update.h"
#include "modify.h"
#include "compute.h"
#include "fix.h"
#include "memory.h"
#include "error.h"
using
namespace
LAMMPS_NS
;
// customize by adding keyword
// also customize compute_atom_property.cpp
enum
{
ID
,
MOL
,
PROC
,
PROCP1
,
TYPE
,
ELEMENT
,
MASS
,
X
,
Y
,
Z
,
XS
,
YS
,
ZS
,
XSTRI
,
YSTRI
,
ZSTRI
,
XU
,
YU
,
ZU
,
XUTRI
,
YUTRI
,
ZUTRI
,
XSU
,
YSU
,
ZSU
,
XSUTRI
,
YSUTRI
,
ZSUTRI
,
IX
,
IY
,
IZ
,
VX
,
VY
,
VZ
,
FX
,
FY
,
FZ
,
Q
,
MUX
,
MUY
,
MUZ
,
MU
,
RADIUS
,
DIAMETER
,
OMEGAX
,
OMEGAY
,
OMEGAZ
,
ANGMOMX
,
ANGMOMY
,
ANGMOMZ
,
TQX
,
TQY
,
TQZ
,
COMPUTE
,
FIX
,
VARIABLE
,
INAME
,
DNAME
};
enum
{
LT
,
LE
,
GT
,
GE
,
EQ
,
NEQ
};
enum
{
INT
,
DOUBLE
,
STRING
,
BIGINT
};
// same as in DumpCFG
#define INVOKED_PERATOM 8
#define ONEFIELD 32
#define DELTA 1048576
/* ---------------------------------------------------------------------- */
DumpCustom
::
DumpCustom
(
LAMMPS
*
lmp
,
int
narg
,
char
**
arg
)
:
Dump
(
lmp
,
narg
,
arg
)
{
if
(
narg
==
5
)
error
->
all
(
FLERR
,
"No dump custom arguments specified"
);
clearstep
=
1
;
nevery
=
force
->
inumeric
(
FLERR
,
arg
[
3
]);
if
(
nevery
<=
0
)
error
->
all
(
FLERR
,
"Illegal dump custom command"
);
// expand args if any have wildcard character "*"
// ok to include trailing optional args,
// so long as they do not have "*" between square brackets
// nfield may be shrunk below if extra optional args exist
expand
=
0
;
nfield
=
nargnew
=
input
->
expand_args
(
narg
-
5
,
&
arg
[
5
],
1
,
earg
);
if
(
earg
!=
&
arg
[
5
])
expand
=
1
;
// allocate field vectors
pack_choice
=
new
FnPtrPack
[
nfield
];
vtype
=
new
int
[
nfield
];
field2index
=
new
int
[
nfield
];
argindex
=
new
int
[
nfield
];
buffer_allow
=
1
;
buffer_flag
=
1
;
iregion
=
-
1
;
idregion
=
NULL
;
nthresh
=
0
;
thresh_array
=
NULL
;
thresh_op
=
NULL
;
thresh_value
=
NULL
;
// computes, fixes, variables which the dump accesses
ncompute
=
0
;
id_compute
=
NULL
;
compute
=
NULL
;
nfix
=
0
;
id_fix
=
NULL
;
fix
=
NULL
;
nvariable
=
0
;
id_variable
=
NULL
;
variable
=
NULL
;
vbuf
=
NULL
;
ncustom
=
0
;
id_custom
=
NULL
;
flag_custom
=
NULL
;
// process attributes
// ioptional = start of additional optional args in expanded args
ioptional
=
parse_fields
(
nfield
,
earg
);
if
(
ioptional
<
nfield
&&
strcmp
(
style
,
"image"
)
!=
0
&&
strcmp
(
style
,
"movie"
)
!=
0
)
error
->
all
(
FLERR
,
"Invalid attribute in dump custom command"
);
// noptional = # of optional args
// reset nfield to subtract off optional args
// reset ioptional to what it would be in original arg list
// only dump image and dump movie styles process optional args,
// they do not use expanded earg list
int
noptional
=
nfield
-
ioptional
;
nfield
-=
noptional
;
size_one
=
nfield
;
ioptional
=
narg
-
noptional
;
// atom selection arrays
maxlocal
=
0
;
choose
=
NULL
;
dchoose
=
NULL
;
clist
=
NULL
;
// default element name for all types = C
ntypes
=
atom
->
ntypes
;
typenames
=
new
char
*
[
ntypes
+
1
];
for
(
int
itype
=
1
;
itype
<=
ntypes
;
itype
++
)
{
typenames
[
itype
]
=
new
char
[
2
];
strcpy
(
typenames
[
itype
],
"C"
);
}
// setup format strings
vformat
=
new
char
*
[
size_one
];
format_default
=
new
char
[
4
*
size_one
+
1
];
format_default
[
0
]
=
'\0'
;
for
(
int
i
=
0
;
i
<
size_one
;
i
++
)
{
if
(
vtype
[
i
]
==
INT
)
strcat
(
format_default
,
"%d "
);
else
if
(
vtype
[
i
]
==
DOUBLE
)
strcat
(
format_default
,
"%g "
);
else
if
(
vtype
[
i
]
==
STRING
)
strcat
(
format_default
,
"%s "
);
else
if
(
vtype
[
i
]
==
BIGINT
)
strcat
(
format_default
,
BIGINT_FORMAT
" "
);
vformat
[
i
]
=
NULL
;
}
format_column_user
=
new
char
*
[
size_one
];
for
(
int
i
=
0
;
i
<
size_one
;
i
++
)
format_column_user
[
i
]
=
NULL
;
// setup column string
int
n
=
0
;
for
(
int
iarg
=
0
;
iarg
<
nfield
;
iarg
++
)
n
+=
strlen
(
earg
[
iarg
])
+
2
;
columns
=
new
char
[
n
];
columns
[
0
]
=
'\0'
;
for
(
int
iarg
=
0
;
iarg
<
nfield
;
iarg
++
)
{
strcat
(
columns
,
earg
[
iarg
]);
strcat
(
columns
,
" "
);
}
}
/* ---------------------------------------------------------------------- */
DumpCustom
::~
DumpCustom
()
{
// if wildcard expansion occurred, free earg memory from expand_args()
// could not do in constructor, b/c some derived classes process earg
if
(
expand
)
{
for
(
int
i
=
0
;
i
<
nargnew
;
i
++
)
delete
[]
earg
[
i
];
memory
->
sfree
(
earg
);
}
delete
[]
pack_choice
;
delete
[]
vtype
;
delete
[]
field2index
;
delete
[]
argindex
;
delete
[]
idregion
;
memory
->
destroy
(
thresh_array
);
memory
->
destroy
(
thresh_op
);
memory
->
destroy
(
thresh_value
);
for
(
int
i
=
0
;
i
<
ncompute
;
i
++
)
delete
[]
id_compute
[
i
];
memory
->
sfree
(
id_compute
);
delete
[]
compute
;
for
(
int
i
=
0
;
i
<
nfix
;
i
++
)
delete
[]
id_fix
[
i
];
memory
->
sfree
(
id_fix
);
delete
[]
fix
;
for
(
int
i
=
0
;
i
<
nvariable
;
i
++
)
delete
[]
id_variable
[
i
];
memory
->
sfree
(
id_variable
);
delete
[]
variable
;
for
(
int
i
=
0
;
i
<
nvariable
;
i
++
)
memory
->
destroy
(
vbuf
[
i
]);
delete
[]
vbuf
;
for
(
int
i
=
0
;
i
<
ncustom
;
i
++
)
delete
[]
id_custom
[
i
];
memory
->
sfree
(
id_custom
);
delete
[]
flag_custom
;
memory
->
destroy
(
choose
);
memory
->
destroy
(
dchoose
);
memory
->
destroy
(
clist
);
for
(
int
i
=
1
;
i
<=
ntypes
;
i
++
)
delete
[]
typenames
[
i
];
delete
[]
typenames
;
for
(
int
i
=
0
;
i
<
size_one
;
i
++
)
delete
[]
vformat
[
i
];
delete
[]
vformat
;
for
(
int
i
=
0
;
i
<
size_one
;
i
++
)
delete
[]
format_column_user
[
i
];
delete
[]
format_column_user
;
delete
[]
columns
;
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
init_style
()
{
// format = copy of default or user-specified line format
delete
[]
format
;
char
*
str
;
if
(
format_line_user
)
str
=
format_line_user
;
else
str
=
format_default
;
int
n
=
strlen
(
str
)
+
1
;
format
=
new
char
[
n
];
strcpy
(
format
,
str
);
// tokenize the format string and add space at end of each format element
// if user-specified int/float format exists, use it instead
// if user-specified column format exists, use it instead
// lo priority = line, medium priority = int/float, hi priority = column
char
*
ptr
;
for
(
int
i
=
0
;
i
<
size_one
;
i
++
)
{
if
(
i
==
0
)
ptr
=
strtok
(
format
,
"
\0
"
);
else
ptr
=
strtok
(
NULL
,
"
\0
"
);
if
(
ptr
==
NULL
)
error
->
all
(
FLERR
,
"Dump_modify format line is too short"
);
delete
[]
vformat
[
i
];
if
(
format_column_user
[
i
])
{
vformat
[
i
]
=
new
char
[
strlen
(
format_column_user
[
i
])
+
2
];
strcpy
(
vformat
[
i
],
format_column_user
[
i
]);
}
else
if
(
vtype
[
i
]
==
INT
&&
format_int_user
)
{
vformat
[
i
]
=
new
char
[
strlen
(
format_int_user
)
+
2
];
strcpy
(
vformat
[
i
],
format_int_user
);
}
else
if
(
vtype
[
i
]
==
DOUBLE
&&
format_float_user
)
{
vformat
[
i
]
=
new
char
[
strlen
(
format_float_user
)
+
2
];
strcpy
(
vformat
[
i
],
format_float_user
);
}
else
if
(
vtype
[
i
]
==
BIGINT
&&
format_bigint_user
)
{
vformat
[
i
]
=
new
char
[
strlen
(
format_bigint_user
)
+
2
];
strcpy
(
vformat
[
i
],
format_bigint_user
);
}
else
{
vformat
[
i
]
=
new
char
[
strlen
(
ptr
)
+
2
];
strcpy
(
vformat
[
i
],
ptr
);
}
vformat
[
i
]
=
strcat
(
vformat
[
i
],
" "
);
}
// setup boundary string
domain
->
boundary_string
(
boundstr
);
// setup function ptrs
if
(
binary
&&
domain
->
triclinic
==
0
)
header_choice
=
&
DumpCustom
::
header_binary
;
else
if
(
binary
&&
domain
->
triclinic
==
1
)
header_choice
=
&
DumpCustom
::
header_binary_triclinic
;
else
if
(
!
binary
&&
domain
->
triclinic
==
0
)
header_choice
=
&
DumpCustom
::
header_item
;
else
if
(
!
binary
&&
domain
->
triclinic
==
1
)
header_choice
=
&
DumpCustom
::
header_item_triclinic
;
if
(
binary
)
write_choice
=
&
DumpCustom
::
write_binary
;
else
if
(
buffer_flag
==
1
)
write_choice
=
&
DumpCustom
::
write_string
;
else
write_choice
=
&
DumpCustom
::
write_lines
;
// find current ptr for each compute,fix,variable
// check that fix frequency is acceptable
int
icompute
;
for
(
int
i
=
0
;
i
<
ncompute
;
i
++
)
{
icompute
=
modify
->
find_compute
(
id_compute
[
i
]);
if
(
icompute
<
0
)
error
->
all
(
FLERR
,
"Could not find dump custom compute ID"
);
compute
[
i
]
=
modify
->
compute
[
icompute
];
}
int
ifix
;
for
(
int
i
=
0
;
i
<
nfix
;
i
++
)
{
ifix
=
modify
->
find_fix
(
id_fix
[
i
]);
if
(
ifix
<
0
)
error
->
all
(
FLERR
,
"Could not find dump custom fix ID"
);
fix
[
i
]
=
modify
->
fix
[
ifix
];
if
(
nevery
%
modify
->
fix
[
ifix
]
->
peratom_freq
)
error
->
all
(
FLERR
,
"Dump custom and fix not computed at compatible times"
);
}
int
ivariable
;
for
(
int
i
=
0
;
i
<
nvariable
;
i
++
)
{
ivariable
=
input
->
variable
->
find
(
id_variable
[
i
]);
if
(
ivariable
<
0
)
error
->
all
(
FLERR
,
"Could not find dump custom variable name"
);
variable
[
i
]
=
ivariable
;
}
int
icustom
;
for
(
int
i
=
0
;
i
<
ncustom
;
i
++
)
{
icustom
=
atom
->
find_custom
(
id_custom
[
i
],
flag_custom
[
i
]);
if
(
icustom
<
0
)
error
->
all
(
FLERR
,
"Could not find custom per-atom property ID"
);
}
// set index and check validity of region
if
(
iregion
>=
0
)
{
iregion
=
domain
->
find_region
(
idregion
);
if
(
iregion
==
-
1
)
error
->
all
(
FLERR
,
"Region ID for dump custom does not exist"
);
}
// open single file, one time only
if
(
multifile
==
0
)
openfile
();
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
write_header
(
bigint
ndump
)
{
if
(
multiproc
)
(
this
->*
header_choice
)(
ndump
);
else
if
(
me
==
0
)
(
this
->*
header_choice
)(
ndump
);
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
header_binary
(
bigint
ndump
)
{
fwrite
(
&
update
->
ntimestep
,
sizeof
(
bigint
),
1
,
fp
);
fwrite
(
&
ndump
,
sizeof
(
bigint
),
1
,
fp
);
fwrite
(
&
domain
->
triclinic
,
sizeof
(
int
),
1
,
fp
);
fwrite
(
&
domain
->
boundary
[
0
][
0
],
6
*
sizeof
(
int
),
1
,
fp
);
fwrite
(
&
boxxlo
,
sizeof
(
double
),
1
,
fp
);
fwrite
(
&
boxxhi
,
sizeof
(
double
),
1
,
fp
);
fwrite
(
&
boxylo
,
sizeof
(
double
),
1
,
fp
);
fwrite
(
&
boxyhi
,
sizeof
(
double
),
1
,
fp
);
fwrite
(
&
boxzlo
,
sizeof
(
double
),
1
,
fp
);
fwrite
(
&
boxzhi
,
sizeof
(
double
),
1
,
fp
);
fwrite
(
&
size_one
,
sizeof
(
int
),
1
,
fp
);
if
(
multiproc
)
fwrite
(
&
nclusterprocs
,
sizeof
(
int
),
1
,
fp
);
else
fwrite
(
&
nprocs
,
sizeof
(
int
),
1
,
fp
);
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
header_binary_triclinic
(
bigint
ndump
)
{
fwrite
(
&
update
->
ntimestep
,
sizeof
(
bigint
),
1
,
fp
);
fwrite
(
&
ndump
,
sizeof
(
bigint
),
1
,
fp
);
fwrite
(
&
domain
->
triclinic
,
sizeof
(
int
),
1
,
fp
);
fwrite
(
&
domain
->
boundary
[
0
][
0
],
6
*
sizeof
(
int
),
1
,
fp
);
fwrite
(
&
boxxlo
,
sizeof
(
double
),
1
,
fp
);
fwrite
(
&
boxxhi
,
sizeof
(
double
),
1
,
fp
);
fwrite
(
&
boxylo
,
sizeof
(
double
),
1
,
fp
);
fwrite
(
&
boxyhi
,
sizeof
(
double
),
1
,
fp
);
fwrite
(
&
boxzlo
,
sizeof
(
double
),
1
,
fp
);
fwrite
(
&
boxzhi
,
sizeof
(
double
),
1
,
fp
);
fwrite
(
&
boxxy
,
sizeof
(
double
),
1
,
fp
);
fwrite
(
&
boxxz
,
sizeof
(
double
),
1
,
fp
);
fwrite
(
&
boxyz
,
sizeof
(
double
),
1
,
fp
);
fwrite
(
&
size_one
,
sizeof
(
int
),
1
,
fp
);
if
(
multiproc
)
fwrite
(
&
nclusterprocs
,
sizeof
(
int
),
1
,
fp
);
else
fwrite
(
&
nprocs
,
sizeof
(
int
),
1
,
fp
);
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
header_item
(
bigint
ndump
)
{
fprintf
(
fp
,
"ITEM: TIMESTEP
\n
"
);
fprintf
(
fp
,
BIGINT_FORMAT
"
\n
"
,
update
->
ntimestep
);
fprintf
(
fp
,
"ITEM: NUMBER OF ATOMS
\n
"
);
fprintf
(
fp
,
BIGINT_FORMAT
"
\n
"
,
ndump
);
fprintf
(
fp
,
"ITEM: BOX BOUNDS %s
\n
"
,
boundstr
);
fprintf
(
fp
,
"%-1.16e %-1.16e
\n
"
,
boxxlo
,
boxxhi
);
fprintf
(
fp
,
"%-1.16e %-1.16e
\n
"
,
boxylo
,
boxyhi
);
fprintf
(
fp
,
"%-1.16e %-1.16e
\n
"
,
boxzlo
,
boxzhi
);
fprintf
(
fp
,
"ITEM: ATOMS %s
\n
"
,
columns
);
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
header_item_triclinic
(
bigint
ndump
)
{
fprintf
(
fp
,
"ITEM: TIMESTEP
\n
"
);
fprintf
(
fp
,
BIGINT_FORMAT
"
\n
"
,
update
->
ntimestep
);
fprintf
(
fp
,
"ITEM: NUMBER OF ATOMS
\n
"
);
fprintf
(
fp
,
BIGINT_FORMAT
"
\n
"
,
ndump
);
fprintf
(
fp
,
"ITEM: BOX BOUNDS xy xz yz %s
\n
"
,
boundstr
);
fprintf
(
fp
,
"%-1.16e %-1.16e %-1.16e
\n
"
,
boxxlo
,
boxxhi
,
boxxy
);
fprintf
(
fp
,
"%-1.16e %-1.16e %-1.16e
\n
"
,
boxylo
,
boxyhi
,
boxxz
);
fprintf
(
fp
,
"%-1.16e %-1.16e %-1.16e
\n
"
,
boxzlo
,
boxzhi
,
boxyz
);
fprintf
(
fp
,
"ITEM: ATOMS %s
\n
"
,
columns
);
}
/* ---------------------------------------------------------------------- */
int
DumpCustom
::
count
()
{
int
i
;
// grow choose and variable vbuf arrays if needed
int
nlocal
=
atom
->
nlocal
;
if
(
atom
->
nmax
>
maxlocal
)
{
maxlocal
=
atom
->
nmax
;
memory
->
destroy
(
choose
);
memory
->
destroy
(
dchoose
);
memory
->
destroy
(
clist
);
memory
->
create
(
choose
,
maxlocal
,
"dump:choose"
);
memory
->
create
(
dchoose
,
maxlocal
,
"dump:dchoose"
);
memory
->
create
(
clist
,
maxlocal
,
"dump:clist"
);
for
(
i
=
0
;
i
<
nvariable
;
i
++
)
{
memory
->
destroy
(
vbuf
[
i
]);
memory
->
create
(
vbuf
[
i
],
maxlocal
,
"dump:vbuf"
);
}
}
// invoke Computes for per-atom quantities
// only if within a run or minimize
// else require that computes are current
// this prevents a compute from being invoked by the WriteDump class
if
(
ncompute
)
{
if
(
update
->
whichflag
==
0
)
{
for
(
i
=
0
;
i
<
ncompute
;
i
++
)
if
(
compute
[
i
]
->
invoked_peratom
!=
update
->
ntimestep
)
error
->
all
(
FLERR
,
"Compute used in dump between runs is not current"
);
}
else
{
for
(
i
=
0
;
i
<
ncompute
;
i
++
)
{
if
(
!
(
compute
[
i
]
->
invoked_flag
&
INVOKED_PERATOM
))
{
compute
[
i
]
->
compute_peratom
();
compute
[
i
]
->
invoked_flag
|=
INVOKED_PERATOM
;
}
}
}
}
// evaluate atom-style Variables for per-atom quantities
if
(
nvariable
)
for
(
i
=
0
;
i
<
nvariable
;
i
++
)
input
->
variable
->
compute_atom
(
variable
[
i
],
igroup
,
vbuf
[
i
],
1
,
0
);
// choose all local atoms for output
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
choose
[
i
]
=
1
;
// un-choose if not in group
if
(
igroup
)
{
int
*
mask
=
atom
->
mask
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
if
(
!
(
mask
[
i
]
&
groupbit
))
choose
[
i
]
=
0
;
}
// un-choose if not in region
if
(
iregion
>=
0
)
{
Region
*
region
=
domain
->
regions
[
iregion
];
region
->
prematch
();
double
**
x
=
atom
->
x
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
if
(
choose
[
i
]
&&
region
->
match
(
x
[
i
][
0
],
x
[
i
][
1
],
x
[
i
][
2
])
==
0
)
choose
[
i
]
=
0
;
}
// un-choose if any threshold criterion isn't met
if
(
nthresh
)
{
double
*
ptr
;
double
value
;
int
nstride
;
int
nlocal
=
atom
->
nlocal
;
for
(
int
ithresh
=
0
;
ithresh
<
nthresh
;
ithresh
++
)
{
// customize by adding to if statement
if
(
thresh_array
[
ithresh
]
==
ID
)
{
tagint
*
tag
=
atom
->
tag
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
tag
[
i
];
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
MOL
)
{
if
(
!
atom
->
molecule_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
tagint
*
molecule
=
atom
->
molecule
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
molecule
[
i
];
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
PROC
)
{
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
me
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
PROCP1
)
{
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
me
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
TYPE
)
{
int
*
type
=
atom
->
type
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
type
[
i
];
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
ELEMENT
)
{
int
*
type
=
atom
->
type
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
type
[
i
];
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
MASS
)
{
if
(
atom
->
rmass
)
{
ptr
=
atom
->
rmass
;
nstride
=
1
;
}
else
{
double
*
mass
=
atom
->
mass
;
int
*
type
=
atom
->
type
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
mass
[
type
[
i
]];
ptr
=
dchoose
;
nstride
=
1
;
}
}
else
if
(
thresh_array
[
ithresh
]
==
X
)
{
ptr
=
&
atom
->
x
[
0
][
0
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
Y
)
{
ptr
=
&
atom
->
x
[
0
][
1
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
Z
)
{
ptr
=
&
atom
->
x
[
0
][
2
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
XS
)
{
double
**
x
=
atom
->
x
;
double
boxxlo
=
domain
->
boxlo
[
0
];
double
invxprd
=
1.0
/
domain
->
xprd
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
(
x
[
i
][
0
]
-
boxxlo
)
*
invxprd
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
YS
)
{
double
**
x
=
atom
->
x
;
double
boxylo
=
domain
->
boxlo
[
1
];
double
invyprd
=
1.0
/
domain
->
yprd
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
(
x
[
i
][
1
]
-
boxylo
)
*
invyprd
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
ZS
)
{
double
**
x
=
atom
->
x
;
double
boxzlo
=
domain
->
boxlo
[
2
];
double
invzprd
=
1.0
/
domain
->
zprd
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
(
x
[
i
][
2
]
-
boxzlo
)
*
invzprd
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
XSTRI
)
{
double
**
x
=
atom
->
x
;
double
*
boxlo
=
domain
->
boxlo
;
double
*
h_inv
=
domain
->
h_inv
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
h_inv
[
0
]
*
(
x
[
i
][
0
]
-
boxlo
[
0
])
+
h_inv
[
5
]
*
(
x
[
i
][
1
]
-
boxlo
[
1
])
+
h_inv
[
4
]
*
(
x
[
i
][
2
]
-
boxlo
[
2
]);
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
YSTRI
)
{
double
**
x
=
atom
->
x
;
double
*
boxlo
=
domain
->
boxlo
;
double
*
h_inv
=
domain
->
h_inv
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
h_inv
[
1
]
*
(
x
[
i
][
1
]
-
boxlo
[
1
])
+
h_inv
[
3
]
*
(
x
[
i
][
2
]
-
boxlo
[
2
]);
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
ZSTRI
)
{
double
**
x
=
atom
->
x
;
double
*
boxlo
=
domain
->
boxlo
;
double
*
h_inv
=
domain
->
h_inv
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
h_inv
[
2
]
*
(
x
[
i
][
2
]
-
boxlo
[
2
]);
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
XU
)
{
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
xprd
=
domain
->
xprd
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
x
[
i
][
0
]
+
((
image
[
i
]
&
IMGMASK
)
-
IMGMAX
)
*
xprd
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
YU
)
{
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
yprd
=
domain
->
yprd
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
x
[
i
][
1
]
+
((
image
[
i
]
>>
IMGBITS
&
IMGMASK
)
-
IMGMAX
)
*
yprd
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
ZU
)
{
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
zprd
=
domain
->
zprd
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
x
[
i
][
2
]
+
((
image
[
i
]
>>
IMG2BITS
)
-
IMGMAX
)
*
zprd
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
XUTRI
)
{
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
*
h
=
domain
->
h
;
int
xbox
,
ybox
,
zbox
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
{
xbox
=
(
image
[
i
]
&
IMGMASK
)
-
IMGMAX
;
ybox
=
(
image
[
i
]
>>
IMGBITS
&
IMGMASK
)
-
IMGMAX
;
zbox
=
(
image
[
i
]
>>
IMG2BITS
)
-
IMGMAX
;
dchoose
[
i
]
=
x
[
i
][
0
]
+
h
[
0
]
*
xbox
+
h
[
5
]
*
ybox
+
h
[
4
]
*
zbox
;
}
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
YUTRI
)
{
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
*
h
=
domain
->
h
;
int
ybox
,
zbox
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
{
ybox
=
(
image
[
i
]
>>
IMGBITS
&
IMGMASK
)
-
IMGMAX
;
zbox
=
(
image
[
i
]
>>
IMG2BITS
)
-
IMGMAX
;
dchoose
[
i
]
=
x
[
i
][
1
]
+
h
[
1
]
*
ybox
+
h
[
3
]
*
zbox
;
}
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
ZUTRI
)
{
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
*
h
=
domain
->
h
;
int
zbox
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
{
zbox
=
(
image
[
i
]
>>
IMG2BITS
)
-
IMGMAX
;
dchoose
[
i
]
=
x
[
i
][
2
]
+
h
[
2
]
*
zbox
;
}
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
XSU
)
{
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
boxxlo
=
domain
->
boxlo
[
0
];
double
invxprd
=
1.0
/
domain
->
xprd
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
(
x
[
i
][
0
]
-
boxxlo
)
*
invxprd
+
(
image
[
i
]
&
IMGMASK
)
-
IMGMAX
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
YSU
)
{
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
boxylo
=
domain
->
boxlo
[
1
];
double
invyprd
=
1.0
/
domain
->
yprd
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
(
x
[
i
][
1
]
-
boxylo
)
*
invyprd
+
(
image
[
i
]
>>
IMGBITS
&
IMGMASK
)
-
IMGMAX
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
ZSU
)
{
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
boxzlo
=
domain
->
boxlo
[
2
];
double
invzprd
=
1.0
/
domain
->
zprd
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
(
x
[
i
][
2
]
-
boxzlo
)
*
invzprd
+
(
image
[
i
]
>>
IMG2BITS
)
-
IMGMAX
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
XSUTRI
)
{
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
*
boxlo
=
domain
->
boxlo
;
double
*
h_inv
=
domain
->
h_inv
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
h_inv
[
0
]
*
(
x
[
i
][
0
]
-
boxlo
[
0
])
+
h_inv
[
5
]
*
(
x
[
i
][
1
]
-
boxlo
[
1
])
+
h_inv
[
4
]
*
(
x
[
i
][
2
]
-
boxlo
[
2
])
+
(
image
[
i
]
&
IMGMASK
)
-
IMGMAX
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
YSUTRI
)
{
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
*
boxlo
=
domain
->
boxlo
;
double
*
h_inv
=
domain
->
h_inv
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
h_inv
[
1
]
*
(
x
[
i
][
1
]
-
boxlo
[
1
])
+
h_inv
[
3
]
*
(
x
[
i
][
2
]
-
boxlo
[
2
])
+
(
image
[
i
]
>>
IMGBITS
&
IMGMASK
)
-
IMGMAX
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
ZSUTRI
)
{
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
*
boxlo
=
domain
->
boxlo
;
double
*
h_inv
=
domain
->
h_inv
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
h_inv
[
2
]
*
(
x
[
i
][
2
]
-
boxlo
[
2
])
+
(
image
[
i
]
>>
IMG2BITS
)
-
IMGMAX
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
IX
)
{
imageint
*
image
=
atom
->
image
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
(
image
[
i
]
&
IMGMASK
)
-
IMGMAX
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
IY
)
{
imageint
*
image
=
atom
->
image
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
(
image
[
i
]
>>
IMGBITS
&
IMGMASK
)
-
IMGMAX
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
IZ
)
{
imageint
*
image
=
atom
->
image
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
(
image
[
i
]
>>
IMG2BITS
)
-
IMGMAX
;
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
VX
)
{
ptr
=
&
atom
->
v
[
0
][
0
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
VY
)
{
ptr
=
&
atom
->
v
[
0
][
1
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
VZ
)
{
ptr
=
&
atom
->
v
[
0
][
2
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
FX
)
{
ptr
=
&
atom
->
f
[
0
][
0
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
FY
)
{
ptr
=
&
atom
->
f
[
0
][
1
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
FZ
)
{
ptr
=
&
atom
->
f
[
0
][
2
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
Q
)
{
if
(
!
atom
->
q_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
ptr
=
atom
->
q
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
MUX
)
{
if
(
!
atom
->
mu_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
ptr
=
&
atom
->
mu
[
0
][
0
];
nstride
=
4
;
}
else
if
(
thresh_array
[
ithresh
]
==
MUY
)
{
if
(
!
atom
->
mu_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
ptr
=
&
atom
->
mu
[
0
][
1
];
nstride
=
4
;
}
else
if
(
thresh_array
[
ithresh
]
==
MUZ
)
{
if
(
!
atom
->
mu_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
ptr
=
&
atom
->
mu
[
0
][
2
];
nstride
=
4
;
}
else
if
(
thresh_array
[
ithresh
]
==
MU
)
{
if
(
!
atom
->
mu_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
ptr
=
&
atom
->
mu
[
0
][
3
];
nstride
=
4
;
}
else
if
(
thresh_array
[
ithresh
]
==
RADIUS
)
{
if
(
!
atom
->
radius_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
ptr
=
atom
->
radius
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
DIAMETER
)
{
if
(
!
atom
->
radius_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
double
*
radius
=
atom
->
radius
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
2.0
*
radius
[
i
];
ptr
=
dchoose
;
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
OMEGAX
)
{
if
(
!
atom
->
omega_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
ptr
=
&
atom
->
omega
[
0
][
0
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
OMEGAY
)
{
if
(
!
atom
->
omega_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
ptr
=
&
atom
->
omega
[
0
][
1
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
OMEGAZ
)
{
if
(
!
atom
->
omega_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
ptr
=
&
atom
->
omega
[
0
][
2
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
ANGMOMX
)
{
if
(
!
atom
->
angmom_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
ptr
=
&
atom
->
angmom
[
0
][
0
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
ANGMOMY
)
{
if
(
!
atom
->
angmom_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
ptr
=
&
atom
->
angmom
[
0
][
1
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
ANGMOMZ
)
{
if
(
!
atom
->
angmom_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
ptr
=
&
atom
->
angmom
[
0
][
2
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
TQX
)
{
if
(
!
atom
->
torque_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
ptr
=
&
atom
->
torque
[
0
][
0
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
TQY
)
{
if
(
!
atom
->
torque_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
ptr
=
&
atom
->
torque
[
0
][
1
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
TQZ
)
{
if
(
!
atom
->
torque_flag
)
error
->
all
(
FLERR
,
"Threshold for an atom property that isn't allocated"
);
ptr
=
&
atom
->
torque
[
0
][
2
];
nstride
=
3
;
}
else
if
(
thresh_array
[
ithresh
]
==
COMPUTE
)
{
i
=
nfield
+
ithresh
;
if
(
argindex
[
i
]
==
0
)
{
ptr
=
compute
[
field2index
[
i
]]
->
vector_atom
;
nstride
=
1
;
}
else
{
ptr
=
&
compute
[
field2index
[
i
]]
->
array_atom
[
0
][
argindex
[
i
]
-
1
];
nstride
=
compute
[
field2index
[
i
]]
->
size_peratom_cols
;
}
}
else
if
(
thresh_array
[
ithresh
]
==
FIX
)
{
i
=
nfield
+
ithresh
;
if
(
argindex
[
i
]
==
0
)
{
ptr
=
fix
[
field2index
[
i
]]
->
vector_atom
;
nstride
=
1
;
}
else
{
ptr
=
&
fix
[
field2index
[
i
]]
->
array_atom
[
0
][
argindex
[
i
]
-
1
];
nstride
=
fix
[
field2index
[
i
]]
->
size_peratom_cols
;
}
}
else
if
(
thresh_array
[
ithresh
]
==
VARIABLE
)
{
i
=
nfield
+
ithresh
;
ptr
=
vbuf
[
field2index
[
i
]];
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
DNAME
)
{
int
iwhich
,
tmp
;
i
=
nfield
+
ithresh
;
iwhich
=
atom
->
find_custom
(
id_custom
[
field2index
[
i
]],
tmp
);
ptr
=
atom
->
dvector
[
iwhich
];
nstride
=
1
;
}
else
if
(
thresh_array
[
ithresh
]
==
INAME
)
{
int
iwhich
,
tmp
;
i
=
nfield
+
ithresh
;
iwhich
=
atom
->
find_custom
(
id_custom
[
field2index
[
i
]],
tmp
);
int
*
ivector
=
atom
->
ivector
[
iwhich
];
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
dchoose
[
i
]
=
ivector
[
i
];
ptr
=
dchoose
;
nstride
=
1
;
}
// unselect atoms that don't meet threshold criterion
value
=
thresh_value
[
ithresh
];
if
(
thresh_op
[
ithresh
]
==
LT
)
{
for
(
i
=
0
;
i
<
nlocal
;
i
++
,
ptr
+=
nstride
)
if
(
choose
[
i
]
&&
*
ptr
>=
value
)
choose
[
i
]
=
0
;
}
else
if
(
thresh_op
[
ithresh
]
==
LE
)
{
for
(
i
=
0
;
i
<
nlocal
;
i
++
,
ptr
+=
nstride
)
if
(
choose
[
i
]
&&
*
ptr
>
value
)
choose
[
i
]
=
0
;
}
else
if
(
thresh_op
[
ithresh
]
==
GT
)
{
for
(
i
=
0
;
i
<
nlocal
;
i
++
,
ptr
+=
nstride
)
if
(
choose
[
i
]
&&
*
ptr
<=
value
)
choose
[
i
]
=
0
;
}
else
if
(
thresh_op
[
ithresh
]
==
GE
)
{
for
(
i
=
0
;
i
<
nlocal
;
i
++
,
ptr
+=
nstride
)
if
(
choose
[
i
]
&&
*
ptr
<
value
)
choose
[
i
]
=
0
;
}
else
if
(
thresh_op
[
ithresh
]
==
EQ
)
{
for
(
i
=
0
;
i
<
nlocal
;
i
++
,
ptr
+=
nstride
)
if
(
choose
[
i
]
&&
*
ptr
!=
value
)
choose
[
i
]
=
0
;
}
else
if
(
thresh_op
[
ithresh
]
==
NEQ
)
{
for
(
i
=
0
;
i
<
nlocal
;
i
++
,
ptr
+=
nstride
)
if
(
choose
[
i
]
&&
*
ptr
==
value
)
choose
[
i
]
=
0
;
}
}
}
// compress choose flags into clist
// nchoose = # of selected atoms
// clist[i] = local index of each selected atom
nchoose
=
0
;
for
(
i
=
0
;
i
<
nlocal
;
i
++
)
if
(
choose
[
i
])
clist
[
nchoose
++
]
=
i
;
return
nchoose
;
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack
(
tagint
*
ids
)
{
for
(
int
n
=
0
;
n
<
size_one
;
n
++
)
(
this
->*
pack_choice
[
n
])(
n
);
if
(
ids
)
{
tagint
*
tag
=
atom
->
tag
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
ids
[
i
]
=
tag
[
clist
[
i
]];
}
}
/* ----------------------------------------------------------------------
convert mybuf of doubles to one big formatted string in sbuf
return -1 if strlen exceeds an int, since used as arg in MPI calls in Dump
------------------------------------------------------------------------- */
int
DumpCustom
::
convert_string
(
int
n
,
double
*
mybuf
)
{
int
i
,
j
;
int
offset
=
0
;
int
m
=
0
;
for
(
i
=
0
;
i
<
n
;
i
++
)
{
if
(
offset
+
size_one
*
ONEFIELD
>
maxsbuf
)
{
if
((
bigint
)
maxsbuf
+
DELTA
>
MAXSMALLINT
)
return
-
1
;
maxsbuf
+=
DELTA
;
memory
->
grow
(
sbuf
,
maxsbuf
,
"dump:sbuf"
);
}
for
(
j
=
0
;
j
<
size_one
;
j
++
)
{
if
(
vtype
[
j
]
==
INT
)
offset
+=
sprintf
(
&
sbuf
[
offset
],
vformat
[
j
],
static_cast
<
int
>
(
mybuf
[
m
]));
else
if
(
vtype
[
j
]
==
DOUBLE
)
offset
+=
sprintf
(
&
sbuf
[
offset
],
vformat
[
j
],
mybuf
[
m
]);
else
if
(
vtype
[
j
]
==
STRING
)
offset
+=
sprintf
(
&
sbuf
[
offset
],
vformat
[
j
],
typenames
[(
int
)
mybuf
[
m
]]);
else
if
(
vtype
[
j
]
==
BIGINT
)
offset
+=
sprintf
(
&
sbuf
[
offset
],
vformat
[
j
],
static_cast
<
bigint
>
(
mybuf
[
m
]));
m
++
;
}
offset
+=
sprintf
(
&
sbuf
[
offset
],
"
\n
"
);
}
return
offset
;
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
write_data
(
int
n
,
double
*
mybuf
)
{
(
this
->*
write_choice
)(
n
,
mybuf
);
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
write_binary
(
int
n
,
double
*
mybuf
)
{
n
*=
size_one
;
fwrite
(
&
n
,
sizeof
(
int
),
1
,
fp
);
fwrite
(
mybuf
,
sizeof
(
double
),
n
,
fp
);
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
write_string
(
int
n
,
double
*
mybuf
)
{
fwrite
(
mybuf
,
sizeof
(
char
),
n
,
fp
);
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
write_lines
(
int
n
,
double
*
mybuf
)
{
int
i
,
j
;
int
m
=
0
;
for
(
i
=
0
;
i
<
n
;
i
++
)
{
for
(
j
=
0
;
j
<
size_one
;
j
++
)
{
if
(
vtype
[
j
]
==
INT
)
fprintf
(
fp
,
vformat
[
j
],
static_cast
<
int
>
(
mybuf
[
m
]));
else
if
(
vtype
[
j
]
==
DOUBLE
)
fprintf
(
fp
,
vformat
[
j
],
mybuf
[
m
]);
else
if
(
vtype
[
j
]
==
STRING
)
fprintf
(
fp
,
vformat
[
j
],
typenames
[(
int
)
mybuf
[
m
]]);
else
if
(
vtype
[
j
]
==
BIGINT
)
fprintf
(
fp
,
vformat
[
j
],
static_cast
<
bigint
>
(
mybuf
[
m
]));
m
++
;
}
fprintf
(
fp
,
"
\n
"
);
}
}
/* ---------------------------------------------------------------------- */
int
DumpCustom
::
parse_fields
(
int
narg
,
char
**
arg
)
{
// customize by adding to if statement
int
i
;
for
(
int
iarg
=
0
;
iarg
<
narg
;
iarg
++
)
{
i
=
iarg
;
if
(
strcmp
(
arg
[
iarg
],
"id"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_id
;
if
(
sizeof
(
tagint
)
==
sizeof
(
smallint
))
vtype
[
i
]
=
INT
;
else
vtype
[
i
]
=
BIGINT
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"mol"
)
==
0
)
{
if
(
!
atom
->
molecule_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_molecule
;
if
(
sizeof
(
tagint
)
==
sizeof
(
smallint
))
vtype
[
i
]
=
INT
;
else
vtype
[
i
]
=
BIGINT
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"proc"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_proc
;
vtype
[
i
]
=
INT
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"procp1"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_procp1
;
vtype
[
i
]
=
INT
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"type"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_type
;
vtype
[
i
]
=
INT
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"element"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_type
;
vtype
[
i
]
=
STRING
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"mass"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_mass
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"x"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_x
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"y"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_y
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"z"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_z
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"xs"
)
==
0
)
{
if
(
domain
->
triclinic
)
pack_choice
[
i
]
=
&
DumpCustom
::
pack_xs_triclinic
;
else
pack_choice
[
i
]
=
&
DumpCustom
::
pack_xs
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"ys"
)
==
0
)
{
if
(
domain
->
triclinic
)
pack_choice
[
i
]
=
&
DumpCustom
::
pack_ys_triclinic
;
else
pack_choice
[
i
]
=
&
DumpCustom
::
pack_ys
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"zs"
)
==
0
)
{
if
(
domain
->
triclinic
)
pack_choice
[
i
]
=
&
DumpCustom
::
pack_zs_triclinic
;
else
pack_choice
[
i
]
=
&
DumpCustom
::
pack_zs
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"xu"
)
==
0
)
{
if
(
domain
->
triclinic
)
pack_choice
[
i
]
=
&
DumpCustom
::
pack_xu_triclinic
;
else
pack_choice
[
i
]
=
&
DumpCustom
::
pack_xu
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"yu"
)
==
0
)
{
if
(
domain
->
triclinic
)
pack_choice
[
i
]
=
&
DumpCustom
::
pack_yu_triclinic
;
else
pack_choice
[
i
]
=
&
DumpCustom
::
pack_yu
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"zu"
)
==
0
)
{
if
(
domain
->
triclinic
)
pack_choice
[
i
]
=
&
DumpCustom
::
pack_zu_triclinic
;
else
pack_choice
[
i
]
=
&
DumpCustom
::
pack_zu
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"xsu"
)
==
0
)
{
if
(
domain
->
triclinic
)
pack_choice
[
i
]
=
&
DumpCustom
::
pack_xsu_triclinic
;
else
pack_choice
[
i
]
=
&
DumpCustom
::
pack_xsu
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"ysu"
)
==
0
)
{
if
(
domain
->
triclinic
)
pack_choice
[
i
]
=
&
DumpCustom
::
pack_ysu_triclinic
;
else
pack_choice
[
i
]
=
&
DumpCustom
::
pack_ysu
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"zsu"
)
==
0
)
{
if
(
domain
->
triclinic
)
pack_choice
[
i
]
=
&
DumpCustom
::
pack_zsu_triclinic
;
else
pack_choice
[
i
]
=
&
DumpCustom
::
pack_zsu
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"ix"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_ix
;
vtype
[
i
]
=
INT
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"iy"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_iy
;
vtype
[
i
]
=
INT
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"iz"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_iz
;
vtype
[
i
]
=
INT
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"vx"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_vx
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"vy"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_vy
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"vz"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_vz
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"fx"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_fx
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"fy"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_fy
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"fz"
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_fz
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"q"
)
==
0
)
{
if
(
!
atom
->
q_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_q
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"mux"
)
==
0
)
{
if
(
!
atom
->
mu_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_mux
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"muy"
)
==
0
)
{
if
(
!
atom
->
mu_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_muy
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"muz"
)
==
0
)
{
if
(
!
atom
->
mu_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_muz
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"mu"
)
==
0
)
{
if
(
!
atom
->
mu_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_mu
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"radius"
)
==
0
)
{
if
(
!
atom
->
radius_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_radius
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"diameter"
)
==
0
)
{
if
(
!
atom
->
radius_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_diameter
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"omegax"
)
==
0
)
{
if
(
!
atom
->
omega_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_omegax
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"omegay"
)
==
0
)
{
if
(
!
atom
->
omega_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_omegay
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"omegaz"
)
==
0
)
{
if
(
!
atom
->
omega_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_omegaz
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"angmomx"
)
==
0
)
{
if
(
!
atom
->
angmom_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_angmomx
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"angmomy"
)
==
0
)
{
if
(
!
atom
->
angmom_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_angmomy
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"angmomz"
)
==
0
)
{
if
(
!
atom
->
angmom_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_angmomz
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"tqx"
)
==
0
)
{
if
(
!
atom
->
torque_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_tqx
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"tqy"
)
==
0
)
{
if
(
!
atom
->
torque_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_tqy
;
vtype
[
i
]
=
DOUBLE
;
}
else
if
(
strcmp
(
arg
[
iarg
],
"tqz"
)
==
0
)
{
if
(
!
atom
->
torque_flag
)
error
->
all
(
FLERR
,
"Dumping an atom property that isn't allocated"
);
pack_choice
[
i
]
=
&
DumpCustom
::
pack_tqz
;
vtype
[
i
]
=
DOUBLE
;
// compute value = c_ID
// if no trailing [], then arg is set to 0, else arg is int between []
}
else
if
(
strncmp
(
arg
[
iarg
],
"c_"
,
2
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_compute
;
vtype
[
i
]
=
DOUBLE
;
int
n
=
strlen
(
arg
[
iarg
]);
char
*
suffix
=
new
char
[
n
];
strcpy
(
suffix
,
&
arg
[
iarg
][
2
]);
char
*
ptr
=
strchr
(
suffix
,
'['
);
if
(
ptr
)
{
if
(
suffix
[
strlen
(
suffix
)
-
1
]
!=
']'
)
error
->
all
(
FLERR
,
"Invalid attribute in dump custom command"
);
argindex
[
i
]
=
atoi
(
ptr
+
1
);
*
ptr
=
'\0'
;
}
else
argindex
[
i
]
=
0
;
n
=
modify
->
find_compute
(
suffix
);
if
(
n
<
0
)
error
->
all
(
FLERR
,
"Could not find dump custom compute ID"
);
if
(
modify
->
compute
[
n
]
->
peratom_flag
==
0
)
error
->
all
(
FLERR
,
"Dump custom compute does not compute per-atom info"
);
if
(
argindex
[
i
]
==
0
&&
modify
->
compute
[
n
]
->
size_peratom_cols
>
0
)
error
->
all
(
FLERR
,
"Dump custom compute does not calculate per-atom vector"
);
if
(
argindex
[
i
]
>
0
&&
modify
->
compute
[
n
]
->
size_peratom_cols
==
0
)
error
->
all
(
FLERR
,
"Dump custom compute does not calculate per-atom array"
);
if
(
argindex
[
i
]
>
0
&&
argindex
[
i
]
>
modify
->
compute
[
n
]
->
size_peratom_cols
)
error
->
all
(
FLERR
,
"Dump custom compute vector is accessed out-of-range"
);
field2index
[
i
]
=
add_compute
(
suffix
);
delete
[]
suffix
;
// fix value = f_ID
// if no trailing [], then arg is set to 0, else arg is between []
}
else
if
(
strncmp
(
arg
[
iarg
],
"f_"
,
2
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_fix
;
vtype
[
i
]
=
DOUBLE
;
int
n
=
strlen
(
arg
[
iarg
]);
char
*
suffix
=
new
char
[
n
];
strcpy
(
suffix
,
&
arg
[
iarg
][
2
]);
char
*
ptr
=
strchr
(
suffix
,
'['
);
if
(
ptr
)
{
if
(
suffix
[
strlen
(
suffix
)
-
1
]
!=
']'
)
error
->
all
(
FLERR
,
"Invalid attribute in dump custom command"
);
argindex
[
i
]
=
atoi
(
ptr
+
1
);
*
ptr
=
'\0'
;
}
else
argindex
[
i
]
=
0
;
n
=
modify
->
find_fix
(
suffix
);
if
(
n
<
0
)
error
->
all
(
FLERR
,
"Could not find dump custom fix ID"
);
if
(
modify
->
fix
[
n
]
->
peratom_flag
==
0
)
error
->
all
(
FLERR
,
"Dump custom fix does not compute per-atom info"
);
if
(
argindex
[
i
]
==
0
&&
modify
->
fix
[
n
]
->
size_peratom_cols
>
0
)
error
->
all
(
FLERR
,
"Dump custom fix does not compute per-atom vector"
);
if
(
argindex
[
i
]
>
0
&&
modify
->
fix
[
n
]
->
size_peratom_cols
==
0
)
error
->
all
(
FLERR
,
"Dump custom fix does not compute per-atom array"
);
if
(
argindex
[
i
]
>
0
&&
argindex
[
i
]
>
modify
->
fix
[
n
]
->
size_peratom_cols
)
error
->
all
(
FLERR
,
"Dump custom fix vector is accessed out-of-range"
);
field2index
[
i
]
=
add_fix
(
suffix
);
delete
[]
suffix
;
// variable value = v_name
}
else
if
(
strncmp
(
arg
[
iarg
],
"v_"
,
2
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_variable
;
vtype
[
i
]
=
DOUBLE
;
int
n
=
strlen
(
arg
[
iarg
]);
char
*
suffix
=
new
char
[
n
];
strcpy
(
suffix
,
&
arg
[
iarg
][
2
]);
argindex
[
i
]
=
0
;
n
=
input
->
variable
->
find
(
suffix
);
if
(
n
<
0
)
error
->
all
(
FLERR
,
"Could not find dump custom variable name"
);
if
(
input
->
variable
->
atomstyle
(
n
)
==
0
)
error
->
all
(
FLERR
,
"Dump custom variable is not atom-style variable"
);
field2index
[
i
]
=
add_variable
(
suffix
);
delete
[]
suffix
;
// custom per-atom floating point value = d_ID
}
else
if
(
strncmp
(
arg
[
iarg
],
"d_"
,
2
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_custom
;
vtype
[
i
]
=
DOUBLE
;
int
n
=
strlen
(
arg
[
iarg
]);
char
*
suffix
=
new
char
[
n
];
strcpy
(
suffix
,
&
arg
[
iarg
][
2
]);
argindex
[
i
]
=
0
;
int
tmp
=
-
1
;
n
=
atom
->
find_custom
(
suffix
,
tmp
);
if
(
n
<
0
)
error
->
all
(
FLERR
,
"Could not find custom per-atom property ID"
);
if
(
tmp
!=
1
)
error
->
all
(
FLERR
,
"Custom per-atom property ID is not floating point"
);
field2index
[
i
]
=
add_custom
(
suffix
,
1
);
delete
[]
suffix
;
// custom per-atom integer value = i_ID
}
else
if
(
strncmp
(
arg
[
iarg
],
"i_"
,
2
)
==
0
)
{
pack_choice
[
i
]
=
&
DumpCustom
::
pack_custom
;
vtype
[
i
]
=
INT
;
int
n
=
strlen
(
arg
[
iarg
]);
char
*
suffix
=
new
char
[
n
];
strcpy
(
suffix
,
&
arg
[
iarg
][
2
]);
argindex
[
i
]
=
0
;
int
tmp
=
-
1
;
n
=
atom
->
find_custom
(
suffix
,
tmp
);
if
(
n
<
0
)
error
->
all
(
FLERR
,
"Could not find custom per-atom property ID"
);
if
(
tmp
!=
0
)
error
->
all
(
FLERR
,
"Custom per-atom property ID is not integer"
);
field2index
[
i
]
=
add_custom
(
suffix
,
0
);
delete
[]
suffix
;
}
else
return
iarg
;
}
return
narg
;
}
/* ----------------------------------------------------------------------
add Compute to list of Compute objects used by dump
return index of where this Compute is in list
if already in list, do not add, just return index, else add to list
------------------------------------------------------------------------- */
int
DumpCustom
::
add_compute
(
char
*
id
)
{
int
icompute
;
for
(
icompute
=
0
;
icompute
<
ncompute
;
icompute
++
)
if
(
strcmp
(
id
,
id_compute
[
icompute
])
==
0
)
break
;
if
(
icompute
<
ncompute
)
return
icompute
;
id_compute
=
(
char
**
)
memory
->
srealloc
(
id_compute
,(
ncompute
+
1
)
*
sizeof
(
char
*
),
"dump:id_compute"
);
delete
[]
compute
;
compute
=
new
Compute
*
[
ncompute
+
1
];
int
n
=
strlen
(
id
)
+
1
;
id_compute
[
ncompute
]
=
new
char
[
n
];
strcpy
(
id_compute
[
ncompute
],
id
);
ncompute
++
;
return
ncompute
-
1
;
}
/* ----------------------------------------------------------------------
add Fix to list of Fix objects used by dump
return index of where this Fix is in list
if already in list, do not add, just return index, else add to list
------------------------------------------------------------------------- */
int
DumpCustom
::
add_fix
(
char
*
id
)
{
int
ifix
;
for
(
ifix
=
0
;
ifix
<
nfix
;
ifix
++
)
if
(
strcmp
(
id
,
id_fix
[
ifix
])
==
0
)
break
;
if
(
ifix
<
nfix
)
return
ifix
;
id_fix
=
(
char
**
)
memory
->
srealloc
(
id_fix
,(
nfix
+
1
)
*
sizeof
(
char
*
),
"dump:id_fix"
);
delete
[]
fix
;
fix
=
new
Fix
*
[
nfix
+
1
];
int
n
=
strlen
(
id
)
+
1
;
id_fix
[
nfix
]
=
new
char
[
n
];
strcpy
(
id_fix
[
nfix
],
id
);
nfix
++
;
return
nfix
-
1
;
}
/* ----------------------------------------------------------------------
add Variable to list of Variables used by dump
return index of where this Variable is in list
if already in list, do not add, just return index, else add to list
------------------------------------------------------------------------- */
int
DumpCustom
::
add_variable
(
char
*
id
)
{
int
ivariable
;
for
(
ivariable
=
0
;
ivariable
<
nvariable
;
ivariable
++
)
if
(
strcmp
(
id
,
id_variable
[
ivariable
])
==
0
)
break
;
if
(
ivariable
<
nvariable
)
return
ivariable
;
id_variable
=
(
char
**
)
memory
->
srealloc
(
id_variable
,(
nvariable
+
1
)
*
sizeof
(
char
*
),
"dump:id_variable"
);
delete
[]
variable
;
variable
=
new
int
[
nvariable
+
1
];
delete
[]
vbuf
;
vbuf
=
new
double
*
[
nvariable
+
1
];
for
(
int
i
=
0
;
i
<=
nvariable
;
i
++
)
vbuf
[
i
]
=
NULL
;
int
n
=
strlen
(
id
)
+
1
;
id_variable
[
nvariable
]
=
new
char
[
n
];
strcpy
(
id_variable
[
nvariable
],
id
);
nvariable
++
;
return
nvariable
-
1
;
}
/* ----------------------------------------------------------------------
add custom atom property to list used by dump
return index of where this property is in list
if already in list, do not add, just return index, else add to list
------------------------------------------------------------------------- */
int
DumpCustom
::
add_custom
(
char
*
id
,
int
flag
)
{
int
icustom
;
for
(
icustom
=
0
;
icustom
<
ncustom
;
icustom
++
)
if
((
strcmp
(
id
,
id_custom
[
icustom
])
==
0
)
&&
(
flag
==
flag_custom
[
icustom
]))
break
;
if
(
icustom
<
ncustom
)
return
icustom
;
id_custom
=
(
char
**
)
memory
->
srealloc
(
id_custom
,(
ncustom
+
1
)
*
sizeof
(
char
*
),
"dump:id_custom"
);
flag_custom
=
(
int
*
)
memory
->
srealloc
(
flag_custom
,(
ncustom
+
1
)
*
sizeof
(
int
),
"dump:flag_custom"
);
int
n
=
strlen
(
id
)
+
1
;
id_custom
[
ncustom
]
=
new
char
[
n
];
strcpy
(
id_custom
[
ncustom
],
id
);
flag_custom
[
ncustom
]
=
flag
;
ncustom
++
;
return
ncustom
-
1
;
}
/* ---------------------------------------------------------------------- */
int
DumpCustom
::
modify_param
(
int
narg
,
char
**
arg
)
{
if
(
strcmp
(
arg
[
0
],
"region"
)
==
0
)
{
if
(
narg
<
2
)
error
->
all
(
FLERR
,
"Illegal dump_modify command"
);
if
(
strcmp
(
arg
[
1
],
"none"
)
==
0
)
iregion
=
-
1
;
else
{
iregion
=
domain
->
find_region
(
arg
[
1
]);
if
(
iregion
==
-
1
)
error
->
all
(
FLERR
,
"Dump_modify region ID does not exist"
);
delete
[]
idregion
;
int
n
=
strlen
(
arg
[
1
])
+
1
;
idregion
=
new
char
[
n
];
strcpy
(
idregion
,
arg
[
1
]);
}
return
2
;
}
if
(
strcmp
(
arg
[
0
],
"format"
)
==
0
)
{
if
(
narg
<
2
)
error
->
all
(
FLERR
,
"Illegal dump_modify command"
);
if
(
strcmp
(
arg
[
1
],
"none"
)
==
0
)
{
// just clear format_column_user allocated by this dump child class
for
(
int
i
=
0
;
i
<
size_one
;
i
++
)
{
delete
[]
format_column_user
[
i
];
format_column_user
[
i
]
=
NULL
;
}
return
2
;
}
if
(
narg
<
3
)
error
->
all
(
FLERR
,
"Illegal dump_modify command"
);
if
(
strcmp
(
arg
[
1
],
"int"
)
==
0
)
{
delete
[]
format_int_user
;
int
n
=
strlen
(
arg
[
2
])
+
1
;
format_int_user
=
new
char
[
n
];
strcpy
(
format_int_user
,
arg
[
2
]);
delete
[]
format_bigint_user
;
n
=
strlen
(
format_int_user
)
+
8
;
format_bigint_user
=
new
char
[
n
];
// replace "d" in format_int_user with bigint format specifier
// use of &str[1] removes leading '%' from BIGINT_FORMAT string
char
*
ptr
=
strchr
(
format_int_user
,
'd'
);
if
(
ptr
==
NULL
)
error
->
all
(
FLERR
,
"Dump_modify int format does not contain d character"
);
char
str
[
8
];
sprintf
(
str
,
"%s"
,
BIGINT_FORMAT
);
*
ptr
=
'\0'
;
sprintf
(
format_bigint_user
,
"%s%s%s"
,
format_int_user
,
&
str
[
1
],
ptr
+
1
);
*
ptr
=
'd'
;
}
else
if
(
strcmp
(
arg
[
1
],
"float"
)
==
0
)
{
delete
[]
format_float_user
;
int
n
=
strlen
(
arg
[
2
])
+
1
;
format_float_user
=
new
char
[
n
];
strcpy
(
format_float_user
,
arg
[
2
]);
}
else
{
int
i
=
force
->
inumeric
(
FLERR
,
arg
[
1
])
-
1
;
if
(
i
<
0
||
i
>=
size_one
)
error
->
all
(
FLERR
,
"Illegal dump_modify command"
);
if
(
format_column_user
[
i
])
delete
[]
format_column_user
[
i
];
int
n
=
strlen
(
arg
[
2
])
+
1
;
format_column_user
[
i
]
=
new
char
[
n
];
strcpy
(
format_column_user
[
i
],
arg
[
2
]);
}
return
3
;
}
if
(
strcmp
(
arg
[
0
],
"element"
)
==
0
)
{
if
(
narg
<
ntypes
+
1
)
error
->
all
(
FLERR
,
"Dump_modify element names do not match atom types"
);
for
(
int
i
=
1
;
i
<=
ntypes
;
i
++
)
delete
[]
typenames
[
i
];
delete
[]
typenames
;
typenames
=
new
char
*
[
ntypes
+
1
];
for
(
int
itype
=
1
;
itype
<=
ntypes
;
itype
++
)
{
int
n
=
strlen
(
arg
[
itype
])
+
1
;
typenames
[
itype
]
=
new
char
[
n
];
strcpy
(
typenames
[
itype
],
arg
[
itype
]);
}
return
ntypes
+
1
;
}
if
(
strcmp
(
arg
[
0
],
"thresh"
)
==
0
)
{
if
(
narg
<
2
)
error
->
all
(
FLERR
,
"Illegal dump_modify command"
);
if
(
strcmp
(
arg
[
1
],
"none"
)
==
0
)
{
if
(
nthresh
)
{
memory
->
destroy
(
thresh_array
);
memory
->
destroy
(
thresh_op
);
memory
->
destroy
(
thresh_value
);
thresh_array
=
NULL
;
thresh_op
=
NULL
;
thresh_value
=
NULL
;
}
nthresh
=
0
;
return
2
;
}
if
(
narg
<
4
)
error
->
all
(
FLERR
,
"Illegal dump_modify command"
);
// grow threshold arrays
memory
->
grow
(
thresh_array
,
nthresh
+
1
,
"dump:thresh_array"
);
memory
->
grow
(
thresh_op
,(
nthresh
+
1
),
"dump:thresh_op"
);
memory
->
grow
(
thresh_value
,(
nthresh
+
1
),
"dump:thresh_value"
);
// set attribute type of threshold
// customize by adding to if statement
if
(
strcmp
(
arg
[
1
],
"id"
)
==
0
)
thresh_array
[
nthresh
]
=
ID
;
else
if
(
strcmp
(
arg
[
1
],
"mol"
)
==
0
)
thresh_array
[
nthresh
]
=
MOL
;
else
if
(
strcmp
(
arg
[
1
],
"proc"
)
==
0
)
thresh_array
[
nthresh
]
=
PROC
;
else
if
(
strcmp
(
arg
[
1
],
"procp1"
)
==
0
)
thresh_array
[
nthresh
]
=
PROCP1
;
else
if
(
strcmp
(
arg
[
1
],
"type"
)
==
0
)
thresh_array
[
nthresh
]
=
TYPE
;
else
if
(
strcmp
(
arg
[
1
],
"mass"
)
==
0
)
thresh_array
[
nthresh
]
=
MASS
;
else
if
(
strcmp
(
arg
[
1
],
"x"
)
==
0
)
thresh_array
[
nthresh
]
=
X
;
else
if
(
strcmp
(
arg
[
1
],
"y"
)
==
0
)
thresh_array
[
nthresh
]
=
Y
;
else
if
(
strcmp
(
arg
[
1
],
"z"
)
==
0
)
thresh_array
[
nthresh
]
=
Z
;
else
if
(
strcmp
(
arg
[
1
],
"xs"
)
==
0
&&
domain
->
triclinic
==
0
)
thresh_array
[
nthresh
]
=
XS
;
else
if
(
strcmp
(
arg
[
1
],
"xs"
)
==
0
&&
domain
->
triclinic
==
1
)
thresh_array
[
nthresh
]
=
XSTRI
;
else
if
(
strcmp
(
arg
[
1
],
"ys"
)
==
0
&&
domain
->
triclinic
==
0
)
thresh_array
[
nthresh
]
=
YS
;
else
if
(
strcmp
(
arg
[
1
],
"ys"
)
==
0
&&
domain
->
triclinic
==
1
)
thresh_array
[
nthresh
]
=
YSTRI
;
else
if
(
strcmp
(
arg
[
1
],
"zs"
)
==
0
&&
domain
->
triclinic
==
0
)
thresh_array
[
nthresh
]
=
ZS
;
else
if
(
strcmp
(
arg
[
1
],
"zs"
)
==
0
&&
domain
->
triclinic
==
1
)
thresh_array
[
nthresh
]
=
ZSTRI
;
else
if
(
strcmp
(
arg
[
1
],
"xu"
)
==
0
&&
domain
->
triclinic
==
0
)
thresh_array
[
nthresh
]
=
XU
;
else
if
(
strcmp
(
arg
[
1
],
"xu"
)
==
0
&&
domain
->
triclinic
==
1
)
thresh_array
[
nthresh
]
=
XUTRI
;
else
if
(
strcmp
(
arg
[
1
],
"yu"
)
==
0
&&
domain
->
triclinic
==
0
)
thresh_array
[
nthresh
]
=
YU
;
else
if
(
strcmp
(
arg
[
1
],
"yu"
)
==
0
&&
domain
->
triclinic
==
1
)
thresh_array
[
nthresh
]
=
YUTRI
;
else
if
(
strcmp
(
arg
[
1
],
"zu"
)
==
0
&&
domain
->
triclinic
==
0
)
thresh_array
[
nthresh
]
=
ZU
;
else
if
(
strcmp
(
arg
[
1
],
"zu"
)
==
0
&&
domain
->
triclinic
==
1
)
thresh_array
[
nthresh
]
=
ZUTRI
;
else
if
(
strcmp
(
arg
[
1
],
"xsu"
)
==
0
&&
domain
->
triclinic
==
0
)
thresh_array
[
nthresh
]
=
XSU
;
else
if
(
strcmp
(
arg
[
1
],
"xsu"
)
==
0
&&
domain
->
triclinic
==
1
)
thresh_array
[
nthresh
]
=
XSUTRI
;
else
if
(
strcmp
(
arg
[
1
],
"ysu"
)
==
0
&&
domain
->
triclinic
==
0
)
thresh_array
[
nthresh
]
=
YSU
;
else
if
(
strcmp
(
arg
[
1
],
"ysu"
)
==
0
&&
domain
->
triclinic
==
1
)
thresh_array
[
nthresh
]
=
YSUTRI
;
else
if
(
strcmp
(
arg
[
1
],
"zsu"
)
==
0
&&
domain
->
triclinic
==
0
)
thresh_array
[
nthresh
]
=
ZSU
;
else
if
(
strcmp
(
arg
[
1
],
"zsu"
)
==
0
&&
domain
->
triclinic
==
1
)
thresh_array
[
nthresh
]
=
ZSUTRI
;
else
if
(
strcmp
(
arg
[
1
],
"ix"
)
==
0
)
thresh_array
[
nthresh
]
=
IX
;
else
if
(
strcmp
(
arg
[
1
],
"iy"
)
==
0
)
thresh_array
[
nthresh
]
=
IY
;
else
if
(
strcmp
(
arg
[
1
],
"iz"
)
==
0
)
thresh_array
[
nthresh
]
=
IZ
;
else
if
(
strcmp
(
arg
[
1
],
"vx"
)
==
0
)
thresh_array
[
nthresh
]
=
VX
;
else
if
(
strcmp
(
arg
[
1
],
"vy"
)
==
0
)
thresh_array
[
nthresh
]
=
VY
;
else
if
(
strcmp
(
arg
[
1
],
"vz"
)
==
0
)
thresh_array
[
nthresh
]
=
VZ
;
else
if
(
strcmp
(
arg
[
1
],
"fx"
)
==
0
)
thresh_array
[
nthresh
]
=
FX
;
else
if
(
strcmp
(
arg
[
1
],
"fy"
)
==
0
)
thresh_array
[
nthresh
]
=
FY
;
else
if
(
strcmp
(
arg
[
1
],
"fz"
)
==
0
)
thresh_array
[
nthresh
]
=
FZ
;
else
if
(
strcmp
(
arg
[
1
],
"q"
)
==
0
)
thresh_array
[
nthresh
]
=
Q
;
else
if
(
strcmp
(
arg
[
1
],
"mux"
)
==
0
)
thresh_array
[
nthresh
]
=
MUX
;
else
if
(
strcmp
(
arg
[
1
],
"muy"
)
==
0
)
thresh_array
[
nthresh
]
=
MUY
;
else
if
(
strcmp
(
arg
[
1
],
"muz"
)
==
0
)
thresh_array
[
nthresh
]
=
MUZ
;
else
if
(
strcmp
(
arg
[
1
],
"mu"
)
==
0
)
thresh_array
[
nthresh
]
=
MU
;
else
if
(
strcmp
(
arg
[
1
],
"radius"
)
==
0
)
thresh_array
[
nthresh
]
=
RADIUS
;
else
if
(
strcmp
(
arg
[
1
],
"diameter"
)
==
0
)
thresh_array
[
nthresh
]
=
DIAMETER
;
else
if
(
strcmp
(
arg
[
1
],
"omegax"
)
==
0
)
thresh_array
[
nthresh
]
=
OMEGAX
;
else
if
(
strcmp
(
arg
[
1
],
"omegay"
)
==
0
)
thresh_array
[
nthresh
]
=
OMEGAY
;
else
if
(
strcmp
(
arg
[
1
],
"omegaz"
)
==
0
)
thresh_array
[
nthresh
]
=
OMEGAZ
;
else
if
(
strcmp
(
arg
[
1
],
"angmomx"
)
==
0
)
thresh_array
[
nthresh
]
=
ANGMOMX
;
else
if
(
strcmp
(
arg
[
1
],
"angmomy"
)
==
0
)
thresh_array
[
nthresh
]
=
ANGMOMY
;
else
if
(
strcmp
(
arg
[
1
],
"angmomz"
)
==
0
)
thresh_array
[
nthresh
]
=
ANGMOMZ
;
else
if
(
strcmp
(
arg
[
1
],
"tqx"
)
==
0
)
thresh_array
[
nthresh
]
=
TQX
;
else
if
(
strcmp
(
arg
[
1
],
"tqy"
)
==
0
)
thresh_array
[
nthresh
]
=
TQY
;
else
if
(
strcmp
(
arg
[
1
],
"tqz"
)
==
0
)
thresh_array
[
nthresh
]
=
TQZ
;
// compute value = c_ID
// if no trailing [], then arg is set to 0, else arg is between []
// must grow field2index and argindex arrays, since access is beyond nfield
else
if
(
strncmp
(
arg
[
1
],
"c_"
,
2
)
==
0
)
{
thresh_array
[
nthresh
]
=
COMPUTE
;
memory
->
grow
(
field2index
,
nfield
+
nthresh
+
1
,
"dump:field2index"
);
memory
->
grow
(
argindex
,
nfield
+
nthresh
+
1
,
"dump:argindex"
);
int
n
=
strlen
(
arg
[
1
]);
char
*
suffix
=
new
char
[
n
];
strcpy
(
suffix
,
&
arg
[
1
][
2
]);
char
*
ptr
=
strchr
(
suffix
,
'['
);
if
(
ptr
)
{
if
(
suffix
[
strlen
(
suffix
)
-
1
]
!=
']'
)
error
->
all
(
FLERR
,
"Invalid attribute in dump modify command"
);
argindex
[
nfield
+
nthresh
]
=
atoi
(
ptr
+
1
);
*
ptr
=
'\0'
;
}
else
argindex
[
nfield
+
nthresh
]
=
0
;
n
=
modify
->
find_compute
(
suffix
);
if
(
n
<
0
)
error
->
all
(
FLERR
,
"Could not find dump modify compute ID"
);
if
(
modify
->
compute
[
n
]
->
peratom_flag
==
0
)
error
->
all
(
FLERR
,
"Dump modify compute ID does not compute per-atom info"
);
if
(
argindex
[
nfield
+
nthresh
]
==
0
&&
modify
->
compute
[
n
]
->
size_peratom_cols
>
0
)
error
->
all
(
FLERR
,
"Dump modify compute ID does not compute per-atom vector"
);
if
(
argindex
[
nfield
+
nthresh
]
>
0
&&
modify
->
compute
[
n
]
->
size_peratom_cols
==
0
)
error
->
all
(
FLERR
,
"Dump modify compute ID does not compute per-atom array"
);
if
(
argindex
[
nfield
+
nthresh
]
>
0
&&
argindex
[
nfield
+
nthresh
]
>
modify
->
compute
[
n
]
->
size_peratom_cols
)
error
->
all
(
FLERR
,
"Dump modify compute ID vector is not large enough"
);
field2index
[
nfield
+
nthresh
]
=
add_compute
(
suffix
);
delete
[]
suffix
;
// fix value = f_ID
// if no trailing [], then arg is set to 0, else arg is between []
// must grow field2index and argindex arrays, since access is beyond nfield
}
else
if
(
strncmp
(
arg
[
1
],
"f_"
,
2
)
==
0
)
{
thresh_array
[
nthresh
]
=
FIX
;
memory
->
grow
(
field2index
,
nfield
+
nthresh
+
1
,
"dump:field2index"
);
memory
->
grow
(
argindex
,
nfield
+
nthresh
+
1
,
"dump:argindex"
);
int
n
=
strlen
(
arg
[
1
]);
char
*
suffix
=
new
char
[
n
];
strcpy
(
suffix
,
&
arg
[
1
][
2
]);
char
*
ptr
=
strchr
(
suffix
,
'['
);
if
(
ptr
)
{
if
(
suffix
[
strlen
(
suffix
)
-
1
]
!=
']'
)
error
->
all
(
FLERR
,
"Invalid attribute in dump modify command"
);
argindex
[
nfield
+
nthresh
]
=
atoi
(
ptr
+
1
);
*
ptr
=
'\0'
;
}
else
argindex
[
nfield
+
nthresh
]
=
0
;
n
=
modify
->
find_fix
(
suffix
);
if
(
n
<
0
)
error
->
all
(
FLERR
,
"Could not find dump modify fix ID"
);
if
(
modify
->
fix
[
n
]
->
peratom_flag
==
0
)
error
->
all
(
FLERR
,
"Dump modify fix ID does not compute per-atom info"
);
if
(
argindex
[
nfield
+
nthresh
]
==
0
&&
modify
->
fix
[
n
]
->
size_peratom_cols
>
0
)
error
->
all
(
FLERR
,
"Dump modify fix ID does not compute per-atom vector"
);
if
(
argindex
[
nfield
+
nthresh
]
>
0
&&
modify
->
fix
[
n
]
->
size_peratom_cols
==
0
)
error
->
all
(
FLERR
,
"Dump modify fix ID does not compute per-atom array"
);
if
(
argindex
[
nfield
+
nthresh
]
>
0
&&
argindex
[
nfield
+
nthresh
]
>
modify
->
fix
[
n
]
->
size_peratom_cols
)
error
->
all
(
FLERR
,
"Dump modify fix ID vector is not large enough"
);
field2index
[
nfield
+
nthresh
]
=
add_fix
(
suffix
);
delete
[]
suffix
;
// variable value = v_ID
// must grow field2index and argindex arrays, since access is beyond nfield
}
else
if
(
strncmp
(
arg
[
1
],
"v_"
,
2
)
==
0
)
{
thresh_array
[
nthresh
]
=
VARIABLE
;
memory
->
grow
(
field2index
,
nfield
+
nthresh
+
1
,
"dump:field2index"
);
memory
->
grow
(
argindex
,
nfield
+
nthresh
+
1
,
"dump:argindex"
);
int
n
=
strlen
(
arg
[
1
]);
char
*
suffix
=
new
char
[
n
];
strcpy
(
suffix
,
&
arg
[
1
][
2
]);
argindex
[
nfield
+
nthresh
]
=
0
;
n
=
input
->
variable
->
find
(
suffix
);
if
(
n
<
0
)
error
->
all
(
FLERR
,
"Could not find dump modify variable name"
);
if
(
input
->
variable
->
atomstyle
(
n
)
==
0
)
error
->
all
(
FLERR
,
"Dump modify variable is not atom-style variable"
);
field2index
[
nfield
+
nthresh
]
=
add_variable
(
suffix
);
delete
[]
suffix
;
// custom per atom floating point value = d_ID
// must grow field2index and argindex arrays, since access is beyond nfield
}
else
if
(
strncmp
(
arg
[
1
],
"d_"
,
2
)
==
0
)
{
thresh_array
[
nthresh
]
=
DNAME
;
memory
->
grow
(
field2index
,
nfield
+
nthresh
+
1
,
"dump:field2index"
);
memory
->
grow
(
argindex
,
nfield
+
nthresh
+
1
,
"dump:argindex"
);
int
n
=
strlen
(
arg
[
1
]);
char
*
suffix
=
new
char
[
n
];
strcpy
(
suffix
,
&
arg
[
1
][
2
]);
argindex
[
nfield
+
nthresh
]
=
0
;
int
tmp
=
-
1
;
n
=
atom
->
find_custom
(
suffix
,
tmp
);
if
((
n
<
0
)
||
(
tmp
!=
1
))
error
->
all
(
FLERR
,
"Could not find dump modify "
"custom atom floating point property ID"
);
field2index
[
nfield
+
nthresh
]
=
add_custom
(
suffix
,
1
);
delete
[]
suffix
;
// custom per atom integer value = i_ID
// must grow field2index and argindex arrays, since access is beyond nfield
}
else
if
(
strncmp
(
arg
[
1
],
"i_"
,
2
)
==
0
)
{
thresh_array
[
nthresh
]
=
INAME
;
memory
->
grow
(
field2index
,
nfield
+
nthresh
+
1
,
"dump:field2index"
);
memory
->
grow
(
argindex
,
nfield
+
nthresh
+
1
,
"dump:argindex"
);
int
n
=
strlen
(
arg
[
1
]);
char
*
suffix
=
new
char
[
n
];
strcpy
(
suffix
,
&
arg
[
1
][
2
]);
argindex
[
nfield
+
nthresh
]
=
0
;
int
tmp
=
-
1
;
n
=
atom
->
find_custom
(
suffix
,
tmp
);
if
((
n
<
0
)
||
(
tmp
!=
0
))
error
->
all
(
FLERR
,
"Could not find dump modify "
"custom atom integer property ID"
);
field2index
[
nfield
+
nthresh
]
=
add_custom
(
suffix
,
0
);
delete
[]
suffix
;
}
else
error
->
all
(
FLERR
,
"Invalid dump_modify threshhold operator"
);
// set operation type of threshold
if
(
strcmp
(
arg
[
2
],
"<"
)
==
0
)
thresh_op
[
nthresh
]
=
LT
;
else
if
(
strcmp
(
arg
[
2
],
"<="
)
==
0
)
thresh_op
[
nthresh
]
=
LE
;
else
if
(
strcmp
(
arg
[
2
],
">"
)
==
0
)
thresh_op
[
nthresh
]
=
GT
;
else
if
(
strcmp
(
arg
[
2
],
">="
)
==
0
)
thresh_op
[
nthresh
]
=
GE
;
else
if
(
strcmp
(
arg
[
2
],
"=="
)
==
0
)
thresh_op
[
nthresh
]
=
EQ
;
else
if
(
strcmp
(
arg
[
2
],
"!="
)
==
0
)
thresh_op
[
nthresh
]
=
NEQ
;
else
error
->
all
(
FLERR
,
"Invalid dump_modify threshold operator"
);
// set threshold value
thresh_value
[
nthresh
]
=
force
->
numeric
(
FLERR
,
arg
[
3
]);
nthresh
++
;
return
4
;
}
return
0
;
}
/* ----------------------------------------------------------------------
return # of bytes of allocated memory in buf, choose, variable arrays
------------------------------------------------------------------------- */
bigint
DumpCustom
::
memory_usage
()
{
bigint
bytes
=
Dump
::
memory_usage
();
bytes
+=
memory
->
usage
(
choose
,
maxlocal
);
bytes
+=
memory
->
usage
(
dchoose
,
maxlocal
);
bytes
+=
memory
->
usage
(
clist
,
maxlocal
);
bytes
+=
memory
->
usage
(
vbuf
,
nvariable
,
maxlocal
);
return
bytes
;
}
/* ----------------------------------------------------------------------
extraction of Compute, Fix, Variable results
------------------------------------------------------------------------- */
void
DumpCustom
::
pack_compute
(
int
n
)
{
double
*
vector
=
compute
[
field2index
[
n
]]
->
vector_atom
;
double
**
array
=
compute
[
field2index
[
n
]]
->
array_atom
;
int
index
=
argindex
[
n
];
if
(
index
==
0
)
{
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
vector
[
clist
[
i
]];
n
+=
size_one
;
}
}
else
{
index
--
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
array
[
clist
[
i
]][
index
];
n
+=
size_one
;
}
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_fix
(
int
n
)
{
double
*
vector
=
fix
[
field2index
[
n
]]
->
vector_atom
;
double
**
array
=
fix
[
field2index
[
n
]]
->
array_atom
;
int
index
=
argindex
[
n
];
if
(
index
==
0
)
{
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
vector
[
clist
[
i
]];
n
+=
size_one
;
}
}
else
{
index
--
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
array
[
clist
[
i
]][
index
];
n
+=
size_one
;
}
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_variable
(
int
n
)
{
double
*
vector
=
vbuf
[
field2index
[
n
]];
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
vector
[
clist
[
i
]];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_custom
(
int
n
)
{
int
index
=
field2index
[
n
];
if
(
flag_custom
[
index
]
==
0
)
{
// integer
int
iwhich
,
tmp
;
iwhich
=
atom
->
find_custom
(
id_custom
[
index
],
tmp
);
int
*
ivector
=
atom
->
ivector
[
iwhich
];
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
ivector
[
clist
[
i
]];
n
+=
size_one
;
}
}
else
if
(
flag_custom
[
index
]
==
1
)
{
// double
int
iwhich
,
tmp
;
iwhich
=
atom
->
find_custom
(
id_custom
[
index
],
tmp
);
double
*
dvector
=
atom
->
dvector
[
iwhich
];
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
dvector
[
clist
[
i
]];
n
+=
size_one
;
}
}
}
/* ----------------------------------------------------------------------
one method for every attribute dump custom can output
the atom property is packed into buf starting at n with stride size_one
customize a new attribute by adding a method
------------------------------------------------------------------------- */
void
DumpCustom
::
pack_id
(
int
n
)
{
tagint
*
tag
=
atom
->
tag
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
tag
[
clist
[
i
]];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_molecule
(
int
n
)
{
tagint
*
molecule
=
atom
->
molecule
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
molecule
[
clist
[
i
]];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_proc
(
int
n
)
{
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
me
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_procp1
(
int
n
)
{
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
me
+
1
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_type
(
int
n
)
{
int
*
type
=
atom
->
type
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
type
[
clist
[
i
]];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_mass
(
int
n
)
{
int
*
type
=
atom
->
type
;
double
*
mass
=
atom
->
mass
;
double
*
rmass
=
atom
->
rmass
;
if
(
rmass
)
{
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
rmass
[
clist
[
i
]];
n
+=
size_one
;
}
}
else
{
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
mass
[
type
[
clist
[
i
]]];
n
+=
size_one
;
}
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_x
(
int
n
)
{
double
**
x
=
atom
->
x
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
x
[
clist
[
i
]][
0
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_y
(
int
n
)
{
double
**
x
=
atom
->
x
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
x
[
clist
[
i
]][
1
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_z
(
int
n
)
{
double
**
x
=
atom
->
x
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
x
[
clist
[
i
]][
2
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_xs
(
int
n
)
{
double
**
x
=
atom
->
x
;
double
boxxlo
=
domain
->
boxlo
[
0
];
double
invxprd
=
1.0
/
domain
->
xprd
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
(
x
[
clist
[
i
]][
0
]
-
boxxlo
)
*
invxprd
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_ys
(
int
n
)
{
double
**
x
=
atom
->
x
;
double
boxylo
=
domain
->
boxlo
[
1
];
double
invyprd
=
1.0
/
domain
->
yprd
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
(
x
[
clist
[
i
]][
1
]
-
boxylo
)
*
invyprd
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_zs
(
int
n
)
{
double
**
x
=
atom
->
x
;
double
boxzlo
=
domain
->
boxlo
[
2
];
double
invzprd
=
1.0
/
domain
->
zprd
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
(
x
[
clist
[
i
]][
2
]
-
boxzlo
)
*
invzprd
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_xs_triclinic
(
int
n
)
{
int
j
;
double
**
x
=
atom
->
x
;
double
*
boxlo
=
domain
->
boxlo
;
double
*
h_inv
=
domain
->
h_inv
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
j
=
clist
[
i
];
buf
[
n
]
=
h_inv
[
0
]
*
(
x
[
j
][
0
]
-
boxlo
[
0
])
+
h_inv
[
5
]
*
(
x
[
j
][
1
]
-
boxlo
[
1
])
+
h_inv
[
4
]
*
(
x
[
j
][
2
]
-
boxlo
[
2
]);
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_ys_triclinic
(
int
n
)
{
int
j
;
double
**
x
=
atom
->
x
;
double
*
boxlo
=
domain
->
boxlo
;
double
*
h_inv
=
domain
->
h_inv
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
j
=
clist
[
i
];
buf
[
n
]
=
h_inv
[
1
]
*
(
x
[
j
][
1
]
-
boxlo
[
1
])
+
h_inv
[
3
]
*
(
x
[
j
][
2
]
-
boxlo
[
2
]);
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_zs_triclinic
(
int
n
)
{
double
**
x
=
atom
->
x
;
double
*
boxlo
=
domain
->
boxlo
;
double
*
h_inv
=
domain
->
h_inv
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
h_inv
[
2
]
*
(
x
[
clist
[
i
]][
2
]
-
boxlo
[
2
]);
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_xu
(
int
n
)
{
int
j
;
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
xprd
=
domain
->
xprd
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
j
=
clist
[
i
];
buf
[
n
]
=
x
[
j
][
0
]
+
((
image
[
j
]
&
IMGMASK
)
-
IMGMAX
)
*
xprd
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_yu
(
int
n
)
{
int
j
;
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
yprd
=
domain
->
yprd
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
j
=
clist
[
i
];
buf
[
n
]
=
x
[
j
][
1
]
+
((
image
[
j
]
>>
IMGBITS
&
IMGMASK
)
-
IMGMAX
)
*
yprd
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_zu
(
int
n
)
{
int
j
;
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
zprd
=
domain
->
zprd
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
j
=
clist
[
i
];
buf
[
n
]
=
x
[
j
][
2
]
+
((
image
[
j
]
>>
IMG2BITS
)
-
IMGMAX
)
*
zprd
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_xu_triclinic
(
int
n
)
{
int
j
;
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
*
h
=
domain
->
h
;
int
xbox
,
ybox
,
zbox
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
j
=
clist
[
i
];
xbox
=
(
image
[
j
]
&
IMGMASK
)
-
IMGMAX
;
ybox
=
(
image
[
j
]
>>
IMGBITS
&
IMGMASK
)
-
IMGMAX
;
zbox
=
(
image
[
j
]
>>
IMG2BITS
)
-
IMGMAX
;
buf
[
n
]
=
x
[
j
][
0
]
+
h
[
0
]
*
xbox
+
h
[
5
]
*
ybox
+
h
[
4
]
*
zbox
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_yu_triclinic
(
int
n
)
{
int
j
;
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
*
h
=
domain
->
h
;
int
ybox
,
zbox
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
j
=
clist
[
i
];
ybox
=
(
image
[
j
]
>>
IMGBITS
&
IMGMASK
)
-
IMGMAX
;
zbox
=
(
image
[
j
]
>>
IMG2BITS
)
-
IMGMAX
;
buf
[
n
]
=
x
[
j
][
1
]
+
h
[
1
]
*
ybox
+
h
[
3
]
*
zbox
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_zu_triclinic
(
int
n
)
{
int
j
;
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
*
h
=
domain
->
h
;
int
zbox
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
j
=
clist
[
i
];
zbox
=
(
image
[
j
]
>>
IMG2BITS
)
-
IMGMAX
;
buf
[
n
]
=
x
[
j
][
2
]
+
h
[
2
]
*
zbox
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_xsu
(
int
n
)
{
int
j
;
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
boxxlo
=
domain
->
boxlo
[
0
];
double
invxprd
=
1.0
/
domain
->
xprd
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
j
=
clist
[
i
];
buf
[
n
]
=
(
x
[
j
][
0
]
-
boxxlo
)
*
invxprd
+
(
image
[
j
]
&
IMGMASK
)
-
IMGMAX
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_ysu
(
int
n
)
{
int
j
;
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
boxylo
=
domain
->
boxlo
[
1
];
double
invyprd
=
1.0
/
domain
->
yprd
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
j
=
clist
[
i
];
buf
[
n
]
=
(
x
[
j
][
1
]
-
boxylo
)
*
invyprd
+
(
image
[
j
]
>>
IMGBITS
&
IMGMASK
)
-
IMGMAX
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_zsu
(
int
n
)
{
int
j
;
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
boxzlo
=
domain
->
boxlo
[
2
];
double
invzprd
=
1.0
/
domain
->
zprd
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
j
=
clist
[
i
];
buf
[
n
]
=
(
x
[
j
][
2
]
-
boxzlo
)
*
invzprd
+
(
image
[
j
]
>>
IMG2BITS
)
-
IMGMAX
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_xsu_triclinic
(
int
n
)
{
int
j
;
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
*
boxlo
=
domain
->
boxlo
;
double
*
h_inv
=
domain
->
h_inv
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
j
=
clist
[
i
];
buf
[
n
]
=
h_inv
[
0
]
*
(
x
[
j
][
0
]
-
boxlo
[
0
])
+
h_inv
[
5
]
*
(
x
[
j
][
1
]
-
boxlo
[
1
])
+
h_inv
[
4
]
*
(
x
[
j
][
2
]
-
boxlo
[
2
])
+
(
image
[
j
]
&
IMGMASK
)
-
IMGMAX
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_ysu_triclinic
(
int
n
)
{
int
j
;
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
*
boxlo
=
domain
->
boxlo
;
double
*
h_inv
=
domain
->
h_inv
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
j
=
clist
[
i
];
buf
[
n
]
=
h_inv
[
1
]
*
(
x
[
j
][
1
]
-
boxlo
[
1
])
+
h_inv
[
3
]
*
(
x
[
j
][
2
]
-
boxlo
[
2
])
+
(
image
[
j
]
>>
IMGBITS
&
IMGMASK
)
-
IMGMAX
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_zsu_triclinic
(
int
n
)
{
int
j
;
double
**
x
=
atom
->
x
;
imageint
*
image
=
atom
->
image
;
double
*
boxlo
=
domain
->
boxlo
;
double
*
h_inv
=
domain
->
h_inv
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
j
=
clist
[
i
];
buf
[
n
]
=
h_inv
[
2
]
*
(
x
[
j
][
2
]
-
boxlo
[
2
])
+
(
image
[
j
]
>>
IMG2BITS
)
-
IMGMAX
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_ix
(
int
n
)
{
imageint
*
image
=
atom
->
image
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
(
image
[
clist
[
i
]]
&
IMGMASK
)
-
IMGMAX
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_iy
(
int
n
)
{
imageint
*
image
=
atom
->
image
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
(
image
[
clist
[
i
]]
>>
IMGBITS
&
IMGMASK
)
-
IMGMAX
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_iz
(
int
n
)
{
imageint
*
image
=
atom
->
image
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
(
image
[
clist
[
i
]]
>>
IMG2BITS
)
-
IMGMAX
;
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_vx
(
int
n
)
{
double
**
v
=
atom
->
v
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
v
[
clist
[
i
]][
0
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_vy
(
int
n
)
{
double
**
v
=
atom
->
v
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
v
[
clist
[
i
]][
1
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_vz
(
int
n
)
{
double
**
v
=
atom
->
v
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
v
[
clist
[
i
]][
2
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_fx
(
int
n
)
{
double
**
f
=
atom
->
f
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
f
[
clist
[
i
]][
0
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_fy
(
int
n
)
{
double
**
f
=
atom
->
f
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
f
[
clist
[
i
]][
1
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_fz
(
int
n
)
{
double
**
f
=
atom
->
f
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
f
[
clist
[
i
]][
2
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_q
(
int
n
)
{
double
*
q
=
atom
->
q
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
q
[
clist
[
i
]];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_mux
(
int
n
)
{
double
**
mu
=
atom
->
mu
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
mu
[
clist
[
i
]][
0
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_muy
(
int
n
)
{
double
**
mu
=
atom
->
mu
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
mu
[
clist
[
i
]][
1
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_muz
(
int
n
)
{
double
**
mu
=
atom
->
mu
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
mu
[
clist
[
i
]][
2
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_mu
(
int
n
)
{
double
**
mu
=
atom
->
mu
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
mu
[
clist
[
i
]][
3
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_radius
(
int
n
)
{
double
*
radius
=
atom
->
radius
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
radius
[
clist
[
i
]];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_diameter
(
int
n
)
{
double
*
radius
=
atom
->
radius
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
2.0
*
radius
[
clist
[
i
]];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_omegax
(
int
n
)
{
double
**
omega
=
atom
->
omega
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
omega
[
clist
[
i
]][
0
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_omegay
(
int
n
)
{
double
**
omega
=
atom
->
omega
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
omega
[
clist
[
i
]][
1
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_omegaz
(
int
n
)
{
double
**
omega
=
atom
->
omega
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
omega
[
clist
[
i
]][
2
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_angmomx
(
int
n
)
{
double
**
angmom
=
atom
->
angmom
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
angmom
[
clist
[
i
]][
0
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_angmomy
(
int
n
)
{
double
**
angmom
=
atom
->
angmom
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
angmom
[
clist
[
i
]][
1
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_angmomz
(
int
n
)
{
double
**
angmom
=
atom
->
angmom
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
angmom
[
clist
[
i
]][
2
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_tqx
(
int
n
)
{
double
**
torque
=
atom
->
torque
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
torque
[
clist
[
i
]][
0
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_tqy
(
int
n
)
{
double
**
torque
=
atom
->
torque
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
torque
[
clist
[
i
]][
1
];
n
+=
size_one
;
}
}
/* ---------------------------------------------------------------------- */
void
DumpCustom
::
pack_tqz
(
int
n
)
{
double
**
torque
=
atom
->
torque
;
for
(
int
i
=
0
;
i
<
nchoose
;
i
++
)
{
buf
[
n
]
=
torque
[
clist
[
i
]][
2
];
n
+=
size_one
;
}
}
Event Timeline
Log In to Comment