Compare commits
65 Commits
patch_7Mar
...
patch_17Ma
| Author | SHA1 | Date | |
|---|---|---|---|
| 4a90bca7a3 | |||
| 9f35b764f8 | |||
| 7ca5dce2f5 | |||
| fcc3b3bd36 | |||
| 53a3877c3d | |||
| a936b7b2ab | |||
| a91b851f3d | |||
| d31c591b60 | |||
| ae5ebf6001 | |||
| 7fb741d53d | |||
| 8e75616c14 | |||
| 411c069ba6 | |||
| ac82d041cc | |||
| 621d7d5ce0 | |||
| 1bb9c7da42 | |||
| f893104b18 | |||
| efb2a942e0 | |||
| 070ce33a13 | |||
| f604f86cfc | |||
| bed288339e | |||
| 1995f434f3 | |||
| db0281b4df | |||
| 2f5e711acd | |||
| bdb7669e27 | |||
| cda8213892 | |||
| ef940d226c | |||
| 36da9223ec | |||
| eb29ef32b1 | |||
| 29550d472d | |||
| 79cae51156 | |||
| a210867025 | |||
| 0262a54ecf | |||
| 0d8f74f0c5 | |||
| 3a2da51a82 | |||
| b1c59126f7 | |||
| 4c77838514 | |||
| f9468f46f5 | |||
| c3ce3747e0 | |||
| fdc390ad05 | |||
| 580f6b567b | |||
| 27b1c33a16 | |||
| 7a75cd111c | |||
| 23b8287933 | |||
| 4cfe623bc1 | |||
| f871ecdc67 | |||
| 470353e320 | |||
| ffe02d20ca | |||
| f70752c18f | |||
| 07fcfd6d54 | |||
| c97feafca6 | |||
| b20d95d495 | |||
| 0b4adaa9e6 | |||
| 5fe6206638 | |||
| 65964f3b31 | |||
| b28b84d444 | |||
| a001a5ceb0 | |||
| 2ef713ea1b | |||
| 1f6c1942b3 | |||
| 683023d820 | |||
| 42d3a8f498 | |||
| 3626496c7c | |||
| 458b6749e7 | |||
| 0efd209480 | |||
| ed0a347fbf | |||
| 149f37e764 |
13
doc/Makefile
13
doc/Makefile
@ -22,7 +22,7 @@ endif
|
||||
SOURCES=$(wildcard src/*.txt)
|
||||
OBJECTS=$(SOURCES:src/%.txt=$(RSTDIR)/%.rst)
|
||||
|
||||
.PHONY: help clean-all clean epub html pdf old venv spelling
|
||||
.PHONY: help clean-all clean epub html pdf old venv spelling anchor_check
|
||||
|
||||
# ------------------------------------------
|
||||
|
||||
@ -36,6 +36,7 @@ help:
|
||||
@echo " clean remove all intermediate RST files"
|
||||
@echo " clean-all reset the entire build environment"
|
||||
@echo " txt2html build txt2html tool"
|
||||
@echo " anchor_check scan for duplicate anchor labels"
|
||||
|
||||
# ------------------------------------------
|
||||
|
||||
@ -54,6 +55,9 @@ html: $(OBJECTS)
|
||||
. $(VENV)/bin/activate ;\
|
||||
cp -r src/* $(RSTDIR)/ ;\
|
||||
sphinx-build -j 8 -b html -c utils/sphinx-config -d $(BUILDDIR)/doctrees $(RSTDIR) html ;\
|
||||
echo "############################################" ;\
|
||||
doc_anchor_check src/*.txt ;\
|
||||
echo "############################################" ;\
|
||||
deactivate ;\
|
||||
)
|
||||
-rm html/searchindex.js
|
||||
@ -127,6 +131,13 @@ fetch:
|
||||
|
||||
txt2html: utils/txt2html/txt2html.exe
|
||||
|
||||
anchor_check : $(TXT2RST)
|
||||
@(\
|
||||
. $(VENV)/bin/activate ;\
|
||||
doc_anchor_check src/*.txt ;\
|
||||
deactivate ;\
|
||||
)
|
||||
|
||||
# ------------------------------------------
|
||||
|
||||
utils/txt2html/txt2html.exe: utils/txt2html/txt2html.cpp
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
<!-- HTML_ONLY -->
|
||||
<HEAD>
|
||||
<TITLE>LAMMPS Users Manual</TITLE>
|
||||
<META NAME="docnumber" CONTENT="7 Mar 2017 version">
|
||||
<META NAME="docnumber" CONTENT="17 Mar 2017 version">
|
||||
<META NAME="author" CONTENT="http://lammps.sandia.gov - Sandia National Laboratories">
|
||||
<META NAME="copyright" CONTENT="Copyright (2003) Sandia Corporation. This software and manual is distributed under the GNU General Public License.">
|
||||
</HEAD>
|
||||
@ -21,7 +21,7 @@
|
||||
<H1></H1>
|
||||
|
||||
LAMMPS Documentation :c,h3
|
||||
7 Mar 2017 version :c,h4
|
||||
17 Mar 2017 version :c,h4
|
||||
|
||||
Version info: :h4
|
||||
|
||||
|
||||
Binary file not shown.
Binary file not shown.
@ -687,6 +687,7 @@ package"_Section_start.html#start_3.
|
||||
"eos/cv"_fix_eos_cv.html,
|
||||
"eos/table"_fix_eos_table.html,
|
||||
"eos/table/rx"_fix_eos_table_rx.html,
|
||||
"filter/corotate"_fix_filter_corotate.html,
|
||||
"flow/gauss"_fix_flow_gauss.html,
|
||||
"gle"_fix_gle.html,
|
||||
"grem"_fix_grem.html,
|
||||
|
||||
@ -1032,6 +1032,10 @@ profile consistent with the applied shear strain rate.
|
||||
An alternative method for calculating viscosities is provided via the
|
||||
"fix viscosity"_fix_viscosity.html command.
|
||||
|
||||
NEMD simulations can also be used to measure transport properties of a fluid
|
||||
through a pore or channel. Simulations of steady-state flow can be performed
|
||||
using the "fix flow/gauss"_fix_flow_gauss.html command.
|
||||
|
||||
:line
|
||||
|
||||
6.14 Finite-size spherical and aspherical particles :link(howto_14),h4
|
||||
|
||||
@ -286,24 +286,32 @@ above. It performs a recursive coordinate bisectioning (RCB) of the
|
||||
simulation domain. The basic idea is as follows.
|
||||
|
||||
The simulation domain is cut into 2 boxes by an axis-aligned cut in
|
||||
the longest dimension, leaving one new box on either side of the cut.
|
||||
All the processors are also partitioned into 2 groups, half assigned
|
||||
to the box on the lower side of the cut, and half to the box on the
|
||||
upper side. (If the processor count is odd, one side gets an extra
|
||||
processor.) The cut is positioned so that the number of particles in
|
||||
the lower box is exactly the number that the processors assigned to
|
||||
that box should own for load balance to be perfect. This also makes
|
||||
load balance for the upper box perfect. The positioning is done
|
||||
iteratively, by a bisectioning method. Note that counting particles
|
||||
on either side of the cut requires communication between all
|
||||
processors at each iteration.
|
||||
one of the dimensions, leaving one new sub-box on either side of the
|
||||
cut. Which dimension is chosen for the cut depends on the particle
|
||||
(weight) distribution within the parent box. Normally the longest
|
||||
dimension of the box is cut, but if all (or most) of the particles are
|
||||
at one end of the box, a cut may be performed in another dimension to
|
||||
induce sub-boxes that are more cube-ish (3d) or square-ish (2d) in
|
||||
shape.
|
||||
|
||||
After the cut is made, all the processors are also partitioned into 2
|
||||
groups, half assigned to the box on the lower side of the cut, and
|
||||
half to the box on the upper side. (If the processor count is odd,
|
||||
one side gets an extra processor.) The cut is positioned so that the
|
||||
number of (weighted) particles in the lower box is exactly the number
|
||||
that the processors assigned to that box should own for load balance
|
||||
to be perfect. This also makes load balance for the upper box
|
||||
perfect. The positioning of the cut is done iteratively, by a
|
||||
bisectioning method (median search). Note that counting particles on
|
||||
either side of the cut requires communication between all processors
|
||||
at each iteration.
|
||||
|
||||
That is the procedure for the first cut. Subsequent cuts are made
|
||||
recursively, in exactly the same manner. The subset of processors
|
||||
assigned to each box make a new cut in the longest dimension of that
|
||||
box, splitting the box, the subset of processors, and the particles
|
||||
in the box in two. The recursion continues until every processor is
|
||||
assigned a sub-box of the entire simulation domain, and owns the
|
||||
assigned to each box make a new cut in one dimension of that box,
|
||||
splitting the box, the subset of processors, and the particles in the
|
||||
box in two. The recursion continues until every processor is assigned
|
||||
a sub-box of the entire simulation domain, and owns the (weighted)
|
||||
particles in that sub-box.
|
||||
|
||||
:line
|
||||
|
||||
@ -101,11 +101,11 @@ Instead you could do something like this, assuming the simulation box
|
||||
is non-periodic and atoms extend from 0 to 20 in all dimensions:
|
||||
|
||||
change_box all x final -10 20
|
||||
create_atoms 1 single -5 5 5 # this will fail to insert an atom :pre
|
||||
create_atoms 1 single -5 5 5 # this will fail to insert an atom :pre
|
||||
|
||||
change_box all x final -10 20 boundary f s s
|
||||
create_atoms 1 single -5 5 5
|
||||
change_box boundary s s s # this will work :pre
|
||||
change_box all boundary s s s # this will work :pre
|
||||
|
||||
NOTE: Unlike the earlier "displace_box" version of this command, atom
|
||||
remapping is NOT performed by default. This command allows remapping
|
||||
|
||||
@ -134,6 +134,17 @@ not overlap existing atoms inappropriately, especially if molecules
|
||||
are being added. The "delete_atoms"_delete_atoms.html command can be
|
||||
used to remove overlapping atoms or molecules.
|
||||
|
||||
NOTE: You cannot use any of the styles explained above to create atoms
|
||||
that are outside the simulation box; they will just be ignored by
|
||||
LAMMPS. This is true even if you are using shrink-wrapped box
|
||||
boundaries, as specified by the "boundary"_boundary.html command.
|
||||
However, you can first use the "change_box"_change_box.html command to
|
||||
temporarily expand the box, then add atoms via create_atoms, then
|
||||
finally use change_box command again if needed to re-shrink-wrap the
|
||||
new atoms. See the "change_box"_change_box.html doc page for an
|
||||
example of how to do this, using the create_atoms {single} style to
|
||||
insert a new atom outside the current simulation box.
|
||||
|
||||
:line
|
||||
|
||||
Individual atoms are inserted by this command, unless the {mol}
|
||||
|
||||
87
doc/src/fix_filter_corotate.txt
Normal file
87
doc/src/fix_filter_corotate.txt
Normal file
@ -0,0 +1,87 @@
|
||||
"LAMMPS WWW Site"_lws - "LAMMPS Documentation"_ld - "LAMMPS Commands"_lc :c
|
||||
|
||||
:link(lws,http://lammps.sandia.gov)
|
||||
:link(ld,Manual.html)
|
||||
:link(lc,Section_commands.html#comm)
|
||||
|
||||
:line
|
||||
|
||||
fix filter/corotate command :h3
|
||||
|
||||
[Syntax:]
|
||||
|
||||
fix ID group-ID filter/corotate keyword value ... :pre
|
||||
|
||||
ID, group-ID are documented in "fix"_fix.html command :ulb,l
|
||||
one or more constraint/value pairs are appended :l
|
||||
constraint = {b} or {a} or {t} or {m} :l
|
||||
{b} values = one or more bond types
|
||||
{a} values = one or more angle types
|
||||
{t} values = one or more atom types
|
||||
{m} value = one or more mass values :pre
|
||||
:ule
|
||||
|
||||
[Examples:]
|
||||
|
||||
timestep 8
|
||||
run_style respa 3 2 8 bond 1 pair 2 kspace 3
|
||||
fix cor all filter/corotate m 1.0 :pre
|
||||
|
||||
fix cor all filter/corotate b 4 19 a 3 5 2 :pre
|
||||
|
||||
[Description:]
|
||||
|
||||
This fix implements a corotational filter for a mollified impulse
|
||||
method. In biomolecular simulations, it allows the usage of larger
|
||||
timesteps for long-range electrostatic interactions. For details, see
|
||||
"(Fath)"_#Fath2017.
|
||||
|
||||
When using "run_style respa"_run_style.html for a biomolecular
|
||||
simulation with high-frequency covalent bonds, the outer time-step is
|
||||
restricted to below ~ 4fs due to resonance problems. This fix filters
|
||||
the outer stage of the respa and thus a larger (outer) time-step can
|
||||
be used. Since in large biomolecular simulations the computation of
|
||||
the long-range electrostatic contributions poses a major bottleneck,
|
||||
this can significantly accelerate the simulation.
|
||||
|
||||
The filter computes a cluster decomposition of the molecular structure
|
||||
following the criteria indicated by the options a, b, t and m. This
|
||||
process is similar to the approach in "fix shake"_fix_shake.html,
|
||||
however, the clusters are not kept contrained. Instead, the position
|
||||
is slightly modified only for the computation of long-range forces. A
|
||||
good cluster decomposition constitutes in building clusters which
|
||||
contain the fastest covalent bonds inside clusters.
|
||||
|
||||
If the clusters are chosen suitably, the "run_style
|
||||
respa"_run_style.html is stable for outer time-steps of at least 8fs.
|
||||
|
||||
:line
|
||||
|
||||
[Restart, fix_modify, output, run start/stop, minimize info:]
|
||||
|
||||
No information about these fixes is written to "binary restart
|
||||
files"_restart.html. None of the "fix_modify"_fix_modify.html options
|
||||
are relevant to these fixes. No global or per-atom quantities are
|
||||
stored by these fixes for access by various "output
|
||||
commands"_Section_howto.html#howto_15. No parameter of these fixes
|
||||
can be used with the {start/stop} keywords of the "run"_run.html
|
||||
command. These fixes are not invoked during "energy
|
||||
minimization"_minimize.html.
|
||||
|
||||
[Restrictions:]
|
||||
|
||||
This fix is part of the USER-MISC package. It is only enabled if
|
||||
LAMMPS was built with that package. See the "Making
|
||||
LAMMPS"_Section_start.html#start_3 section for more info.
|
||||
|
||||
Currently, it does not support "molecule templates"_molecule.html.
|
||||
|
||||
[Related commands:]
|
||||
|
||||
|
||||
[Default:] none
|
||||
|
||||
:line
|
||||
|
||||
:link(Fath2017)
|
||||
[(Fath)] Fath, Hochbruck, Singh, J Comp Phys, 333, 180-198 (2017).
|
||||
@ -15,15 +15,16 @@ fix ID group-ID halt N attribute operator avalue keyword value ... :pre
|
||||
ID, group-ID are documented in "fix"_fix.html command :ulb,l
|
||||
halt = style name of this fix command :l
|
||||
N = check halt condition every N steps :l
|
||||
attribute = hstyle or v_name :l
|
||||
hstyle = {bondmax}
|
||||
attribute = {bondmax} or {tlimit} or v_name :l
|
||||
bondmax = length of longest bond in the system
|
||||
tlimit = elapsed CPU time
|
||||
v_name = name of "equal-style variable"_variable.html :pre
|
||||
operator = "<" or "<=" or ">" or ">=" or "==" or "!=" or "|^" :l
|
||||
avalue = numeric value to compare attribute to :l
|
||||
string = text string to print with optional variable names :l
|
||||
zero or more keyword/value pairs may be appended :l
|
||||
keyword = {error} :l
|
||||
{error} value = {hard} or {soft} or {continue} :pre
|
||||
keyword = {error} or {message} :l
|
||||
{error} value = {hard} or {soft} or {continue}
|
||||
{message} value = {yes} or {no} :pre
|
||||
:ule
|
||||
|
||||
[Examples:]
|
||||
@ -40,14 +41,33 @@ specified by the "run"_run.html or "minimize"_minimize.html command.
|
||||
|
||||
The specified group-ID is ignored by this fix.
|
||||
|
||||
The specified {attribute} can be one of the {hstyle} options listed
|
||||
above, or an "equal-style variable"_variable.html referenced as
|
||||
{v_name}, where "name" is the name of a variable that has been defined
|
||||
previously in the input script.
|
||||
The specified {attribute} can be one of the options listed above,
|
||||
namely {bondmax} or {tlimit}, or an "equal-style
|
||||
variable"_variable.html referenced as {v_name}, where "name" is the
|
||||
name of a variable that has been defined previously in the input
|
||||
script.
|
||||
|
||||
The only {hstyle} option currently implemented is {bondmax}. This
|
||||
will loop over all bonds in the system, compute their current
|
||||
lengths, and set {attribute} to the longest bond distance.
|
||||
The {bondmax} attribute will loop over all bonds in the system,
|
||||
compute their current lengths, and set {attribute} to the longest bond
|
||||
distance.
|
||||
|
||||
The {tlimit} attribute queries the elapsed CPU time (in seconds) since
|
||||
the current run began, and sets {attribute} to that value. This is an
|
||||
alternative way to limit the length of a simulation run, similar to
|
||||
the "timer"_timer.html timeout command. There are two differences in
|
||||
using this method versus the timer command option. The first is that
|
||||
the clock starts at the beginning of the current run (not when the
|
||||
timer or fix command is specified), so that any setup time for the run
|
||||
is not included in the elapsed time. The second is that the timer
|
||||
invocation and syncing across all processors (via MPI_Allreduce) is
|
||||
not performed once every {N} steps by this command. Instead it is
|
||||
performed (typically) only a small number of times and the elapsed
|
||||
times are used to predict when the end-of-the-run will be. Both of
|
||||
these attributes can be useful when performing benchmark calculations
|
||||
for a desired length of time with minmimal overhead. For example, if
|
||||
a run is performing 1000s of timesteps/sec, the overhead for syncing
|
||||
the timer frequently across a large number of processors may be
|
||||
non-negligble.
|
||||
|
||||
Equal-style variables evaluate to a numeric value. See the
|
||||
"variable"_variable.html command for a description. They calculate
|
||||
@ -100,6 +120,14 @@ Note that you may wish use the "unfix"_unfix.html command on the fix
|
||||
halt ID, so that the same condition is not immediately triggered in a
|
||||
subsequent run.
|
||||
|
||||
The optional {message} keyword determines whether a message is printed
|
||||
to the screen and logfile when the halt condition is triggered. If
|
||||
{message} is set to yes, a one line message with the values that
|
||||
triggered the halt is printed. If {message} is set to no, no message
|
||||
is printed; the run simply exits. The latter may be desirable for
|
||||
post-processing tools that extract thermodyanmic information from log
|
||||
files.
|
||||
|
||||
[Restart, fix_modify, output, run start/stop, minimize info:]
|
||||
|
||||
No information about this fix is written to "binary restart
|
||||
@ -118,4 +146,4 @@ This fix is not invoked during "energy minimization"_minimize.html.
|
||||
|
||||
[Default:]
|
||||
|
||||
The option defaults are error = hard.
|
||||
The option defaults are error = hard and message = yes.
|
||||
|
||||
@ -36,7 +36,7 @@ uses charges on each atom. The "fix qeq/comb"_fix_qeq_comb.html
|
||||
command should be used to perform charge equilibration with the "COMB
|
||||
potential"_pair_comb.html. For more technical details about the
|
||||
charge equilibration performed by fix qeq/reax, see the
|
||||
"(Aktulga)"_#Aktulga paper.
|
||||
"(Aktulga)"_#qeq-Aktulga paper.
|
||||
|
||||
The QEq method minimizes the electrostatic energy of the system by
|
||||
adjusting the partial charge on individual atoms based on interactions
|
||||
@ -119,6 +119,6 @@ be used for periodic cell dimensions less than 10 angstroms.
|
||||
:link(Nakano)
|
||||
[(Nakano)] Nakano, Computer Physics Communications, 104, 59-69 (1997).
|
||||
|
||||
:link(Aktulga)
|
||||
(Aktulga) Aktulga, Fogarty, Pandit, Grama, Parallel Computing, 38,
|
||||
:link(qeq-Aktulga)
|
||||
[(Aktulga)] Aktulga, Fogarty, Pandit, Grama, Parallel Computing, 38,
|
||||
245-259 (2012).
|
||||
|
||||
@ -42,6 +42,7 @@ Fixes :h1
|
||||
fix_eos_table_rx
|
||||
fix_evaporate
|
||||
fix_external
|
||||
fix_filter_corotate
|
||||
fix_flow_gauss
|
||||
fix_freeze
|
||||
fix_gcmc
|
||||
|
||||
@ -12,7 +12,7 @@ info command :h3
|
||||
|
||||
info args :pre
|
||||
|
||||
args = one or more of the following keywords: {out}, {all}, {system}, {communication}, {computes}, {dumps}, {fixes}, {groups}, {regions}, {variables}, {styles}, {time}, or {configuration}
|
||||
args = one or more of the following keywords: {out}, {all}, {system}, {memory}, {communication}, {computes}, {dumps}, {fixes}, {groups}, {regions}, {variables}, {styles}, {time}, or {configuration}
|
||||
{out} values = {screen}, {log}, {append} filename, {overwrite} filename
|
||||
{styles} values = {all}, {angle}, {atom}, {bond}, {compute}, {command}, {dump}, {dihedral}, {fix}, {improper}, {integrate}, {kspace}, {minimize}, {pair}, {region} :ul
|
||||
|
||||
@ -40,6 +40,17 @@ to that file, which is either appended to or overwritten, respectively.
|
||||
|
||||
The {all} flag activates printing all categories listed below.
|
||||
|
||||
The {configuration} category prints some information about the
|
||||
LAMMPS version as well as architecture and OS it is run on.
|
||||
|
||||
The {memory} category prints some information about the current
|
||||
memory allocation of MPI rank 0 (this the amount of dynamically
|
||||
allocated memory reported by LAMMPS classes). Where supported,
|
||||
also some OS specific information about the size of the reserved
|
||||
memory pool size (this is where malloc() and the new operator
|
||||
request memory from) and the maximum resident set size is reported
|
||||
(this is the maximum amount of physical memory occupied so far).
|
||||
|
||||
The {system} category prints a general system overview listing. This
|
||||
includes the unit style, atom style, number of atoms, bonds, angles,
|
||||
dihedrals, and impropers and the number of the respective types, box
|
||||
@ -93,11 +104,6 @@ region :ul
|
||||
The {time} category prints the accumulated CPU and wall time for the
|
||||
process that writes output (usually MPI rank 0).
|
||||
|
||||
The {configuration} command prints some information about the LAMMPS
|
||||
version and architecture and OS it is run on. Where supported, also
|
||||
information about the memory consumption provided by the OS is
|
||||
reported.
|
||||
|
||||
[Restrictions:] none
|
||||
|
||||
[Related commands:]
|
||||
|
||||
@ -168,6 +168,7 @@ fix_eos_table.html
|
||||
fix_eos_table_rx.html
|
||||
fix_evaporate.html
|
||||
fix_external.html
|
||||
fix_filter_corotate.html
|
||||
fix_flow_gauss.html
|
||||
fix_freeze.html
|
||||
fix_gcmc.html
|
||||
|
||||
@ -62,12 +62,13 @@ args = arguments specific to the style :l
|
||||
{no_affinity} values = none
|
||||
{kokkos} args = keyword value ...
|
||||
zero or more keyword/value pairs may be appended
|
||||
keywords = {neigh} or {newton} or {binsize} or {comm} or {comm/exchange} or {comm/forward}
|
||||
{neigh} value = {full} or {half} or {n2} or {full/cluster}
|
||||
keywords = {neigh} or {neigh/qeq} or {newton} or {binsize} or {comm} or {comm/exchange} or {comm/forward}
|
||||
{neigh} value = {full} or {half}
|
||||
full = full neighbor list
|
||||
half = half neighbor list built in thread-safe manner
|
||||
{neigh/qeq} value = {full} or {half}
|
||||
full = full neighbor list
|
||||
half = half neighbor list built in thread-safe manner
|
||||
n2 = non-binning neighbor list build, O(N^2) algorithm
|
||||
full/cluster = full neighbor list with clustered groups of atoms
|
||||
{newton} = {off} or {on}
|
||||
off = set Newton pairwise and bonded flags off (default)
|
||||
on = set Newton pairwise and bonded flags on
|
||||
@ -392,10 +393,7 @@ default value as listed below.
|
||||
|
||||
The {neigh} keyword determines how neighbor lists are built. A value
|
||||
of {half} uses a thread-safe variant of half-neighbor lists,
|
||||
the same as used by most pair styles in LAMMPS. A value of
|
||||
{n2} uses an O(N^2) algorithm to build the neighbor list without
|
||||
binning, where N = # of atoms on a processor. It is typically slower
|
||||
than the other methods, which use binning.
|
||||
the same as used by most pair styles in LAMMPS.
|
||||
|
||||
A value of {full} uses a full neighbor lists and is the default. This
|
||||
performs twice as much computation as the {half} option, however that
|
||||
@ -403,15 +401,9 @@ is often a win because it is thread-safe and doesn't require atomic
|
||||
operations in the calculation of pair forces. For that reason, {full}
|
||||
is the default setting. However, when running in MPI-only mode with 1
|
||||
thread per MPI task, {half} neighbor lists will typically be faster,
|
||||
just as it is for non-accelerated pair styles.
|
||||
|
||||
A value of {full/cluster} is an experimental neighbor style, where
|
||||
particles interact with all particles within a small cluster, if at
|
||||
least one of the clusters particles is within the neighbor cutoff
|
||||
range. This potentially allows for better vectorization on
|
||||
architectures such as the Intel Phi. If also reduces the size of the
|
||||
neighbor list by roughly a factor of the cluster size, thus reducing
|
||||
the total memory footprint considerably.
|
||||
just as it is for non-accelerated pair styles. Similarly, the {neigh/qeq}
|
||||
keyword determines how neighbor lists are built for "fix qeq/reax/kk"_fix_qeq_reax.html.
|
||||
If not explicitly set, the value of {neigh/qeq} will match {neigh}.
|
||||
|
||||
The {newton} keyword sets the Newton flags for pairwise and bonded
|
||||
interactions to {off} or {on}, the same as the "newton"_newton.html
|
||||
@ -582,9 +574,9 @@ is used. If it is not used, you must invoke the package intel
|
||||
command in your input script or or via the "-pk intel" "command-line
|
||||
switch"_Section_start.html#start_7.
|
||||
|
||||
For the KOKKOS package, the option defaults neigh = full, newton =
|
||||
off, binsize = 0.0, and comm = device. These settings are made
|
||||
automatically by the required "-k on" "command-line
|
||||
For the KOKKOS package, the option defaults neigh = full, neigh/qeq
|
||||
= full, newton = off, binsize = 0.0, and comm = device. These settings
|
||||
are made automatically by the required "-k on" "command-line
|
||||
switch"_Section_start.html#start_7. You can change them bu using the
|
||||
package kokkos command in your input script or via the "-pk kokkos"
|
||||
"command-line switch"_Section_start.html#start_7.
|
||||
|
||||
@ -52,7 +52,7 @@ to Stillinger-Weber potential ("SW"_#SW) if we set
|
||||
:c,image(Eqs/polymorphic4.jpg)
|
||||
|
||||
The potential reduces to Tersoff types of potential
|
||||
("Tersoff"_#Tersoff or "Albe"_#Albe) if we set
|
||||
("Tersoff"_#Tersoff or "Albe"_#poly-Albe) if we set
|
||||
|
||||
:c,image(Eqs/polymorphic5.jpg)
|
||||
:c,image(Eqs/polymorphic6.jpg)
|
||||
@ -63,7 +63,7 @@ The potential reduces to Rockett-Tersoff ("Wang"_#Wang) type if we set
|
||||
:c,image(Eqs/polymorphic6.jpg)
|
||||
:c,image(Eqs/polymorphic8.jpg)
|
||||
|
||||
The potential becomes embedded atom method ("Daw"_#Daw) if we set
|
||||
The potential becomes embedded atom method ("Daw"_#poly-Daw) if we set
|
||||
|
||||
:c,image(Eqs/polymorphic9.jpg)
|
||||
|
||||
@ -218,12 +218,12 @@ F. P. Doty, J. Mater. Sci. Res., 4, 15 (2015).
|
||||
:link(Tersoff)
|
||||
[(Tersoff)] J. Tersoff, Phys. Rev. B, 39, 5566 (1989).
|
||||
|
||||
:link(Albe)
|
||||
:link(poly-Albe)
|
||||
[(Albe)] K. Albe, K. Nordlund, J. Nord, and A. Kuronen, Phys. Rev. B,
|
||||
66, 035205 (2002).
|
||||
|
||||
:link(Wang)
|
||||
[(Wang)] J. Wang, and A. Rockett, Phys. Rev. B, 43, 12571 (1991).
|
||||
|
||||
:link(Daw)
|
||||
:link(poly-Daw)
|
||||
[(Daw)] M. S. Daw, and M. I. Baskes, Phys. Rev. B, 29, 6443 (1984).
|
||||
|
||||
@ -23,9 +23,9 @@ pair_coeff * * SiC.tersoff.zbl Si C Si :pre
|
||||
[Description:]
|
||||
|
||||
The {tersoff/zbl} style computes a 3-body Tersoff potential
|
||||
"(Tersoff_1)"_#Tersoff_1 with a close-separation pairwise modification
|
||||
"(Tersoff_1)"_#zbl-Tersoff_1 with a close-separation pairwise modification
|
||||
based on a Coulomb potential and the Ziegler-Biersack-Littmark
|
||||
universal screening function "(ZBL)"_#ZBL, giving the energy E of a
|
||||
universal screening function "(ZBL)"_#zbl-ZBL, giving the energy E of a
|
||||
system of atoms as
|
||||
|
||||
:c,image(Eqs/pair_tersoff_zbl.jpg)
|
||||
@ -146,16 +146,16 @@ be set to 0.0 if desired.
|
||||
Note that the twobody parameters in entries such as SiCC and CSiSi
|
||||
are often the same, due to the common use of symmetric mixing rules,
|
||||
but this is not always the case. For example, the beta and n parameters in
|
||||
Tersoff_2 "(Tersoff_2)"_#Tersoff_2 are not symmetric.
|
||||
Tersoff_2 "(Tersoff_2)"_#zbl-Tersoff_2 are not symmetric.
|
||||
|
||||
We chose the above form so as to enable users to define all commonly
|
||||
used variants of the Tersoff portion of the potential. In particular,
|
||||
our form reduces to the original Tersoff form when m = 3 and gamma =
|
||||
1, while it reduces to the form of "Albe et al."_#Albe when beta = 1
|
||||
1, while it reduces to the form of "Albe et al."_#zbl-Albe when beta = 1
|
||||
and m = 1. Note that in the current Tersoff implementation in LAMMPS,
|
||||
m must be specified as either 3 or 1. Tersoff used a slightly
|
||||
different but equivalent form for alloys, which we will refer to as
|
||||
Tersoff_2 potential "(Tersoff_2)"_#Tersoff_2.
|
||||
Tersoff_2 potential "(Tersoff_2)"_#zbl-Tersoff_2.
|
||||
|
||||
LAMMPS parameter values for Tersoff_2 can be obtained as follows:
|
||||
gamma = omega_ijk, lambda3 = 0 and the value of
|
||||
@ -253,16 +253,16 @@ units.
|
||||
|
||||
:line
|
||||
|
||||
:link(Tersoff_1)
|
||||
:link(zbl-Tersoff_1)
|
||||
[(Tersoff_1)] J. Tersoff, Phys Rev B, 37, 6991 (1988).
|
||||
|
||||
:link(ZBL)
|
||||
:link(zbl-ZBL)
|
||||
[(ZBL)] J.F. Ziegler, J.P. Biersack, U. Littmark, 'Stopping and Ranges
|
||||
of Ions in Matter' Vol 1, 1985, Pergamon Press.
|
||||
|
||||
:link(Albe)
|
||||
:link(zbl-Albe)
|
||||
[(Albe)] J. Nord, K. Albe, P. Erhart and K. Nordlund, J. Phys.:
|
||||
Condens. Matter, 15, 5649(2003).
|
||||
|
||||
:link(Tersoff_2)
|
||||
:link(zbl-Tersoff_2)
|
||||
[(Tersoff_2)] J. Tersoff, Phys Rev B, 39, 5566 (1989); errata (PRB 41, 3248)
|
||||
|
||||
@ -17,7 +17,7 @@ status = numerical exit status (optional)
|
||||
[Examples:]
|
||||
|
||||
quit
|
||||
if "$n > 10000" then "quit 1":pre
|
||||
if "$n > 10000" then "quit 1" :pre
|
||||
|
||||
[Description:]
|
||||
|
||||
|
||||
@ -36,7 +36,7 @@ args = list of arguments for a particular style :l
|
||||
elaplong = timesteps since start of initial run in a series of runs
|
||||
dt = timestep size
|
||||
time = simulation time
|
||||
cpu = elapsed CPU time in seconds
|
||||
cpu = elapsed CPU time in seconds since start of this run
|
||||
tpcpu = time per CPU second
|
||||
spcpu = timesteps per CPU second
|
||||
cpuremain = estimated CPU time remaining in run
|
||||
|
||||
60
doc/utils/converters/lammpsdoc/doc_anchor_check.py
Executable file
60
doc/utils/converters/lammpsdoc/doc_anchor_check.py
Executable file
@ -0,0 +1,60 @@
|
||||
#! /usr/bin/env python3
|
||||
# LAMMPS Documentation Utilities
|
||||
#
|
||||
# Scan for duplicate anchor labels in documentation files
|
||||
#
|
||||
# Copyright (C) 2017 Richard Berger
|
||||
#
|
||||
# This program is free software: you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation, either version 3 of the License, or
|
||||
# (at your option) any later version.
|
||||
#
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
import re
|
||||
import sys
|
||||
import argparse
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description='scan for duplicate anchor labels in documentation files')
|
||||
parser.add_argument('files', metavar='file', nargs='+', help='one or more files to scan')
|
||||
parsed_args = parser.parse_args()
|
||||
|
||||
anchor_pattern = re.compile(r'^:link\(([^,\)]*)\)')
|
||||
anchors = {}
|
||||
|
||||
for filename in parsed_args.files:
|
||||
with open(filename, 'rt') as f:
|
||||
for line_number, line in enumerate(f):
|
||||
m = anchor_pattern.match(line)
|
||||
if m:
|
||||
label = m.group(1)
|
||||
if label in anchors:
|
||||
anchors[label].append((filename, line_number+1))
|
||||
else:
|
||||
anchors[label] = [(filename, line_number+1)]
|
||||
|
||||
count = 0
|
||||
|
||||
for label in sorted(anchors.keys()):
|
||||
if len(anchors[label]) > 1:
|
||||
print(label)
|
||||
count += 1
|
||||
for filename, line_number in anchors[label]:
|
||||
print(" - %s:%d" % (filename, line_number))
|
||||
|
||||
|
||||
if count > 0:
|
||||
print("Found %d anchor label errors." % count)
|
||||
sys.exit(1)
|
||||
else:
|
||||
print("No anchor label errors.")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -12,6 +12,7 @@ setup(name='LAMMPS Documentation Utilities',
|
||||
tests_require=['nose'],
|
||||
entry_points = {
|
||||
"console_scripts": ['txt2html = lammpsdoc.txt2html:main',
|
||||
'txt2rst = lammpsdoc.txt2rst:main']
|
||||
'txt2rst = lammpsdoc.txt2rst:main',
|
||||
'doc_anchor_check = lammpsdoc.doc_anchor_check:main ']
|
||||
},
|
||||
)
|
||||
|
||||
630
examples/USER/cgdna/util/generate.py
Normal file
630
examples/USER/cgdna/util/generate.py
Normal file
@ -0,0 +1,630 @@
|
||||
#!/usr/bin/env python
|
||||
"""
|
||||
/* ----------------------------------------------------------------------
|
||||
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.
|
||||
------------------------------------------------------------------------- */
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
Contributing author: Oliver Henrich (EPCC, University of Edinburgh)
|
||||
------------------------------------------------------------------------- */
|
||||
"""
|
||||
|
||||
|
||||
"""
|
||||
Import basic modules
|
||||
"""
|
||||
import sys, os, timeit
|
||||
|
||||
from timeit import default_timer as timer
|
||||
start_time = timer()
|
||||
"""
|
||||
Try to import numpy; if failed, import a local version mynumpy
|
||||
which needs to be provided
|
||||
"""
|
||||
try:
|
||||
import numpy as np
|
||||
except:
|
||||
print >> sys.stderr, "numpy not found. Exiting."
|
||||
sys.exit(1)
|
||||
|
||||
"""
|
||||
Check that the required arguments (box offset and size in simulation units
|
||||
and the sequence file were provided
|
||||
"""
|
||||
try:
|
||||
box_offset = float(sys.argv[1])
|
||||
box_length = float(sys.argv[2])
|
||||
infile = sys.argv[3]
|
||||
except:
|
||||
print >> sys.stderr, "Usage: %s <%s> <%s> <%s>" % (sys.argv[0], \
|
||||
"box offset", "box length", "file with sequences")
|
||||
sys.exit(1)
|
||||
box = np.array ([box_length, box_length, box_length])
|
||||
|
||||
"""
|
||||
Try to open the file and fail gracefully if file cannot be opened
|
||||
"""
|
||||
try:
|
||||
inp = open (infile, 'r')
|
||||
inp.close()
|
||||
except:
|
||||
print >> sys.stderr, "Could not open file '%s' for reading. \
|
||||
Aborting." % infile
|
||||
sys.exit(2)
|
||||
|
||||
# return parts of a string
|
||||
def partition(s, d):
|
||||
if d in s:
|
||||
sp = s.split(d, 1)
|
||||
return sp[0], d, sp[1]
|
||||
else:
|
||||
return s, "", ""
|
||||
|
||||
"""
|
||||
Define the model constants
|
||||
"""
|
||||
# set model constants
|
||||
PI = np.pi
|
||||
POS_BASE = 0.4
|
||||
POS_BACK = -0.4
|
||||
EXCL_RC1 = 0.711879214356
|
||||
EXCL_RC2 = 0.335388426126
|
||||
EXCL_RC3 = 0.52329943261
|
||||
|
||||
"""
|
||||
Define auxillary variables for the construction of a helix
|
||||
"""
|
||||
# center of the double strand
|
||||
CM_CENTER_DS = POS_BASE + 0.2
|
||||
|
||||
# ideal distance between base sites of two nucleotides
|
||||
# which are to be base paired in a duplex
|
||||
BASE_BASE = 0.3897628551303122
|
||||
|
||||
# cutoff distance for overlap check
|
||||
RC2 = 16
|
||||
|
||||
# squares of the excluded volume distances for overlap check
|
||||
RC2_BACK = EXCL_RC1**2
|
||||
RC2_BASE = EXCL_RC2**2
|
||||
RC2_BACK_BASE = EXCL_RC3**2
|
||||
|
||||
# enumeration to translate from letters to numbers and vice versa
|
||||
number_to_base = {1 : 'A', 2 : 'C', 3 : 'G', 4 : 'T'}
|
||||
base_to_number = {'A' : 1, 'a' : 1, 'C' : 2, 'c' : 2,
|
||||
'G' : 3, 'g' : 3, 'T' : 4, 't' : 4}
|
||||
|
||||
# auxillary arrays
|
||||
positions = []
|
||||
a1s = []
|
||||
a3s = []
|
||||
quaternions = []
|
||||
|
||||
newpositions = []
|
||||
newa1s = []
|
||||
newa3s = []
|
||||
|
||||
basetype = []
|
||||
strandnum = []
|
||||
|
||||
bonds = []
|
||||
|
||||
"""
|
||||
Convert local body frame to quaternion DOF
|
||||
"""
|
||||
def exyz_to_quat (mya1, mya3):
|
||||
|
||||
mya2 = np.cross(mya3, mya1)
|
||||
myquat = [1,0,0,0]
|
||||
|
||||
q0sq = 0.25 * (mya1[0] + mya2[1] + mya3[2] + 1.0)
|
||||
q1sq = q0sq - 0.5 * (mya2[1] + mya3[2])
|
||||
q2sq = q0sq - 0.5 * (mya1[0] + mya3[2])
|
||||
q3sq = q0sq - 0.5 * (mya1[0] + mya2[1])
|
||||
|
||||
# some component must be greater than 1/4 since they sum to 1
|
||||
# compute other components from it
|
||||
|
||||
if q0sq >= 0.25:
|
||||
myquat[0] = np.sqrt(q0sq)
|
||||
myquat[1] = (mya2[2] - mya3[1]) / (4.0*myquat[0])
|
||||
myquat[2] = (mya3[0] - mya1[2]) / (4.0*myquat[0])
|
||||
myquat[3] = (mya1[1] - mya2[0]) / (4.0*myquat[0])
|
||||
elif q1sq >= 0.25:
|
||||
myquat[1] = np.sqrt(q1sq)
|
||||
myquat[0] = (mya2[2] - mya3[1]) / (4.0*myquat[1])
|
||||
myquat[2] = (mya2[0] + mya1[1]) / (4.0*myquat[1])
|
||||
myquat[3] = (mya1[2] + mya3[0]) / (4.0*myquat[1])
|
||||
elif q2sq >= 0.25:
|
||||
myquat[2] = np.sqrt(q2sq)
|
||||
myquat[0] = (mya3[0] - mya1[2]) / (4.0*myquat[2])
|
||||
myquat[1] = (mya2[0] + mya1[1]) / (4.0*myquat[2])
|
||||
myquat[3] = (mya3[1] + mya2[2]) / (4.0*myquat[2])
|
||||
elif q3sq >= 0.25:
|
||||
myquat[3] = np.sqrt(q3sq)
|
||||
myquat[0] = (mya1[1] - mya2[0]) / (4.0*myquat[3])
|
||||
myquat[1] = (mya3[0] + mya1[2]) / (4.0*myquat[3])
|
||||
myquat[2] = (mya3[1] + mya2[2]) / (4.0*myquat[3])
|
||||
|
||||
norm = 1.0/np.sqrt(myquat[0]*myquat[0] + myquat[1]*myquat[1] + \
|
||||
myquat[2]*myquat[2] + myquat[3]*myquat[3])
|
||||
myquat[0] *= norm
|
||||
myquat[1] *= norm
|
||||
myquat[2] *= norm
|
||||
myquat[3] *= norm
|
||||
|
||||
return np.array([myquat[0],myquat[1],myquat[2],myquat[3]])
|
||||
|
||||
"""
|
||||
Adds a strand to the system by appending it to the array of previous strands
|
||||
"""
|
||||
def add_strands (mynewpositions, mynewa1s, mynewa3s):
|
||||
overlap = False
|
||||
|
||||
# This is a simple check for each of the particles where for previously
|
||||
# placed particles i we check whether it overlaps with any of the
|
||||
# newly created particles j
|
||||
|
||||
print >> sys.stdout, "## Checking for overlaps"
|
||||
|
||||
for i in xrange(len(positions)):
|
||||
|
||||
p = positions[i]
|
||||
pa1 = a1s[i]
|
||||
|
||||
for j in xrange (len(mynewpositions)):
|
||||
|
||||
q = mynewpositions[j]
|
||||
qa1 = mynewa1s[j]
|
||||
|
||||
# skip particles that are anyway too far away
|
||||
dr = p - q
|
||||
dr -= box * np.rint (dr / box)
|
||||
if np.dot(dr, dr) > RC2:
|
||||
continue
|
||||
|
||||
# base site and backbone site of the two particles
|
||||
p_pos_back = p + pa1 * POS_BACK
|
||||
p_pos_base = p + pa1 * POS_BASE
|
||||
q_pos_back = q + qa1 * POS_BACK
|
||||
q_pos_base = q + qa1 * POS_BASE
|
||||
|
||||
# check for no overlap between the two backbone sites
|
||||
dr = p_pos_back - q_pos_back
|
||||
dr -= box * np.rint (dr / box)
|
||||
if np.dot(dr, dr) < RC2_BACK:
|
||||
overlap = True
|
||||
|
||||
# check for no overlap between the two base sites
|
||||
dr = p_pos_base - q_pos_base
|
||||
dr -= box * np.rint (dr / box)
|
||||
if np.dot(dr, dr) < RC2_BASE:
|
||||
overlap = True
|
||||
|
||||
# check for no overlap between backbone site of particle p
|
||||
# with base site of particle q
|
||||
dr = p_pos_back - q_pos_base
|
||||
dr -= box * np.rint (dr / box)
|
||||
if np.dot(dr, dr) < RC2_BACK_BASE:
|
||||
overlap = True
|
||||
|
||||
# check for no overlap between base site of particle p and
|
||||
# backbone site of particle q
|
||||
dr = p_pos_base - q_pos_back
|
||||
dr -= box * np.rint (dr / box)
|
||||
if np.dot(dr, dr) < RC2_BACK_BASE:
|
||||
overlap = True
|
||||
|
||||
# exit if there is an overlap
|
||||
if overlap:
|
||||
return False
|
||||
|
||||
# append to the existing list if no overlap is found
|
||||
if not overlap:
|
||||
|
||||
for p in mynewpositions:
|
||||
positions.append(p)
|
||||
for p in mynewa1s:
|
||||
a1s.append (p)
|
||||
for p in mynewa3s:
|
||||
a3s.append (p)
|
||||
# calculate quaternion from local body frame and append
|
||||
for ia in xrange(len(mynewpositions)):
|
||||
mynewquaternions = exyz_to_quat(mynewa1s[ia],mynewa3s[ia])
|
||||
quaternions.append(mynewquaternions)
|
||||
|
||||
return True
|
||||
|
||||
|
||||
"""
|
||||
Returns the rotation matrix defined by an axis and angle
|
||||
"""
|
||||
def get_rotation_matrix(axis, anglest):
|
||||
# The argument anglest can be either an angle in radiants
|
||||
# (accepted types are float, int or np.float64 or np.float64)
|
||||
# or a tuple [angle, units] where angle is a number and
|
||||
# units is a string. It tells the routine whether to use degrees,
|
||||
# radiants (the default) or base pairs turns.
|
||||
if not isinstance (anglest, (np.float64, np.float32, float, int)):
|
||||
if len(anglest) > 1:
|
||||
if anglest[1] in ["degrees", "deg", "o"]:
|
||||
#angle = np.deg2rad (anglest[0])
|
||||
angle = (np.pi / 180.) * (anglest[0])
|
||||
elif anglest[1] in ["bp"]:
|
||||
angle = int(anglest[0]) * (np.pi / 180.) * (35.9)
|
||||
else:
|
||||
angle = float(anglest[0])
|
||||
else:
|
||||
angle = float(anglest[0])
|
||||
else:
|
||||
angle = float(anglest) # in degrees (?)
|
||||
|
||||
axis = np.array(axis)
|
||||
axis /= np.sqrt(np.dot(axis, axis))
|
||||
|
||||
ct = np.cos(angle)
|
||||
st = np.sin(angle)
|
||||
olc = 1. - ct
|
||||
x, y, z = axis
|
||||
|
||||
return np.array([[olc*x*x+ct, olc*x*y-st*z, olc*x*z+st*y],
|
||||
[olc*x*y+st*z, olc*y*y+ct, olc*y*z-st*x],
|
||||
[olc*x*z-st*y, olc*y*z+st*x, olc*z*z+ct]])
|
||||
|
||||
"""
|
||||
Generates the position and orientation vectors of a
|
||||
(single or double) strand from a sequence string
|
||||
"""
|
||||
def generate_strand(bp, sequence=None, start_pos=np.array([0, 0, 0]), \
|
||||
dir=np.array([0, 0, 1]), perp=False, double=True, rot=0.):
|
||||
# generate empty arrays
|
||||
mynewpositions, mynewa1s, mynewa3s = [], [], []
|
||||
|
||||
# cast the provided start_pos array into a numpy array
|
||||
start_pos = np.array(start_pos, dtype=float)
|
||||
|
||||
# overall direction of the helix
|
||||
dir = np.array(dir, dtype=float)
|
||||
if sequence == None:
|
||||
sequence = np.random.randint(1, 5, bp)
|
||||
|
||||
# the elseif here is most likely redundant
|
||||
elif len(sequence) != bp:
|
||||
n = bp - len(sequence)
|
||||
sequence += np.random.randint(1, 5, n)
|
||||
print >> sys.stderr, "sequence is too short, adding %d random bases" % n
|
||||
|
||||
# normalize direction
|
||||
dir_norm = np.sqrt(np.dot(dir,dir))
|
||||
if dir_norm < 1e-10:
|
||||
print >> sys.stderr, "direction must be a valid vector, \
|
||||
defaulting to (0, 0, 1)"
|
||||
dir = np.array([0, 0, 1])
|
||||
else: dir /= dir_norm
|
||||
|
||||
# find a vector orthogonal to dir to act as helix direction,
|
||||
# if not provided switch off random orientation
|
||||
if perp is None or perp is False:
|
||||
v1 = np.random.random_sample(3)
|
||||
v1 -= dir * (np.dot(dir, v1))
|
||||
v1 /= np.sqrt(sum(v1*v1))
|
||||
else:
|
||||
v1 = perp;
|
||||
|
||||
# generate rotational matrix representing the overall rotation of the helix
|
||||
R0 = get_rotation_matrix(dir, rot)
|
||||
|
||||
# rotation matrix corresponding to one step along the helix
|
||||
R = get_rotation_matrix(dir, [1, "bp"])
|
||||
|
||||
# set the vector a1 (backbone to base) to v1
|
||||
a1 = v1
|
||||
|
||||
# apply the global rotation to a1
|
||||
a1 = np.dot(R0, a1)
|
||||
|
||||
# set the position of the fist backbone site to start_pos
|
||||
rb = np.array(start_pos)
|
||||
|
||||
# set a3 to the direction of the helix
|
||||
a3 = dir
|
||||
for i in range(bp):
|
||||
# work out the position of the centre of mass of the nucleotide
|
||||
rcdm = rb - CM_CENTER_DS * a1
|
||||
|
||||
# append to newpositions
|
||||
mynewpositions.append(rcdm)
|
||||
mynewa1s.append(a1)
|
||||
mynewa3s.append(a3)
|
||||
|
||||
# if we are not at the end of the helix, we work out a1 and rb for the
|
||||
# next nucleotide along the helix
|
||||
if i != bp - 1:
|
||||
a1 = np.dot(R, a1)
|
||||
rb += a3 * BASE_BASE
|
||||
|
||||
# if we are working on a double strand, we do a cycle similar
|
||||
# to the previous one but backwards
|
||||
if double == True:
|
||||
a1 = -a1
|
||||
a3 = -dir
|
||||
R = R.transpose()
|
||||
for i in range(bp):
|
||||
rcdm = rb - CM_CENTER_DS * a1
|
||||
mynewpositions.append (rcdm)
|
||||
mynewa1s.append (a1)
|
||||
mynewa3s.append (a3)
|
||||
a1 = np.dot(R, a1)
|
||||
rb += a3 * BASE_BASE
|
||||
|
||||
assert (len (mynewpositions) > 0)
|
||||
|
||||
return [mynewpositions, mynewa1s, mynewa3s]
|
||||
|
||||
|
||||
"""
|
||||
Main function for this script.
|
||||
Reads a text file with the following format:
|
||||
- Each line contains the sequence for a single strand (A,C,G,T)
|
||||
- Lines beginning with the keyword 'DOUBLE' produce double-stranded DNA
|
||||
|
||||
Ex: Two ssDNA (single stranded DNA)
|
||||
ATATATA
|
||||
GCGCGCG
|
||||
|
||||
Ex: Two strands, one double stranded, the other single stranded.
|
||||
DOUBLE AGGGCT
|
||||
CCTGTA
|
||||
|
||||
"""
|
||||
|
||||
def read_strands(filename):
|
||||
try:
|
||||
infile = open (filename)
|
||||
except:
|
||||
print >> sys.stderr, "Could not open file '%s'. Aborting." % filename
|
||||
sys.exit(2)
|
||||
|
||||
# This block works out the number of nucleotides and strands by reading
|
||||
# the number of non-empty lines in the input file and the number of letters,
|
||||
# taking the possible DOUBLE keyword into account.
|
||||
nstrands, nnucl, nbonds = 0, 0, 0
|
||||
lines = infile.readlines()
|
||||
for line in lines:
|
||||
line = line.upper().strip()
|
||||
if len(line) == 0:
|
||||
continue
|
||||
if line[:6] == 'DOUBLE':
|
||||
line = line.split()[1]
|
||||
length = len(line)
|
||||
print >> sys.stdout, "## Found duplex of %i base pairs" % length
|
||||
nnucl += 2*length
|
||||
nstrands += 2
|
||||
nbonds += (2*length-2)
|
||||
else:
|
||||
line = line.split()[0]
|
||||
length = len(line)
|
||||
print >> sys.stdout, \
|
||||
"## Found single strand of %i bases" % length
|
||||
nnucl += length
|
||||
nstrands += 1
|
||||
nbonds += length-1
|
||||
# rewind the sequence input file
|
||||
infile.seek(0)
|
||||
|
||||
print >> sys.stdout, "## nstrands, nnucl = ", nstrands, nnucl
|
||||
|
||||
# generate the data file in LAMMPS format
|
||||
try:
|
||||
out = open ("data.oxdna", "w")
|
||||
except:
|
||||
print >> sys.stderr, "Could not open data file for writing. Aborting."
|
||||
sys.exit(2)
|
||||
|
||||
lines = infile.readlines()
|
||||
nlines = len(lines)
|
||||
i = 1
|
||||
myns = 0
|
||||
noffset = 1
|
||||
|
||||
for line in lines:
|
||||
line = line.upper().strip()
|
||||
|
||||
# skip empty lines
|
||||
if len(line) == 0:
|
||||
i += 1
|
||||
continue
|
||||
|
||||
# block for duplexes: last argument of the generate function
|
||||
# is set to 'True'
|
||||
if line[:6] == 'DOUBLE':
|
||||
line = line.split()[1]
|
||||
length = len(line)
|
||||
seq = [(base_to_number[x]) for x in line]
|
||||
|
||||
myns += 1
|
||||
for b in xrange(length):
|
||||
basetype.append(seq[b])
|
||||
strandnum.append(myns)
|
||||
|
||||
for b in xrange(length-1):
|
||||
bondpair = [noffset + b, noffset + b + 1]
|
||||
bonds.append(bondpair)
|
||||
noffset += length
|
||||
|
||||
# create the sequence of the second strand as made of
|
||||
# complementary bases
|
||||
seq2 = [5-s for s in seq]
|
||||
seq2.reverse()
|
||||
|
||||
myns += 1
|
||||
for b in xrange(length):
|
||||
basetype.append(seq2[b])
|
||||
strandnum.append(myns)
|
||||
|
||||
for b in xrange(length-1):
|
||||
bondpair = [noffset + b, noffset + b + 1]
|
||||
bonds.append(bondpair)
|
||||
noffset += length
|
||||
|
||||
print >> sys.stdout, "## Created duplex of %i bases" % (2*length)
|
||||
|
||||
# generate random position of the first nucleotide
|
||||
cdm = box_offset + np.random.random_sample(3) * box
|
||||
|
||||
# generate the random direction of the helix
|
||||
axis = np.random.random_sample(3)
|
||||
axis /= np.sqrt(np.dot(axis, axis))
|
||||
|
||||
# use the generate function defined above to create
|
||||
# the position and orientation vector of the strand
|
||||
newpositions, newa1s, newa3s = generate_strand(len(line), \
|
||||
sequence=seq, dir=axis, start_pos=cdm, double=True)
|
||||
|
||||
# generate a new position for the strand until it does not overlap
|
||||
# with anything already present
|
||||
start = timer()
|
||||
while not add_strands(newpositions, newa1s, newa3s):
|
||||
cdm = box_offset + np.random.random_sample(3) * box
|
||||
axis = np.random.random_sample(3)
|
||||
axis /= np.sqrt(np.dot(axis, axis))
|
||||
newpositions, newa1s, newa3s = generate_strand(len(line), \
|
||||
sequence=seq, dir=axis, start_pos=cdm, double=True)
|
||||
print >> sys.stdout, "## Trying %i" % i
|
||||
end = timer()
|
||||
print >> sys.stdout, "## Added duplex of %i bases (line %i/%i) in %.2fs, now at %i/%i" % \
|
||||
(2*length, i, nlines, end-start, len(positions), nnucl)
|
||||
|
||||
# block for single strands: last argument of the generate function
|
||||
# is set to 'False'
|
||||
else:
|
||||
length = len(line)
|
||||
seq = [(base_to_number[x]) for x in line]
|
||||
|
||||
myns += 1
|
||||
for b in xrange(length):
|
||||
basetype.append(seq[b])
|
||||
strandnum.append(myns)
|
||||
|
||||
for b in xrange(length-1):
|
||||
bondpair = [noffset + b, noffset + b + 1]
|
||||
bonds.append(bondpair)
|
||||
noffset += length
|
||||
|
||||
# generate random position of the first nucleotide
|
||||
cdm = box_offset + np.random.random_sample(3) * box
|
||||
|
||||
# generate the random direction of the helix
|
||||
axis = np.random.random_sample(3)
|
||||
axis /= np.sqrt(np.dot(axis, axis))
|
||||
|
||||
print >> sys.stdout, \
|
||||
"## Created single strand of %i bases" % length
|
||||
|
||||
newpositions, newa1s, newa3s = generate_strand(length, \
|
||||
sequence=seq, dir=axis, start_pos=cdm, double=False)
|
||||
start = timer()
|
||||
while not add_strands(newpositions, newa1s, newa3s):
|
||||
cdm = box_offset + np.random.random_sample(3) * box
|
||||
axis = np.random.random_sample(3)
|
||||
axis /= np.sqrt(np.dot(axis, axis))
|
||||
newpositions, newa1s, newa3s = generate_strand(length, \
|
||||
sequence=seq, dir=axis, start_pos=cdm, double=False)
|
||||
print >> sys.stdout, "## Trying %i" % (i)
|
||||
end = timer()
|
||||
print >> sys.stdout, "## Added single strand of %i bases (line %i/%i) in %.2fs, now at %i/%i" % \
|
||||
(length, i, nlines, end-start,len(positions), nnucl)
|
||||
|
||||
i += 1
|
||||
|
||||
# sanity check
|
||||
if not len(positions) == nnucl:
|
||||
print len(positions), nnucl
|
||||
raise AssertionError
|
||||
|
||||
out.write('# LAMMPS data file\n')
|
||||
out.write('%d atoms\n' % nnucl)
|
||||
out.write('%d ellipsoids\n' % nnucl)
|
||||
out.write('%d bonds\n' % nbonds)
|
||||
out.write('\n')
|
||||
out.write('4 atom types\n')
|
||||
out.write('1 bond types\n')
|
||||
out.write('\n')
|
||||
out.write('# System size\n')
|
||||
out.write('%f %f xlo xhi\n' % (box_offset,box_offset+box_length))
|
||||
out.write('%f %f ylo yhi\n' % (box_offset,box_offset+box_length))
|
||||
out.write('%f %f zlo zhi\n' % (box_offset,box_offset+box_length))
|
||||
|
||||
out.write('\n')
|
||||
out.write('Masses\n')
|
||||
out.write('\n')
|
||||
out.write('1 3.1575\n')
|
||||
out.write('2 3.1575\n')
|
||||
out.write('3 3.1575\n')
|
||||
out.write('4 3.1575\n')
|
||||
|
||||
# for each nucleotide print a line under the headers
|
||||
# Atoms, Velocities, Ellipsoids and Bonds
|
||||
out.write('\n')
|
||||
out.write(\
|
||||
'# Atom-ID, type, position, molecule-ID, ellipsoid flag, density\n')
|
||||
out.write('Atoms\n')
|
||||
out.write('\n')
|
||||
|
||||
for i in xrange(nnucl):
|
||||
out.write('%d %d %22.15le %22.15le %22.15le %d 1 1\n' \
|
||||
% (i+1, basetype[i], \
|
||||
positions[i][0], positions[i][1], positions[i][2], \
|
||||
strandnum[i]))
|
||||
|
||||
out.write('\n')
|
||||
out.write('# Atom-ID, translational, rotational velocity\n')
|
||||
out.write('Velocities\n')
|
||||
out.write('\n')
|
||||
|
||||
for i in xrange(nnucl):
|
||||
out.write("%d %22.15le %22.15le %22.15le %22.15le %22.15le %22.15le\n" \
|
||||
% (i+1,0.0,0.0,0.0,0.0,0.0,0.0))
|
||||
|
||||
out.write('\n')
|
||||
out.write('# Atom-ID, shape, quaternion\n')
|
||||
out.write('Ellipsoids\n')
|
||||
out.write('\n')
|
||||
|
||||
for i in xrange(nnucl):
|
||||
out.write(\
|
||||
"%d %22.15le %22.15le %22.15le %22.15le %22.15le %22.15le %22.15le\n" \
|
||||
% (i+1,1.1739845031423408,1.1739845031423408,1.1739845031423408, \
|
||||
quaternions[i][0],quaternions[i][1], quaternions[i][2],quaternions[i][3]))
|
||||
|
||||
out.write('\n')
|
||||
out.write('# Bond topology\n')
|
||||
out.write('Bonds\n')
|
||||
out.write('\n')
|
||||
|
||||
for i in xrange(nbonds):
|
||||
out.write("%d %d %d %d\n" % (i+1,1,bonds[i][0],bonds[i][1]))
|
||||
|
||||
out.close()
|
||||
|
||||
print >> sys.stdout, "## Wrote data to 'data.oxdna'"
|
||||
print >> sys.stdout, "## DONE"
|
||||
|
||||
# call the above main() function, which executes the program
|
||||
read_strands (infile)
|
||||
|
||||
end_time=timer()
|
||||
runtime = end_time-start_time
|
||||
hours = runtime/3600
|
||||
minutes = (runtime-np.rint(hours)*3600)/60
|
||||
seconds = (runtime-np.rint(hours)*3600-np.rint(minutes)*60)%60
|
||||
print >> sys.stdout, "## Total runtime %ih:%im:%.2fs" % (hours,minutes,seconds)
|
||||
@ -29,7 +29,7 @@ def single():
|
||||
|
||||
strandstart=len(nucleotide)+1
|
||||
|
||||
for letter in strand[2]:
|
||||
for letter in strand[1]:
|
||||
temp=[]
|
||||
|
||||
temp.append(nt2num[letter])
|
||||
@ -58,7 +58,7 @@ def single_helix():
|
||||
strand = inp[1].split(':')
|
||||
|
||||
com_start=strand[0].split(',')
|
||||
twist=float(strand[1])
|
||||
twist=0.6
|
||||
|
||||
posx = float(com_start[0])
|
||||
posy = float(com_start[1])
|
||||
@ -79,7 +79,7 @@ def single_helix():
|
||||
qrot2=0
|
||||
qrot3=math.sin(0.5*twist)
|
||||
|
||||
for letter in strand[2]:
|
||||
for letter in strand[1]:
|
||||
temp=[]
|
||||
|
||||
temp.append(nt2num[letter])
|
||||
@ -114,7 +114,7 @@ def duplex():
|
||||
strand = inp[1].split(':')
|
||||
|
||||
com_start=strand[0].split(',')
|
||||
twist=float(strand[1])
|
||||
twist=0.6
|
||||
|
||||
compstrand=[]
|
||||
comptopo=[]
|
||||
@ -145,7 +145,7 @@ def duplex():
|
||||
qrot2=0
|
||||
qrot3=math.sin(0.5*twist)
|
||||
|
||||
for letter in strand[2]:
|
||||
for letter in strand[1]:
|
||||
temp1=[]
|
||||
temp2=[]
|
||||
|
||||
@ -189,7 +189,7 @@ def duplex():
|
||||
|
||||
if (len(nucleotide)+1 > strandstart):
|
||||
topology.append([1,len(nucleotide),len(nucleotide)+1])
|
||||
comptopo.append([1,len(nucleotide)+len(strand[2]),len(nucleotide)+len(strand[2])+1])
|
||||
comptopo.append([1,len(nucleotide)+len(strand[1]),len(nucleotide)+len(strand[1])+1])
|
||||
|
||||
nucleotide.append(temp1)
|
||||
compstrand.append(temp2)
|
||||
@ -208,7 +208,7 @@ def duplex_array():
|
||||
strand = inp[1].split(':')
|
||||
number=strand[0].split(',')
|
||||
posz1_0 = float(strand[1])
|
||||
twist=float(strand[2])
|
||||
twist=0.6
|
||||
|
||||
nx = int(number[0])
|
||||
ny = int(number[1])
|
||||
@ -249,7 +249,7 @@ def duplex_array():
|
||||
qrot2=0
|
||||
qrot3=math.sin(0.5*twist)
|
||||
|
||||
for letter in strand[3]:
|
||||
for letter in strand[2]:
|
||||
temp1=[]
|
||||
temp2=[]
|
||||
|
||||
@ -293,7 +293,7 @@ def duplex_array():
|
||||
|
||||
if (len(nucleotide)+1 > strandstart):
|
||||
topology.append([1,len(nucleotide),len(nucleotide)+1])
|
||||
comptopo.append([1,len(nucleotide)+len(strand[3]),len(nucleotide)+len(strand[3])+1])
|
||||
comptopo.append([1,len(nucleotide)+len(strand[2]),len(nucleotide)+len(strand[2])+1])
|
||||
|
||||
nucleotide.append(temp1)
|
||||
compstrand.append(temp2)
|
||||
@ -1,4 +1,3 @@
|
||||
single 0,0,0:0.6:AAAAA
|
||||
single_helix 0,0,0:0.6:AAAAA
|
||||
duplex 0,0,0:0.6:AAAAA
|
||||
duplex_array 10,10:-112.0:0.6:AAAAA
|
||||
DOUBLE ACGTA
|
||||
|
||||
ACGTA
|
||||
|
||||
4
examples/USER/cgdna/util/sequence_simple.txt
Normal file
4
examples/USER/cgdna/util/sequence_simple.txt
Normal file
@ -0,0 +1,4 @@
|
||||
single 0,0,0:AAAAA
|
||||
single_helix 0,0,0:AAAAA
|
||||
duplex 0,0,0:AAAAA
|
||||
duplex_array 10,10:-112.0:AAAAA
|
||||
6587
examples/USER/misc/filter-corotate/data.bpti
Normal file
6587
examples/USER/misc/filter-corotate/data.bpti
Normal file
File diff suppressed because it is too large
Load Diff
6531
examples/USER/misc/filter-corotate/data.peptide
Normal file
6531
examples/USER/misc/filter-corotate/data.peptide
Normal file
File diff suppressed because it is too large
Load Diff
43
examples/USER/misc/filter-corotate/in.bpti
Normal file
43
examples/USER/misc/filter-corotate/in.bpti
Normal file
@ -0,0 +1,43 @@
|
||||
|
||||
units real
|
||||
|
||||
atom_style full
|
||||
bond_style harmonic
|
||||
angle_style charmm
|
||||
dihedral_style charmm
|
||||
improper_style harmonic
|
||||
|
||||
pair_style lj/charmm/coul/long 8 10
|
||||
pair_modify mix arithmetic
|
||||
kspace_style pppm 1e-4
|
||||
|
||||
read_data data.bpti
|
||||
|
||||
special_bonds charmm
|
||||
neigh_modify delay 2 every 1
|
||||
|
||||
|
||||
# ------------- MINIMIZE ----------
|
||||
|
||||
minimize 1e-4 1e-6 1000 10000
|
||||
reset_timestep 0
|
||||
|
||||
# ------------- RUN ---------------
|
||||
|
||||
thermo 100
|
||||
thermo_style multi
|
||||
timestep 8
|
||||
|
||||
run_style respa 3 2 8 bond 1 pair 2 kspace 3
|
||||
|
||||
velocity all create 200.0 12345678 dist uniform
|
||||
#dump dump1 all atom 100 4pti.dump
|
||||
|
||||
fix 1 all nvt temp 200 300 25
|
||||
fix cor all filter/corotate m 1.0
|
||||
|
||||
run 1000
|
||||
|
||||
unfix cor
|
||||
unfix 1
|
||||
|
||||
32
examples/USER/misc/filter-corotate/in.peptide
Normal file
32
examples/USER/misc/filter-corotate/in.peptide
Normal file
@ -0,0 +1,32 @@
|
||||
# Solvated 5-mer peptide, run for 8ps in NVT
|
||||
|
||||
units real
|
||||
atom_style full
|
||||
|
||||
pair_style lj/charmm/coul/long 8.0 10.0 10.0
|
||||
bond_style harmonic
|
||||
angle_style charmm
|
||||
dihedral_style charmm
|
||||
improper_style harmonic
|
||||
kspace_style pppm 0.0001
|
||||
|
||||
read_data data.peptide
|
||||
|
||||
neighbor 2.0 bin
|
||||
neigh_modify delay 5
|
||||
|
||||
thermo 50
|
||||
#dump dump1 all atom 100 peptide.dump
|
||||
|
||||
timestep 8
|
||||
|
||||
run_style respa 3 2 8 bond 1 pair 2 kspace 3
|
||||
|
||||
fix 1 all nvt temp 250.0 250.0 100.0 tchain 1
|
||||
fix cor all filter/corotate m 1.0
|
||||
run 1000
|
||||
unfix cor
|
||||
unfix 1
|
||||
|
||||
|
||||
|
||||
240
examples/USER/misc/filter-corotate/log.10Mar2017.bpti.g++.1
Normal file
240
examples/USER/misc/filter-corotate/log.10Mar2017.bpti.g++.1
Normal file
@ -0,0 +1,240 @@
|
||||
LAMMPS (10 Mar 2017)
|
||||
using 1 OpenMP thread(s) per MPI task
|
||||
|
||||
units real
|
||||
|
||||
atom_style full
|
||||
bond_style harmonic
|
||||
angle_style charmm
|
||||
dihedral_style charmm
|
||||
improper_style harmonic
|
||||
|
||||
pair_style lj/charmm/coul/long 8 10
|
||||
pair_modify mix arithmetic
|
||||
kspace_style pppm 1e-4
|
||||
|
||||
read_data data.bpti
|
||||
orthogonal box = (-10 -10 -30) to (50 50 30)
|
||||
1 by 1 by 1 MPI processor grid
|
||||
reading atoms ...
|
||||
892 atoms
|
||||
scanning bonds ...
|
||||
4 = max bonds/atom
|
||||
scanning angles ...
|
||||
6 = max angles/atom
|
||||
scanning dihedrals ...
|
||||
18 = max dihedrals/atom
|
||||
scanning impropers ...
|
||||
2 = max impropers/atom
|
||||
reading bonds ...
|
||||
906 bonds
|
||||
reading angles ...
|
||||
1626 angles
|
||||
reading dihedrals ...
|
||||
2501 dihedrals
|
||||
reading impropers ...
|
||||
137 impropers
|
||||
4 = max # of 1-2 neighbors
|
||||
9 = max # of 1-3 neighbors
|
||||
19 = max # of 1-4 neighbors
|
||||
21 = max # of special neighbors
|
||||
|
||||
special_bonds charmm
|
||||
neigh_modify delay 2 every 1
|
||||
|
||||
|
||||
# ------------- MINIMIZE ----------
|
||||
|
||||
minimize 1e-4 1e-6 1000 10000
|
||||
WARNING: Resetting reneighboring criteria during minimization (../min.cpp:168)
|
||||
PPPM initialization ...
|
||||
WARNING: System is not charge neutral, net charge = 6 (../kspace.cpp:302)
|
||||
WARNING: Using 12-bit tables for long-range coulomb (../kspace.cpp:321)
|
||||
G vector (1/distance) = 0.203272
|
||||
grid = 16 16 16
|
||||
stencil order = 5
|
||||
estimated absolute RMS force accuracy = 0.0316399
|
||||
estimated relative force accuracy = 9.52826e-05
|
||||
using double precision FFTs
|
||||
3d grid and FFT values/proc = 9261 4096
|
||||
Neighbor list info ...
|
||||
update every 1 steps, delay 0 steps, check yes
|
||||
max neighbors/atom: 2000, page size: 100000
|
||||
master list distance cutoff = 12
|
||||
ghost atom cutoff = 12
|
||||
binsize = 6, bins = 10 10 10
|
||||
1 neighbor lists, perpetual/occasional/extra = 1 0 0
|
||||
(1) pair lj/charmm/coul/long, perpetual
|
||||
attributes: half, newton on
|
||||
pair build: half/bin/newton
|
||||
stencil: half/bin/3d/newton
|
||||
bin: standard
|
||||
Per MPI rank memory usage (min/avg/max) = 17.8596/1/0 Mbytes
|
||||
Step Temp E_pair E_mol TotEng Press
|
||||
0 0 -3075.6498 943.91164 -2131.7381 -380.67776
|
||||
241 0 -4503.313 749.58662 -3753.7264 -29.045104
|
||||
Loop time of 3.35722 on 1 procs for 241 steps with 892 atoms
|
||||
|
||||
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads
|
||||
|
||||
Minimization stats:
|
||||
Stopping criterion = energy tolerance
|
||||
Energy initial, next-to-last, final =
|
||||
-2131.73812515 -3753.43984087 -3753.72636847
|
||||
Force two-norm initial, final = 1086.21 26.3688
|
||||
Force max component initial, final = 310.811 3.92748
|
||||
Final line search alpha, max atom move = 0.00596649 0.0234333
|
||||
Iterations, force evaluations = 241 463
|
||||
|
||||
MPI task timing breakdown:
|
||||
Section | min time | avg time | max time |%varavg| %total
|
||||
---------------------------------------------------------------
|
||||
Pair | 2.5003 | 2.5003 | 2.5003 | 0.0 | 74.48
|
||||
Bond | 0.24287 | 0.24287 | 0.24287 | 0.0 | 7.23
|
||||
Kspace | 0.53428 | 0.53428 | 0.53428 | 0.0 | 15.91
|
||||
Neigh | 0.069765 | 0.069765 | 0.069765 | 0.0 | 2.08
|
||||
Comm | 0.00065374 | 0.00065374 | 0.00065374 | 0.0 | 0.02
|
||||
Output | 0 | 0 | 0 | 0.0 | 0.00
|
||||
Modify | 0 | 0 | 0 | 0.0 | 0.00
|
||||
Other | | 0.009358 | | | 0.28
|
||||
|
||||
Nlocal: 892 ave 892 max 892 min
|
||||
Histogram: 1 0 0 0 0 0 0 0 0 0
|
||||
Nghost: 31 ave 31 max 31 min
|
||||
Histogram: 1 0 0 0 0 0 0 0 0 0
|
||||
Neighs: 148891 ave 148891 max 148891 min
|
||||
Histogram: 1 0 0 0 0 0 0 0 0 0
|
||||
|
||||
Total # of neighbors = 148891
|
||||
Ave neighs/atom = 166.918
|
||||
Ave special neighs/atom = 10.9395
|
||||
Neighbor list builds = 15
|
||||
Dangerous builds = 0
|
||||
reset_timestep 0
|
||||
|
||||
# ------------- RUN ---------------
|
||||
|
||||
thermo 100
|
||||
thermo_style multi
|
||||
timestep 8
|
||||
|
||||
run_style respa 3 2 8 bond 1 pair 2 kspace 3
|
||||
Respa levels:
|
||||
1 = bond angle dihedral improper
|
||||
2 = pair
|
||||
3 = kspace
|
||||
|
||||
velocity all create 200.0 12345678 dist uniform
|
||||
#dump dump1 all atom 100 4pti.dump
|
||||
|
||||
fix 1 all nvt temp 200 300 25
|
||||
fix cor all filter/corotate m 1.0
|
||||
163 = # of size 2 clusters
|
||||
0 = # of size 3 clusters
|
||||
25 = # of size 4 clusters
|
||||
0 = # of size 5 clusters
|
||||
100 = # of frozen angles
|
||||
|
||||
run 1000
|
||||
PPPM initialization ...
|
||||
WARNING: Using 12-bit tables for long-range coulomb (../kspace.cpp:321)
|
||||
G vector (1/distance) = 0.203272
|
||||
grid = 16 16 16
|
||||
stencil order = 5
|
||||
estimated absolute RMS force accuracy = 0.0316399
|
||||
estimated relative force accuracy = 9.52826e-05
|
||||
using double precision FFTs
|
||||
3d grid and FFT values/proc = 9261 4096
|
||||
Per MPI rank memory usage (min/avg/max) = 19.5425/1/0 Mbytes
|
||||
---------------- Step 0 ----- CPU = 0.0000 (sec) ----------------
|
||||
TotEng = -3220.3378 KinEng = 531.1804 Temp = 200.0000
|
||||
PotEng = -3751.5181 E_bond = 42.2810 E_angle = 345.2592
|
||||
E_dihed = 337.8361 E_impro = 24.2103 E_vdwl = -288.5339
|
||||
E_coul = -886.3622 E_long = -3326.2088 Press = 83.2283
|
||||
---------------- Step 100 ----- CPU = 3.9414 (sec) ----------------
|
||||
TotEng = -2718.8970 KinEng = 538.6206 Temp = 202.8014
|
||||
PotEng = -3257.5176 E_bond = 203.3367 E_angle = 566.5317
|
||||
E_dihed = 397.6202 E_impro = 34.6623 E_vdwl = -248.7451
|
||||
E_coul = -874.5122 E_long = -3336.4111 Press = 135.8662
|
||||
---------------- Step 200 ----- CPU = 7.9028 (sec) ----------------
|
||||
TotEng = -2660.1406 KinEng = 626.3319 Temp = 235.8265
|
||||
PotEng = -3286.4725 E_bond = 209.5147 E_angle = 591.7773
|
||||
E_dihed = 388.9591 E_impro = 29.4992 E_vdwl = -243.5808
|
||||
E_coul = -923.5115 E_long = -3339.1306 Press = 88.9000
|
||||
---------------- Step 300 ----- CPU = 11.8246 (sec) ----------------
|
||||
TotEng = -2673.8090 KinEng = 616.7924 Temp = 232.2346
|
||||
PotEng = -3290.6014 E_bond = 202.8254 E_angle = 568.6860
|
||||
E_dihed = 378.4182 E_impro = 38.2399 E_vdwl = -221.3236
|
||||
E_coul = -915.3004 E_long = -3342.1468 Press = 78.8527
|
||||
---------------- Step 400 ----- CPU = 15.7990 (sec) ----------------
|
||||
TotEng = -2614.9416 KinEng = 649.3474 Temp = 244.4922
|
||||
PotEng = -3264.2890 E_bond = 211.6116 E_angle = 617.2026
|
||||
E_dihed = 399.8744 E_impro = 40.2678 E_vdwl = -211.7790
|
||||
E_coul = -978.1624 E_long = -3343.3041 Press = -4.1958
|
||||
---------------- Step 500 ----- CPU = 19.8146 (sec) ----------------
|
||||
TotEng = -2588.6772 KinEng = 660.1424 Temp = 248.5568
|
||||
PotEng = -3248.8196 E_bond = 218.4786 E_angle = 620.8605
|
||||
E_dihed = 390.3220 E_impro = 41.6794 E_vdwl = -226.3657
|
||||
E_coul = -953.1676 E_long = -3340.6269 Press = 99.3200
|
||||
---------------- Step 600 ----- CPU = 23.8587 (sec) ----------------
|
||||
TotEng = -2550.4618 KinEng = 693.3384 Temp = 261.0557
|
||||
PotEng = -3243.8002 E_bond = 232.3563 E_angle = 606.2922
|
||||
E_dihed = 396.2469 E_impro = 37.1980 E_vdwl = -235.8425
|
||||
E_coul = -937.1208 E_long = -3342.9303 Press = -21.7737
|
||||
---------------- Step 700 ----- CPU = 27.8381 (sec) ----------------
|
||||
TotEng = -2554.4355 KinEng = 692.8951 Temp = 260.8888
|
||||
PotEng = -3247.3306 E_bond = 216.3395 E_angle = 637.7785
|
||||
E_dihed = 391.5940 E_impro = 43.1426 E_vdwl = -187.6159
|
||||
E_coul = -1008.1694 E_long = -3340.3998 Press = 75.1484
|
||||
---------------- Step 800 ----- CPU = 31.8039 (sec) ----------------
|
||||
TotEng = -2508.3551 KinEng = 699.0766 Temp = 263.2163
|
||||
PotEng = -3207.4317 E_bond = 241.9936 E_angle = 641.3631
|
||||
E_dihed = 386.2198 E_impro = 43.7793 E_vdwl = -217.7523
|
||||
E_coul = -964.6070 E_long = -3338.4282 Press = -127.7337
|
||||
---------------- Step 900 ----- CPU = 35.7700 (sec) ----------------
|
||||
TotEng = -2452.7644 KinEng = 762.1842 Temp = 286.9776
|
||||
PotEng = -3214.9485 E_bond = 243.9191 E_angle = 649.8664
|
||||
E_dihed = 382.4351 E_impro = 39.0029 E_vdwl = -221.3389
|
||||
E_coul = -970.8965 E_long = -3337.9366 Press = 122.7720
|
||||
---------------- Step 1000 ----- CPU = 39.7695 (sec) ----------------
|
||||
TotEng = -2386.6805 KinEng = 799.0253 Temp = 300.8490
|
||||
PotEng = -3185.7058 E_bond = 265.3649 E_angle = 661.7543
|
||||
E_dihed = 374.6843 E_impro = 38.6877 E_vdwl = -229.2030
|
||||
E_coul = -960.7041 E_long = -3336.2899 Press = -17.9910
|
||||
Loop time of 39.7695 on 1 procs for 1000 steps with 892 atoms
|
||||
|
||||
Performance: 17.380 ns/day, 1.381 hours/ns, 25.145 timesteps/s
|
||||
99.6% CPU use with 1 MPI tasks x 1 OpenMP threads
|
||||
|
||||
MPI task timing breakdown:
|
||||
Section | min time | avg time | max time |%varavg| %total
|
||||
---------------------------------------------------------------
|
||||
Pair | 29.169 | 29.169 | 29.169 | 0.0 | 73.34
|
||||
Bond | 7.6249 | 7.6249 | 7.6249 | 0.0 | 19.17
|
||||
Kspace | 1.1525 | 1.1525 | 1.1525 | 0.0 | 2.90
|
||||
Neigh | 0.87606 | 0.87606 | 0.87606 | 0.0 | 2.20
|
||||
Comm | 0.01563 | 0.01563 | 0.01563 | 0.0 | 0.04
|
||||
Output | 0.00048423 | 0.00048423 | 0.00048423 | 0.0 | 0.00
|
||||
Modify | 0.80446 | 0.80446 | 0.80446 | 0.0 | 2.02
|
||||
Other | | 0.1266 | | | 0.32
|
||||
|
||||
Nlocal: 892 ave 892 max 892 min
|
||||
Histogram: 1 0 0 0 0 0 0 0 0 0
|
||||
Nghost: 27 ave 27 max 27 min
|
||||
Histogram: 1 0 0 0 0 0 0 0 0 0
|
||||
Neighs: 146206 ave 146206 max 146206 min
|
||||
Histogram: 1 0 0 0 0 0 0 0 0 0
|
||||
|
||||
Total # of neighbors = 146206
|
||||
Ave neighs/atom = 163.908
|
||||
Ave special neighs/atom = 10.9395
|
||||
Neighbor list builds = 186
|
||||
Dangerous builds = 0
|
||||
|
||||
unfix cor
|
||||
unfix 1
|
||||
|
||||
|
||||
Please see the log.cite file for references relevant to this simulation
|
||||
|
||||
Total wall time: 0:00:43
|
||||
240
examples/USER/misc/filter-corotate/log.10Mar2017.bpti.g++.4
Normal file
240
examples/USER/misc/filter-corotate/log.10Mar2017.bpti.g++.4
Normal file
@ -0,0 +1,240 @@
|
||||
LAMMPS (10 Mar 2017)
|
||||
using 1 OpenMP thread(s) per MPI task
|
||||
|
||||
units real
|
||||
|
||||
atom_style full
|
||||
bond_style harmonic
|
||||
angle_style charmm
|
||||
dihedral_style charmm
|
||||
improper_style harmonic
|
||||
|
||||
pair_style lj/charmm/coul/long 8 10
|
||||
pair_modify mix arithmetic
|
||||
kspace_style pppm 1e-4
|
||||
|
||||
read_data data.bpti
|
||||
orthogonal box = (-10 -10 -30) to (50 50 30)
|
||||
1 by 2 by 2 MPI processor grid
|
||||
reading atoms ...
|
||||
892 atoms
|
||||
scanning bonds ...
|
||||
4 = max bonds/atom
|
||||
scanning angles ...
|
||||
6 = max angles/atom
|
||||
scanning dihedrals ...
|
||||
18 = max dihedrals/atom
|
||||
scanning impropers ...
|
||||
2 = max impropers/atom
|
||||
reading bonds ...
|
||||
906 bonds
|
||||
reading angles ...
|
||||
1626 angles
|
||||
reading dihedrals ...
|
||||
2501 dihedrals
|
||||
reading impropers ...
|
||||
137 impropers
|
||||
4 = max # of 1-2 neighbors
|
||||
9 = max # of 1-3 neighbors
|
||||
19 = max # of 1-4 neighbors
|
||||
21 = max # of special neighbors
|
||||
|
||||
special_bonds charmm
|
||||
neigh_modify delay 2 every 1
|
||||
|
||||
|
||||
# ------------- MINIMIZE ----------
|
||||
|
||||
minimize 1e-4 1e-6 1000 10000
|
||||
WARNING: Resetting reneighboring criteria during minimization (../min.cpp:168)
|
||||
PPPM initialization ...
|
||||
WARNING: System is not charge neutral, net charge = 6 (../kspace.cpp:302)
|
||||
WARNING: Using 12-bit tables for long-range coulomb (../kspace.cpp:321)
|
||||
G vector (1/distance) = 0.203272
|
||||
grid = 16 16 16
|
||||
stencil order = 5
|
||||
estimated absolute RMS force accuracy = 0.0316399
|
||||
estimated relative force accuracy = 9.52826e-05
|
||||
using double precision FFTs
|
||||
3d grid and FFT values/proc = 3549 1024
|
||||
Neighbor list info ...
|
||||
update every 1 steps, delay 0 steps, check yes
|
||||
max neighbors/atom: 2000, page size: 100000
|
||||
master list distance cutoff = 12
|
||||
ghost atom cutoff = 12
|
||||
binsize = 6, bins = 10 10 10
|
||||
1 neighbor lists, perpetual/occasional/extra = 1 0 0
|
||||
(1) pair lj/charmm/coul/long, perpetual
|
||||
attributes: half, newton on
|
||||
pair build: half/bin/newton
|
||||
stencil: half/bin/3d/newton
|
||||
bin: standard
|
||||
Per MPI rank memory usage (min/avg/max) = 16.9693/0.981879/0 Mbytes
|
||||
Step Temp E_pair E_mol TotEng Press
|
||||
0 0 -3075.6498 943.91164 -2131.7381 -380.67776
|
||||
241 0 -4503.3131 749.58666 -3753.7264 -29.045153
|
||||
Loop time of 1.26594 on 4 procs for 241 steps with 892 atoms
|
||||
|
||||
99.0% CPU use with 4 MPI tasks x 1 OpenMP threads
|
||||
|
||||
Minimization stats:
|
||||
Stopping criterion = energy tolerance
|
||||
Energy initial, next-to-last, final =
|
||||
-2131.73812515 -3753.43983927 -3753.72640137
|
||||
Force two-norm initial, final = 1086.21 26.3688
|
||||
Force max component initial, final = 310.811 3.92751
|
||||
Final line search alpha, max atom move = 0.00596649 0.0234334
|
||||
Iterations, force evaluations = 241 463
|
||||
|
||||
MPI task timing breakdown:
|
||||
Section | min time | avg time | max time |%varavg| %total
|
||||
---------------------------------------------------------------
|
||||
Pair | 0.34267 | 0.63792 | 0.90268 | 25.2 | 50.39
|
||||
Bond | 0.025776 | 0.063318 | 0.095631 | 10.8 | 5.00
|
||||
Kspace | 0.21904 | 0.51601 | 0.84895 | 31.3 | 40.76
|
||||
Neigh | 0.023185 | 0.023363 | 0.023538 | 0.1 | 1.85
|
||||
Comm | 0.012025 | 0.014189 | 0.016335 | 1.4 | 1.12
|
||||
Output | 0 | 0 | 0 | 0.0 | 0.00
|
||||
Modify | 0 | 0 | 0 | 0.0 | 0.00
|
||||
Other | | 0.01114 | | | 0.88
|
||||
|
||||
Nlocal: 223 ave 323 max 89 min
|
||||
Histogram: 1 0 0 0 1 0 0 0 1 1
|
||||
Nghost: 613 ave 675 max 557 min
|
||||
Histogram: 1 0 0 1 0 1 0 0 0 1
|
||||
Neighs: 37222.8 ave 50005 max 20830 min
|
||||
Histogram: 1 0 0 0 1 0 0 1 0 1
|
||||
|
||||
Total # of neighbors = 148891
|
||||
Ave neighs/atom = 166.918
|
||||
Ave special neighs/atom = 10.9395
|
||||
Neighbor list builds = 15
|
||||
Dangerous builds = 0
|
||||
reset_timestep 0
|
||||
|
||||
# ------------- RUN ---------------
|
||||
|
||||
thermo 100
|
||||
thermo_style multi
|
||||
timestep 8
|
||||
|
||||
run_style respa 3 2 8 bond 1 pair 2 kspace 3
|
||||
Respa levels:
|
||||
1 = bond angle dihedral improper
|
||||
2 = pair
|
||||
3 = kspace
|
||||
|
||||
velocity all create 200.0 12345678 dist uniform
|
||||
#dump dump1 all atom 100 4pti.dump
|
||||
|
||||
fix 1 all nvt temp 200 300 25
|
||||
fix cor all filter/corotate m 1.0
|
||||
163 = # of size 2 clusters
|
||||
0 = # of size 3 clusters
|
||||
25 = # of size 4 clusters
|
||||
0 = # of size 5 clusters
|
||||
100 = # of frozen angles
|
||||
|
||||
run 1000
|
||||
PPPM initialization ...
|
||||
WARNING: Using 12-bit tables for long-range coulomb (../kspace.cpp:321)
|
||||
G vector (1/distance) = 0.203272
|
||||
grid = 16 16 16
|
||||
stencil order = 5
|
||||
estimated absolute RMS force accuracy = 0.0316399
|
||||
estimated relative force accuracy = 9.52826e-05
|
||||
using double precision FFTs
|
||||
3d grid and FFT values/proc = 3549 1024
|
||||
Per MPI rank memory usage (min/avg/max) = 17.142/0.97212/0 Mbytes
|
||||
---------------- Step 0 ----- CPU = 0.0000 (sec) ----------------
|
||||
TotEng = -3220.3378 KinEng = 531.1804 Temp = 200.0000
|
||||
PotEng = -3751.5182 E_bond = 42.2810 E_angle = 345.2592
|
||||
E_dihed = 337.8361 E_impro = 24.2103 E_vdwl = -288.5339
|
||||
E_coul = -886.3622 E_long = -3326.2088 Press = 83.2282
|
||||
---------------- Step 100 ----- CPU = 1.5457 (sec) ----------------
|
||||
TotEng = -2718.9184 KinEng = 538.6205 Temp = 202.8014
|
||||
PotEng = -3257.5389 E_bond = 203.3365 E_angle = 566.5311
|
||||
E_dihed = 397.6202 E_impro = 34.6621 E_vdwl = -248.7451
|
||||
E_coul = -874.5326 E_long = -3336.4111 Press = 135.8435
|
||||
---------------- Step 200 ----- CPU = 3.0720 (sec) ----------------
|
||||
TotEng = -2660.1146 KinEng = 626.3474 Temp = 235.8323
|
||||
PotEng = -3286.4620 E_bond = 209.5168 E_angle = 591.7735
|
||||
E_dihed = 388.9615 E_impro = 29.5000 E_vdwl = -243.5840
|
||||
E_coul = -923.4998 E_long = -3339.1299 Press = 88.8857
|
||||
---------------- Step 300 ----- CPU = 4.5597 (sec) ----------------
|
||||
TotEng = -2669.7442 KinEng = 619.3625 Temp = 233.2023
|
||||
PotEng = -3289.1067 E_bond = 203.4405 E_angle = 569.5281
|
||||
E_dihed = 378.3314 E_impro = 38.2880 E_vdwl = -221.1904
|
||||
E_coul = -915.3396 E_long = -3342.1646 Press = 79.3780
|
||||
---------------- Step 400 ----- CPU = 5.9808 (sec) ----------------
|
||||
TotEng = -2618.9975 KinEng = 644.6145 Temp = 242.7102
|
||||
PotEng = -3263.6119 E_bond = 209.5864 E_angle = 618.8954
|
||||
E_dihed = 401.3798 E_impro = 39.9064 E_vdwl = -212.1271
|
||||
E_coul = -977.1589 E_long = -3344.0940 Press = -7.8938
|
||||
---------------- Step 500 ----- CPU = 7.4159 (sec) ----------------
|
||||
TotEng = -2579.7486 KinEng = 666.4643 Temp = 250.9371
|
||||
PotEng = -3246.2129 E_bond = 219.2549 E_angle = 620.3474
|
||||
E_dihed = 388.4395 E_impro = 41.4499 E_vdwl = -225.9686
|
||||
E_coul = -949.3689 E_long = -3340.3672 Press = 113.2543
|
||||
---------------- Step 600 ----- CPU = 8.9252 (sec) ----------------
|
||||
TotEng = -2535.8235 KinEng = 708.5919 Temp = 266.7990
|
||||
PotEng = -3244.4154 E_bond = 243.9451 E_angle = 606.0866
|
||||
E_dihed = 400.0562 E_impro = 33.9708 E_vdwl = -223.1319
|
||||
E_coul = -964.9940 E_long = -3340.3482 Press = -102.4475
|
||||
---------------- Step 700 ----- CPU = 10.4022 (sec) ----------------
|
||||
TotEng = -2552.6681 KinEng = 702.3080 Temp = 264.4330
|
||||
PotEng = -3254.9761 E_bond = 250.8834 E_angle = 639.0977
|
||||
E_dihed = 386.4014 E_impro = 42.3004 E_vdwl = -224.4816
|
||||
E_coul = -1011.8551 E_long = -3337.3222 Press = 10.6424
|
||||
---------------- Step 800 ----- CPU = 11.8699 (sec) ----------------
|
||||
TotEng = -2423.5415 KinEng = 772.1254 Temp = 290.7206
|
||||
PotEng = -3195.6670 E_bond = 238.5831 E_angle = 640.9180
|
||||
E_dihed = 377.7994 E_impro = 40.3135 E_vdwl = -216.5705
|
||||
E_coul = -935.1087 E_long = -3341.6019 Press = -38.2479
|
||||
---------------- Step 900 ----- CPU = 13.3548 (sec) ----------------
|
||||
TotEng = -2394.4779 KinEng = 766.6895 Temp = 288.6739
|
||||
PotEng = -3161.1673 E_bond = 284.8428 E_angle = 671.0959
|
||||
E_dihed = 380.3406 E_impro = 51.2975 E_vdwl = -219.5211
|
||||
E_coul = -990.6305 E_long = -3338.5925 Press = -15.2279
|
||||
---------------- Step 1000 ----- CPU = 14.7908 (sec) ----------------
|
||||
TotEng = -2340.1471 KinEng = 799.0198 Temp = 300.8469
|
||||
PotEng = -3139.1669 E_bond = 271.0389 E_angle = 683.8278
|
||||
E_dihed = 407.0795 E_impro = 39.6209 E_vdwl = -230.5355
|
||||
E_coul = -974.2981 E_long = -3335.9003 Press = -94.3420
|
||||
Loop time of 14.7909 on 4 procs for 1000 steps with 892 atoms
|
||||
|
||||
Performance: 46.732 ns/day, 0.514 hours/ns, 67.609 timesteps/s
|
||||
99.1% CPU use with 4 MPI tasks x 1 OpenMP threads
|
||||
|
||||
MPI task timing breakdown:
|
||||
Section | min time | avg time | max time |%varavg| %total
|
||||
---------------------------------------------------------------
|
||||
Pair | 4.4184 | 7.5543 | 10.133 | 74.2 | 51.07
|
||||
Bond | 0.94027 | 1.9781 | 2.7492 | 54.4 | 13.37
|
||||
Kspace | 0.45487 | 0.45887 | 0.46343 | 0.4 | 3.10
|
||||
Neigh | 0.28145 | 0.28339 | 0.28539 | 0.3 | 1.92
|
||||
Comm | 0.7515 | 4.1484 | 8.3861 | 135.5 | 28.05
|
||||
Output | 0.00049973 | 0.00055474 | 0.00066924 | 0.0 | 0.00
|
||||
Modify | 0.26165 | 0.31142 | 0.35023 | 6.7 | 2.11
|
||||
Other | | 0.05572 | | | 0.38
|
||||
|
||||
Nlocal: 223 ave 313 max 122 min
|
||||
Histogram: 1 0 0 1 0 0 0 1 0 1
|
||||
Nghost: 584.5 ave 605 max 553 min
|
||||
Histogram: 1 0 0 0 0 1 0 0 0 2
|
||||
Neighs: 35448 ave 42093 max 25175 min
|
||||
Histogram: 1 0 0 0 0 0 1 1 0 1
|
||||
|
||||
Total # of neighbors = 141792
|
||||
Ave neighs/atom = 158.96
|
||||
Ave special neighs/atom = 10.9395
|
||||
Neighbor list builds = 186
|
||||
Dangerous builds = 0
|
||||
|
||||
unfix cor
|
||||
unfix 1
|
||||
|
||||
|
||||
Please see the log.cite file for references relevant to this simulation
|
||||
|
||||
Total wall time: 0:00:16
|
||||
146
examples/USER/misc/filter-corotate/log.10Mar2017.peptide.g++.1
Normal file
146
examples/USER/misc/filter-corotate/log.10Mar2017.peptide.g++.1
Normal file
@ -0,0 +1,146 @@
|
||||
LAMMPS (10 Mar 2017)
|
||||
using 1 OpenMP thread(s) per MPI task
|
||||
# Solvated 5-mer peptide, run for 8ps in NVT
|
||||
|
||||
units real
|
||||
atom_style full
|
||||
|
||||
pair_style lj/charmm/coul/long 8.0 10.0 10.0
|
||||
bond_style harmonic
|
||||
angle_style charmm
|
||||
dihedral_style charmm
|
||||
improper_style harmonic
|
||||
kspace_style pppm 0.0001
|
||||
|
||||
read_data data.peptide
|
||||
orthogonal box = (36.8402 41.0137 29.7681) to (64.2116 68.3851 57.1395)
|
||||
1 by 1 by 1 MPI processor grid
|
||||
reading atoms ...
|
||||
2004 atoms
|
||||
reading velocities ...
|
||||
2004 velocities
|
||||
scanning bonds ...
|
||||
3 = max bonds/atom
|
||||
scanning angles ...
|
||||
6 = max angles/atom
|
||||
scanning dihedrals ...
|
||||
14 = max dihedrals/atom
|
||||
scanning impropers ...
|
||||
1 = max impropers/atom
|
||||
reading bonds ...
|
||||
1365 bonds
|
||||
reading angles ...
|
||||
786 angles
|
||||
reading dihedrals ...
|
||||
207 dihedrals
|
||||
reading impropers ...
|
||||
12 impropers
|
||||
4 = max # of 1-2 neighbors
|
||||
7 = max # of 1-3 neighbors
|
||||
14 = max # of 1-4 neighbors
|
||||
18 = max # of special neighbors
|
||||
|
||||
neighbor 2.0 bin
|
||||
neigh_modify delay 5
|
||||
|
||||
thermo 50
|
||||
#dump dump1 all atom 100 peptide.dump
|
||||
|
||||
timestep 8
|
||||
|
||||
run_style respa 3 2 8 bond 1 pair 2 kspace 3
|
||||
Respa levels:
|
||||
1 = bond angle dihedral improper
|
||||
2 = pair
|
||||
3 = kspace
|
||||
|
||||
fix 1 all nvt temp 250.0 250.0 100.0 tchain 1
|
||||
fix cor all filter/corotate m 1.0
|
||||
19 = # of size 2 clusters
|
||||
0 = # of size 3 clusters
|
||||
3 = # of size 4 clusters
|
||||
0 = # of size 5 clusters
|
||||
646 = # of frozen angles
|
||||
run 1000
|
||||
PPPM initialization ...
|
||||
WARNING: Using 12-bit tables for long-range coulomb (../kspace.cpp:321)
|
||||
G vector (1/distance) = 0.268725
|
||||
grid = 15 15 15
|
||||
stencil order = 5
|
||||
estimated absolute RMS force accuracy = 0.0228209
|
||||
estimated relative force accuracy = 6.87243e-05
|
||||
using double precision FFTs
|
||||
3d grid and FFT values/proc = 10648 3375
|
||||
Neighbor list info ...
|
||||
update every 1 steps, delay 5 steps, check yes
|
||||
max neighbors/atom: 2000, page size: 100000
|
||||
master list distance cutoff = 12
|
||||
ghost atom cutoff = 12
|
||||
binsize = 6, bins = 5 5 5
|
||||
1 neighbor lists, perpetual/occasional/extra = 1 0 0
|
||||
(1) pair lj/charmm/coul/long, perpetual
|
||||
attributes: half, newton on
|
||||
pair build: half/bin/newton
|
||||
stencil: half/bin/3d/newton
|
||||
bin: standard
|
||||
Per MPI rank memory usage (min/avg/max) = 22.6706/1/0 Mbytes
|
||||
Step Temp E_pair E_mol TotEng Press
|
||||
0 190.0857 -6785.6785 70.391457 -5580.3684 19434.821
|
||||
50 239.46028 -7546.5667 1092.8874 -5023.9668 -24643.891
|
||||
100 242.81799 -7125.5527 416.0788 -5259.7139 15525.465
|
||||
150 235.97108 -7531.9334 932.35464 -5190.6987 -14838.489
|
||||
200 252.06415 -7195.6011 568.02993 -5122.6064 8841.332
|
||||
250 249.99431 -7586.5092 881.83491 -5212.0676 -9330.345
|
||||
300 240.3382 -7333.0933 633.29951 -5264.8395 5137.9757
|
||||
350 255.34529 -7568.2413 856.46371 -5187.2226 -6206.063
|
||||
400 242.99276 -7419.9031 713.23943 -5255.8602 2447.0091
|
||||
450 251.10653 -7622.061 844.20584 -5278.6079 -4906.6559
|
||||
500 255.59314 -7439.253 710.84907 -5202.3691 1571.0032
|
||||
550 253.2025 -7660.5101 823.05373 -5325.695 -4551.399
|
||||
600 249.05313 -7509.6729 741.48104 -5281.2046 992.87
|
||||
650 251.75984 -7593.6589 847.08244 -5243.4286 -3510.1176
|
||||
700 249.25027 -7601.9112 794.0912 -5319.6557 305.76021
|
||||
750 255.415 -7602.2674 822.98524 -5254.3109 -2333.421
|
||||
800 241.99621 -7643.8878 796.53352 -5402.5008 -298.66565
|
||||
850 253.6428 -7598.3764 816.45457 -5267.5316 -1905.3478
|
||||
900 247.20231 -7690.2806 789.75999 -5424.5838 -1331.7228
|
||||
950 255.92583 -7634.7505 831.18272 -5275.5466 -2186.5117
|
||||
1000 253.2126 -7647.9526 823.93602 -5312.195 -1189.9659
|
||||
Loop time of 150.664 on 1 procs for 1000 steps with 2004 atoms
|
||||
|
||||
Performance: 4.588 ns/day, 5.231 hours/ns, 6.637 timesteps/s
|
||||
99.7% CPU use with 1 MPI tasks x 1 OpenMP threads
|
||||
|
||||
MPI task timing breakdown:
|
||||
Section | min time | avg time | max time |%varavg| %total
|
||||
---------------------------------------------------------------
|
||||
Pair | 135.81 | 135.81 | 135.81 | 0.0 | 90.14
|
||||
Bond | 2.5889 | 2.5889 | 2.5889 | 0.0 | 1.72
|
||||
Kspace | 2.0379 | 2.0379 | 2.0379 | 0.0 | 1.35
|
||||
Neigh | 5.893 | 5.893 | 5.893 | 0.0 | 3.91
|
||||
Comm | 1.6998 | 1.6998 | 1.6998 | 0.0 | 1.13
|
||||
Output | 0.00077915 | 0.00077915 | 0.00077915 | 0.0 | 0.00
|
||||
Modify | 2 | 2 | 2 | 0.0 | 1.33
|
||||
Other | | 0.6352 | | | 0.42
|
||||
|
||||
Nlocal: 2004 ave 2004 max 2004 min
|
||||
Histogram: 1 0 0 0 0 0 0 0 0 0
|
||||
Nghost: 11197 ave 11197 max 11197 min
|
||||
Histogram: 1 0 0 0 0 0 0 0 0 0
|
||||
Neighs: 707779 ave 707779 max 707779 min
|
||||
Histogram: 1 0 0 0 0 0 0 0 0 0
|
||||
|
||||
Total # of neighbors = 707779
|
||||
Ave neighs/atom = 353.183
|
||||
Ave special neighs/atom = 2.34032
|
||||
Neighbor list builds = 200
|
||||
Dangerous builds = 200
|
||||
unfix cor
|
||||
unfix 1
|
||||
|
||||
|
||||
|
||||
|
||||
Please see the log.cite file for references relevant to this simulation
|
||||
|
||||
Total wall time: 0:02:30
|
||||
146
examples/USER/misc/filter-corotate/log.10Mar2017.peptide.g++.4
Normal file
146
examples/USER/misc/filter-corotate/log.10Mar2017.peptide.g++.4
Normal file
@ -0,0 +1,146 @@
|
||||
LAMMPS (10 Mar 2017)
|
||||
using 1 OpenMP thread(s) per MPI task
|
||||
# Solvated 5-mer peptide, run for 8ps in NVT
|
||||
|
||||
units real
|
||||
atom_style full
|
||||
|
||||
pair_style lj/charmm/coul/long 8.0 10.0 10.0
|
||||
bond_style harmonic
|
||||
angle_style charmm
|
||||
dihedral_style charmm
|
||||
improper_style harmonic
|
||||
kspace_style pppm 0.0001
|
||||
|
||||
read_data data.peptide
|
||||
orthogonal box = (36.8402 41.0137 29.7681) to (64.2116 68.3851 57.1395)
|
||||
1 by 2 by 2 MPI processor grid
|
||||
reading atoms ...
|
||||
2004 atoms
|
||||
reading velocities ...
|
||||
2004 velocities
|
||||
scanning bonds ...
|
||||
3 = max bonds/atom
|
||||
scanning angles ...
|
||||
6 = max angles/atom
|
||||
scanning dihedrals ...
|
||||
14 = max dihedrals/atom
|
||||
scanning impropers ...
|
||||
1 = max impropers/atom
|
||||
reading bonds ...
|
||||
1365 bonds
|
||||
reading angles ...
|
||||
786 angles
|
||||
reading dihedrals ...
|
||||
207 dihedrals
|
||||
reading impropers ...
|
||||
12 impropers
|
||||
4 = max # of 1-2 neighbors
|
||||
7 = max # of 1-3 neighbors
|
||||
14 = max # of 1-4 neighbors
|
||||
18 = max # of special neighbors
|
||||
|
||||
neighbor 2.0 bin
|
||||
neigh_modify delay 5
|
||||
|
||||
thermo 50
|
||||
#dump dump1 all atom 100 peptide.dump
|
||||
|
||||
timestep 8
|
||||
|
||||
run_style respa 3 2 8 bond 1 pair 2 kspace 3
|
||||
Respa levels:
|
||||
1 = bond angle dihedral improper
|
||||
2 = pair
|
||||
3 = kspace
|
||||
|
||||
fix 1 all nvt temp 250.0 250.0 100.0 tchain 1
|
||||
fix cor all filter/corotate m 1.0
|
||||
19 = # of size 2 clusters
|
||||
0 = # of size 3 clusters
|
||||
3 = # of size 4 clusters
|
||||
0 = # of size 5 clusters
|
||||
646 = # of frozen angles
|
||||
run 1000
|
||||
PPPM initialization ...
|
||||
WARNING: Using 12-bit tables for long-range coulomb (../kspace.cpp:321)
|
||||
G vector (1/distance) = 0.268725
|
||||
grid = 15 15 15
|
||||
stencil order = 5
|
||||
estimated absolute RMS force accuracy = 0.0228209
|
||||
estimated relative force accuracy = 6.87243e-05
|
||||
using double precision FFTs
|
||||
3d grid and FFT values/proc = 4312 960
|
||||
Neighbor list info ...
|
||||
update every 1 steps, delay 5 steps, check yes
|
||||
max neighbors/atom: 2000, page size: 100000
|
||||
master list distance cutoff = 12
|
||||
ghost atom cutoff = 12
|
||||
binsize = 6, bins = 5 5 5
|
||||
1 neighbor lists, perpetual/occasional/extra = 1 0 0
|
||||
(1) pair lj/charmm/coul/long, perpetual
|
||||
attributes: half, newton on
|
||||
pair build: half/bin/newton
|
||||
stencil: half/bin/3d/newton
|
||||
bin: standard
|
||||
Per MPI rank memory usage (min/avg/max) = 16.8394/0.98826/0 Mbytes
|
||||
Step Temp E_pair E_mol TotEng Press
|
||||
0 190.0857 -6785.6785 70.391457 -5580.3684 19434.821
|
||||
50 239.46028 -7546.5668 1092.8874 -5023.9668 -24643.891
|
||||
100 242.81819 -7125.5629 416.08082 -5259.7209 15525.244
|
||||
150 235.94928 -7531.9186 932.50658 -5190.6621 -14842.431
|
||||
200 255.85551 -7254.4065 568.8803 -5157.9249 8936.8651
|
||||
250 247.8705 -7607.4583 858.06087 -5269.4711 -9926.0442
|
||||
300 257.64176 -7267.424 618.5573 -5110.6004 5173.3307
|
||||
350 251.65439 -7572.3806 821.15745 -5248.7049 -7092.327
|
||||
400 256.87927 -7414.2145 655.33178 -5225.169 4119.4095
|
||||
450 257.12393 -7576.5541 853.39773 -5187.9819 -5224.8823
|
||||
500 242.42371 -7524.705 705.75357 -5371.5455 2111.3878
|
||||
550 248.97188 -7541.076 792.86994 -5261.7038 -2278.4185
|
||||
600 249.81862 -7592.0499 767.17722 -5333.3149 -1149.4759
|
||||
650 253.31349 -7578.2665 813.75975 -5252.0827 -2915.5706
|
||||
700 256.61152 -7588.1475 761.03356 -5294.9988 -747.88089
|
||||
750 248.3606 -7660.457 837.71615 -5339.8883 -3072.8311
|
||||
800 253.81464 -7638.6089 782.4229 -5340.7698 -1025.909
|
||||
850 245.69185 -7660.9036 795.66792 -5398.3172 -2717.5851
|
||||
900 249.13156 -7589.4769 806.43464 -5295.5867 -761.63361
|
||||
950 251.11482 -7691.4981 869.34937 -5322.852 -3282.3031
|
||||
1000 241.9195 -7630.9899 828.59107 -5358.0033 -95.962685
|
||||
Loop time of 45.5507 on 4 procs for 1000 steps with 2004 atoms
|
||||
|
||||
Performance: 15.174 ns/day, 1.582 hours/ns, 21.954 timesteps/s
|
||||
99.4% CPU use with 4 MPI tasks x 1 OpenMP threads
|
||||
|
||||
MPI task timing breakdown:
|
||||
Section | min time | avg time | max time |%varavg| %total
|
||||
---------------------------------------------------------------
|
||||
Pair | 35.545 | 36.674 | 38.004 | 15.8 | 80.51
|
||||
Bond | 0.51302 | 0.67796 | 0.86345 | 18.6 | 1.49
|
||||
Kspace | 0.66031 | 0.68459 | 0.70506 | 2.1 | 1.50
|
||||
Neigh | 1.5605 | 1.5627 | 1.5649 | 0.1 | 3.43
|
||||
Comm | 3.4611 | 4.9841 | 6.294 | 47.2 | 10.94
|
||||
Output | 0.00079799 | 0.00086641 | 0.0010369 | 0.0 | 0.00
|
||||
Modify | 0.67341 | 0.69059 | 0.71186 | 1.7 | 1.52
|
||||
Other | | 0.2762 | | | 0.61
|
||||
|
||||
Nlocal: 501 ave 523 max 473 min
|
||||
Histogram: 1 0 0 0 0 0 2 0 0 1
|
||||
Nghost: 6643.25 ave 6708 max 6566 min
|
||||
Histogram: 1 1 0 0 0 0 0 0 0 2
|
||||
Neighs: 176977 ave 185765 max 164931 min
|
||||
Histogram: 1 0 0 0 1 0 0 0 1 1
|
||||
|
||||
Total # of neighbors = 707908
|
||||
Ave neighs/atom = 353.248
|
||||
Ave special neighs/atom = 2.34032
|
||||
Neighbor list builds = 200
|
||||
Dangerous builds = 200
|
||||
unfix cor
|
||||
unfix 1
|
||||
|
||||
|
||||
|
||||
|
||||
Please see the log.cite file for references relevant to this simulation
|
||||
|
||||
Total wall time: 0:00:45
|
||||
@ -1,5 +1,5 @@
|
||||
// -*- c++ -*-
|
||||
|
||||
// -*- c++ -*-
|
||||
// This file is part of the Collective Variables module (Colvars).
|
||||
// The original version of Colvars and its updates are located at:
|
||||
// https://github.com/colvars/colvars
|
||||
@ -7,6 +7,7 @@
|
||||
// If you wish to distribute your changes, please submit them to the
|
||||
// Colvars repository at GitHub.
|
||||
|
||||
|
||||
#include "colvarmodule.h"
|
||||
#include "colvarvalue.h"
|
||||
#include "colvarparse.h"
|
||||
@ -23,20 +24,31 @@ bool compare(colvar::cvc *i, colvar::cvc *j) {
|
||||
}
|
||||
|
||||
|
||||
colvar::colvar(std::string const &conf)
|
||||
: colvarparse(conf)
|
||||
colvar::colvar()
|
||||
{
|
||||
// Initialize static array once and for all
|
||||
init_cv_requires();
|
||||
}
|
||||
|
||||
|
||||
int colvar::init(std::string const &conf)
|
||||
{
|
||||
cvm::log("Initializing a new collective variable.\n");
|
||||
colvarparse::init(conf);
|
||||
|
||||
int error_code = COLVARS_OK;
|
||||
|
||||
get_keyval(conf, "name", this->name,
|
||||
(std::string("colvar")+cvm::to_str(cvm::colvars.size()+1)));
|
||||
colvarmodule *cv = cvm::main();
|
||||
|
||||
if (cvm::colvar_by_name(this->name) != NULL) {
|
||||
get_keyval(conf, "name", this->name,
|
||||
(std::string("colvar")+cvm::to_str(cv->variables()->size()+1)));
|
||||
|
||||
if ((cvm::colvar_by_name(this->name) != NULL) &&
|
||||
(cvm::colvar_by_name(this->name) != this)) {
|
||||
cvm::error("Error: this colvar cannot have the same name, \""+this->name+
|
||||
"\", as another colvar.\n",
|
||||
INPUT_ERROR);
|
||||
return;
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
|
||||
// Initialize dependency members
|
||||
@ -44,14 +56,13 @@ colvar::colvar(std::string const &conf)
|
||||
|
||||
this->description = "colvar " + this->name;
|
||||
|
||||
// Initialize static array once and for all
|
||||
init_cv_requires();
|
||||
|
||||
kinetic_energy = 0.0;
|
||||
potential_energy = 0.0;
|
||||
|
||||
error_code |= init_components(conf);
|
||||
if (error_code != COLVARS_OK) return;
|
||||
if (error_code != COLVARS_OK) {
|
||||
return cvm::get_error();
|
||||
}
|
||||
|
||||
size_t i;
|
||||
|
||||
@ -59,8 +70,6 @@ colvar::colvar(std::string const &conf)
|
||||
if (get_keyval(conf, "scriptedFunction", scripted_function,
|
||||
"", colvarparse::parse_silent)) {
|
||||
|
||||
// Make feature available only on user request
|
||||
provide(f_cv_scripted);
|
||||
enable(f_cv_scripted);
|
||||
cvm::log("This colvar uses scripted function \"" + scripted_function + "\".");
|
||||
|
||||
@ -76,8 +85,8 @@ colvar::colvar(std::string const &conf)
|
||||
}
|
||||
}
|
||||
if (x.type() == colvarvalue::type_notset) {
|
||||
cvm::error("Could not parse scripted colvar type.");
|
||||
return;
|
||||
cvm::error("Could not parse scripted colvar type.", INPUT_ERROR);
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
|
||||
cvm::log(std::string("Expecting colvar value of type ")
|
||||
@ -86,8 +95,9 @@ colvar::colvar(std::string const &conf)
|
||||
if (x.type() == colvarvalue::type_vector) {
|
||||
int size;
|
||||
if (!get_keyval(conf, "scriptedFunctionVectorSize", size)) {
|
||||
cvm::error("Error: no size specified for vector scripted function.");
|
||||
return;
|
||||
cvm::error("Error: no size specified for vector scripted function.",
|
||||
INPUT_ERROR);
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
x.vector1d_value.resize(size);
|
||||
}
|
||||
@ -154,7 +164,7 @@ colvar::colvar(std::string const &conf)
|
||||
}
|
||||
}
|
||||
}
|
||||
feature_states[f_cv_linear]->enabled = lin;
|
||||
set_enabled(f_cv_linear, lin);
|
||||
}
|
||||
|
||||
// Colvar is homogeneous if:
|
||||
@ -168,7 +178,7 @@ colvar::colvar(std::string const &conf)
|
||||
homogeneous = false;
|
||||
}
|
||||
}
|
||||
feature_states[f_cv_homogeneous]->enabled = homogeneous;
|
||||
set_enabled(f_cv_homogeneous, homogeneous);
|
||||
}
|
||||
|
||||
// Colvar is deemed periodic if:
|
||||
@ -188,7 +198,7 @@ colvar::colvar(std::string const &conf)
|
||||
"Make sure that you know what you are doing!");
|
||||
}
|
||||
}
|
||||
feature_states[f_cv_periodic]->enabled = b_periodic;
|
||||
set_enabled(f_cv_periodic, b_periodic);
|
||||
}
|
||||
|
||||
// check that cvcs are compatible
|
||||
@ -202,7 +212,7 @@ colvar::colvar(std::string const &conf)
|
||||
"by using components of different types. "
|
||||
"You must use the same type in order to "
|
||||
"sum them together.\n", INPUT_ERROR);
|
||||
return;
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
@ -215,44 +225,110 @@ colvar::colvar(std::string const &conf)
|
||||
f.type(value());
|
||||
f_accumulated.type(value());
|
||||
|
||||
x_old.type(value());
|
||||
v_fdiff.type(value());
|
||||
v_reported.type(value());
|
||||
fj.type(value());
|
||||
ft.type(value());
|
||||
ft_reported.type(value());
|
||||
f_old.type(value());
|
||||
f_old.reset();
|
||||
|
||||
x_restart.type(value());
|
||||
after_restart = false;
|
||||
|
||||
reset_bias_force();
|
||||
|
||||
// TODO use here information from the CVCs' own natural boundaries
|
||||
error_code |= init_grid_parameters(conf);
|
||||
|
||||
get_keyval(conf, "timeStepFactor", time_step_factor, 1);
|
||||
|
||||
error_code |= init_extended_Lagrangian(conf);
|
||||
error_code |= init_output_flags(conf);
|
||||
|
||||
// Start in active state by default
|
||||
enable(f_cv_active);
|
||||
// Make sure dependency side-effects are correct
|
||||
refresh_deps();
|
||||
|
||||
if (cvm::b_analysis)
|
||||
parse_analysis(conf);
|
||||
|
||||
if (cvm::debug())
|
||||
cvm::log("Done initializing collective variable \""+this->name+"\".\n");
|
||||
|
||||
return error_code;
|
||||
}
|
||||
|
||||
|
||||
int colvar::init_grid_parameters(std::string const &conf)
|
||||
{
|
||||
colvarmodule *cv = cvm::main();
|
||||
|
||||
get_keyval(conf, "width", width, 1.0);
|
||||
if (width <= 0.0) {
|
||||
cvm::error("Error: \"width\" must be positive.\n", INPUT_ERROR);
|
||||
return;
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
|
||||
lower_boundary.type(value());
|
||||
lower_wall.type(value());
|
||||
|
||||
upper_boundary.type(value());
|
||||
upper_wall.type(value());
|
||||
|
||||
feature_states[f_cv_scalar]->enabled = (value().type() == colvarvalue::type_scalar);
|
||||
set_enabled(f_cv_scalar, (value().type() == colvarvalue::type_scalar));
|
||||
|
||||
if (is_enabled(f_cv_scalar)) {
|
||||
|
||||
if (get_keyval(conf, "lowerBoundary", lower_boundary, lower_boundary)) {
|
||||
provide(f_cv_lower_boundary);
|
||||
enable(f_cv_lower_boundary);
|
||||
}
|
||||
std::string lw_conf, uw_conf;
|
||||
|
||||
get_keyval(conf, "lowerWallConstant", lower_wall_k, 0.0);
|
||||
if (lower_wall_k > 0.0) {
|
||||
if (get_keyval(conf, "lowerWallConstant", lower_wall_k, 0.0, parse_silent)) {
|
||||
cvm::log("Warning: lowerWallConstant and lowerWall are deprecated, "
|
||||
"please define a harmonicWalls bias instead.\n");
|
||||
lower_wall.type(value());
|
||||
get_keyval(conf, "lowerWall", lower_wall, lower_boundary);
|
||||
enable(f_cv_lower_wall);
|
||||
lw_conf = std::string("\n\
|
||||
lowerWallConstant "+cvm::to_str(lower_wall_k*width*width)+"\n\
|
||||
lowerWalls "+cvm::to_str(lower_wall)+"\n");
|
||||
}
|
||||
|
||||
if (get_keyval(conf, "upperBoundary", upper_boundary, upper_boundary)) {
|
||||
provide(f_cv_upper_boundary);
|
||||
enable(f_cv_upper_boundary);
|
||||
}
|
||||
|
||||
get_keyval(conf, "upperWallConstant", upper_wall_k, 0.0);
|
||||
if (upper_wall_k > 0.0) {
|
||||
if (get_keyval(conf, "upperWallConstant", upper_wall_k, 0.0, parse_silent)) {
|
||||
cvm::log("Warning: upperWallConstant and upperWall are deprecated, "
|
||||
"please define a harmonicWalls bias instead.\n");
|
||||
upper_wall.type(value());
|
||||
get_keyval(conf, "upperWall", upper_wall, upper_boundary);
|
||||
enable(f_cv_upper_wall);
|
||||
uw_conf = std::string("\n\
|
||||
upperWallConstant "+cvm::to_str(upper_wall_k*width*width)+"\n\
|
||||
upperWalls "+cvm::to_str(upper_wall)+"\n");
|
||||
}
|
||||
|
||||
if (lw_conf.size() && uw_conf.size()) {
|
||||
if (lower_wall >= upper_wall) {
|
||||
cvm::error("Error: the upper wall, "+
|
||||
cvm::to_str(upper_wall)+
|
||||
", is not higher than the lower wall, "+
|
||||
cvm::to_str(lower_wall)+".\n",
|
||||
INPUT_ERROR);
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
if (lw_conf.size() || uw_conf.size()) {
|
||||
cvm::log("Generating a new harmonicWalls bias for compatibility purposes.\n");
|
||||
std::string const walls_conf("\n\
|
||||
harmonicWalls {\n\
|
||||
name "+this->name+"w\n\
|
||||
colvars "+this->name+"\n"+lw_conf+uw_conf+
|
||||
"}\n");
|
||||
cv->append_new_config(walls_conf);
|
||||
}
|
||||
}
|
||||
|
||||
@ -271,16 +347,7 @@ colvar::colvar(std::string const &conf)
|
||||
", is not higher than the lower boundary, "+
|
||||
cvm::to_str(lower_boundary)+".\n",
|
||||
INPUT_ERROR);
|
||||
}
|
||||
}
|
||||
|
||||
if (is_enabled(f_cv_lower_wall) && is_enabled(f_cv_upper_wall)) {
|
||||
if (lower_wall >= upper_wall) {
|
||||
cvm::error("Error: the upper wall, "+
|
||||
cvm::to_str(upper_wall)+
|
||||
", is not higher than the lower wall, "+
|
||||
cvm::to_str(lower_wall)+".\n",
|
||||
INPUT_ERROR);
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
@ -289,83 +356,90 @@ colvar::colvar(std::string const &conf)
|
||||
cvm::error("Error: trying to expand boundaries that already "
|
||||
"cover a whole period of a periodic colvar.\n",
|
||||
INPUT_ERROR);
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
if (expand_boundaries && hard_lower_boundary && hard_upper_boundary) {
|
||||
cvm::error("Error: inconsistent configuration "
|
||||
"(trying to expand boundaries with both "
|
||||
"hardLowerBoundary and hardUpperBoundary enabled).\n",
|
||||
INPUT_ERROR);
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
|
||||
get_keyval(conf, "timeStepFactor", time_step_factor, 1);
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
{
|
||||
bool b_extended_Lagrangian;
|
||||
get_keyval(conf, "extendedLagrangian", b_extended_Lagrangian, false);
|
||||
|
||||
if (b_extended_Lagrangian) {
|
||||
cvm::real temp, tolerance, period;
|
||||
int colvar::init_extended_Lagrangian(std::string const &conf)
|
||||
{
|
||||
bool b_extended_Lagrangian;
|
||||
get_keyval(conf, "extendedLagrangian", b_extended_Lagrangian, false);
|
||||
|
||||
cvm::log("Enabling the extended Lagrangian term for colvar \""+
|
||||
this->name+"\".\n");
|
||||
if (b_extended_Lagrangian) {
|
||||
cvm::real temp, tolerance, period;
|
||||
|
||||
// Make feature available only on user request
|
||||
provide(f_cv_extended_Lagrangian);
|
||||
enable(f_cv_extended_Lagrangian);
|
||||
provide(f_cv_Langevin);
|
||||
cvm::log("Enabling the extended Lagrangian term for colvar \""+
|
||||
this->name+"\".\n");
|
||||
|
||||
// The extended mass will apply forces
|
||||
enable(f_cv_gradient);
|
||||
enable(f_cv_extended_Lagrangian);
|
||||
|
||||
xr.type(value());
|
||||
vr.type(value());
|
||||
fr.type(value());
|
||||
xr.type(value());
|
||||
vr.type(value());
|
||||
fr.type(value());
|
||||
|
||||
const bool found = get_keyval(conf, "extendedTemp", temp, cvm::temperature());
|
||||
if (temp <= 0.0) {
|
||||
if (found)
|
||||
cvm::error("Error: \"extendedTemp\" must be positive.\n", INPUT_ERROR);
|
||||
else
|
||||
cvm::error("Error: a positive temperature must be provided, either "
|
||||
"by enabling a thermostat, or through \"extendedTemp\".\n",
|
||||
INPUT_ERROR);
|
||||
const bool found = get_keyval(conf, "extendedTemp", temp, cvm::temperature());
|
||||
if (temp <= 0.0) {
|
||||
if (found)
|
||||
cvm::error("Error: \"extendedTemp\" must be positive.\n", INPUT_ERROR);
|
||||
else
|
||||
cvm::error("Error: a positive temperature must be provided, either "
|
||||
"by enabling a thermostat, or through \"extendedTemp\".\n",
|
||||
INPUT_ERROR);
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
|
||||
get_keyval(conf, "extendedFluctuation", tolerance);
|
||||
if (tolerance <= 0.0) {
|
||||
cvm::error("Error: \"extendedFluctuation\" must be positive.\n", INPUT_ERROR);
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
ext_force_k = cvm::boltzmann() * temp / (tolerance * tolerance);
|
||||
cvm::log("Computed extended system force constant: " + cvm::to_str(ext_force_k) + " kcal/mol/U^2");
|
||||
|
||||
get_keyval(conf, "extendedTimeConstant", period, 200.0);
|
||||
if (period <= 0.0) {
|
||||
cvm::error("Error: \"extendedTimeConstant\" must be positive.\n", INPUT_ERROR);
|
||||
}
|
||||
ext_mass = (cvm::boltzmann() * temp * period * period)
|
||||
/ (4.0 * PI * PI * tolerance * tolerance);
|
||||
cvm::log("Computed fictitious mass: " + cvm::to_str(ext_mass) + " kcal/mol/(U/fs)^2 (U: colvar unit)");
|
||||
|
||||
{
|
||||
bool b_output_energy;
|
||||
get_keyval(conf, "outputEnergy", b_output_energy, false);
|
||||
if (b_output_energy) {
|
||||
enable(f_cv_output_energy);
|
||||
}
|
||||
}
|
||||
|
||||
get_keyval(conf, "extendedFluctuation", tolerance);
|
||||
if (tolerance <= 0.0) {
|
||||
cvm::error("Error: \"extendedFluctuation\" must be positive.\n", INPUT_ERROR);
|
||||
}
|
||||
ext_force_k = cvm::boltzmann() * temp / (tolerance * tolerance);
|
||||
cvm::log("Computed extended system force constant: " + cvm::to_str(ext_force_k) + " kcal/mol/U^2");
|
||||
|
||||
get_keyval(conf, "extendedTimeConstant", period, 200.0);
|
||||
if (period <= 0.0) {
|
||||
cvm::error("Error: \"extendedTimeConstant\" must be positive.\n", INPUT_ERROR);
|
||||
}
|
||||
ext_mass = (cvm::boltzmann() * temp * period * period)
|
||||
/ (4.0 * PI * PI * tolerance * tolerance);
|
||||
cvm::log("Computed fictitious mass: " + cvm::to_str(ext_mass) + " kcal/mol/(U/fs)^2 (U: colvar unit)");
|
||||
|
||||
{
|
||||
bool b_output_energy;
|
||||
get_keyval(conf, "outputEnergy", b_output_energy, false);
|
||||
if (b_output_energy) {
|
||||
enable(f_cv_output_energy);
|
||||
}
|
||||
}
|
||||
|
||||
get_keyval(conf, "extendedLangevinDamping", ext_gamma, 1.0);
|
||||
if (ext_gamma < 0.0) {
|
||||
cvm::error("Error: \"extendedLangevinDamping\" may not be negative.\n", INPUT_ERROR);
|
||||
}
|
||||
if (ext_gamma != 0.0) {
|
||||
enable(f_cv_Langevin);
|
||||
ext_gamma *= 1.0e-3; // convert from ps-1 to fs-1
|
||||
ext_sigma = std::sqrt(2.0 * cvm::boltzmann() * temp * ext_gamma * ext_mass / cvm::dt());
|
||||
}
|
||||
get_keyval(conf, "extendedLangevinDamping", ext_gamma, 1.0);
|
||||
if (ext_gamma < 0.0) {
|
||||
cvm::error("Error: \"extendedLangevinDamping\" may not be negative.\n", INPUT_ERROR);
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
if (ext_gamma != 0.0) {
|
||||
enable(f_cv_Langevin);
|
||||
ext_gamma *= 1.0e-3; // convert from ps-1 to fs-1
|
||||
ext_sigma = std::sqrt(2.0 * cvm::boltzmann() * temp * ext_gamma * ext_mass / cvm::dt());
|
||||
}
|
||||
}
|
||||
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
|
||||
int colvar::init_output_flags(std::string const &conf)
|
||||
{
|
||||
{
|
||||
bool b_output_value;
|
||||
get_keyval(conf, "outputValue", b_output_value, true);
|
||||
@ -387,7 +461,7 @@ colvar::colvar(std::string const &conf)
|
||||
if (get_keyval(conf, "outputSystemForce", temp, false, colvarparse::parse_silent)) {
|
||||
cvm::error("Option outputSystemForce is deprecated: only outputTotalForce is supported instead.\n"
|
||||
"The two are NOT identical: see http://colvars.github.io/totalforce.html.\n", INPUT_ERROR);
|
||||
return;
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
@ -395,28 +469,7 @@ colvar::colvar(std::string const &conf)
|
||||
get_keyval_feature(this, conf, "outputAppliedForce", f_cv_output_applied_force, false);
|
||||
get_keyval_feature(this, conf, "subtractAppliedForce", f_cv_subtract_applied_force, false);
|
||||
|
||||
// Start in active state by default
|
||||
enable(f_cv_active);
|
||||
// Make sure dependency side-effects are correct
|
||||
refresh_deps();
|
||||
|
||||
x_old.type(value());
|
||||
v_fdiff.type(value());
|
||||
v_reported.type(value());
|
||||
fj.type(value());
|
||||
ft.type(value());
|
||||
ft_reported.type(value());
|
||||
f_old.type(value());
|
||||
f_old.reset();
|
||||
|
||||
x_restart.type(value());
|
||||
after_restart = false;
|
||||
|
||||
if (cvm::b_analysis)
|
||||
parse_analysis(conf);
|
||||
|
||||
if (cvm::debug())
|
||||
cvm::log("Done initializing collective variable \""+this->name+"\".\n");
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
|
||||
@ -637,7 +690,7 @@ int colvar::parse_analysis(std::string const &conf)
|
||||
|
||||
std::string runave_outfile;
|
||||
get_keyval(conf, "runAveOutputFile", runave_outfile,
|
||||
std::string(cvm::output_prefix+"."+
|
||||
std::string(cvm::output_prefix()+"."+
|
||||
this->name+".runave.traj"));
|
||||
|
||||
size_t const this_cv_width = x.output_width(cvm::cv_width);
|
||||
@ -693,7 +746,7 @@ int colvar::parse_analysis(std::string const &conf)
|
||||
|
||||
get_keyval(conf, "corrFuncNormalize", acf_normalize, true);
|
||||
get_keyval(conf, "corrFuncOutputFile", acf_outfile,
|
||||
std::string(cvm::output_prefix+"."+this->name+
|
||||
std::string(cvm::output_prefix()+"."+this->name+
|
||||
".corrfunc.dat"));
|
||||
}
|
||||
return (cvm::get_error() ? COLVARS_ERROR : COLVARS_OK);
|
||||
@ -730,11 +783,12 @@ colvar::~colvar()
|
||||
}
|
||||
|
||||
// remove reference to this colvar from the CVM
|
||||
for (std::vector<colvar *>::iterator cvi = cvm::colvars.begin();
|
||||
cvi != cvm::colvars.end();
|
||||
colvarmodule *cv = cvm::main();
|
||||
for (std::vector<colvar *>::iterator cvi = cv->variables()->begin();
|
||||
cvi != cv->variables()->end();
|
||||
++cvi) {
|
||||
if ( *cvi == this) {
|
||||
cvm::colvars.erase(cvi);
|
||||
cv->variables()->erase(cvi);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -892,7 +946,6 @@ int colvar::collect_cvc_values()
|
||||
cvm::to_str(x, cvm::cv_width, cvm::cv_prec)+".\n");
|
||||
|
||||
if (after_restart) {
|
||||
after_restart = false;
|
||||
if (cvm::proxy->simulation_running()) {
|
||||
cvm::real const jump2 = dist2(x, x_restart) / (width*width);
|
||||
if (jump2 > 0.25) {
|
||||
@ -1122,8 +1175,7 @@ int colvar::calc_colvar_properties()
|
||||
|
||||
// initialize the restraint center in the first step to the value
|
||||
// just calculated from the cvcs
|
||||
// TODO: put it in the restart information
|
||||
if (cvm::step_relative() == 0) {
|
||||
if (cvm::step_relative() == 0 && !after_restart) {
|
||||
xr = x;
|
||||
vr.reset(); // (already 0; added for clarity)
|
||||
}
|
||||
@ -1148,6 +1200,8 @@ int colvar::calc_colvar_properties()
|
||||
ft_reported = ft;
|
||||
}
|
||||
|
||||
// At the end of the first update after a restart, we can reset the flag
|
||||
after_restart = false;
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
@ -1173,51 +1227,17 @@ cvm::real colvar::update_forces_energy()
|
||||
f -= fj;
|
||||
}
|
||||
|
||||
// Wall force
|
||||
colvarvalue fw(x);
|
||||
fw.reset();
|
||||
|
||||
if (is_enabled(f_cv_lower_wall) || is_enabled(f_cv_upper_wall)) {
|
||||
|
||||
if (cvm::debug())
|
||||
cvm::log("Calculating wall forces for colvar \""+this->name+"\".\n");
|
||||
|
||||
// For a periodic colvar, both walls may be applicable at the same time
|
||||
// in which case we pick the closer one
|
||||
if ( (!is_enabled(f_cv_upper_wall)) ||
|
||||
(this->dist2(x, lower_wall) < this->dist2(x, upper_wall)) ) {
|
||||
|
||||
cvm::real const grad = this->dist2_lgrad(x, lower_wall);
|
||||
if (grad < 0.0) {
|
||||
fw = -0.5 * lower_wall_k * grad;
|
||||
if (cvm::debug())
|
||||
cvm::log("Applying a lower wall force("+
|
||||
cvm::to_str(fw)+") to \""+this->name+"\".\n");
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
cvm::real const grad = this->dist2_lgrad(x, upper_wall);
|
||||
if (grad > 0.0) {
|
||||
fw = -0.5 * upper_wall_k * grad;
|
||||
if (cvm::debug())
|
||||
cvm::log("Applying an upper wall force("+
|
||||
cvm::to_str(fw)+") to \""+this->name+"\".\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// At this point f is the force f from external biases that will be applied to the
|
||||
// extended variable if there is one
|
||||
|
||||
if (is_enabled(f_cv_extended_Lagrangian)) {
|
||||
|
||||
if (cvm::debug()) {
|
||||
cvm::log("Updating extended-Lagrangian degrees of freedom.\n");
|
||||
cvm::log("Updating extended-Lagrangian degree of freedom.\n");
|
||||
}
|
||||
|
||||
cvm::real dt = cvm::dt();
|
||||
colvarvalue f_ext(fr.type());
|
||||
colvarvalue f_ext(fr.type()); // force acting on the extended variable
|
||||
f_ext.reset();
|
||||
|
||||
// the total force is applied to the fictitious mass, while the
|
||||
@ -1226,7 +1246,7 @@ cvm::real colvar::update_forces_energy()
|
||||
// f_ext: total force on extended variable (including harmonic spring)
|
||||
// f: - initially, external biasing force
|
||||
// - after this code block, colvar force to be applied to atomic coordinates
|
||||
// ie. spring force + wall force
|
||||
// ie. spring force (fb_actual will be added just below)
|
||||
fr = f;
|
||||
f_ext = f + (-0.5 * ext_force_k) * this->dist2_lgrad(xr, x);
|
||||
f = (-0.5 * ext_force_k) * this->dist2_rgrad(xr, x);
|
||||
@ -1259,8 +1279,6 @@ cvm::real colvar::update_forces_energy()
|
||||
if (this->is_enabled(f_cv_periodic)) this->wrap(xr);
|
||||
}
|
||||
|
||||
// TODO remove the wall force
|
||||
f += fw;
|
||||
// Now adding the force on the actual colvar (for those biases who
|
||||
// bypass the extended Lagrangian mass)
|
||||
f += fb_actual;
|
||||
@ -1286,8 +1304,10 @@ cvm::real colvar::update_forces_energy()
|
||||
void colvar::communicate_forces()
|
||||
{
|
||||
size_t i;
|
||||
if (cvm::debug())
|
||||
if (cvm::debug()) {
|
||||
cvm::log("Communicating forces from colvar \""+this->name+"\".\n");
|
||||
cvm::log("Force to be applied: " + cvm::to_str(f_accumulated) + "\n");
|
||||
}
|
||||
|
||||
if (is_enabled(f_cv_scripted)) {
|
||||
std::vector<cvm::matrix2d<cvm::real> > func_grads;
|
||||
@ -1364,7 +1384,7 @@ int colvar::update_cvc_flags()
|
||||
active_cvc_square_norm = 0.;
|
||||
|
||||
for (size_t i = 0; i < cvcs.size(); i++) {
|
||||
cvcs[i]->feature_states[f_cvc_active]->enabled = cvc_flags[i];
|
||||
cvcs[i]->set_enabled(f_cvc_active, cvc_flags[i]);
|
||||
if (cvcs[i]->is_enabled()) {
|
||||
n_active_cvcs++;
|
||||
active_cvc_square_norm += cvcs[i]->sup_coeff * cvcs[i]->sup_coeff;
|
||||
|
||||
@ -227,11 +227,23 @@ public:
|
||||
|
||||
|
||||
/// Constructor
|
||||
colvar(std::string const &conf);
|
||||
colvar();
|
||||
|
||||
/// Main init function
|
||||
int init(std::string const &conf);
|
||||
|
||||
/// Parse the CVC configuration and allocate their data
|
||||
int init_components(std::string const &conf);
|
||||
|
||||
/// Init defaults for grid options
|
||||
int init_grid_parameters(std::string const &conf);
|
||||
|
||||
/// Init extended Lagrangian parameters
|
||||
int init_extended_Lagrangian(std::string const &conf);
|
||||
|
||||
/// Init output flags
|
||||
int init_output_flags(std::string const &conf);
|
||||
|
||||
private:
|
||||
/// Parse the CVC configuration for all components of a certain type
|
||||
template<typename def_class_name> int init_components_type(std::string const &conf,
|
||||
|
||||
@ -98,7 +98,7 @@ cvm::atom_group::atom_group()
|
||||
|
||||
cvm::atom_group::~atom_group()
|
||||
{
|
||||
if (is_enabled(f_ag_scalable)) {
|
||||
if (is_enabled(f_ag_scalable) && !b_dummy) {
|
||||
(cvm::proxy)->clear_atom_group(index);
|
||||
index = -1;
|
||||
}
|
||||
@ -418,7 +418,7 @@ int cvm::atom_group::parse(std::string const &conf)
|
||||
// We need to know the fitting options to decide whether the group is scalable
|
||||
parse_error |= parse_fitting_options(group_conf);
|
||||
|
||||
if (is_available(f_ag_scalable_com) && !b_rotate) {
|
||||
if (is_available(f_ag_scalable_com) && !b_rotate && !b_center) {
|
||||
enable(f_ag_scalable_com);
|
||||
enable(f_ag_scalable);
|
||||
}
|
||||
@ -500,14 +500,16 @@ int cvm::atom_group::add_atom_numbers(std::string const &numbers_conf)
|
||||
|
||||
int cvm::atom_group::add_index_group(std::string const &index_group_name)
|
||||
{
|
||||
std::list<std::string>::iterator names_i = cvm::index_group_names.begin();
|
||||
std::list<std::vector<int> >::iterator index_groups_i = cvm::index_groups.begin();
|
||||
for ( ; names_i != cvm::index_group_names.end() ; ++names_i, ++index_groups_i) {
|
||||
colvarmodule *cv = cvm::main();
|
||||
|
||||
std::list<std::string>::iterator names_i = cv->index_group_names.begin();
|
||||
std::list<std::vector<int> >::iterator index_groups_i = cv->index_groups.begin();
|
||||
for ( ; names_i != cv->index_group_names.end() ; ++names_i, ++index_groups_i) {
|
||||
if (*names_i == index_group_name)
|
||||
break;
|
||||
}
|
||||
|
||||
if (names_i == cvm::index_group_names.end()) {
|
||||
if (names_i == cv->index_group_names.end()) {
|
||||
cvm::error("Error: could not find index group "+
|
||||
index_group_name+" among those provided by the index file.\n",
|
||||
INPUT_ERROR);
|
||||
|
||||
@ -19,20 +19,6 @@ colvarbias::colvarbias(char const *key)
|
||||
|
||||
rank = 1;
|
||||
|
||||
if (bias_type == std::string("abf")) {
|
||||
rank = cvm::n_abf_biases+1;
|
||||
}
|
||||
if (bias_type == std::string("harmonic") ||
|
||||
bias_type == std::string("linear")) {
|
||||
rank = cvm::n_rest_biases+1;
|
||||
}
|
||||
if (bias_type == std::string("histogram")) {
|
||||
rank = cvm::n_histo_biases+1;
|
||||
}
|
||||
if (bias_type == std::string("metadynamics")) {
|
||||
rank = cvm::n_meta_biases+1;
|
||||
}
|
||||
|
||||
has_data = false;
|
||||
b_output_energy = false;
|
||||
reset();
|
||||
@ -48,7 +34,11 @@ int colvarbias::init(std::string const &conf)
|
||||
colvarparse::init(conf);
|
||||
|
||||
if (name.size() == 0) {
|
||||
|
||||
// first initialization
|
||||
|
||||
cvm::log("Initializing a new \""+bias_type+"\" instance.\n");
|
||||
rank = cvm::num_biases_type(bias_type);
|
||||
get_keyval(conf, "name", name, bias_type+cvm::to_str(rank));
|
||||
|
||||
{
|
||||
@ -69,7 +59,7 @@ int colvarbias::init(std::string const &conf)
|
||||
// lookup the associated colvars
|
||||
std::vector<std::string> colvar_names;
|
||||
if (get_keyval(conf, "colvars", colvar_names)) {
|
||||
if (colvars.size()) {
|
||||
if (num_variables()) {
|
||||
cvm::error("Error: cannot redefine the colvars that a bias was already defined on.\n",
|
||||
INPUT_ERROR);
|
||||
return INPUT_ERROR;
|
||||
@ -80,7 +70,7 @@ int colvarbias::init(std::string const &conf)
|
||||
}
|
||||
}
|
||||
|
||||
if (!colvars.size()) {
|
||||
if (!num_variables()) {
|
||||
cvm::error("Error: no collective variables specified.\n", INPUT_ERROR);
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
@ -89,6 +79,8 @@ int colvarbias::init(std::string const &conf)
|
||||
cvm::log("Reinitializing bias \""+name+"\".\n");
|
||||
}
|
||||
|
||||
output_prefix = cvm::output_prefix();
|
||||
|
||||
get_keyval(conf, "outputEnergy", b_output_energy, b_output_energy);
|
||||
|
||||
return COLVARS_OK;
|
||||
@ -98,7 +90,7 @@ int colvarbias::init(std::string const &conf)
|
||||
int colvarbias::reset()
|
||||
{
|
||||
bias_energy = 0.0;
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
colvar_forces[i].reset();
|
||||
}
|
||||
return COLVARS_OK;
|
||||
@ -132,12 +124,13 @@ int colvarbias::clear()
|
||||
}
|
||||
}
|
||||
|
||||
colvarmodule *cv = cvm::main();
|
||||
// ...and from the colvars module
|
||||
for (std::vector<colvarbias *>::iterator bi = cvm::biases.begin();
|
||||
bi != cvm::biases.end();
|
||||
for (std::vector<colvarbias *>::iterator bi = cv->biases.begin();
|
||||
bi != cv->biases.end();
|
||||
++bi) {
|
||||
if ( *bi == this) {
|
||||
cvm::biases.erase(bi);
|
||||
cv->biases.erase(bi);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -185,21 +178,29 @@ int colvarbias::add_colvar(std::string const &cv_name)
|
||||
|
||||
int colvarbias::update()
|
||||
{
|
||||
// Note: if anything is added here, it should be added also in the SMP block of calc_biases()
|
||||
// TODO move here debug msg of bias update
|
||||
if (cvm::debug()) {
|
||||
cvm::log("Updating the "+bias_type+" bias \""+this->name+"\".\n");
|
||||
}
|
||||
|
||||
has_data = true;
|
||||
|
||||
bias_energy = 0.0;
|
||||
for (size_t ir = 0; ir < num_variables(); ir++) {
|
||||
colvar_forces[ir].reset();
|
||||
}
|
||||
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
|
||||
void colvarbias::communicate_forces()
|
||||
{
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
if (cvm::debug()) {
|
||||
cvm::log("Communicating a force to colvar \""+
|
||||
colvars[i]->name+"\".\n");
|
||||
variables(i)->name+"\".\n");
|
||||
}
|
||||
colvars[i]->add_bias_force(colvar_forces[i]);
|
||||
variables(i)->add_bias_force(colvar_forces[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -32,17 +32,39 @@ public:
|
||||
/// Add a new collective variable to this bias
|
||||
int add_colvar(std::string const &cv_name);
|
||||
|
||||
/// Add a new collective variable to this bias
|
||||
size_t number_of_colvars() const
|
||||
/// How many variables are defined for this bias
|
||||
inline size_t num_variables() const
|
||||
{
|
||||
return colvars.size();
|
||||
}
|
||||
|
||||
/// Access the variables vector
|
||||
inline std::vector<colvar *> *variables()
|
||||
{
|
||||
return &colvars;
|
||||
}
|
||||
|
||||
/// Access the i-th variable
|
||||
inline colvar * variables(int i) const
|
||||
{
|
||||
return colvars[i];
|
||||
}
|
||||
|
||||
/// Retrieve colvar values and calculate their biasing forces
|
||||
/// Return bias energy
|
||||
virtual int update();
|
||||
|
||||
// TODO: move update_bias here (share with metadynamics)
|
||||
/// \brief Compute the energy of the bias with alternative values of the
|
||||
/// collective variables (suitable for bias exchange)
|
||||
virtual int calc_energy(std::vector<colvarvalue> const &values =
|
||||
std::vector<colvarvalue>(0))
|
||||
{
|
||||
cvm::error("Error: calc_energy() not implemented.\n", COLVARS_NOT_IMPLEMENTED);
|
||||
return COLVARS_NOT_IMPLEMENTED;
|
||||
}
|
||||
|
||||
/// Send forces to the collective variables
|
||||
virtual void communicate_forces();
|
||||
|
||||
/// Load new configuration - force constant and/or centers only
|
||||
virtual int change_configuration(std::string const &conf);
|
||||
@ -51,10 +73,13 @@ public:
|
||||
virtual cvm::real energy_difference(std::string const &conf);
|
||||
|
||||
/// Give the total number of bins for a given bias.
|
||||
// FIXME this is currently 1D only
|
||||
virtual int bin_num();
|
||||
/// Calculate the bin index for a given bias.
|
||||
// FIXME this is currently 1D only
|
||||
virtual int current_bin();
|
||||
//// Give the count at a given bin index.
|
||||
// FIXME this is currently 1D only
|
||||
virtual int bin_count(int bin_index);
|
||||
//// Share information between replicas, whatever it may be.
|
||||
virtual int replica_share();
|
||||
@ -62,9 +87,6 @@ public:
|
||||
/// Perform analysis tasks
|
||||
virtual void analyze() {}
|
||||
|
||||
/// Send forces to the collective variables
|
||||
virtual void communicate_forces();
|
||||
|
||||
/// \brief Constructor
|
||||
colvarbias(char const *key);
|
||||
|
||||
@ -135,6 +157,9 @@ public:
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
/// Use this prefix for all output files
|
||||
std::string output_prefix;
|
||||
|
||||
/// If this bias is communicating with other replicas through files, send it to them
|
||||
virtual int write_state_to_replicas()
|
||||
{
|
||||
@ -162,7 +187,7 @@ protected:
|
||||
/// through each colvar object
|
||||
std::vector<colvar *> colvars;
|
||||
|
||||
/// \brief Current forces from this bias to the colvars
|
||||
/// \brief Current forces from this bias to the variables
|
||||
std::vector<colvarvalue> colvar_forces;
|
||||
|
||||
/// \brief Current energy of this bias (colvar_forces should be obtained by deriving this)
|
||||
|
||||
@ -30,9 +30,8 @@ int colvarbias_abf::init(std::string const &conf)
|
||||
{
|
||||
colvarbias::init(conf);
|
||||
|
||||
provide(f_cvb_scalar_variables);
|
||||
enable(f_cvb_scalar_variables);
|
||||
provide(f_cvb_history_dependent);
|
||||
enable(f_cvb_calc_pmf);
|
||||
|
||||
// TODO relax this in case of VMD plugin
|
||||
if (cvm::temperature() == 0.0)
|
||||
@ -221,9 +220,6 @@ colvarbias_abf::~colvarbias_abf()
|
||||
delete [] system_force;
|
||||
system_force = NULL;
|
||||
}
|
||||
|
||||
if (cvm::n_abf_biases > 0)
|
||||
cvm::n_abf_biases -= 1;
|
||||
}
|
||||
|
||||
|
||||
@ -319,11 +315,11 @@ int colvarbias_abf::update()
|
||||
}
|
||||
|
||||
// update the output prefix; TODO: move later to setup_output() function
|
||||
if ( cvm::n_abf_biases == 1 && cvm::n_meta_biases == 0 ) {
|
||||
// This is the only ABF bias
|
||||
output_prefix = cvm::output_prefix;
|
||||
if (cvm::num_biases_feature(colvardeps::f_cvb_calc_pmf) == 1) {
|
||||
// This is the only bias computing PMFs
|
||||
output_prefix = cvm::output_prefix();
|
||||
} else {
|
||||
output_prefix = cvm::output_prefix + "." + this->name;
|
||||
output_prefix = cvm::output_prefix() + "." + this->name;
|
||||
}
|
||||
|
||||
if (output_freq && (cvm::step_absolute() % output_freq) == 0) {
|
||||
|
||||
@ -40,11 +40,8 @@ int colvarbias_alb::init(std::string const &conf)
|
||||
{
|
||||
colvarbias::init(conf);
|
||||
|
||||
provide(f_cvb_scalar_variables);
|
||||
enable(f_cvb_scalar_variables);
|
||||
|
||||
provide(f_cvb_history_dependent);
|
||||
|
||||
size_t i;
|
||||
|
||||
// get the initial restraint centers
|
||||
@ -138,8 +135,6 @@ int colvarbias_alb::init(std::string const &conf)
|
||||
|
||||
colvarbias_alb::~colvarbias_alb()
|
||||
{
|
||||
if (cvm::n_rest_biases > 0)
|
||||
cvm::n_rest_biases -= 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -24,10 +24,7 @@ int colvarbias_histogram::init(std::string const &conf)
|
||||
{
|
||||
colvarbias::init(conf);
|
||||
|
||||
provide(f_cvb_scalar_variables);
|
||||
enable(f_cvb_scalar_variables);
|
||||
|
||||
provide(f_cvb_history_dependent);
|
||||
enable(f_cvb_history_dependent);
|
||||
|
||||
size_t i;
|
||||
@ -104,9 +101,6 @@ colvarbias_histogram::~colvarbias_histogram()
|
||||
delete grid;
|
||||
grid = NULL;
|
||||
}
|
||||
|
||||
if (cvm::n_histo_biases > 0)
|
||||
cvm::n_histo_biases -= 1;
|
||||
}
|
||||
|
||||
|
||||
@ -127,14 +121,14 @@ int colvarbias_histogram::update()
|
||||
// At the first timestep, we need to assign out_name since
|
||||
// output_prefix is unset during the constructor
|
||||
if (cvm::step_relative() == 0) {
|
||||
out_name = cvm::output_prefix + "." + this->name + ".dat";
|
||||
out_name = cvm::output_prefix() + "." + this->name + ".dat";
|
||||
cvm::log("Histogram " + this->name + " will be written to file \"" + out_name + "\"");
|
||||
}
|
||||
}
|
||||
|
||||
if (out_name_dx.size() == 0) {
|
||||
if (cvm::step_relative() == 0) {
|
||||
out_name_dx = cvm::output_prefix + "." + this->name + ".dx";
|
||||
out_name_dx = cvm::output_prefix() + "." + this->name + ".dx";
|
||||
cvm::log("Histogram " + this->name + " will be written to file \"" + out_name_dx + "\"");
|
||||
}
|
||||
}
|
||||
|
||||
@ -43,7 +43,7 @@ int colvarbias_meta::init(std::string const &conf)
|
||||
{
|
||||
colvarbias::init(conf);
|
||||
|
||||
provide(f_cvb_history_dependent);
|
||||
enable(f_cvb_calc_pmf);
|
||||
|
||||
get_keyval(conf, "hillWeight", hill_weight, 0.0);
|
||||
if (hill_weight > 0.0) {
|
||||
@ -59,9 +59,9 @@ int colvarbias_meta::init(std::string const &conf)
|
||||
|
||||
get_keyval(conf, "hillWidth", hill_width, std::sqrt(2.0 * PI) / 2.0);
|
||||
cvm::log("Half-widths of the Gaussian hills (sigma's):\n");
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
cvm::log(colvars[i]->name+std::string(": ")+
|
||||
cvm::to_str(0.5 * colvars[i]->width * hill_width));
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
cvm::log(variables(i)->name+std::string(": ")+
|
||||
cvm::to_str(0.5 * variables(i)->width * hill_width));
|
||||
}
|
||||
|
||||
{
|
||||
@ -73,8 +73,10 @@ int colvarbias_meta::init(std::string const &conf)
|
||||
comm = single_replica;
|
||||
}
|
||||
|
||||
// This implies gradients for all colvars
|
||||
enable(f_cvb_apply_force);
|
||||
// in all cases, the first replica is this bias itself
|
||||
if (replicas.size() == 0) {
|
||||
replicas.push_back(this);
|
||||
}
|
||||
|
||||
get_keyval(conf, "useGrids", use_grids, true);
|
||||
|
||||
@ -84,14 +86,14 @@ int colvarbias_meta::init(std::string const &conf)
|
||||
|
||||
expand_grids = false;
|
||||
size_t i;
|
||||
for (i = 0; i < colvars.size(); i++) {
|
||||
colvars[i]->enable(f_cv_grid);
|
||||
if (colvars[i]->expand_boundaries) {
|
||||
for (i = 0; i < num_variables(); i++) {
|
||||
variables(i)->enable(f_cv_grid);
|
||||
if (variables(i)->expand_boundaries) {
|
||||
expand_grids = true;
|
||||
cvm::log("Metadynamics bias \""+this->name+"\""+
|
||||
((comm != single_replica) ? ", replica \""+replica_id+"\"" : "")+
|
||||
": Will expand grids when the colvar \""+
|
||||
colvars[i]->name+"\" approaches its boundaries.\n");
|
||||
variables(i)->name+"\" approaches its boundaries.\n");
|
||||
}
|
||||
}
|
||||
|
||||
@ -100,7 +102,7 @@ int colvarbias_meta::init(std::string const &conf)
|
||||
get_keyval(conf, "dumpFreeEnergyFile", dump_fes, true, colvarparse::parse_silent);
|
||||
if (get_keyval(conf, "saveFreeEnergyFile", dump_fes_save, false, colvarparse::parse_silent)) {
|
||||
cvm::log("Option \"saveFreeEnergyFile\" is deprecated, "
|
||||
"please use \"keepFreeEnergyFiles\" instead.");
|
||||
"please use \"keepFreeEnergyFile\" instead.");
|
||||
}
|
||||
get_keyval(conf, "keepFreeEnergyFiles", dump_fes_save, dump_fes_save);
|
||||
|
||||
@ -154,6 +156,20 @@ int colvarbias_meta::init(std::string const &conf)
|
||||
|
||||
get_keyval(conf, "writeHillsTrajectory", b_hills_traj, false);
|
||||
|
||||
init_well_tempered_params(conf);
|
||||
init_ebmeta_params(conf);
|
||||
|
||||
if (cvm::debug())
|
||||
cvm::log("Done initializing the metadynamics bias \""+this->name+"\""+
|
||||
((comm != single_replica) ? ", replica \""+replica_id+"\"" : "")+".\n");
|
||||
|
||||
save_delimiters = false;
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
|
||||
int colvarbias_meta::init_well_tempered_params(std::string const &conf)
|
||||
{
|
||||
// for well-tempered metadynamics
|
||||
get_keyval(conf, "wellTempered", well_tempered, false);
|
||||
get_keyval(conf, "biasTemperature", bias_temperature, -1.0);
|
||||
@ -164,8 +180,12 @@ int colvarbias_meta::init(std::string const &conf)
|
||||
cvm::log("Well-tempered metadynamics is used.\n");
|
||||
cvm::log("The bias temperature is "+cvm::to_str(bias_temperature)+".\n");
|
||||
}
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
|
||||
int colvarbias_meta::init_ebmeta_params(std::string const &conf)
|
||||
{
|
||||
// for ebmeta
|
||||
target_dist = NULL;
|
||||
get_keyval(conf, "ebMeta", ebmeta, false);
|
||||
@ -203,11 +223,6 @@ int colvarbias_meta::init(std::string const &conf)
|
||||
get_keyval(conf, "ebMetaEquilSteps", ebmeta_equil_steps, 0);
|
||||
}
|
||||
|
||||
if (cvm::debug())
|
||||
cvm::log("Done initializing the metadynamics bias \""+this->name+"\""+
|
||||
((comm != single_replica) ? ", replica \""+replica_id+"\"" : "")+".\n");
|
||||
|
||||
save_delimiters = false;
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
@ -234,9 +249,6 @@ colvarbias_meta::~colvarbias_meta()
|
||||
delete target_dist;
|
||||
target_dist = NULL;
|
||||
}
|
||||
|
||||
if (cvm::n_meta_biases > 0)
|
||||
cvm::n_meta_biases -= 1;
|
||||
}
|
||||
|
||||
|
||||
@ -314,23 +326,45 @@ colvarbias_meta::delete_hill(hill_iter &h)
|
||||
|
||||
int colvarbias_meta::update()
|
||||
{
|
||||
if (cvm::debug())
|
||||
cvm::log("Updating the metadynamics bias \""+this->name+"\""+
|
||||
((comm != single_replica) ? ", replica \""+replica_id+"\"" : "")+".\n");
|
||||
int error_code = COLVARS_OK;
|
||||
|
||||
// update base class
|
||||
error_code |= colvarbias::update();
|
||||
|
||||
// update grid definition, if needed
|
||||
error_code |= update_grid_params();
|
||||
// add new biasing energy/forces
|
||||
error_code |= update_bias();
|
||||
// update grid content to reflect new bias
|
||||
error_code |= update_grid_data();
|
||||
|
||||
if (comm != single_replica &&
|
||||
(cvm::step_absolute() % replica_update_freq) == 0) {
|
||||
// sync with the other replicas (if needed)
|
||||
error_code |= replica_share();
|
||||
}
|
||||
|
||||
error_code |= calc_energy();
|
||||
error_code |= calc_forces();
|
||||
|
||||
return error_code;
|
||||
}
|
||||
|
||||
|
||||
int colvarbias_meta::update_grid_params()
|
||||
{
|
||||
if (use_grids) {
|
||||
|
||||
std::vector<int> curr_bin = hills_energy->get_colvars_index();
|
||||
if (cvm::debug()) {
|
||||
cvm::log("Metadynamics bias \""+this->name+"\""+
|
||||
((comm != single_replica) ? ", replica \""+replica_id+"\"" : "")+
|
||||
": current coordinates on the grid: "+
|
||||
cvm::to_str(curr_bin)+".\n");
|
||||
}
|
||||
|
||||
if (expand_grids) {
|
||||
|
||||
// first of all, expand the grids, if specified
|
||||
if (cvm::debug())
|
||||
cvm::log("Metadynamics bias \""+this->name+"\""+
|
||||
((comm != single_replica) ? ", replica \""+replica_id+"\"" : "")+
|
||||
": current coordinates on the grid: "+
|
||||
cvm::to_str(curr_bin)+".\n");
|
||||
|
||||
bool changed_grids = false;
|
||||
int const min_buffer =
|
||||
(3 * (size_t) std::floor(hill_width)) + 1;
|
||||
@ -339,9 +373,9 @@ int colvarbias_meta::update()
|
||||
std::vector<colvarvalue> new_lower_boundaries(hills_energy->lower_boundaries);
|
||||
std::vector<colvarvalue> new_upper_boundaries(hills_energy->upper_boundaries);
|
||||
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
|
||||
if (! colvars[i]->expand_boundaries)
|
||||
if (! variables(i)->expand_boundaries)
|
||||
continue;
|
||||
|
||||
cvm::real &new_lb = new_lower_boundaries[i].real_value;
|
||||
@ -349,10 +383,10 @@ int colvarbias_meta::update()
|
||||
int &new_size = new_sizes[i];
|
||||
bool changed_lb = false, changed_ub = false;
|
||||
|
||||
if (!colvars[i]->hard_lower_boundary)
|
||||
if (!variables(i)->hard_lower_boundary)
|
||||
if (curr_bin[i] < min_buffer) {
|
||||
int const extra_points = (min_buffer - curr_bin[i]);
|
||||
new_lb -= extra_points * colvars[i]->width;
|
||||
new_lb -= extra_points * variables(i)->width;
|
||||
new_size += extra_points;
|
||||
// changed offset in this direction => the pointer needs to
|
||||
// be changed, too
|
||||
@ -362,21 +396,21 @@ int colvarbias_meta::update()
|
||||
cvm::log("Metadynamics bias \""+this->name+"\""+
|
||||
((comm != single_replica) ? ", replica \""+replica_id+"\"" : "")+
|
||||
": new lower boundary for colvar \""+
|
||||
colvars[i]->name+"\", at "+
|
||||
variables(i)->name+"\", at "+
|
||||
cvm::to_str(new_lower_boundaries[i])+".\n");
|
||||
}
|
||||
|
||||
if (!colvars[i]->hard_upper_boundary)
|
||||
if (!variables(i)->hard_upper_boundary)
|
||||
if (curr_bin[i] > new_size - min_buffer - 1) {
|
||||
int const extra_points = (curr_bin[i] - (new_size - 1) + min_buffer);
|
||||
new_ub += extra_points * colvars[i]->width;
|
||||
new_ub += extra_points * variables(i)->width;
|
||||
new_size += extra_points;
|
||||
|
||||
changed_ub = true;
|
||||
cvm::log("Metadynamics bias \""+this->name+"\""+
|
||||
((comm != single_replica) ? ", replica \""+replica_id+"\"" : "")+
|
||||
": new upper boundary for colvar \""+
|
||||
colvars[i]->name+"\", at "+
|
||||
variables(i)->name+"\", at "+
|
||||
cvm::to_str(new_upper_boundaries[i])+".\n");
|
||||
}
|
||||
|
||||
@ -401,7 +435,7 @@ int colvarbias_meta::update()
|
||||
|
||||
new_hills_energy_gradients->lower_boundaries = new_lower_boundaries;
|
||||
new_hills_energy_gradients->upper_boundaries = new_upper_boundaries;
|
||||
new_hills_energy_gradients->setup(new_sizes, 0.0, colvars.size());
|
||||
new_hills_energy_gradients->setup(new_sizes, 0.0, num_variables());
|
||||
|
||||
new_hills_energy->map_grid(*hills_energy);
|
||||
new_hills_energy_gradients->map_grid(*hills_energy_gradients);
|
||||
@ -418,25 +452,32 @@ int colvarbias_meta::update()
|
||||
}
|
||||
}
|
||||
}
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
|
||||
int colvarbias_meta::update_bias()
|
||||
{
|
||||
// add a new hill if the required time interval has passed
|
||||
if ((cvm::step_absolute() % new_hill_freq) == 0) {
|
||||
if ((cvm::step_absolute() % new_hill_freq) == 0 &&
|
||||
is_enabled(f_cvb_history_dependent)) {
|
||||
|
||||
if (cvm::debug())
|
||||
if (cvm::debug()) {
|
||||
cvm::log("Metadynamics bias \""+this->name+"\""+
|
||||
((comm != single_replica) ? ", replica \""+replica_id+"\"" : "")+
|
||||
": adding a new hill at step "+cvm::to_str(cvm::step_absolute())+".\n");
|
||||
}
|
||||
|
||||
cvm::real hills_scale=1.0;
|
||||
|
||||
if (ebmeta) {
|
||||
hills_scale *= 1.0/target_dist->value(target_dist->get_colvars_index());
|
||||
if(cvm::step_absolute() <= long(ebmeta_equil_steps)) {
|
||||
cvm::real const hills_lambda =
|
||||
(cvm::real(long(ebmeta_equil_steps) - cvm::step_absolute())) /
|
||||
(cvm::real(ebmeta_equil_steps));
|
||||
hills_scale = hills_lambda + (1-hills_lambda)*hills_scale;
|
||||
}
|
||||
hills_scale *= 1.0/target_dist->value(target_dist->get_colvars_index());
|
||||
if(cvm::step_absolute() <= long(ebmeta_equil_steps)) {
|
||||
cvm::real const hills_lambda =
|
||||
(cvm::real(long(ebmeta_equil_steps) - cvm::step_absolute())) /
|
||||
(cvm::real(ebmeta_equil_steps));
|
||||
hills_scale = hills_lambda + (1-hills_lambda)*hills_scale;
|
||||
}
|
||||
}
|
||||
|
||||
if (well_tempered) {
|
||||
@ -471,160 +512,165 @@ int colvarbias_meta::update()
|
||||
}
|
||||
}
|
||||
|
||||
// sync with the other replicas (if needed)
|
||||
if (comm != single_replica) {
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
// reread the replicas registry
|
||||
if ((cvm::step_absolute() % replica_update_freq) == 0) {
|
||||
update_replicas_registry();
|
||||
// empty the output buffer
|
||||
if (replica_hills_os.is_open())
|
||||
replica_hills_os.flush();
|
||||
|
||||
read_replica_files();
|
||||
int colvarbias_meta::update_grid_data()
|
||||
{
|
||||
if ((cvm::step_absolute() % grids_freq) == 0) {
|
||||
// map the most recent gaussians to the grids
|
||||
project_hills(new_hills_begin, hills.end(),
|
||||
hills_energy, hills_energy_gradients);
|
||||
new_hills_begin = hills.end();
|
||||
|
||||
// TODO: we may want to condense all into one replicas array,
|
||||
// including "this" as the first element
|
||||
if (comm == multiple_replicas) {
|
||||
for (size_t ir = 0; ir < replicas.size(); ir++) {
|
||||
replicas[ir]->project_hills(replicas[ir]->new_hills_begin,
|
||||
replicas[ir]->hills.end(),
|
||||
replicas[ir]->hills_energy,
|
||||
replicas[ir]->hills_energy_gradients);
|
||||
replicas[ir]->new_hills_begin = replicas[ir]->hills.end();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// calculate the biasing energy and forces
|
||||
bias_energy = 0.0;
|
||||
for (size_t ir = 0; ir < colvars.size(); ir++) {
|
||||
colvar_forces[ir].reset();
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
|
||||
int colvarbias_meta::calc_energy(std::vector<colvarvalue> const &values)
|
||||
{
|
||||
size_t ir = 0;
|
||||
|
||||
for (ir = 0; ir < replicas.size(); ir++) {
|
||||
replicas[ir]->bias_energy = 0.0;
|
||||
}
|
||||
if (comm == multiple_replicas)
|
||||
for (size_t ir = 0; ir < replicas.size(); ir++) {
|
||||
replicas[ir]->bias_energy = 0.0;
|
||||
for (size_t ic = 0; ic < colvars.size(); ic++) {
|
||||
replicas[ir]->colvar_forces[ic].reset();
|
||||
|
||||
std::vector<int> const curr_bin = values.size() ?
|
||||
hills_energy->get_colvars_index(values) :
|
||||
hills_energy->get_colvars_index();
|
||||
|
||||
if (hills_energy->index_ok(curr_bin)) {
|
||||
// index is within the grid: get the energy from there
|
||||
for (ir = 0; ir < replicas.size(); ir++) {
|
||||
|
||||
bias_energy += replicas[ir]->hills_energy->value(curr_bin);
|
||||
if (cvm::debug()) {
|
||||
cvm::log("Metadynamics bias \""+this->name+"\""+
|
||||
((comm != single_replica) ? ", replica \""+replica_id+"\"" : "")+
|
||||
": current coordinates on the grid: "+
|
||||
cvm::to_str(curr_bin)+".\n");
|
||||
cvm::log("Grid energy = "+cvm::to_str(bias_energy)+".\n");
|
||||
}
|
||||
}
|
||||
|
||||
if (use_grids) {
|
||||
|
||||
// get the forces from the grid
|
||||
|
||||
if ((cvm::step_absolute() % grids_freq) == 0) {
|
||||
// map the most recent gaussians to the grids
|
||||
project_hills(new_hills_begin, hills.end(),
|
||||
hills_energy, hills_energy_gradients);
|
||||
new_hills_begin = hills.end();
|
||||
|
||||
// TODO: we may want to condense all into one replicas array,
|
||||
// including "this" as the first element
|
||||
if (comm == multiple_replicas) {
|
||||
for (size_t ir = 0; ir < replicas.size(); ir++) {
|
||||
replicas[ir]->project_hills(replicas[ir]->new_hills_begin,
|
||||
replicas[ir]->hills.end(),
|
||||
replicas[ir]->hills_energy,
|
||||
replicas[ir]->hills_energy_gradients);
|
||||
replicas[ir]->new_hills_begin = replicas[ir]->hills.end();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<int> curr_bin = hills_energy->get_colvars_index();
|
||||
if (cvm::debug())
|
||||
cvm::log("Metadynamics bias \""+this->name+"\""+
|
||||
((comm != single_replica) ? ", replica \""+replica_id+"\"" : "")+
|
||||
": current coordinates on the grid: "+
|
||||
cvm::to_str(curr_bin)+".\n");
|
||||
|
||||
if (hills_energy->index_ok(curr_bin)) {
|
||||
|
||||
// within the grid: add the energy and the forces from there
|
||||
|
||||
bias_energy += hills_energy->value(curr_bin);
|
||||
for (size_t ic = 0; ic < colvars.size(); ic++) {
|
||||
cvm::real const *f = &(hills_energy_gradients->value(curr_bin));
|
||||
colvar_forces[ic].real_value += -1.0 * f[ic];
|
||||
// the gradients are stored, not the forces
|
||||
}
|
||||
if (comm == multiple_replicas)
|
||||
for (size_t ir = 0; ir < replicas.size(); ir++) {
|
||||
bias_energy += replicas[ir]->hills_energy->value(curr_bin);
|
||||
cvm::real const *f = &(replicas[ir]->hills_energy_gradients->value(curr_bin));
|
||||
for (size_t ic = 0; ic < colvars.size(); ic++) {
|
||||
colvar_forces[ic].real_value += -1.0 * f[ic];
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
// off the grid: compute analytically only the hills at the grid's edges
|
||||
|
||||
calc_hills(hills_off_grid.begin(), hills_off_grid.end(), bias_energy);
|
||||
for (size_t ic = 0; ic < colvars.size(); ic++) {
|
||||
calc_hills_force(ic, hills_off_grid.begin(), hills_off_grid.end(), colvar_forces);
|
||||
}
|
||||
|
||||
if (comm == multiple_replicas)
|
||||
for (size_t ir = 0; ir < replicas.size(); ir++) {
|
||||
calc_hills(replicas[ir]->hills_off_grid.begin(),
|
||||
replicas[ir]->hills_off_grid.end(),
|
||||
bias_energy);
|
||||
for (size_t ic = 0; ic < colvars.size(); ic++) {
|
||||
calc_hills_force(ic,
|
||||
replicas[ir]->hills_off_grid.begin(),
|
||||
replicas[ir]->hills_off_grid.end(),
|
||||
colvar_forces);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// off the grid: compute analytically only the hills at the grid's edges
|
||||
for (ir = 0; ir < replicas.size(); ir++) {
|
||||
calc_hills(replicas[ir]->hills_off_grid.begin(),
|
||||
replicas[ir]->hills_off_grid.end(),
|
||||
bias_energy,
|
||||
values);
|
||||
}
|
||||
}
|
||||
|
||||
// now include the hills that have not been binned yet (starting
|
||||
// from new_hills_begin)
|
||||
|
||||
calc_hills(new_hills_begin, hills.end(), bias_energy);
|
||||
for (size_t ic = 0; ic < colvars.size(); ic++) {
|
||||
calc_hills_force(ic, new_hills_begin, hills.end(), colvar_forces);
|
||||
}
|
||||
|
||||
if (cvm::debug())
|
||||
cvm::log("Hills energy = "+cvm::to_str(bias_energy)+
|
||||
", hills forces = "+cvm::to_str(colvar_forces)+".\n");
|
||||
|
||||
if (cvm::debug())
|
||||
cvm::log("Metadynamics bias \""+this->name+"\""+
|
||||
((comm != single_replica) ? ", replica \""+replica_id+"\"" : "")+
|
||||
": adding the forces from the other replicas.\n");
|
||||
|
||||
if (comm == multiple_replicas)
|
||||
for (size_t ir = 0; ir < replicas.size(); ir++) {
|
||||
calc_hills(replicas[ir]->new_hills_begin,
|
||||
replicas[ir]->hills.end(),
|
||||
bias_energy);
|
||||
for (size_t ic = 0; ic < colvars.size(); ic++) {
|
||||
calc_hills_force(ic,
|
||||
replicas[ir]->new_hills_begin,
|
||||
replicas[ir]->hills.end(),
|
||||
colvar_forces);
|
||||
}
|
||||
if (cvm::debug())
|
||||
cvm::log("Hills energy = "+cvm::to_str(bias_energy)+
|
||||
", hills forces = "+cvm::to_str(colvar_forces)+".\n");
|
||||
for (ir = 0; ir < replicas.size(); ir++) {
|
||||
calc_hills(replicas[ir]->new_hills_begin,
|
||||
replicas[ir]->hills.end(),
|
||||
bias_energy);
|
||||
if (cvm::debug()) {
|
||||
cvm::log("Hills energy = "+cvm::to_str(bias_energy)+".\n");
|
||||
}
|
||||
}
|
||||
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
|
||||
int colvarbias_meta::calc_forces(std::vector<colvarvalue> const &values)
|
||||
{
|
||||
size_t ir = 0, ic = 0;
|
||||
for (ir = 0; ir < replicas.size(); ir++) {
|
||||
for (ic = 0; ic < num_variables(); ic++) {
|
||||
replicas[ir]->colvar_forces[ic].reset();
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<int> const curr_bin = values.size() ?
|
||||
hills_energy->get_colvars_index(values) :
|
||||
hills_energy->get_colvars_index();
|
||||
|
||||
if (hills_energy->index_ok(curr_bin)) {
|
||||
for (ir = 0; ir < replicas.size(); ir++) {
|
||||
cvm::real const *f = &(replicas[ir]->hills_energy_gradients->value(curr_bin));
|
||||
for (ic = 0; ic < num_variables(); ic++) {
|
||||
// the gradients are stored, not the forces
|
||||
colvar_forces[ic].real_value += -1.0 * f[ic];
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// off the grid: compute analytically only the hills at the grid's edges
|
||||
for (ir = 0; ir < replicas.size(); ir++) {
|
||||
for (ic = 0; ic < num_variables(); ic++) {
|
||||
calc_hills_force(ic,
|
||||
replicas[ir]->hills_off_grid.begin(),
|
||||
replicas[ir]->hills_off_grid.end(),
|
||||
colvar_forces,
|
||||
values);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// now include the hills that have not been binned yet (starting
|
||||
// from new_hills_begin)
|
||||
|
||||
if (cvm::debug()) {
|
||||
cvm::log("Metadynamics bias \""+this->name+"\""+
|
||||
((comm != single_replica) ? ", replica \""+replica_id+"\"" : "")+
|
||||
": adding the forces from the other replicas.\n");
|
||||
}
|
||||
|
||||
for (ir = 0; ir < replicas.size(); ir++) {
|
||||
for (ic = 0; ic < num_variables(); ic++) {
|
||||
calc_hills_force(ic,
|
||||
replicas[ir]->new_hills_begin,
|
||||
replicas[ir]->hills.end(),
|
||||
colvar_forces,
|
||||
values);
|
||||
if (cvm::debug()) {
|
||||
cvm::log("Hills forces = "+cvm::to_str(colvar_forces)+".\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
|
||||
|
||||
void colvarbias_meta::calc_hills(colvarbias_meta::hill_iter h_first,
|
||||
colvarbias_meta::hill_iter h_last,
|
||||
cvm::real &energy,
|
||||
std::vector<colvarvalue> const &colvar_values)
|
||||
{
|
||||
std::vector<colvarvalue> curr_values(colvars.size());
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
curr_values[i].type(colvars[i]->value());
|
||||
size_t i = 0;
|
||||
std::vector<colvarvalue> curr_values(num_variables());
|
||||
for (i = 0; i < num_variables(); i++) {
|
||||
curr_values[i].type(variables(i)->value());
|
||||
}
|
||||
|
||||
if (colvar_values.size()) {
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
for (i = 0; i < num_variables(); i++) {
|
||||
curr_values[i] = colvar_values[i];
|
||||
}
|
||||
} else {
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
curr_values[i] = colvars[i]->value();
|
||||
for (i = 0; i < num_variables(); i++) {
|
||||
curr_values[i] = variables(i)->value();
|
||||
}
|
||||
}
|
||||
|
||||
@ -632,11 +678,11 @@ void colvarbias_meta::calc_hills(colvarbias_meta::hill_iter h_first,
|
||||
|
||||
// compute the gaussian exponent
|
||||
cvm::real cv_sqdev = 0.0;
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
for (i = 0; i < num_variables(); i++) {
|
||||
colvarvalue const &x = curr_values[i];
|
||||
colvarvalue const ¢er = h->centers[i];
|
||||
cvm::real const half_width = 0.5 * h->widths[i];
|
||||
cv_sqdev += (colvars[i]->dist2(x, center)) / (half_width*half_width);
|
||||
cv_sqdev += (variables(i)->dist2(x, center)) / (half_width*half_width);
|
||||
}
|
||||
|
||||
// compute the gaussian
|
||||
@ -658,14 +704,14 @@ void colvarbias_meta::calc_hills_force(size_t const &i,
|
||||
std::vector<colvarvalue> const &values)
|
||||
{
|
||||
// Retrieve the value of the colvar
|
||||
colvarvalue const x(values.size() ? values[i] : colvars[i]->value());
|
||||
colvarvalue const x(values.size() ? values[i] : variables(i)->value());
|
||||
|
||||
// do the type check only once (all colvarvalues in the hills series
|
||||
// were already saved with their types matching those in the
|
||||
// colvars)
|
||||
|
||||
hill_iter h;
|
||||
switch (colvars[i]->value().type()) {
|
||||
switch (variables(i)->value().type()) {
|
||||
|
||||
case colvarvalue::type_scalar:
|
||||
for (h = h_first; h != h_last; h++) {
|
||||
@ -674,7 +720,7 @@ void colvarbias_meta::calc_hills_force(size_t const &i,
|
||||
cvm::real const half_width = 0.5 * h->widths[i];
|
||||
forces[i].real_value +=
|
||||
( h->weight() * h->value() * (0.5 / (half_width*half_width)) *
|
||||
(colvars[i]->dist2_lgrad(x, center)).real_value );
|
||||
(variables(i)->dist2_lgrad(x, center)).real_value );
|
||||
}
|
||||
break;
|
||||
|
||||
@ -687,7 +733,7 @@ void colvarbias_meta::calc_hills_force(size_t const &i,
|
||||
cvm::real const half_width = 0.5 * h->widths[i];
|
||||
forces[i].rvector_value +=
|
||||
( h->weight() * h->value() * (0.5 / (half_width*half_width)) *
|
||||
(colvars[i]->dist2_lgrad(x, center)).rvector_value );
|
||||
(variables(i)->dist2_lgrad(x, center)).rvector_value );
|
||||
}
|
||||
break;
|
||||
|
||||
@ -699,7 +745,7 @@ void colvarbias_meta::calc_hills_force(size_t const &i,
|
||||
cvm::real const half_width = 0.5 * h->widths[i];
|
||||
forces[i].quaternion_value +=
|
||||
( h->weight() * h->value() * (0.5 / (half_width*half_width)) *
|
||||
(colvars[i]->dist2_lgrad(x, center)).quaternion_value );
|
||||
(variables(i)->dist2_lgrad(x, center)).quaternion_value );
|
||||
}
|
||||
break;
|
||||
|
||||
@ -710,7 +756,7 @@ void colvarbias_meta::calc_hills_force(size_t const &i,
|
||||
cvm::real const half_width = 0.5 * h->widths[i];
|
||||
forces[i].vector1d_value +=
|
||||
( h->weight() * h->value() * (0.5 / (half_width*half_width)) *
|
||||
(colvars[i]->dist2_lgrad(x, center)).vector1d_value );
|
||||
(variables(i)->dist2_lgrad(x, center)).vector1d_value );
|
||||
}
|
||||
break;
|
||||
|
||||
@ -739,13 +785,13 @@ void colvarbias_meta::project_hills(colvarbias_meta::hill_iter h_first,
|
||||
|
||||
// TODO: improve it by looping over a small subgrid instead of the whole grid
|
||||
|
||||
std::vector<colvarvalue> colvar_values(colvars.size());
|
||||
std::vector<cvm::real> colvar_forces_scalar(colvars.size());
|
||||
std::vector<colvarvalue> colvar_values(num_variables());
|
||||
std::vector<cvm::real> colvar_forces_scalar(num_variables());
|
||||
|
||||
std::vector<int> he_ix = he->new_index();
|
||||
std::vector<int> hg_ix = (hg != NULL) ? hg->new_index() : std::vector<int> (0);
|
||||
cvm::real hills_energy_here = 0.0;
|
||||
std::vector<colvarvalue> hills_forces_here(colvars.size(), 0.0);
|
||||
std::vector<colvarvalue> hills_forces_here(num_variables(), 0.0);
|
||||
|
||||
size_t count = 0;
|
||||
size_t const print_frequency = ((hills.size() >= 1000000) ? 1 : (1000000/(hills.size()+1)));
|
||||
@ -757,7 +803,7 @@ void colvarbias_meta::project_hills(colvarbias_meta::hill_iter h_first,
|
||||
(he->index_ok(he_ix)) && (hg->index_ok(hg_ix));
|
||||
count++) {
|
||||
size_t i;
|
||||
for (i = 0; i < colvars.size(); i++) {
|
||||
for (i = 0; i < num_variables(); i++) {
|
||||
colvar_values[i] = hills_energy->bin_to_value_scalar(he_ix[i], i);
|
||||
}
|
||||
|
||||
@ -766,7 +812,7 @@ void colvarbias_meta::project_hills(colvarbias_meta::hill_iter h_first,
|
||||
calc_hills(h_first, h_last, hills_energy_here, colvar_values);
|
||||
he->acc_value(he_ix, hills_energy_here);
|
||||
|
||||
for (i = 0; i < colvars.size(); i++) {
|
||||
for (i = 0; i < num_variables(); i++) {
|
||||
hills_forces_here[i].reset();
|
||||
calc_hills_force(i, h_first, h_last, hills_forces_here, colvar_values);
|
||||
colvar_forces_scalar[i] = hills_forces_here[i].real_value;
|
||||
@ -795,7 +841,7 @@ void colvarbias_meta::project_hills(colvarbias_meta::hill_iter h_first,
|
||||
|
||||
for ( ; (he->index_ok(he_ix)); ) {
|
||||
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
colvar_values[i] = hills_energy->bin_to_value_scalar(he_ix[i], i);
|
||||
}
|
||||
|
||||
@ -851,6 +897,21 @@ void colvarbias_meta::recount_hills_off_grid(colvarbias_meta::hill_iter h_first
|
||||
// **********************************************************************
|
||||
|
||||
|
||||
int colvarbias_meta::replica_share()
|
||||
{
|
||||
// sync with the other replicas (if needed)
|
||||
if (comm == multiple_replicas) {
|
||||
// reread the replicas registry
|
||||
update_replicas_registry();
|
||||
// empty the output buffer
|
||||
if (replica_hills_os.is_open())
|
||||
replica_hills_os.flush();
|
||||
read_replica_files();
|
||||
}
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
|
||||
void colvarbias_meta::update_replicas_registry()
|
||||
{
|
||||
if (cvm::debug())
|
||||
@ -975,7 +1036,6 @@ void colvarbias_meta::update_replicas_registry()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (cvm::debug())
|
||||
cvm::log("Metadynamics bias \""+this->name+"\": the list of replicas contains "+
|
||||
cvm::to_str(replicas.size())+" elements.\n");
|
||||
@ -984,7 +1044,8 @@ void colvarbias_meta::update_replicas_registry()
|
||||
|
||||
void colvarbias_meta::read_replica_files()
|
||||
{
|
||||
for (size_t ir = 0; ir < replicas.size(); ir++) {
|
||||
// Note: we start from the 2nd replica.
|
||||
for (size_t ir = 1; ir < replicas.size(); ir++) {
|
||||
|
||||
if (! (replicas[ir])->replica_state_file_in_sync) {
|
||||
// if a new state file is being read, the hills file is also new
|
||||
@ -1352,9 +1413,9 @@ std::istream & colvarbias_meta::read_hill(std::istream &is)
|
||||
cvm::real h_weight;
|
||||
get_keyval(data, "weight", h_weight, hill_weight, parse_silent);
|
||||
|
||||
std::vector<colvarvalue> h_centers(colvars.size());
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
h_centers[i].type(colvars[i]->value());
|
||||
std::vector<colvarvalue> h_centers(num_variables());
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
h_centers[i].type(variables(i)->value());
|
||||
}
|
||||
{
|
||||
// it is safer to read colvarvalue objects one at a time;
|
||||
@ -1362,14 +1423,14 @@ std::istream & colvarbias_meta::read_hill(std::istream &is)
|
||||
std::string centers_input;
|
||||
key_lookup(data, "centers", centers_input);
|
||||
std::istringstream centers_is(centers_input);
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
centers_is >> h_centers[i];
|
||||
}
|
||||
}
|
||||
|
||||
std::vector<cvm::real> h_widths(colvars.size());
|
||||
std::vector<cvm::real> h_widths(num_variables());
|
||||
get_keyval(data, "widths", h_widths,
|
||||
std::vector<cvm::real> (colvars.size(), (std::sqrt(2.0 * PI) / 2.0)),
|
||||
std::vector<cvm::real>(num_variables(), (std::sqrt(2.0 * PI) / 2.0)),
|
||||
parse_silent);
|
||||
|
||||
std::string h_replica = "";
|
||||
@ -1406,6 +1467,13 @@ std::istream & colvarbias_meta::read_hill(std::istream &is)
|
||||
|
||||
int colvarbias_meta::setup_output()
|
||||
{
|
||||
output_prefix = cvm::output_prefix();
|
||||
if (cvm::num_biases_feature(colvardeps::f_cvb_calc_pmf) > 1) {
|
||||
// if this is not the only free energy integrator, append
|
||||
// this bias's name, to distinguish it from the output of the other
|
||||
// biases producing a .pmf file
|
||||
output_prefix += ("."+this->name);
|
||||
}
|
||||
|
||||
if (comm == multiple_replicas) {
|
||||
|
||||
@ -1421,10 +1489,10 @@ int colvarbias_meta::setup_output()
|
||||
// those by another replica
|
||||
replica_hills_file =
|
||||
(std::string(pwd)+std::string(PATHSEP)+
|
||||
cvm::output_prefix+".colvars."+this->name+"."+replica_id+".hills");
|
||||
cvm::output_prefix()+".colvars."+this->name+"."+replica_id+".hills");
|
||||
replica_state_file =
|
||||
(std::string(pwd)+std::string(PATHSEP)+
|
||||
cvm::output_prefix+".colvars."+this->name+"."+replica_id+".state");
|
||||
cvm::output_prefix()+".colvars."+this->name+"."+replica_id+".state");
|
||||
delete[] pwd;
|
||||
|
||||
// now register this replica
|
||||
@ -1492,13 +1560,14 @@ int colvarbias_meta::setup_output()
|
||||
}
|
||||
|
||||
if (b_hills_traj) {
|
||||
std::string const traj_file_name(cvm::output_prefix+
|
||||
std::string const traj_file_name(cvm::output_prefix()+
|
||||
".colvars."+this->name+
|
||||
( (comm != single_replica) ?
|
||||
("."+replica_id) :
|
||||
("") )+
|
||||
".hills.traj");
|
||||
if (!hills_traj_os.is_open()) {
|
||||
cvm::backup_file(traj_file_name.c_str());
|
||||
hills_traj_os.open(traj_file_name.c_str());
|
||||
}
|
||||
if (!hills_traj_os.is_open())
|
||||
@ -1585,16 +1654,6 @@ void colvarbias_meta::write_pmf()
|
||||
colvar_grid_scalar *pmf = new colvar_grid_scalar(*hills_energy);
|
||||
pmf->setup();
|
||||
|
||||
std::string fes_file_name_prefix(cvm::output_prefix);
|
||||
|
||||
if ((cvm::n_meta_biases > 1) || (cvm::n_abf_biases > 0)) {
|
||||
// if this is not the only free energy integrator, append
|
||||
// this bias's name, to distinguish it from the output of the other
|
||||
// biases producing a .pmf file
|
||||
// TODO: fix for ABF with updateBias == no
|
||||
fes_file_name_prefix += ("."+this->name);
|
||||
}
|
||||
|
||||
if ((comm == single_replica) || (dump_replica_fes)) {
|
||||
// output the PMF from this instance or replica
|
||||
pmf->reset();
|
||||
@ -1607,7 +1666,7 @@ void colvarbias_meta::write_pmf()
|
||||
pmf->multiply_constant(well_temper_scale);
|
||||
}
|
||||
{
|
||||
std::string const fes_file_name(fes_file_name_prefix +
|
||||
std::string const fes_file_name(this->output_prefix +
|
||||
((comm != single_replica) ? ".partial" : "") +
|
||||
(dump_fes_save ?
|
||||
"."+cvm::to_str(cvm::step_absolute()) : "") +
|
||||
@ -1632,7 +1691,7 @@ void colvarbias_meta::write_pmf()
|
||||
cvm::real const well_temper_scale = (bias_temperature + cvm::temperature()) / bias_temperature;
|
||||
pmf->multiply_constant(well_temper_scale);
|
||||
}
|
||||
std::string const fes_file_name(fes_file_name_prefix +
|
||||
std::string const fes_file_name(this->output_prefix +
|
||||
(dump_fes_save ?
|
||||
"."+cvm::to_str(cvm::step_absolute()) : "") +
|
||||
".pmf");
|
||||
|
||||
@ -36,8 +36,20 @@ public:
|
||||
|
||||
colvarbias_meta(char const *key);
|
||||
virtual int init(std::string const &conf);
|
||||
virtual int init_well_tempered_params(std::string const &conf);
|
||||
virtual int init_ebmeta_params(std::string const &conf);
|
||||
virtual ~colvarbias_meta();
|
||||
|
||||
virtual int update();
|
||||
virtual int update_grid_params();
|
||||
virtual int update_bias();
|
||||
virtual int update_grid_data();
|
||||
virtual int replica_share();
|
||||
|
||||
virtual int calc_energy(std::vector<colvarvalue> const &values =
|
||||
std::vector<colvarvalue>(0));
|
||||
virtual int calc_forces(std::vector<colvarvalue> const &values =
|
||||
std::vector<colvarvalue>(0));
|
||||
|
||||
virtual std::string const get_state_params() const;
|
||||
virtual int set_state_params(std::string const &state_conf);
|
||||
@ -102,18 +114,18 @@ protected:
|
||||
/// \brief Calculate the values of the hills, incrementing
|
||||
/// bias_energy
|
||||
virtual void calc_hills(hill_iter h_first,
|
||||
hill_iter h_last,
|
||||
cvm::real &energy,
|
||||
std::vector<colvarvalue> const &values = std::vector<colvarvalue> (0));
|
||||
hill_iter h_last,
|
||||
cvm::real &energy,
|
||||
std::vector<colvarvalue> const &values = std::vector<colvarvalue>(0));
|
||||
|
||||
/// \brief Calculate the forces acting on the i-th colvar,
|
||||
/// incrementing colvar_forces[i]; must be called after calc_hills
|
||||
/// each time the values of the colvars are changed
|
||||
virtual void calc_hills_force(size_t const &i,
|
||||
hill_iter h_first,
|
||||
hill_iter h_last,
|
||||
std::vector<colvarvalue> &forces,
|
||||
std::vector<colvarvalue> const &values = std::vector<colvarvalue> (0));
|
||||
hill_iter h_first,
|
||||
hill_iter h_last,
|
||||
std::vector<colvarvalue> &forces,
|
||||
std::vector<colvarvalue> const &values = std::vector<colvarvalue>(0));
|
||||
|
||||
|
||||
/// Height of new hills
|
||||
|
||||
@ -33,17 +33,15 @@ int colvarbias_restraint::init(std::string const &conf)
|
||||
|
||||
int colvarbias_restraint::update()
|
||||
{
|
||||
bias_energy = 0.0;
|
||||
|
||||
if (cvm::debug())
|
||||
cvm::log("Updating the restraint bias \""+this->name+"\".\n");
|
||||
// Update base class (bias_energy and colvar_forces are zeroed there)
|
||||
colvarbias::update();
|
||||
|
||||
// Force and energy calculation
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
colvar_forces[i].type(colvars[i]->value());
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
bias_energy += restraint_potential(i);
|
||||
colvar_forces[i].type(variables(i)->value());
|
||||
colvar_forces[i].is_derivative();
|
||||
colvar_forces[i] = restraint_force(i);
|
||||
bias_energy += restraint_potential(i);
|
||||
}
|
||||
|
||||
if (cvm::debug())
|
||||
@ -59,8 +57,6 @@ int colvarbias_restraint::update()
|
||||
|
||||
colvarbias_restraint::~colvarbias_restraint()
|
||||
{
|
||||
if (cvm::n_rest_biases > 0)
|
||||
cvm::n_rest_biases -= 1;
|
||||
}
|
||||
|
||||
|
||||
@ -102,18 +98,18 @@ int colvarbias_restraint_centers::init(std::string const &conf)
|
||||
bool null_centers = (colvar_centers.size() == 0);
|
||||
if (null_centers) {
|
||||
// try to initialize the restraint centers for the first time
|
||||
colvar_centers.resize(colvars.size());
|
||||
colvar_centers_raw.resize(colvars.size());
|
||||
for (i = 0; i < colvars.size(); i++) {
|
||||
colvar_centers[i].type(colvars[i]->value());
|
||||
colvar_centers.resize(num_variables());
|
||||
colvar_centers_raw.resize(num_variables());
|
||||
for (i = 0; i < num_variables(); i++) {
|
||||
colvar_centers[i].type(variables(i)->value());
|
||||
colvar_centers[i].reset();
|
||||
colvar_centers_raw[i].type(colvars[i]->value());
|
||||
colvar_centers_raw[i].type(variables(i)->value());
|
||||
colvar_centers_raw[i].reset();
|
||||
}
|
||||
}
|
||||
|
||||
if (get_keyval(conf, "centers", colvar_centers, colvar_centers)) {
|
||||
for (i = 0; i < colvars.size(); i++) {
|
||||
for (i = 0; i < num_variables(); i++) {
|
||||
if (cvm::debug()) {
|
||||
cvm::log("colvarbias_restraint: parsing initial centers, i = "+cvm::to_str(i)+".\n");
|
||||
}
|
||||
@ -129,7 +125,7 @@ int colvarbias_restraint_centers::init(std::string const &conf)
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
|
||||
if (colvar_centers.size() != colvars.size()) {
|
||||
if (colvar_centers.size() != num_variables()) {
|
||||
cvm::error("Error: number of centers does not match "
|
||||
"that of collective variables.\n", INPUT_ERROR);
|
||||
return INPUT_ERROR;
|
||||
@ -142,10 +138,10 @@ int colvarbias_restraint_centers::init(std::string const &conf)
|
||||
int colvarbias_restraint_centers::change_configuration(std::string const &conf)
|
||||
{
|
||||
if (get_keyval(conf, "centers", colvar_centers, colvar_centers)) {
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
colvar_centers[i].type(colvars[i]->value());
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
colvar_centers[i].type(variables(i)->value());
|
||||
colvar_centers[i].apply_constraints();
|
||||
colvar_centers_raw[i].type(colvars[i]->value());
|
||||
colvar_centers_raw[i].type(variables(i)->value());
|
||||
colvar_centers_raw[i] = colvar_centers[i];
|
||||
}
|
||||
}
|
||||
@ -269,7 +265,7 @@ int colvarbias_restraint_centers_moving::init(std::string const &conf)
|
||||
|
||||
size_t i;
|
||||
if (get_keyval(conf, "targetCenters", target_centers, colvar_centers)) {
|
||||
if (colvar_centers.size() != colvars.size()) {
|
||||
if (colvar_centers.size() != num_variables()) {
|
||||
cvm::error("Error: number of target centers does not match "
|
||||
"that of collective variables.\n");
|
||||
}
|
||||
@ -308,9 +304,9 @@ int colvarbias_restraint_centers_moving::update()
|
||||
// at each simulation step (or stage, if applicable)
|
||||
// (take current stage into account: it can be non-zero
|
||||
// if we are restarting a staged calculation)
|
||||
centers_incr.resize(colvars.size());
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
centers_incr[i].type(colvars[i]->value());
|
||||
centers_incr.resize(num_variables());
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
centers_incr[i].type(variables(i)->value());
|
||||
centers_incr[i] = (target_centers[i] - colvar_centers_raw[i]) /
|
||||
cvm::real( target_nstages ? (target_nstages - stage) :
|
||||
(target_nsteps - cvm::step_absolute()));
|
||||
@ -326,10 +322,10 @@ int colvarbias_restraint_centers_moving::update()
|
||||
&& (cvm::step_absolute() % target_nsteps) == 0
|
||||
&& stage < target_nstages) {
|
||||
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
colvar_centers_raw[i] += centers_incr[i];
|
||||
colvar_centers[i] = colvar_centers_raw[i];
|
||||
colvars[i]->wrap(colvar_centers[i]);
|
||||
variables(i)->wrap(colvar_centers[i]);
|
||||
colvar_centers[i].apply_constraints();
|
||||
}
|
||||
stage++;
|
||||
@ -341,10 +337,10 @@ int colvarbias_restraint_centers_moving::update()
|
||||
} else if ((cvm::step_relative() > 0) && (cvm::step_absolute() <= target_nsteps)) {
|
||||
// move the restraint centers in the direction of the targets
|
||||
// (slow growth)
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
colvar_centers_raw[i] += centers_incr[i];
|
||||
colvar_centers[i] = colvar_centers_raw[i];
|
||||
colvars[i]->wrap(colvar_centers[i]);
|
||||
variables(i)->wrap(colvar_centers[i]);
|
||||
colvar_centers[i].apply_constraints();
|
||||
}
|
||||
}
|
||||
@ -363,7 +359,7 @@ int colvarbias_restraint_centers_moving::update_acc_work()
|
||||
{
|
||||
if (b_output_acc_work) {
|
||||
if ((cvm::step_relative() > 0) || (cvm::step_absolute() == 0)) {
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
// project forces on the calculated increments at this step
|
||||
acc_work += colvar_forces[i] * centers_incr[i];
|
||||
}
|
||||
@ -381,14 +377,14 @@ std::string const colvarbias_restraint_centers_moving::get_state_params() const
|
||||
if (b_chg_centers) {
|
||||
size_t i;
|
||||
os << "centers ";
|
||||
for (i = 0; i < colvars.size(); i++) {
|
||||
for (i = 0; i < num_variables(); i++) {
|
||||
os << " "
|
||||
<< std::setprecision(cvm::cv_prec) << std::setw(cvm::cv_width)
|
||||
<< colvar_centers[i];
|
||||
}
|
||||
os << "\n";
|
||||
os << "centers_raw ";
|
||||
for (i = 0; i < colvars.size(); i++) {
|
||||
for (i = 0; i < num_variables(); i++) {
|
||||
os << " "
|
||||
<< std::setprecision(cvm::cv_prec) << std::setw(cvm::cv_width)
|
||||
<< colvar_centers_raw[i];
|
||||
@ -429,10 +425,10 @@ int colvarbias_restraint_centers_moving::set_state_params(std::string const &con
|
||||
std::ostream & colvarbias_restraint_centers_moving::write_traj_label(std::ostream &os)
|
||||
{
|
||||
if (b_output_centers) {
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
size_t const this_cv_width = (colvars[i]->value()).output_width(cvm::cv_width);
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
size_t const this_cv_width = (variables(i)->value()).output_width(cvm::cv_width);
|
||||
os << " x0_"
|
||||
<< cvm::wrap_string(colvars[i]->name, this_cv_width-3);
|
||||
<< cvm::wrap_string(variables(i)->name, this_cv_width-3);
|
||||
}
|
||||
}
|
||||
|
||||
@ -448,7 +444,7 @@ std::ostream & colvarbias_restraint_centers_moving::write_traj_label(std::ostrea
|
||||
std::ostream & colvarbias_restraint_centers_moving::write_traj(std::ostream &os)
|
||||
{
|
||||
if (b_output_centers) {
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
os << " "
|
||||
<< std::setprecision(cvm::cv_prec) << std::setw(cvm::cv_width)
|
||||
<< colvar_centers[i];
|
||||
@ -539,9 +535,9 @@ int colvarbias_restraint_k_moving::update()
|
||||
}
|
||||
force_k = starting_force_k + (target_force_k - starting_force_k)
|
||||
* std::pow(lambda, force_k_exp);
|
||||
cvm::log("Restraint " + this->name + ", stage " +
|
||||
cvm::to_str(stage) + " : lambda = " + cvm::to_str(lambda));
|
||||
cvm::log("Setting force constant to " + cvm::to_str(force_k));
|
||||
cvm::log("Restraint " + this->name + ", stage " + cvm::to_str(stage)
|
||||
+ " : lambda = " + cvm::to_str(lambda)
|
||||
+ ", k = " + cvm::to_str(force_k));
|
||||
}
|
||||
|
||||
// TI calculation: estimate free energy derivative
|
||||
@ -557,7 +553,7 @@ int colvarbias_restraint_k_moving::update()
|
||||
|
||||
// Square distance normalized by square colvar width
|
||||
cvm::real dist_sq = 0.0;
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
dist_sq += d_restraint_potential_dk(i);
|
||||
}
|
||||
|
||||
@ -569,7 +565,8 @@ int colvarbias_restraint_k_moving::update()
|
||||
if (cvm::step_absolute() % target_nsteps == 0 &&
|
||||
cvm::step_absolute() > 0) {
|
||||
|
||||
cvm::log("Lambda= " + cvm::to_str(lambda) + " dA/dLambda= "
|
||||
cvm::log("Restraint " + this->name + " Lambda= "
|
||||
+ cvm::to_str(lambda) + " dA/dLambda= "
|
||||
+ cvm::to_str(restraint_FE / cvm::real(target_nsteps - target_equil_steps)));
|
||||
|
||||
// ...and move on to the next one
|
||||
@ -584,9 +581,9 @@ int colvarbias_restraint_k_moving::update()
|
||||
}
|
||||
force_k = starting_force_k + (target_force_k - starting_force_k)
|
||||
* std::pow(lambda, force_k_exp);
|
||||
cvm::log("Restraint " + this->name + ", stage " +
|
||||
cvm::to_str(stage) + " : lambda = " + cvm::to_str(lambda));
|
||||
cvm::log("Setting force constant to " + cvm::to_str(force_k));
|
||||
cvm::log("Restraint " + this->name + ", stage " + cvm::to_str(stage)
|
||||
+ " : lambda = " + cvm::to_str(lambda)
|
||||
+ ", k = " + cvm::to_str(force_k));
|
||||
}
|
||||
}
|
||||
|
||||
@ -721,11 +718,11 @@ int colvarbias_restraint_harmonic::init(std::string const &conf)
|
||||
colvarbias_restraint_centers_moving::init(conf);
|
||||
colvarbias_restraint_k_moving::init(conf);
|
||||
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
if (colvars[i]->width != 1.0)
|
||||
cvm::log("The force constant for colvar \""+colvars[i]->name+
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
if (variables(i)->width != 1.0)
|
||||
cvm::log("The force constant for colvar \""+variables(i)->name+
|
||||
"\" will be rescaled to "+
|
||||
cvm::to_str(force_k / (colvars[i]->width * colvars[i]->width))+
|
||||
cvm::to_str(force_k / (variables(i)->width * variables(i)->width))+
|
||||
" according to the specified width.\n");
|
||||
}
|
||||
|
||||
@ -751,22 +748,22 @@ int colvarbias_restraint_harmonic::update()
|
||||
|
||||
cvm::real colvarbias_restraint_harmonic::restraint_potential(size_t i) const
|
||||
{
|
||||
return 0.5 * force_k / (colvars[i]->width * colvars[i]->width) *
|
||||
colvars[i]->dist2(colvars[i]->value(), colvar_centers[i]);
|
||||
return 0.5 * force_k / (variables(i)->width * variables(i)->width) *
|
||||
variables(i)->dist2(variables(i)->value(), colvar_centers[i]);
|
||||
}
|
||||
|
||||
|
||||
colvarvalue const colvarbias_restraint_harmonic::restraint_force(size_t i) const
|
||||
{
|
||||
return -0.5 * force_k / (colvars[i]->width * colvars[i]->width) *
|
||||
colvars[i]->dist2_lgrad(colvars[i]->value(), colvar_centers[i]);
|
||||
return -0.5 * force_k / (variables(i)->width * variables(i)->width) *
|
||||
variables(i)->dist2_lgrad(variables(i)->value(), colvar_centers[i]);
|
||||
}
|
||||
|
||||
|
||||
cvm::real colvarbias_restraint_harmonic::d_restraint_potential_dk(size_t i) const
|
||||
{
|
||||
return 0.5 / (colvars[i]->width * colvars[i]->width) *
|
||||
colvars[i]->dist2(colvars[i]->value(), colvar_centers[i]);
|
||||
return 0.5 / (variables(i)->width * variables(i)->width) *
|
||||
variables(i)->dist2(variables(i)->value(), colvar_centers[i]);
|
||||
}
|
||||
|
||||
|
||||
@ -840,6 +837,8 @@ colvarbias_restraint_harmonic_walls::colvarbias_restraint_harmonic_walls(char co
|
||||
colvarbias_restraint_moving(key),
|
||||
colvarbias_restraint_k_moving(key)
|
||||
{
|
||||
lower_wall_k = 0.0;
|
||||
upper_wall_k = 0.0;
|
||||
}
|
||||
|
||||
|
||||
@ -849,7 +848,11 @@ int colvarbias_restraint_harmonic_walls::init(std::string const &conf)
|
||||
colvarbias_restraint_moving::init(conf);
|
||||
colvarbias_restraint_k_moving::init(conf);
|
||||
|
||||
provide(f_cvb_scalar_variables);
|
||||
get_keyval(conf, "lowerWallConstant", lower_wall_k,
|
||||
(lower_wall_k > 0.0) ? lower_wall_k : force_k);
|
||||
get_keyval(conf, "upperWallConstant", upper_wall_k,
|
||||
(upper_wall_k > 0.0) ? upper_wall_k : force_k);
|
||||
|
||||
enable(f_cvb_scalar_variables);
|
||||
|
||||
size_t i;
|
||||
@ -857,9 +860,9 @@ int colvarbias_restraint_harmonic_walls::init(std::string const &conf)
|
||||
bool b_null_lower_walls = false;
|
||||
if (lower_walls.size() == 0) {
|
||||
b_null_lower_walls = true;
|
||||
lower_walls.resize(number_of_colvars());
|
||||
for (i = 0; i < colvars.size(); i++) {
|
||||
lower_walls[i].type(colvars[i]->value());
|
||||
lower_walls.resize(num_variables());
|
||||
for (i = 0; i < num_variables(); i++) {
|
||||
lower_walls[i].type(variables(i)->value());
|
||||
lower_walls[i].reset();
|
||||
}
|
||||
}
|
||||
@ -872,9 +875,9 @@ int colvarbias_restraint_harmonic_walls::init(std::string const &conf)
|
||||
bool b_null_upper_walls = false;
|
||||
if (upper_walls.size() == 0) {
|
||||
b_null_upper_walls = true;
|
||||
upper_walls.resize(number_of_colvars());
|
||||
for (i = 0; i < colvars.size(); i++) {
|
||||
upper_walls[i].type(colvars[i]->value());
|
||||
upper_walls.resize(num_variables());
|
||||
for (i = 0; i < num_variables(); i++) {
|
||||
upper_walls[i].type(variables(i)->value());
|
||||
upper_walls[i].reset();
|
||||
}
|
||||
}
|
||||
@ -890,17 +893,17 @@ int colvarbias_restraint_harmonic_walls::init(std::string const &conf)
|
||||
}
|
||||
|
||||
if ((lower_walls.size() == 0) || (upper_walls.size() == 0)) {
|
||||
for (i = 0; i < colvars.size(); i++) {
|
||||
if (colvars[i]->is_enabled(f_cv_periodic)) {
|
||||
for (i = 0; i < num_variables(); i++) {
|
||||
if (variables(i)->is_enabled(f_cv_periodic)) {
|
||||
cvm::error("Error: at least one variable is periodic, "
|
||||
"both walls must be provided .\n", INPUT_ERROR);
|
||||
"both walls must be provided.\n", INPUT_ERROR);
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ((lower_walls.size() > 0) && (upper_walls.size() > 0)) {
|
||||
for (i = 0; i < colvars.size(); i++) {
|
||||
for (i = 0; i < num_variables(); i++) {
|
||||
if (lower_walls[i] >= upper_walls[i]) {
|
||||
cvm::error("Error: one upper wall, "+
|
||||
cvm::to_str(upper_walls[i])+
|
||||
@ -909,13 +912,24 @@ int colvarbias_restraint_harmonic_walls::init(std::string const &conf)
|
||||
INPUT_ERROR);
|
||||
}
|
||||
}
|
||||
if (lower_wall_k * upper_wall_k == 0.0) {
|
||||
cvm::error("Error: lowerWallConstant and upperWallConstant, "
|
||||
"when defined, must both be positive.\n",
|
||||
INPUT_ERROR);
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
force_k = lower_wall_k * upper_wall_k;
|
||||
// transform the two constants to relative values
|
||||
// (allow changing both via force_k)
|
||||
lower_wall_k /= force_k;
|
||||
upper_wall_k /= force_k;
|
||||
}
|
||||
|
||||
for (i = 0; i < colvars.size(); i++) {
|
||||
if (colvars[i]->width != 1.0)
|
||||
cvm::log("The force constant for colvar \""+colvars[i]->name+
|
||||
for (i = 0; i < num_variables(); i++) {
|
||||
if (variables(i)->width != 1.0)
|
||||
cvm::log("The force constant for colvar \""+variables(i)->name+
|
||||
"\" will be rescaled to "+
|
||||
cvm::to_str(force_k / (colvars[i]->width * colvars[i]->width))+
|
||||
cvm::to_str(force_k / (variables(i)->width * variables(i)->width))+
|
||||
" according to the specified width.\n");
|
||||
}
|
||||
|
||||
@ -935,20 +949,20 @@ int colvarbias_restraint_harmonic_walls::update()
|
||||
|
||||
void colvarbias_restraint_harmonic_walls::communicate_forces()
|
||||
{
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
if (cvm::debug()) {
|
||||
cvm::log("Communicating a force to colvar \""+
|
||||
colvars[i]->name+"\".\n");
|
||||
variables(i)->name+"\".\n");
|
||||
}
|
||||
colvars[i]->add_bias_force_actual_value(colvar_forces[i]);
|
||||
variables(i)->add_bias_force_actual_value(colvar_forces[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
cvm::real colvarbias_restraint_harmonic_walls::colvar_distance(size_t i) const
|
||||
{
|
||||
colvar *cv = colvars[i];
|
||||
colvarvalue const &cvv = colvars[i]->actual_value();
|
||||
colvar *cv = variables(i);
|
||||
colvarvalue const &cvv = variables(i)->actual_value();
|
||||
|
||||
// For a periodic colvar, both walls may be applicable at the same time
|
||||
// in which case we pick the closer one
|
||||
@ -958,21 +972,21 @@ cvm::real colvarbias_restraint_harmonic_walls::colvar_distance(size_t i) const
|
||||
cvm::real const upper_wall_dist2 = cv->dist2(cvv, upper_walls[i]);
|
||||
if (lower_wall_dist2 < upper_wall_dist2) {
|
||||
cvm::real const grad = cv->dist2_lgrad(cvv, lower_walls[i]);
|
||||
if (grad < 0.0) { return grad; }
|
||||
if (grad < 0.0) { return 0.5 * grad; }
|
||||
} else {
|
||||
cvm::real const grad = cv->dist2_lgrad(cvv, upper_walls[i]);
|
||||
if (grad > 0.0) { return grad; }
|
||||
if (grad > 0.0) { return 0.5 * grad; }
|
||||
}
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
if (lower_walls.size() > 0) {
|
||||
cvm::real const grad = cv->dist2_lgrad(cvv, lower_walls[i]);
|
||||
if (grad < 0.0) { return grad; }
|
||||
if (grad < 0.0) { return 0.5 * grad; }
|
||||
}
|
||||
if (upper_walls.size() > 0) {
|
||||
cvm::real const grad = cv->dist2_lgrad(cvv, upper_walls[i]);
|
||||
if (grad > 0.0) { return grad; }
|
||||
if (grad > 0.0) { return 0.5 * grad; }
|
||||
}
|
||||
return 0.0;
|
||||
}
|
||||
@ -981,7 +995,8 @@ cvm::real colvarbias_restraint_harmonic_walls::colvar_distance(size_t i) const
|
||||
cvm::real colvarbias_restraint_harmonic_walls::restraint_potential(size_t i) const
|
||||
{
|
||||
cvm::real const dist = colvar_distance(i);
|
||||
return 0.5 * force_k / (colvars[i]->width * colvars[i]->width) *
|
||||
cvm::real const scale = dist > 0.0 ? upper_wall_k : lower_wall_k;
|
||||
return 0.5 * force_k * scale / (variables(i)->width * variables(i)->width) *
|
||||
dist * dist;
|
||||
}
|
||||
|
||||
@ -989,15 +1004,16 @@ cvm::real colvarbias_restraint_harmonic_walls::restraint_potential(size_t i) con
|
||||
colvarvalue const colvarbias_restraint_harmonic_walls::restraint_force(size_t i) const
|
||||
{
|
||||
cvm::real const dist = colvar_distance(i);
|
||||
return -0.5 * force_k / (colvars[i]->width * colvars[i]->width) *
|
||||
dist;
|
||||
cvm::real const scale = dist > 0.0 ? upper_wall_k : lower_wall_k;
|
||||
return - force_k * scale / (variables(i)->width * variables(i)->width) * dist;
|
||||
}
|
||||
|
||||
|
||||
cvm::real colvarbias_restraint_harmonic_walls::d_restraint_potential_dk(size_t i) const
|
||||
{
|
||||
cvm::real const dist = colvar_distance(i);
|
||||
return 0.5 / (colvars[i]->width * colvars[i]->width) *
|
||||
cvm::real const scale = dist > 0.0 ? upper_wall_k : lower_wall_k;
|
||||
return 0.5 * scale / (variables(i)->width * variables(i)->width) *
|
||||
dist * dist;
|
||||
}
|
||||
|
||||
@ -1054,16 +1070,16 @@ int colvarbias_restraint_linear::init(std::string const &conf)
|
||||
colvarbias_restraint_centers_moving::init(conf);
|
||||
colvarbias_restraint_k_moving::init(conf);
|
||||
|
||||
for (size_t i = 0; i < colvars.size(); i++) {
|
||||
if (colvars[i]->is_enabled(f_cv_periodic)) {
|
||||
for (size_t i = 0; i < num_variables(); i++) {
|
||||
if (variables(i)->is_enabled(f_cv_periodic)) {
|
||||
cvm::error("Error: linear biases cannot be applied to periodic variables.\n",
|
||||
INPUT_ERROR);
|
||||
return INPUT_ERROR;
|
||||
}
|
||||
if (colvars[i]->width != 1.0)
|
||||
cvm::log("The force constant for colvar \""+colvars[i]->name+
|
||||
if (variables(i)->width != 1.0)
|
||||
cvm::log("The force constant for colvar \""+variables(i)->name+
|
||||
"\" will be rescaled to "+
|
||||
cvm::to_str(force_k / colvars[i]->width)+
|
||||
cvm::to_str(force_k / variables(i)->width)+
|
||||
" according to the specified width.\n");
|
||||
}
|
||||
|
||||
@ -1113,19 +1129,19 @@ cvm::real colvarbias_restraint_linear::energy_difference(std::string const &conf
|
||||
|
||||
cvm::real colvarbias_restraint_linear::restraint_potential(size_t i) const
|
||||
{
|
||||
return force_k / colvars[i]->width * (colvars[i]->value() - colvar_centers[i]);
|
||||
return force_k / variables(i)->width * (variables(i)->value() - colvar_centers[i]);
|
||||
}
|
||||
|
||||
|
||||
colvarvalue const colvarbias_restraint_linear::restraint_force(size_t i) const
|
||||
{
|
||||
return -1.0 * force_k / colvars[i]->width;
|
||||
return -1.0 * force_k / variables(i)->width;
|
||||
}
|
||||
|
||||
|
||||
cvm::real colvarbias_restraint_linear::d_restraint_potential_dk(size_t i) const
|
||||
{
|
||||
return 1.0 / colvars[i]->width * (colvars[i]->value() - colvar_centers[i]);
|
||||
return 1.0 / variables(i)->width * (variables(i)->value() - colvar_centers[i]);
|
||||
}
|
||||
|
||||
|
||||
@ -1279,16 +1295,16 @@ int colvarbias_restraint_histogram::update()
|
||||
|
||||
size_t vector_size = 0;
|
||||
size_t icv;
|
||||
for (icv = 0; icv < colvars.size(); icv++) {
|
||||
vector_size += colvars[icv]->value().size();
|
||||
for (icv = 0; icv < num_variables(); icv++) {
|
||||
vector_size += variables(icv)->value().size();
|
||||
}
|
||||
|
||||
cvm::real const norm = 1.0/(std::sqrt(2.0*PI)*gaussian_width*vector_size);
|
||||
|
||||
// calculate the histogram
|
||||
p.reset();
|
||||
for (icv = 0; icv < colvars.size(); icv++) {
|
||||
colvarvalue const &cv = colvars[icv]->value();
|
||||
for (icv = 0; icv < num_variables(); icv++) {
|
||||
colvarvalue const &cv = variables(icv)->value();
|
||||
if (cv.type() == colvarvalue::type_scalar) {
|
||||
cvm::real const cv_value = cv.real_value;
|
||||
size_t igrid;
|
||||
@ -1309,7 +1325,9 @@ int colvarbias_restraint_histogram::update()
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// TODO
|
||||
cvm::error("Error: unsupported type for variable "+variables(icv)->name+".\n",
|
||||
COLVARS_NOT_IMPLEMENTED);
|
||||
return COLVARS_NOT_IMPLEMENTED;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1320,8 +1338,8 @@ int colvarbias_restraint_histogram::update()
|
||||
bias_energy = 0.5 * force_k_cv * p_diff * p_diff;
|
||||
|
||||
// calculate the forces
|
||||
for (icv = 0; icv < colvars.size(); icv++) {
|
||||
colvarvalue const &cv = colvars[icv]->value();
|
||||
for (icv = 0; icv < num_variables(); icv++) {
|
||||
colvarvalue const &cv = variables(icv)->value();
|
||||
colvarvalue &cv_force = colvar_forces[icv];
|
||||
cv_force.type(cv);
|
||||
cv_force.reset();
|
||||
@ -1363,10 +1381,10 @@ int colvarbias_restraint_histogram::update()
|
||||
std::ostream & colvarbias_restraint_histogram::write_restart(std::ostream &os)
|
||||
{
|
||||
if (b_write_histogram) {
|
||||
std::string file_name(cvm::output_prefix+"."+this->name+".hist.dat");
|
||||
std::string file_name(cvm::output_prefix()+"."+this->name+".hist.dat");
|
||||
std::ofstream os(file_name.c_str());
|
||||
os << "# " << cvm::wrap_string(colvars[0]->name, cvm::cv_width)
|
||||
<< " " << "p(" << cvm::wrap_string(colvars[0]->name, cvm::cv_width-3)
|
||||
os << "# " << cvm::wrap_string(variables(0)->name, cvm::cv_width)
|
||||
<< " " << "p(" << cvm::wrap_string(variables(0)->name, cvm::cv_width-3)
|
||||
<< ")\n";
|
||||
size_t igrid;
|
||||
for (igrid = 0; igrid < p.size(); igrid++) {
|
||||
|
||||
@ -260,6 +260,12 @@ protected:
|
||||
/// \brief Location of the upper walls
|
||||
std::vector<colvarvalue> upper_walls;
|
||||
|
||||
/// \brief If both walls are defined, use this k for the lower
|
||||
cvm::real lower_wall_k;
|
||||
|
||||
/// \brief If both walls are defined, use this k for the upper
|
||||
cvm::real upper_wall_k;
|
||||
|
||||
virtual cvm::real colvar_distance(size_t i) const;
|
||||
virtual cvm::real restraint_potential(size_t i) const;
|
||||
virtual colvarvalue const restraint_force(size_t i) const;
|
||||
|
||||
@ -48,8 +48,6 @@ colvar::cvc::cvc(std::string const &conf)
|
||||
get_keyval(conf, "period", period, 0.0);
|
||||
get_keyval(conf, "wrapAround", wrap_center, 0.0);
|
||||
|
||||
// All cvcs implement this
|
||||
provide(f_cvc_debug_gradient);
|
||||
get_keyval_feature((colvarparse *)this, conf, "debugGradients",
|
||||
f_cvc_debug_gradient, false, parse_silent);
|
||||
|
||||
@ -63,6 +61,8 @@ colvar::cvc::cvc(std::string const &conf)
|
||||
|
||||
int colvar::cvc::init_total_force_params(std::string const &conf)
|
||||
{
|
||||
if (cvm::get_error()) return COLVARS_ERROR;
|
||||
|
||||
if (get_keyval_feature(this, conf, "oneSiteSystemForce",
|
||||
f_cvc_one_site_total_force, is_enabled(f_cvc_one_site_total_force))) {
|
||||
cvm::log("Warning: keyword \"oneSiteSystemForce\" is deprecated: "
|
||||
@ -72,6 +72,19 @@ int colvar::cvc::init_total_force_params(std::string const &conf)
|
||||
f_cvc_one_site_total_force, is_enabled(f_cvc_one_site_total_force))) {
|
||||
cvm::log("Computing total force on group 1 only");
|
||||
}
|
||||
|
||||
if (! is_enabled(f_cvc_one_site_total_force)) {
|
||||
// check whether any of the other atom groups is dummy
|
||||
std::vector<cvm::atom_group *>::iterator agi = atom_groups.begin();
|
||||
agi++;
|
||||
for ( ; agi != atom_groups.end(); agi++) {
|
||||
if ((*agi)->b_dummy) {
|
||||
provide(f_cvc_inv_gradient, false);
|
||||
provide(f_cvc_Jacobian, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
@ -87,8 +100,7 @@ cvm::atom_group *colvar::cvc::parse_group(std::string const &conf,
|
||||
group->key = group_key;
|
||||
|
||||
if (b_try_scalable) {
|
||||
// TODO rewrite this logic in terms of dependencies
|
||||
if (is_available(f_cvc_scalable_com) && is_available(f_cvc_com_based)) {
|
||||
if (is_available(f_cvc_scalable_com) && is_enabled(f_cvc_com_based)) {
|
||||
enable(f_cvc_scalable_com);
|
||||
enable(f_cvc_scalable);
|
||||
// The CVC makes the feature available;
|
||||
|
||||
@ -343,6 +343,15 @@ public:
|
||||
virtual void calc_value();
|
||||
virtual void calc_gradients();
|
||||
virtual void apply_force(colvarvalue const &force);
|
||||
/// Redefined to override the distance ones
|
||||
virtual cvm::real dist2(colvarvalue const &x1,
|
||||
colvarvalue const &x2) const;
|
||||
/// Redefined to override the distance ones
|
||||
virtual colvarvalue dist2_lgrad(colvarvalue const &x1,
|
||||
colvarvalue const &x2) const;
|
||||
/// Redefined to override the distance ones
|
||||
virtual colvarvalue dist2_rgrad(colvarvalue const &x1,
|
||||
colvarvalue const &x2) const;
|
||||
};
|
||||
|
||||
|
||||
|
||||
@ -21,7 +21,7 @@ colvar::angle::angle(std::string const &conf)
|
||||
function_type = "angle";
|
||||
provide(f_cvc_inv_gradient);
|
||||
provide(f_cvc_Jacobian);
|
||||
provide(f_cvc_com_based);
|
||||
enable(f_cvc_com_based);
|
||||
|
||||
group1 = parse_group(conf, "group1");
|
||||
group2 = parse_group(conf, "group2");
|
||||
@ -40,7 +40,7 @@ colvar::angle::angle(cvm::atom const &a1,
|
||||
function_type = "angle";
|
||||
provide(f_cvc_inv_gradient);
|
||||
provide(f_cvc_Jacobian);
|
||||
provide(f_cvc_com_based);
|
||||
enable(f_cvc_com_based);
|
||||
|
||||
group1 = new cvm::atom_group(std::vector<cvm::atom>(1, a1));
|
||||
group2 = new cvm::atom_group(std::vector<cvm::atom>(1, a2));
|
||||
@ -259,7 +259,7 @@ colvar::dihedral::dihedral(std::string const &conf)
|
||||
b_periodic = true;
|
||||
provide(f_cvc_inv_gradient);
|
||||
provide(f_cvc_Jacobian);
|
||||
provide(f_cvc_com_based);
|
||||
enable(f_cvc_com_based);
|
||||
|
||||
group1 = parse_group(conf, "group1");
|
||||
group2 = parse_group(conf, "group2");
|
||||
@ -285,7 +285,7 @@ colvar::dihedral::dihedral(cvm::atom const &a1,
|
||||
b_periodic = true;
|
||||
provide(f_cvc_inv_gradient);
|
||||
provide(f_cvc_Jacobian);
|
||||
provide(f_cvc_com_based);
|
||||
enable(f_cvc_com_based);
|
||||
|
||||
b_1site_force = false;
|
||||
|
||||
|
||||
@ -23,7 +23,7 @@ colvar::distance::distance(std::string const &conf)
|
||||
function_type = "distance";
|
||||
provide(f_cvc_inv_gradient);
|
||||
provide(f_cvc_Jacobian);
|
||||
provide(f_cvc_com_based);
|
||||
enable(f_cvc_com_based);
|
||||
|
||||
group1 = parse_group(conf, "group1");
|
||||
group2 = parse_group(conf, "group2");
|
||||
@ -44,7 +44,7 @@ colvar::distance::distance()
|
||||
function_type = "distance";
|
||||
provide(f_cvc_inv_gradient);
|
||||
provide(f_cvc_Jacobian);
|
||||
provide(f_cvc_com_based);
|
||||
enable(f_cvc_com_based);
|
||||
b_no_PBC = false;
|
||||
x.type(colvarvalue::type_scalar);
|
||||
}
|
||||
@ -106,7 +106,7 @@ colvar::distance_vec::distance_vec(std::string const &conf)
|
||||
: distance(conf)
|
||||
{
|
||||
function_type = "distance_vec";
|
||||
provide(f_cvc_com_based);
|
||||
enable(f_cvc_com_based);
|
||||
x.type(colvarvalue::type_3vector);
|
||||
}
|
||||
|
||||
@ -115,7 +115,7 @@ colvar::distance_vec::distance_vec()
|
||||
: distance()
|
||||
{
|
||||
function_type = "distance_vec";
|
||||
provide(f_cvc_com_based);
|
||||
enable(f_cvc_com_based);
|
||||
x.type(colvarvalue::type_3vector);
|
||||
}
|
||||
|
||||
@ -176,7 +176,7 @@ colvar::distance_z::distance_z(std::string const &conf)
|
||||
function_type = "distance_z";
|
||||
provide(f_cvc_inv_gradient);
|
||||
provide(f_cvc_Jacobian);
|
||||
provide(f_cvc_com_based);
|
||||
enable(f_cvc_com_based);
|
||||
x.type(colvarvalue::type_scalar);
|
||||
|
||||
// TODO detect PBC from MD engine (in simple cases)
|
||||
@ -228,7 +228,7 @@ colvar::distance_z::distance_z()
|
||||
function_type = "distance_z";
|
||||
provide(f_cvc_inv_gradient);
|
||||
provide(f_cvc_Jacobian);
|
||||
provide(f_cvc_com_based);
|
||||
enable(f_cvc_com_based);
|
||||
x.type(colvarvalue::type_scalar);
|
||||
}
|
||||
|
||||
@ -372,7 +372,7 @@ colvar::distance_xy::distance_xy(std::string const &conf)
|
||||
function_type = "distance_xy";
|
||||
provide(f_cvc_inv_gradient);
|
||||
provide(f_cvc_Jacobian);
|
||||
provide(f_cvc_com_based);
|
||||
enable(f_cvc_com_based);
|
||||
x.type(colvarvalue::type_scalar);
|
||||
}
|
||||
|
||||
@ -383,7 +383,7 @@ colvar::distance_xy::distance_xy()
|
||||
function_type = "distance_xy";
|
||||
provide(f_cvc_inv_gradient);
|
||||
provide(f_cvc_Jacobian);
|
||||
provide(f_cvc_com_based);
|
||||
enable(f_cvc_com_based);
|
||||
x.type(colvarvalue::type_scalar);
|
||||
}
|
||||
|
||||
@ -479,7 +479,7 @@ colvar::distance_dir::distance_dir(std::string const &conf)
|
||||
: distance(conf)
|
||||
{
|
||||
function_type = "distance_dir";
|
||||
provide(f_cvc_com_based);
|
||||
enable(f_cvc_com_based);
|
||||
x.type(colvarvalue::type_unit3vector);
|
||||
}
|
||||
|
||||
@ -488,7 +488,7 @@ colvar::distance_dir::distance_dir()
|
||||
: distance()
|
||||
{
|
||||
function_type = "distance_dir";
|
||||
provide(f_cvc_com_based);
|
||||
enable(f_cvc_com_based);
|
||||
x.type(colvarvalue::type_unit3vector);
|
||||
}
|
||||
|
||||
@ -529,6 +529,27 @@ void colvar::distance_dir::apply_force(colvarvalue const &force)
|
||||
}
|
||||
|
||||
|
||||
cvm::real colvar::distance_dir::dist2(colvarvalue const &x1,
|
||||
colvarvalue const &x2) const
|
||||
{
|
||||
return (x1.rvector_value - x2.rvector_value).norm2();
|
||||
}
|
||||
|
||||
|
||||
colvarvalue colvar::distance_dir::dist2_lgrad(colvarvalue const &x1,
|
||||
colvarvalue const &x2) const
|
||||
{
|
||||
return colvarvalue((x1.rvector_value - x2.rvector_value), colvarvalue::type_unit3vector);
|
||||
}
|
||||
|
||||
|
||||
colvarvalue colvar::distance_dir::dist2_rgrad(colvarvalue const &x1,
|
||||
colvarvalue const &x2) const
|
||||
{
|
||||
return colvarvalue((x2.rvector_value - x1.rvector_value), colvarvalue::type_unit3vector);
|
||||
}
|
||||
|
||||
|
||||
|
||||
colvar::distance_inv::distance_inv(std::string const &conf)
|
||||
: distance(conf)
|
||||
|
||||
@ -14,9 +14,6 @@
|
||||
colvardeps::~colvardeps() {
|
||||
size_t i;
|
||||
|
||||
for (i=0; i<feature_states.size(); i++) {
|
||||
if (feature_states[i] != NULL) delete feature_states[i];
|
||||
}
|
||||
// Do not delete features if it's static
|
||||
// for (i=0; i<features.size(); i++) {
|
||||
// if (features[i] != NULL) delete features[i];
|
||||
@ -34,16 +31,34 @@ colvardeps::~colvardeps() {
|
||||
}
|
||||
|
||||
|
||||
void colvardeps::provide(int feature_id) {
|
||||
feature_states[feature_id]->available = true;
|
||||
void colvardeps::provide(int feature_id, bool truefalse) {
|
||||
feature_states[feature_id].available = truefalse;
|
||||
}
|
||||
|
||||
|
||||
void colvardeps::set_enabled(int feature_id, bool truefalse) {
|
||||
// if (!is_static(feature_id)) {
|
||||
// cvm::error("Cannot set feature " + features()[feature_id]->description + " statically in " + description + ".\n");
|
||||
// return;
|
||||
// }
|
||||
if (truefalse) {
|
||||
// Resolve dependencies too
|
||||
enable(feature_id);
|
||||
} else {
|
||||
feature_states[feature_id].enabled = false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
bool colvardeps::get_keyval_feature(colvarparse *cvp,
|
||||
std::string const &conf, char const *key,
|
||||
int feature_id, bool const &def_value,
|
||||
colvarparse::Parse_Mode const parse_mode)
|
||||
std::string const &conf, char const *key,
|
||||
int feature_id, bool const &def_value,
|
||||
colvarparse::Parse_Mode const parse_mode)
|
||||
{
|
||||
if (!is_user(feature_id)) {
|
||||
cvm::error("Cannot set feature " + features()[feature_id]->description + " from user input in " + description + ".\n");
|
||||
return false;
|
||||
}
|
||||
bool value;
|
||||
bool const found = cvp->get_keyval(conf, key, value, def_value, parse_mode);
|
||||
if (value) enable(feature_id);
|
||||
@ -52,19 +67,19 @@ bool colvardeps::get_keyval_feature(colvarparse *cvp,
|
||||
|
||||
|
||||
int colvardeps::enable(int feature_id,
|
||||
bool dry_run /* default: false */,
|
||||
// dry_run: fail silently, do not enable if available
|
||||
// flag is passed recursively to deps of this feature
|
||||
bool toplevel /* default: true */)
|
||||
// toplevel: false if this is called as part of a chain of dependency resolution
|
||||
// this is used to diagnose failed dependencies by displaying the full stack
|
||||
// only the toplevel dependency will throw a fatal error
|
||||
bool dry_run /* default: false */,
|
||||
// dry_run: fail silently, do not enable if available
|
||||
// flag is passed recursively to deps of this feature
|
||||
bool toplevel /* default: true */)
|
||||
// toplevel: false if this is called as part of a chain of dependency resolution
|
||||
// this is used to diagnose failed dependencies by displaying the full stack
|
||||
// only the toplevel dependency will throw a fatal error
|
||||
{
|
||||
int res;
|
||||
size_t i, j;
|
||||
bool ok;
|
||||
feature *f = features()[feature_id];
|
||||
feature_state *fs = feature_states[feature_id];
|
||||
feature_state *fs = &feature_states[feature_id];
|
||||
|
||||
if (cvm::debug()) {
|
||||
cvm::log("DEPS: " + description +
|
||||
@ -88,6 +103,14 @@ int colvardeps::enable(int feature_id,
|
||||
return COLVARS_ERROR;
|
||||
}
|
||||
|
||||
if (!toplevel && !is_dynamic(feature_id)) {
|
||||
if (!dry_run) {
|
||||
cvm::log("Non-dynamic feature : \"" + f->description
|
||||
+ "\" in " + description + " may not be enabled as a dependency.\n");
|
||||
}
|
||||
return COLVARS_ERROR;
|
||||
}
|
||||
|
||||
// 1) enforce exclusions
|
||||
for (i=0; i<f->requires_exclude.size(); i++) {
|
||||
feature *g = features()[f->requires_exclude[i]];
|
||||
@ -168,9 +191,9 @@ int colvardeps::enable(int feature_id,
|
||||
if (res != COLVARS_OK) {
|
||||
if (!dry_run) {
|
||||
cvm::log("...required by \"" + f->description + "\" in " + description);
|
||||
}
|
||||
if (toplevel) {
|
||||
cvm::error("Error: Failed dependency in " + description + ".");
|
||||
if (toplevel) {
|
||||
cvm::error("Error: Failed dependency in " + description + ".");
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
@ -194,9 +217,12 @@ int colvardeps::enable(int feature_id,
|
||||
// // we need refs to parents to walk up the deps tree!
|
||||
// // or refresh
|
||||
// }
|
||||
void colvardeps::init_feature(int feature_id, const char *description, feature_type type) {
|
||||
features()[feature_id]->description = description;
|
||||
features()[feature_id]->type = type;
|
||||
}
|
||||
|
||||
// Shorthand macros for describing dependencies
|
||||
#define f_description(f, d) features()[f]->description = d
|
||||
// Shorthand macros for describing dependencies
|
||||
#define f_req_self(f, g) features()[f]->requires_self.push_back(g)
|
||||
// This macro ensures that exclusions are symmetric
|
||||
#define f_req_exclude(f, g) features()[f]->requires_exclude.push_back(g); \
|
||||
@ -216,35 +242,31 @@ void colvardeps::init_cvb_requires() {
|
||||
for (i = 0; i < f_cvb_ntot; i++) {
|
||||
features().push_back(new feature);
|
||||
}
|
||||
|
||||
init_feature(f_cvb_active, "active", f_type_dynamic);
|
||||
f_req_children(f_cvb_active, f_cv_active);
|
||||
|
||||
init_feature(f_cvb_apply_force, "apply force", f_type_user);
|
||||
f_req_children(f_cvb_apply_force, f_cv_gradient);
|
||||
|
||||
init_feature(f_cvb_get_total_force, "obtain total force");
|
||||
f_req_children(f_cvb_get_total_force, f_cv_total_force);
|
||||
|
||||
init_feature(f_cvb_history_dependent, "history-dependent", f_type_static);
|
||||
|
||||
init_feature(f_cvb_scalar_variables, "require scalar variables", f_type_static);
|
||||
f_req_children(f_cvb_scalar_variables, f_cv_scalar);
|
||||
|
||||
init_feature(f_cvb_calc_pmf, "calculate a PMF", f_type_static);
|
||||
}
|
||||
|
||||
f_description(f_cvb_active, "active");
|
||||
f_req_children(f_cvb_active, f_cv_active);
|
||||
|
||||
f_description(f_cvb_apply_force, "apply force");
|
||||
f_req_children(f_cvb_apply_force, f_cv_gradient);
|
||||
|
||||
f_description(f_cvb_get_total_force, "obtain total force");
|
||||
f_req_children(f_cvb_get_total_force, f_cv_total_force);
|
||||
|
||||
f_description(f_cvb_history_dependent, "history-dependent");
|
||||
|
||||
f_description(f_cvb_scalar_variables, "require scalar variables");
|
||||
f_req_children(f_cvb_scalar_variables, f_cv_scalar);
|
||||
|
||||
// Initialize feature_states for each instance
|
||||
feature_states.reserve(f_cvb_ntot);
|
||||
for (i = 0; i < f_cvb_ntot; i++) {
|
||||
feature_states.push_back(new feature_state(true, false));
|
||||
feature_states.push_back(feature_state(true, false));
|
||||
// Most features are available, so we set them so
|
||||
// and list exceptions below
|
||||
}
|
||||
|
||||
// some biases are not history-dependent
|
||||
feature_states[f_cvb_history_dependent]->available = false;
|
||||
|
||||
// by default, biases should work with vector variables, too
|
||||
feature_states[f_cvb_scalar_variables]->available = false;
|
||||
}
|
||||
|
||||
|
||||
@ -255,117 +277,111 @@ void colvardeps::init_cv_requires() {
|
||||
features().push_back(new feature);
|
||||
}
|
||||
|
||||
f_description(f_cv_active, "active");
|
||||
init_feature(f_cv_active, "active", f_type_dynamic);
|
||||
f_req_children(f_cv_active, f_cvc_active);
|
||||
// Colvars must be either a linear combination, or scalar (and polynomial) or scripted
|
||||
f_req_alt3(f_cv_active, f_cv_scalar, f_cv_linear, f_cv_scripted);
|
||||
|
||||
f_description(f_cv_gradient, "gradient");
|
||||
init_feature(f_cv_gradient, "gradient", f_type_dynamic);
|
||||
f_req_children(f_cv_gradient, f_cvc_gradient);
|
||||
|
||||
f_description(f_cv_collect_gradient, "collect gradient");
|
||||
init_feature(f_cv_collect_gradient, "collect gradient", f_type_dynamic);
|
||||
f_req_self(f_cv_collect_gradient, f_cv_gradient);
|
||||
f_req_self(f_cv_collect_gradient, f_cv_scalar);
|
||||
|
||||
f_description(f_cv_fdiff_velocity, "fdiff_velocity");
|
||||
init_feature(f_cv_fdiff_velocity, "fdiff_velocity", f_type_dynamic);
|
||||
|
||||
// System force: either trivial (spring force); through extended Lagrangian, or calculated explicitly
|
||||
f_description(f_cv_total_force, "total force");
|
||||
init_feature(f_cv_total_force, "total force", f_type_dynamic);
|
||||
f_req_alt2(f_cv_total_force, f_cv_extended_Lagrangian, f_cv_total_force_calc);
|
||||
|
||||
// Deps for explicit total force calculation
|
||||
f_description(f_cv_total_force_calc, "total force calculation");
|
||||
init_feature(f_cv_total_force_calc, "total force calculation", f_type_dynamic);
|
||||
f_req_self(f_cv_total_force_calc, f_cv_scalar);
|
||||
f_req_self(f_cv_total_force_calc, f_cv_linear);
|
||||
f_req_children(f_cv_total_force_calc, f_cvc_inv_gradient);
|
||||
f_req_self(f_cv_total_force_calc, f_cv_Jacobian);
|
||||
|
||||
f_description(f_cv_Jacobian, "Jacobian derivative");
|
||||
init_feature(f_cv_Jacobian, "Jacobian derivative", f_type_dynamic);
|
||||
f_req_self(f_cv_Jacobian, f_cv_scalar);
|
||||
f_req_self(f_cv_Jacobian, f_cv_linear);
|
||||
f_req_children(f_cv_Jacobian, f_cvc_Jacobian);
|
||||
|
||||
f_description(f_cv_hide_Jacobian, "hide Jacobian force");
|
||||
init_feature(f_cv_hide_Jacobian, "hide Jacobian force", f_type_user);
|
||||
f_req_self(f_cv_hide_Jacobian, f_cv_Jacobian); // can only hide if calculated
|
||||
|
||||
f_description(f_cv_extended_Lagrangian, "extended Lagrangian");
|
||||
init_feature(f_cv_extended_Lagrangian, "extended Lagrangian", f_type_user);
|
||||
f_req_self(f_cv_extended_Lagrangian, f_cv_scalar);
|
||||
f_req_self(f_cv_extended_Lagrangian, f_cv_gradient);
|
||||
|
||||
f_description(f_cv_Langevin, "Langevin dynamics");
|
||||
init_feature(f_cv_Langevin, "Langevin dynamics", f_type_user);
|
||||
f_req_self(f_cv_Langevin, f_cv_extended_Lagrangian);
|
||||
|
||||
f_description(f_cv_linear, "linear");
|
||||
init_feature(f_cv_linear, "linear", f_type_static);
|
||||
|
||||
f_description(f_cv_scalar, "scalar");
|
||||
init_feature(f_cv_scalar, "scalar", f_type_static);
|
||||
|
||||
f_description(f_cv_output_energy, "output energy");
|
||||
init_feature(f_cv_output_energy, "output energy", f_type_user);
|
||||
|
||||
f_description(f_cv_output_value, "output value");
|
||||
init_feature(f_cv_output_value, "output value", f_type_user);
|
||||
|
||||
f_description(f_cv_output_velocity, "output velocity");
|
||||
init_feature(f_cv_output_velocity, "output velocity", f_type_user);
|
||||
f_req_self(f_cv_output_velocity, f_cv_fdiff_velocity);
|
||||
|
||||
f_description(f_cv_output_applied_force, "output applied force");
|
||||
init_feature(f_cv_output_applied_force, "output applied force", f_type_user);
|
||||
|
||||
f_description(f_cv_output_total_force, "output total force");
|
||||
init_feature(f_cv_output_total_force, "output total force", f_type_user);
|
||||
f_req_self(f_cv_output_total_force, f_cv_total_force);
|
||||
|
||||
f_description(f_cv_subtract_applied_force, "subtract applied force from total force");
|
||||
init_feature(f_cv_subtract_applied_force, "subtract applied force from total force", f_type_user);
|
||||
f_req_self(f_cv_subtract_applied_force, f_cv_total_force);
|
||||
|
||||
f_description(f_cv_lower_boundary, "lower boundary");
|
||||
init_feature(f_cv_lower_boundary, "lower boundary", f_type_user);
|
||||
f_req_self(f_cv_lower_boundary, f_cv_scalar);
|
||||
|
||||
f_description(f_cv_upper_boundary, "upper boundary");
|
||||
init_feature(f_cv_upper_boundary, "upper boundary", f_type_user);
|
||||
f_req_self(f_cv_upper_boundary, f_cv_scalar);
|
||||
|
||||
f_description(f_cv_grid, "grid");
|
||||
init_feature(f_cv_grid, "grid", f_type_user);
|
||||
f_req_self(f_cv_grid, f_cv_lower_boundary);
|
||||
f_req_self(f_cv_grid, f_cv_upper_boundary);
|
||||
|
||||
f_description(f_cv_lower_wall, "lower wall");
|
||||
f_req_self(f_cv_lower_wall, f_cv_lower_boundary);
|
||||
f_req_self(f_cv_lower_wall, f_cv_gradient);
|
||||
init_feature(f_cv_runave, "running average", f_type_user);
|
||||
|
||||
f_description(f_cv_upper_wall, "upper wall");
|
||||
f_req_self(f_cv_upper_wall, f_cv_upper_boundary);
|
||||
f_req_self(f_cv_upper_wall, f_cv_gradient);
|
||||
init_feature(f_cv_corrfunc, "correlation function", f_type_user);
|
||||
|
||||
f_description(f_cv_runave, "running average");
|
||||
|
||||
f_description(f_cv_corrfunc, "correlation function");
|
||||
|
||||
// The features below are set programmatically
|
||||
f_description(f_cv_scripted, "scripted");
|
||||
f_description(f_cv_periodic, "periodic");
|
||||
init_feature(f_cv_scripted, "scripted", f_type_static);
|
||||
init_feature(f_cv_periodic, "periodic", f_type_static);
|
||||
f_req_self(f_cv_periodic, f_cv_homogeneous);
|
||||
f_description(f_cv_scalar, "scalar");
|
||||
f_description(f_cv_linear, "linear");
|
||||
f_description(f_cv_homogeneous, "homogeneous");
|
||||
init_feature(f_cv_scalar, "scalar", f_type_static);
|
||||
init_feature(f_cv_linear, "linear", f_type_static);
|
||||
init_feature(f_cv_homogeneous, "homogeneous", f_type_static);
|
||||
}
|
||||
|
||||
// Initialize feature_states for each instance
|
||||
feature_states.reserve(f_cv_ntot);
|
||||
for (i = 0; i < f_cv_ntot; i++) {
|
||||
feature_states.push_back(new feature_state(true, false));
|
||||
feature_states.push_back(feature_state(true, false));
|
||||
// Most features are available, so we set them so
|
||||
// and list exceptions below
|
||||
}
|
||||
|
||||
// properties that may NOT be enabled as a dependency
|
||||
int unavailable_deps[] = {
|
||||
f_cv_lower_boundary,
|
||||
f_cv_upper_boundary,
|
||||
f_cv_extended_Lagrangian,
|
||||
f_cv_Langevin,
|
||||
f_cv_scripted,
|
||||
f_cv_periodic,
|
||||
f_cv_scalar,
|
||||
f_cv_linear,
|
||||
f_cv_homogeneous
|
||||
};
|
||||
for (i = 0; i < sizeof(unavailable_deps) / sizeof(unavailable_deps[0]); i++) {
|
||||
feature_states[unavailable_deps[i]]->available = false;
|
||||
}
|
||||
// // properties that may NOT be enabled as a dependency
|
||||
// // This will be deprecated by feature types
|
||||
// int unavailable_deps[] = {
|
||||
// f_cv_lower_boundary,
|
||||
// f_cv_upper_boundary,
|
||||
// f_cv_extended_Lagrangian,
|
||||
// f_cv_Langevin,
|
||||
// f_cv_scripted,
|
||||
// f_cv_periodic,
|
||||
// f_cv_scalar,
|
||||
// f_cv_linear,
|
||||
// f_cv_homogeneous
|
||||
// };
|
||||
// for (i = 0; i < sizeof(unavailable_deps) / sizeof(unavailable_deps[0]); i++) {
|
||||
// feature_states[unavailable_deps[i]].available = false;
|
||||
// }
|
||||
}
|
||||
|
||||
|
||||
@ -377,34 +393,34 @@ void colvardeps::init_cvc_requires() {
|
||||
features().push_back(new feature);
|
||||
}
|
||||
|
||||
f_description(f_cvc_active, "active");
|
||||
init_feature(f_cvc_active, "active", f_type_dynamic);
|
||||
// The dependency below may become useful if we use dynamic atom groups
|
||||
// f_req_children(f_cvc_active, f_ag_active);
|
||||
|
||||
f_description(f_cvc_scalar, "scalar");
|
||||
init_feature(f_cvc_scalar, "scalar", f_type_static);
|
||||
|
||||
f_description(f_cvc_gradient, "gradient");
|
||||
init_feature(f_cvc_gradient, "gradient", f_type_dynamic);
|
||||
|
||||
f_description(f_cvc_inv_gradient, "inverse gradient");
|
||||
init_feature(f_cvc_inv_gradient, "inverse gradient", f_type_dynamic);
|
||||
f_req_self(f_cvc_inv_gradient, f_cvc_gradient);
|
||||
|
||||
f_description(f_cvc_debug_gradient, "debug gradient");
|
||||
init_feature(f_cvc_debug_gradient, "debug gradient", f_type_user);
|
||||
f_req_self(f_cvc_debug_gradient, f_cvc_gradient);
|
||||
|
||||
f_description(f_cvc_Jacobian, "Jacobian derivative");
|
||||
init_feature(f_cvc_Jacobian, "Jacobian derivative", f_type_dynamic);
|
||||
f_req_self(f_cvc_Jacobian, f_cvc_inv_gradient);
|
||||
|
||||
f_description(f_cvc_com_based, "depends on group centers of mass");
|
||||
init_feature(f_cvc_com_based, "depends on group centers of mass", f_type_static);
|
||||
|
||||
// Compute total force on first site only to avoid unwanted
|
||||
// coupling to other colvars (see e.g. Ciccotti et al., 2005)
|
||||
f_description(f_cvc_one_site_total_force, "compute total collective force only from one group center");
|
||||
init_feature(f_cvc_one_site_total_force, "compute total collective force only from one group center", f_type_user);
|
||||
f_req_self(f_cvc_one_site_total_force, f_cvc_com_based);
|
||||
|
||||
f_description(f_cvc_scalable, "scalable calculation");
|
||||
init_feature(f_cvc_scalable, "scalable calculation", f_type_static);
|
||||
f_req_self(f_cvc_scalable, f_cvc_scalable_com);
|
||||
|
||||
f_description(f_cvc_scalable_com, "scalable calculation of centers of mass");
|
||||
init_feature(f_cvc_scalable_com, "scalable calculation of centers of mass", f_type_static);
|
||||
f_req_self(f_cvc_scalable_com, f_cvc_com_based);
|
||||
|
||||
|
||||
@ -414,23 +430,25 @@ void colvardeps::init_cvc_requires() {
|
||||
}
|
||||
|
||||
// Initialize feature_states for each instance
|
||||
// default as unavailable, not enabled
|
||||
// default as available, not enabled
|
||||
// except dynamic features which default as unavailable
|
||||
feature_states.reserve(f_cvc_ntot);
|
||||
for (i = 0; i < colvardeps::f_cvc_ntot; i++) {
|
||||
feature_states.push_back(new feature_state(false, false));
|
||||
bool avail = is_dynamic(i) ? false : true;
|
||||
feature_states.push_back(feature_state(avail, false));
|
||||
}
|
||||
|
||||
// Features that are implemented by all cvcs by default
|
||||
// Each cvc specifies what other features are available
|
||||
feature_states[f_cvc_active]->available = true;
|
||||
feature_states[f_cvc_gradient]->available = true;
|
||||
feature_states[f_cvc_active].available = true;
|
||||
feature_states[f_cvc_gradient].available = true;
|
||||
|
||||
// Features that are implemented by default if their requirements are
|
||||
feature_states[f_cvc_one_site_total_force]->available = true;
|
||||
feature_states[f_cvc_one_site_total_force].available = true;
|
||||
|
||||
// Features That are implemented only for certain simulation engine configurations
|
||||
feature_states[f_cvc_scalable_com]->available = (cvm::proxy->scalable_group_coms() == COLVARS_OK);
|
||||
feature_states[f_cvc_scalable]->available = feature_states[f_cvc_scalable_com]->available;
|
||||
feature_states[f_cvc_scalable_com].available = (cvm::proxy->scalable_group_coms() == COLVARS_OK);
|
||||
feature_states[f_cvc_scalable].available = feature_states[f_cvc_scalable_com].available;
|
||||
}
|
||||
|
||||
|
||||
@ -442,21 +460,21 @@ void colvardeps::init_ag_requires() {
|
||||
features().push_back(new feature);
|
||||
}
|
||||
|
||||
f_description(f_ag_active, "active");
|
||||
f_description(f_ag_center, "translational fit");
|
||||
f_description(f_ag_rotate, "rotational fit");
|
||||
f_description(f_ag_fitting_group, "reference positions group");
|
||||
f_description(f_ag_fit_gradient_group, "fit gradient for main group");
|
||||
f_description(f_ag_fit_gradient_ref, "fit gradient for reference group");
|
||||
f_description(f_ag_atom_forces, "atomic forces");
|
||||
init_feature(f_ag_active, "active", f_type_dynamic);
|
||||
init_feature(f_ag_center, "translational fit", f_type_static);
|
||||
init_feature(f_ag_rotate, "rotational fit", f_type_static);
|
||||
init_feature(f_ag_fitting_group, "reference positions group", f_type_static);
|
||||
init_feature(f_ag_fit_gradient_group, "fit gradient for main group", f_type_static);
|
||||
init_feature(f_ag_fit_gradient_ref, "fit gradient for reference group", f_type_static);
|
||||
init_feature(f_ag_atom_forces, "atomic forces", f_type_dynamic);
|
||||
|
||||
// parallel calculation implies that we have at least a scalable center of mass,
|
||||
// but f_ag_scalable is kept as a separate feature to deal with future dependencies
|
||||
f_description(f_ag_scalable, "scalable group calculation");
|
||||
f_description(f_ag_scalable_com, "scalable group center of mass calculation");
|
||||
init_feature(f_ag_scalable, "scalable group calculation", f_type_static);
|
||||
init_feature(f_ag_scalable_com, "scalable group center of mass calculation", f_type_static);
|
||||
f_req_self(f_ag_scalable, f_ag_scalable_com);
|
||||
|
||||
// f_description(f_ag_min_msd_fit, "minimum MSD fit")
|
||||
// init_feature(f_ag_min_msd_fit, "minimum MSD fit")
|
||||
// f_req_self(f_ag_min_msd_fit, f_ag_center)
|
||||
// f_req_self(f_ag_min_msd_fit, f_ag_rotate)
|
||||
// f_req_exclude(f_ag_min_msd_fit, f_ag_fitting_group)
|
||||
@ -466,15 +484,15 @@ void colvardeps::init_ag_requires() {
|
||||
// default as unavailable, not enabled
|
||||
feature_states.reserve(f_ag_ntot);
|
||||
for (i = 0; i < colvardeps::f_ag_ntot; i++) {
|
||||
feature_states.push_back(new feature_state(false, false));
|
||||
feature_states.push_back(feature_state(false, false));
|
||||
}
|
||||
|
||||
// Features that are implemented (or not) by all atom groups
|
||||
feature_states[f_ag_active]->available = true;
|
||||
feature_states[f_ag_active].available = true;
|
||||
// f_ag_scalable_com is provided by the CVC iff it is COM-based
|
||||
feature_states[f_ag_scalable_com]->available = false;
|
||||
feature_states[f_ag_scalable_com].available = false;
|
||||
// TODO make f_ag_scalable depend on f_ag_scalable_com (or something else)
|
||||
feature_states[f_ag_scalable]->available = true;
|
||||
feature_states[f_ag_scalable].available = true;
|
||||
}
|
||||
|
||||
|
||||
@ -482,7 +500,7 @@ void colvardeps::print_state() {
|
||||
size_t i;
|
||||
cvm::log("Enabled features of " + description);
|
||||
for (i = 0; i < feature_states.size(); i++) {
|
||||
if (feature_states[i]->enabled)
|
||||
if (feature_states[i].enabled)
|
||||
cvm::log("- " + features()[i]->description);
|
||||
}
|
||||
for (i=0; i<children.size(); i++) {
|
||||
|
||||
@ -13,17 +13,16 @@
|
||||
#include "colvarmodule.h"
|
||||
#include "colvarparse.h"
|
||||
|
||||
/// Parent class for a member object of a bias, cv or cvc etc. containing dependencies
|
||||
/// (features) and handling dependency resolution
|
||||
|
||||
// Some features like colvar::f_linear have no dependencies, require() doesn't enable anything but fails if unavailable
|
||||
// Policy: those features are unavailable at all times
|
||||
// Other features are under user control
|
||||
// They are unavailable unless requested by the user, then they may be enabled subject to
|
||||
// satisfied dependencies
|
||||
|
||||
// It seems important to have available default to false (for safety) and enabled to false (for efficiency)
|
||||
|
||||
/// \brief Parent class for a member object of a bias, cv or cvc etc. containing features and
|
||||
/// their dependencies, and handling dependency resolution
|
||||
///
|
||||
/// There are 3 kinds of features:
|
||||
/// 1. Dynamic features are under the control of the dependency resolution
|
||||
/// system. They may be enabled or disabled depending on dependencies.
|
||||
/// 2. User features may be enabled based on user input (they may trigger a failure upon dependency resolution, though)
|
||||
/// 3. Static features are static properties of the object, determined
|
||||
/// programatically at initialization time.
|
||||
///
|
||||
class colvardeps {
|
||||
public:
|
||||
|
||||
@ -39,12 +38,7 @@ public:
|
||||
feature_state(bool a, bool e)
|
||||
: available(a), enabled(e) {}
|
||||
|
||||
/// Available means: supported, subject to dependencies as listed,
|
||||
/// MAY BE ENABLED AS A RESULT OF DEPENDENCY SOLVING
|
||||
/// Remains false for passive flags that are set based on other object properties,
|
||||
/// eg. f_cv_linear
|
||||
/// Is set to true upon user request for features that are implemented by the user
|
||||
/// or under his/her direct control, e.g. f_cv_scripted or f_cv_extended_Lagrangian
|
||||
/// Feature may be enabled, subject to possible dependencies
|
||||
bool available;
|
||||
/// Currently enabled - this flag is subject to change dynamically
|
||||
/// TODO consider implications for dependency solving: anyone who disables
|
||||
@ -53,8 +47,22 @@ public:
|
||||
// bool enabledOnce; // this should trigger an update when object is evaluated
|
||||
};
|
||||
|
||||
/// List of the state of all features
|
||||
std::vector<feature_state *> feature_states;
|
||||
|
||||
private:
|
||||
/// List of the states of all features
|
||||
std::vector<feature_state> feature_states;
|
||||
|
||||
/// Enum of possible feature types
|
||||
enum feature_type {
|
||||
f_type_not_set,
|
||||
f_type_dynamic,
|
||||
f_type_user,
|
||||
f_type_static
|
||||
};
|
||||
|
||||
public:
|
||||
/// Pair a numerical feature ID with a description and type
|
||||
void init_feature(int feature_id, const char *description, feature_type type = f_type_not_set);
|
||||
|
||||
/// Describes a feature and its dependecies
|
||||
/// used in a static array within each subclass
|
||||
@ -83,8 +91,18 @@ public:
|
||||
|
||||
// features that this feature requires in children
|
||||
std::vector<int> requires_children;
|
||||
|
||||
inline bool is_dynamic() { return type == f_type_dynamic; }
|
||||
inline bool is_static() { return type == f_type_static; }
|
||||
inline bool is_user() { return type == f_type_user; }
|
||||
/// Type of this feature, from the enum feature_type
|
||||
feature_type type;
|
||||
};
|
||||
|
||||
inline bool is_dynamic(int id) { return features()[id]->type == f_type_dynamic; }
|
||||
inline bool is_static(int id) { return features()[id]->type == f_type_static; }
|
||||
inline bool is_user(int id) { return features()[id]->type == f_type_user; }
|
||||
|
||||
// Accessor to array of all features with deps, static in most derived classes
|
||||
// Subclasses with dynamic dependency trees may override this
|
||||
// with a non-static array
|
||||
@ -100,9 +118,8 @@ public:
|
||||
/// (useful for cvcs because their children are member objects)
|
||||
void remove_all_children();
|
||||
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// pointers to objects this object depends on
|
||||
// list should be maintained by any code that modifies the object
|
||||
// this could be secured by making lists of colvars / cvcs / atom groups private and modified through accessor functions
|
||||
@ -130,16 +147,28 @@ public:
|
||||
// Checks whether given feature is enabled
|
||||
// Defaults to querying f_*_active
|
||||
inline bool is_enabled(int f = f_cv_active) const {
|
||||
return feature_states[f]->enabled;
|
||||
return feature_states[f].enabled;
|
||||
}
|
||||
|
||||
// Checks whether given feature is available
|
||||
// Defaults to querying f_*_active
|
||||
inline bool is_available(int f = f_cv_active) const {
|
||||
return feature_states[f]->available;
|
||||
return feature_states[f].available;
|
||||
}
|
||||
|
||||
void provide(int feature_id); // set the feature's flag to available in local object
|
||||
/// Set the feature's available flag, without checking
|
||||
/// To be used for dynamic properties
|
||||
/// dependencies will be checked by enable()
|
||||
void provide(int feature_id, bool truefalse = true);
|
||||
|
||||
/// Set the feature's enabled flag, without dependency check or resolution
|
||||
/// To be used for static properties only
|
||||
/// Checking for availability is up to the caller
|
||||
void set_enabled(int feature_id, bool truefalse = true);
|
||||
|
||||
protected:
|
||||
|
||||
|
||||
|
||||
/// Parse a keyword and enable a feature accordingly
|
||||
bool get_keyval_feature(colvarparse *cvp,
|
||||
@ -147,6 +176,8 @@ public:
|
||||
int feature_id, bool const &def_value,
|
||||
colvarparse::Parse_Mode const parse_mode = colvarparse::parse_normal);
|
||||
|
||||
public:
|
||||
|
||||
int enable(int f, bool dry_run = false, bool toplevel = true); // enable a feature and recursively solve its dependencies
|
||||
// dry_run is set to true to recursively test if a feature is available, without enabling it
|
||||
// int disable(int f);
|
||||
@ -165,6 +196,7 @@ public:
|
||||
f_cvb_get_total_force, // requires total forces
|
||||
f_cvb_history_dependent, // depends on simulation history
|
||||
f_cvb_scalar_variables, // requires scalar colvars
|
||||
f_cvb_calc_pmf, // whether this bias will compute a PMF
|
||||
f_cvb_ntot
|
||||
};
|
||||
|
||||
@ -216,12 +248,6 @@ public:
|
||||
/// be used by the biases or in analysis (needs lower and upper
|
||||
/// boundary)
|
||||
f_cv_grid,
|
||||
/// \brief Apply a restraining potential (|x-xb|^2) to the colvar
|
||||
/// when it goes below the lower wall
|
||||
f_cv_lower_wall,
|
||||
/// \brief Apply a restraining potential (|x-xb|^2) to the colvar
|
||||
/// when it goes above the upper wall
|
||||
f_cv_upper_wall,
|
||||
/// \brief Compute running average
|
||||
f_cv_runave,
|
||||
/// \brief Compute time correlation function
|
||||
|
||||
@ -36,6 +36,9 @@ colvarmodule::colvarmodule(colvarproxy *proxy_in)
|
||||
"variable module twice.\n");
|
||||
return;
|
||||
}
|
||||
|
||||
depth_s = 0;
|
||||
|
||||
cvm::log(cvm::line_marker);
|
||||
cvm::log("Initializing the collective variables module, version "+
|
||||
cvm::to_str(COLVARS_VERSION)+".\n");
|
||||
@ -71,6 +74,48 @@ colvarmodule::colvarmodule(colvarproxy *proxy_in)
|
||||
}
|
||||
|
||||
|
||||
colvarmodule * colvarmodule::main()
|
||||
{
|
||||
return proxy->colvars;
|
||||
}
|
||||
|
||||
|
||||
std::vector<colvar *> *colvarmodule::variables()
|
||||
{
|
||||
return &colvars;
|
||||
}
|
||||
|
||||
|
||||
std::vector<colvar *> *colvarmodule::variables_active()
|
||||
{
|
||||
return &colvars_active;
|
||||
}
|
||||
|
||||
|
||||
std::vector<colvar *> *colvarmodule::variables_active_smp()
|
||||
{
|
||||
return &colvars_smp;
|
||||
}
|
||||
|
||||
|
||||
std::vector<int> *colvarmodule::variables_active_smp_items()
|
||||
{
|
||||
return &colvars_smp_items;
|
||||
}
|
||||
|
||||
|
||||
std::vector<colvarbias *> *colvarmodule::biases_active()
|
||||
{
|
||||
return &(biases_active_);
|
||||
}
|
||||
|
||||
|
||||
size_t colvarmodule::size() const
|
||||
{
|
||||
return colvars.size() + biases.size();
|
||||
}
|
||||
|
||||
|
||||
int colvarmodule::read_config_file(char const *config_filename)
|
||||
{
|
||||
cvm::log(cvm::line_marker);
|
||||
@ -118,8 +163,29 @@ int colvarmodule::read_config_string(std::string const &config_str)
|
||||
}
|
||||
|
||||
|
||||
std::istream & colvarmodule::getline(std::istream &is, std::string &line)
|
||||
{
|
||||
std::string l;
|
||||
if (std::getline(is, l)) {
|
||||
size_t const sz = l.size();
|
||||
if (sz > 0) {
|
||||
if (l[sz-1] == '\r' ) {
|
||||
line = l.substr(0, sz-1);
|
||||
} else {
|
||||
line = l;
|
||||
}
|
||||
} else {
|
||||
line.clear();
|
||||
}
|
||||
}
|
||||
return is;
|
||||
}
|
||||
|
||||
|
||||
int colvarmodule::parse_config(std::string &conf)
|
||||
{
|
||||
extra_conf.clear();
|
||||
|
||||
// parse global options
|
||||
if (catch_input_errors(parse_global_params(conf))) {
|
||||
return get_error();
|
||||
@ -140,6 +206,15 @@ int colvarmodule::parse_config(std::string &conf)
|
||||
return get_error();
|
||||
}
|
||||
|
||||
if (extra_conf.size()) {
|
||||
catch_input_errors(parse_global_params(extra_conf));
|
||||
catch_input_errors(parse_colvars(extra_conf));
|
||||
catch_input_errors(parse_biases(extra_conf));
|
||||
parse->check_keywords(extra_conf, "colvarmodule");
|
||||
extra_conf.clear();
|
||||
if (get_error() != COLVARS_OK) return get_error();
|
||||
}
|
||||
|
||||
cvm::log(cvm::line_marker);
|
||||
cvm::log("Collective variables module (re)initialized.\n");
|
||||
cvm::log(cvm::line_marker);
|
||||
@ -156,11 +231,20 @@ int colvarmodule::parse_config(std::string &conf)
|
||||
}
|
||||
|
||||
|
||||
int colvarmodule::append_new_config(std::string const &new_conf)
|
||||
{
|
||||
extra_conf += new_conf;
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
|
||||
int colvarmodule::parse_global_params(std::string const &conf)
|
||||
{
|
||||
colvarmodule *cvm = cvm::main();
|
||||
|
||||
std::string index_file_name;
|
||||
if (parse->get_keyval(conf, "indexFile", index_file_name)) {
|
||||
read_index_file(index_file_name.c_str());
|
||||
cvm->read_index_file(index_file_name.c_str());
|
||||
}
|
||||
|
||||
if (parse->get_keyval(conf, "smp", proxy->b_smp_active, proxy->b_smp_active)) {
|
||||
@ -216,8 +300,8 @@ int colvarmodule::parse_colvars(std::string const &conf)
|
||||
if (colvar_conf.size()) {
|
||||
cvm::log(cvm::line_marker);
|
||||
cvm::increase_depth();
|
||||
colvars.push_back(new colvar(colvar_conf));
|
||||
if (cvm::get_error() ||
|
||||
colvars.push_back(new colvar());
|
||||
if (((colvars.back())->init(colvar_conf) != COLVARS_OK) ||
|
||||
((colvars.back())->check_keywords(colvar_conf, "colvar") != COLVARS_OK)) {
|
||||
cvm::log("Error while constructing colvar number " +
|
||||
cvm::to_str(colvars.size()) + " : deleting.");
|
||||
@ -262,8 +346,7 @@ bool colvarmodule::check_new_bias(std::string &conf, char const *key)
|
||||
|
||||
template <class bias_type>
|
||||
int colvarmodule::parse_biases_type(std::string const &conf,
|
||||
char const *keyword,
|
||||
size_t &bias_count)
|
||||
char const *keyword)
|
||||
{
|
||||
std::string bias_conf = "";
|
||||
size_t conf_saved_pos = 0;
|
||||
@ -277,7 +360,6 @@ int colvarmodule::parse_biases_type(std::string const &conf,
|
||||
return COLVARS_ERROR;
|
||||
}
|
||||
cvm::decrease_depth();
|
||||
bias_count++;
|
||||
} else {
|
||||
cvm::error("Error: keyword \""+std::string(keyword)+"\" found without configuration.\n",
|
||||
INPUT_ERROR);
|
||||
@ -295,28 +377,28 @@ int colvarmodule::parse_biases(std::string const &conf)
|
||||
cvm::log("Initializing the collective variables biases.\n");
|
||||
|
||||
/// initialize ABF instances
|
||||
parse_biases_type<colvarbias_abf>(conf, "abf", n_abf_biases);
|
||||
parse_biases_type<colvarbias_abf>(conf, "abf");
|
||||
|
||||
/// initialize adaptive linear biases
|
||||
parse_biases_type<colvarbias_alb>(conf, "ALB", n_rest_biases);
|
||||
parse_biases_type<colvarbias_alb>(conf, "ALB");
|
||||
|
||||
/// initialize harmonic restraints
|
||||
parse_biases_type<colvarbias_restraint_harmonic>(conf, "harmonic", n_rest_biases);
|
||||
parse_biases_type<colvarbias_restraint_harmonic>(conf, "harmonic");
|
||||
|
||||
/// initialize harmonic walls restraints
|
||||
parse_biases_type<colvarbias_restraint_harmonic_walls>(conf, "harmonicWalls", n_rest_biases);
|
||||
parse_biases_type<colvarbias_restraint_harmonic_walls>(conf, "harmonicWalls");
|
||||
|
||||
/// initialize histograms
|
||||
parse_biases_type<colvarbias_histogram>(conf, "histogram", n_histo_biases);
|
||||
parse_biases_type<colvarbias_histogram>(conf, "histogram");
|
||||
|
||||
/// initialize histogram restraints
|
||||
parse_biases_type<colvarbias_restraint_histogram>(conf, "histogramRestraint", n_rest_biases);
|
||||
parse_biases_type<colvarbias_restraint_histogram>(conf, "histogramRestraint");
|
||||
|
||||
/// initialize linear restraints
|
||||
parse_biases_type<colvarbias_restraint_linear>(conf, "linear", n_rest_biases);
|
||||
parse_biases_type<colvarbias_restraint_linear>(conf, "linear");
|
||||
|
||||
/// initialize metadynamics instances
|
||||
parse_biases_type<colvarbias_meta>(conf, "metadynamics", n_meta_biases);
|
||||
parse_biases_type<colvarbias_meta>(conf, "metadynamics");
|
||||
|
||||
if (use_scripted_forces) {
|
||||
cvm::log(cvm::line_marker);
|
||||
@ -363,6 +445,36 @@ int colvarmodule::parse_biases(std::string const &conf)
|
||||
}
|
||||
|
||||
|
||||
int colvarmodule::num_biases_feature(int feature_id)
|
||||
{
|
||||
colvarmodule *cv = cvm::main();
|
||||
size_t n = 0;
|
||||
for (std::vector<colvarbias *>::iterator bi = cv->biases.begin();
|
||||
bi != cv->biases.end();
|
||||
bi++) {
|
||||
if ((*bi)->is_enabled(feature_id)) {
|
||||
n++;
|
||||
}
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
|
||||
int colvarmodule::num_biases_type(std::string const &type)
|
||||
{
|
||||
colvarmodule *cv = cvm::main();
|
||||
size_t n = 0;
|
||||
for (std::vector<colvarbias *>::iterator bi = cv->biases.begin();
|
||||
bi != cv->biases.end();
|
||||
bi++) {
|
||||
if ((*bi)->bias_type == type) {
|
||||
n++;
|
||||
}
|
||||
}
|
||||
return n;
|
||||
}
|
||||
|
||||
|
||||
int colvarmodule::catch_input_errors(int result)
|
||||
{
|
||||
if (result != COLVARS_OK || get_error()) {
|
||||
@ -376,8 +488,9 @@ int colvarmodule::catch_input_errors(int result)
|
||||
|
||||
|
||||
colvarbias * colvarmodule::bias_by_name(std::string const &name) {
|
||||
for (std::vector<colvarbias *>::iterator bi = biases.begin();
|
||||
bi != biases.end();
|
||||
colvarmodule *cv = cvm::main();
|
||||
for (std::vector<colvarbias *>::iterator bi = cv->biases.begin();
|
||||
bi != cv->biases.end();
|
||||
bi++) {
|
||||
if ((*bi)->name == name) {
|
||||
return (*bi);
|
||||
@ -388,8 +501,9 @@ colvarbias * colvarmodule::bias_by_name(std::string const &name) {
|
||||
|
||||
|
||||
colvar *colvarmodule::colvar_by_name(std::string const &name) {
|
||||
for (std::vector<colvar *>::iterator cvi = colvars.begin();
|
||||
cvi != colvars.end();
|
||||
colvarmodule *cv = cvm::main();
|
||||
for (std::vector<colvar *>::iterator cvi = cv->colvars.begin();
|
||||
cvi != cv->colvars.end();
|
||||
cvi++) {
|
||||
if ((*cvi)->name == name) {
|
||||
return (*cvi);
|
||||
@ -555,9 +669,15 @@ int colvarmodule::calc_colvars()
|
||||
int error_code = COLVARS_OK;
|
||||
std::vector<colvar *>::iterator cvi;
|
||||
|
||||
// Determine which colvars are active at this time step
|
||||
for (cvi = colvars.begin(); cvi != colvars.end(); cvi++) {
|
||||
(*cvi)->feature_states[colvardeps::f_cv_active]->enabled = (step_absolute() % (*cvi)->get_time_step_factor() == 0);
|
||||
// Determine which colvars are active at this iteration
|
||||
variables_active()->resize(0);
|
||||
variables_active()->reserve(variables()->size());
|
||||
for (cvi = variables()->begin(); cvi != variables()->end(); cvi++) {
|
||||
// This is a dynamic feature - the next call should be to enable()
|
||||
// or disable() when dynamic dependency resolution is fully implemented
|
||||
(*cvi)->set_enabled(colvardeps::f_cv_active,
|
||||
step_absolute() % (*cvi)->get_time_step_factor() == 0);
|
||||
variables_active()->push_back(*cvi);
|
||||
}
|
||||
|
||||
// if SMP support is available, split up the work
|
||||
@ -565,25 +685,24 @@ int colvarmodule::calc_colvars()
|
||||
|
||||
// first, calculate how much work (currently, how many active CVCs) each colvar has
|
||||
|
||||
colvars_smp.resize(0);
|
||||
colvars_smp_items.resize(0);
|
||||
variables_active_smp()->resize(0);
|
||||
variables_active_smp_items()->resize(0);
|
||||
|
||||
colvars_smp.reserve(colvars.size());
|
||||
colvars_smp_items.reserve(colvars.size());
|
||||
variables_active_smp()->reserve(variables_active()->size());
|
||||
variables_active_smp_items()->reserve(variables_active()->size());
|
||||
|
||||
// set up a vector containing all components
|
||||
cvm::increase_depth();
|
||||
for (cvi = colvars.begin(); cvi != colvars.end(); cvi++) {
|
||||
for (cvi = variables_active()->begin(); cvi != variables_active()->end(); cvi++) {
|
||||
|
||||
if (!(*cvi)->is_enabled()) continue;
|
||||
error_code |= (*cvi)->update_cvc_flags();
|
||||
|
||||
size_t num_items = (*cvi)->num_active_cvcs();
|
||||
colvars_smp.reserve(colvars_smp.size() + num_items);
|
||||
colvars_smp_items.reserve(colvars_smp_items.size() + num_items);
|
||||
variables_active_smp()->reserve(variables_active_smp()->size() + num_items);
|
||||
variables_active_smp_items()->reserve(variables_active_smp_items()->size() + num_items);
|
||||
for (size_t icvc = 0; icvc < num_items; icvc++) {
|
||||
colvars_smp.push_back(*cvi);
|
||||
colvars_smp_items.push_back(icvc);
|
||||
variables_active_smp()->push_back(*cvi);
|
||||
variables_active_smp_items()->push_back(icvc);
|
||||
}
|
||||
}
|
||||
cvm::decrease_depth();
|
||||
@ -592,8 +711,7 @@ int colvarmodule::calc_colvars()
|
||||
error_code |= proxy->smp_colvars_loop();
|
||||
|
||||
cvm::increase_depth();
|
||||
for (cvi = colvars.begin(); cvi != colvars.end(); cvi++) {
|
||||
if (!(*cvi)->is_enabled()) continue;
|
||||
for (cvi = variables_active()->begin(); cvi != variables_active()->end(); cvi++) {
|
||||
error_code |= (*cvi)->collect_cvc_data();
|
||||
}
|
||||
cvm::decrease_depth();
|
||||
@ -602,8 +720,7 @@ int colvarmodule::calc_colvars()
|
||||
|
||||
// calculate colvars one at a time
|
||||
cvm::increase_depth();
|
||||
for (cvi = colvars.begin(); cvi != colvars.end(); cvi++) {
|
||||
if (!(*cvi)->is_enabled()) continue;
|
||||
for (cvi = variables_active()->begin(); cvi != variables_active()->end(); cvi++) {
|
||||
error_code |= (*cvi)->calc();
|
||||
if (cvm::get_error()) {
|
||||
return COLVARS_ERROR;
|
||||
@ -627,6 +744,18 @@ int colvarmodule::calc_biases()
|
||||
std::vector<colvarbias *>::iterator bi;
|
||||
int error_code = COLVARS_OK;
|
||||
|
||||
// Total bias energy is reset before calling scripted biases
|
||||
total_bias_energy = 0.0;
|
||||
|
||||
// update the list of active biases
|
||||
biases_active()->resize(0);
|
||||
biases_active()->reserve(biases.size());
|
||||
for (bi = biases.begin(); bi != biases.end(); bi++) {
|
||||
if ((*bi)->is_enabled()) {
|
||||
biases_active()->push_back(*bi);
|
||||
}
|
||||
}
|
||||
|
||||
// if SMP support is available, split up the work
|
||||
if (proxy->smp_enabled() == COLVARS_OK) {
|
||||
|
||||
@ -645,7 +774,7 @@ int colvarmodule::calc_biases()
|
||||
}
|
||||
|
||||
cvm::increase_depth();
|
||||
for (bi = biases.begin(); bi != biases.end(); bi++) {
|
||||
for (bi = biases_active()->begin(); bi != biases_active()->end(); bi++) {
|
||||
error_code |= (*bi)->update();
|
||||
if (cvm::get_error()) {
|
||||
return error_code;
|
||||
@ -654,12 +783,10 @@ int colvarmodule::calc_biases()
|
||||
cvm::decrease_depth();
|
||||
}
|
||||
|
||||
cvm::real total_bias_energy = 0.0;
|
||||
for (bi = biases.begin(); bi != biases.end(); bi++) {
|
||||
for (bi = biases_active()->begin(); bi != biases_active()->end(); bi++) {
|
||||
total_bias_energy += (*bi)->get_energy();
|
||||
}
|
||||
|
||||
proxy->add_energy(total_bias_energy);
|
||||
return (cvm::get_error() ? COLVARS_ERROR : COLVARS_OK);
|
||||
}
|
||||
|
||||
@ -675,7 +802,7 @@ int colvarmodule::update_colvar_forces()
|
||||
if (cvm::debug() && biases.size())
|
||||
cvm::log("Collecting forces from all biases.\n");
|
||||
cvm::increase_depth();
|
||||
for (bi = biases.begin(); bi != biases.end(); bi++) {
|
||||
for (bi = biases_active()->begin(); bi != biases_active()->end(); bi++) {
|
||||
(*bi)->communicate_forces();
|
||||
if (cvm::get_error()) {
|
||||
return COLVARS_ERROR;
|
||||
@ -687,6 +814,11 @@ int colvarmodule::update_colvar_forces()
|
||||
error_code |= calc_scripted_forces();
|
||||
}
|
||||
|
||||
// Now we have collected energies from both built-in and scripted biases
|
||||
if (cvm::debug())
|
||||
cvm::log("Adding total bias energy: " + cvm::to_str(total_bias_energy) + "\n");
|
||||
proxy->add_energy(total_bias_energy);
|
||||
|
||||
cvm::real total_colvar_energy = 0.0;
|
||||
// sum up the forces for each colvar, including wall forces
|
||||
// and integrate any internal
|
||||
@ -695,7 +827,7 @@ int colvarmodule::update_colvar_forces()
|
||||
cvm::log("Updating the internal degrees of freedom "
|
||||
"of colvars (if they have any).\n");
|
||||
cvm::increase_depth();
|
||||
for (cvi = colvars.begin(); cvi != colvars.end(); cvi++) {
|
||||
for (cvi = variables()->begin(); cvi != variables()->end(); cvi++) {
|
||||
// Here we call even inactive colvars, so they accumulate biasing forces
|
||||
// as well as update their extended-system dynamics
|
||||
total_colvar_energy += (*cvi)->update_forces_energy();
|
||||
@ -704,6 +836,8 @@ int colvarmodule::update_colvar_forces()
|
||||
}
|
||||
}
|
||||
cvm::decrease_depth();
|
||||
if (cvm::debug())
|
||||
cvm::log("Adding total colvar energy: " + cvm::to_str(total_colvar_energy) + "\n");
|
||||
proxy->add_energy(total_colvar_energy);
|
||||
|
||||
// make collective variables communicate their forces to their
|
||||
@ -711,9 +845,8 @@ int colvarmodule::update_colvar_forces()
|
||||
if (cvm::debug())
|
||||
cvm::log("Communicating forces from the colvars to the atoms.\n");
|
||||
cvm::increase_depth();
|
||||
for (cvi = colvars.begin(); cvi != colvars.end(); cvi++) {
|
||||
for (cvi = variables_active()->begin(); cvi != variables_active()->end(); cvi++) {
|
||||
if ((*cvi)->is_enabled(colvardeps::f_cv_gradient)) {
|
||||
if (!(*cvi)->is_enabled()) continue;
|
||||
(*cvi)->communicate_forces();
|
||||
if (cvm::get_error()) {
|
||||
return COLVARS_ERROR;
|
||||
@ -800,8 +933,8 @@ int colvarmodule::analyze()
|
||||
cvm::log("Performing analysis.\n");
|
||||
|
||||
// perform colvar-specific analysis
|
||||
for (std::vector<colvar *>::iterator cvi = colvars.begin();
|
||||
cvi != colvars.end();
|
||||
for (std::vector<colvar *>::iterator cvi = variables_active()->begin();
|
||||
cvi != variables_active()->end();
|
||||
cvi++) {
|
||||
cvm::increase_depth();
|
||||
(*cvi)->analyze();
|
||||
@ -825,8 +958,8 @@ int colvarmodule::setup()
|
||||
{
|
||||
if (this->size() == 0) return cvm::get_error();
|
||||
// loop over all components of all colvars to reset masses of all groups
|
||||
for (std::vector<colvar *>::iterator cvi = colvars.begin();
|
||||
cvi != colvars.end(); cvi++) {
|
||||
for (std::vector<colvar *>::iterator cvi = variables()->begin();
|
||||
cvi != variables()->end(); cvi++) {
|
||||
(*cvi)->setup();
|
||||
}
|
||||
return (cvm::get_error() ? COLVARS_ERROR : COLVARS_OK);
|
||||
@ -934,18 +1067,18 @@ int colvarmodule::setup_output()
|
||||
cvm::log("The restart output state file will be \""+restart_out_name+"\".\n");
|
||||
}
|
||||
|
||||
output_prefix = proxy->output_prefix();
|
||||
if (output_prefix.size()) {
|
||||
output_prefix() = proxy->output_prefix();
|
||||
if (output_prefix().size()) {
|
||||
cvm::log("The final output state file will be \""+
|
||||
(output_prefix.size() ?
|
||||
std::string(output_prefix+".colvars.state") :
|
||||
(output_prefix().size() ?
|
||||
std::string(output_prefix()+".colvars.state") :
|
||||
std::string("colvars.state"))+"\".\n");
|
||||
// cvm::log (cvm::line_marker);
|
||||
}
|
||||
|
||||
cv_traj_name =
|
||||
(output_prefix.size() ?
|
||||
std::string(output_prefix+".colvars.traj") :
|
||||
(output_prefix().size() ?
|
||||
std::string(output_prefix()+".colvars.traj") :
|
||||
std::string(""));
|
||||
|
||||
if (cv_traj_freq && cv_traj_name.size()) {
|
||||
@ -1077,14 +1210,14 @@ continue the previous simulation.\n\n");
|
||||
cvm::log(cvm::line_marker);
|
||||
|
||||
// update this ahead of time in this special case
|
||||
output_prefix = proxy->input_prefix();
|
||||
cvm::log("All output files will now be saved with the prefix \""+output_prefix+".tmp.*\".\n");
|
||||
output_prefix() = proxy->input_prefix();
|
||||
cvm::log("All output files will now be saved with the prefix \""+output_prefix()+".tmp.*\".\n");
|
||||
cvm::log(cvm::line_marker);
|
||||
cvm::log("Please review the important warning above. After that, you may rename:\n\
|
||||
\""+output_prefix+".tmp.colvars.state\"\n\
|
||||
\""+output_prefix()+".tmp.colvars.state\"\n\
|
||||
to:\n\
|
||||
\""+ proxy->input_prefix()+".colvars.state\"\n");
|
||||
output_prefix = output_prefix+".tmp";
|
||||
output_prefix() = output_prefix()+".tmp";
|
||||
write_output_files();
|
||||
cvm::error("Exiting with error until issue is addressed.\n", FATAL_ERROR);
|
||||
}
|
||||
@ -1104,8 +1237,8 @@ int colvarmodule::write_output_files()
|
||||
// if this is a simulation run (i.e. not a postprocessing), output data
|
||||
// must be written to be able to restart the simulation
|
||||
std::string const out_name =
|
||||
(output_prefix.size() ?
|
||||
std::string(output_prefix+".colvars.state") :
|
||||
(output_prefix().size() ?
|
||||
std::string(output_prefix()+".colvars.state") :
|
||||
std::string("colvars.state"));
|
||||
cvm::log("Saving collective variables state to \""+out_name+"\".\n");
|
||||
|
||||
@ -1340,7 +1473,8 @@ std::ostream & colvarmodule::write_traj(std::ostream &os)
|
||||
|
||||
void cvm::log(std::string const &message)
|
||||
{
|
||||
size_t const d = depth();
|
||||
// allow logging when the module is not fully initialized
|
||||
size_t const d = (cvm::main() != NULL) ? depth() : 0;
|
||||
if (d > 0)
|
||||
proxy->log((std::string(2*d, ' '))+message);
|
||||
else
|
||||
@ -1365,19 +1499,20 @@ void cvm::decrease_depth()
|
||||
size_t & cvm::depth()
|
||||
{
|
||||
// NOTE: do not call log() or error() here, to avoid recursion
|
||||
size_t const nt = proxy->smp_num_threads();
|
||||
colvarmodule *cv = cvm::main();
|
||||
if (proxy->smp_enabled() == COLVARS_OK) {
|
||||
if (depth_v.size() != nt) {
|
||||
// update array of depths
|
||||
int const nt = proxy->smp_num_threads();
|
||||
if (int(cv->depth_v.size()) != nt) {
|
||||
proxy->smp_lock();
|
||||
if (depth_v.size() > 0) { depth_s = depth_v[0]; }
|
||||
depth_v.clear();
|
||||
depth_v.assign(nt, depth_s);
|
||||
// update array of depths
|
||||
if (cv->depth_v.size() > 0) { cv->depth_s = cv->depth_v[0]; }
|
||||
cv->depth_v.clear();
|
||||
cv->depth_v.assign(nt, cv->depth_s);
|
||||
proxy->smp_unlock();
|
||||
}
|
||||
return depth_v[proxy->smp_thread_id()];
|
||||
return cv->depth_v[proxy->smp_thread_id()];
|
||||
}
|
||||
return depth_s;
|
||||
return cv->depth_s;
|
||||
}
|
||||
|
||||
|
||||
@ -1451,8 +1586,8 @@ int cvm::read_index_file(char const *filename)
|
||||
FILE_ERROR);
|
||||
}
|
||||
}
|
||||
cvm::index_group_names.push_back(group_name);
|
||||
cvm::index_groups.push_back(std::vector<int> ());
|
||||
index_group_names.push_back(group_name);
|
||||
index_groups.push_back(std::vector<int>());
|
||||
} else {
|
||||
cvm::error("Error: in parsing index file \""+
|
||||
std::string(filename)+"\".\n",
|
||||
@ -1462,7 +1597,7 @@ int cvm::read_index_file(char const *filename)
|
||||
int atom_number = 1;
|
||||
size_t pos = is.tellg();
|
||||
while ( (is >> atom_number) && (atom_number > 0) ) {
|
||||
(cvm::index_groups.back()).push_back(atom_number);
|
||||
(index_groups.back()).push_back(atom_number);
|
||||
pos = is.tellg();
|
||||
}
|
||||
is.clear();
|
||||
@ -1532,8 +1667,8 @@ int cvm::load_coords_xyz(char const *filename,
|
||||
+ std::string(filename) + ".\n", INPUT_ERROR);
|
||||
}
|
||||
// skip comment line
|
||||
std::getline(xyz_is, line);
|
||||
std::getline(xyz_is, line);
|
||||
cvm::getline(xyz_is, line);
|
||||
cvm::getline(xyz_is, line);
|
||||
xyz_is.width(255);
|
||||
std::vector<atom_pos>::iterator pos_i = pos.begin();
|
||||
|
||||
@ -1543,7 +1678,7 @@ int cvm::load_coords_xyz(char const *filename,
|
||||
for ( ; pos_i != pos.end() ; pos_i++, index++) {
|
||||
|
||||
while ( next < *index ) {
|
||||
std::getline(xyz_is, line);
|
||||
cvm::getline(xyz_is, line);
|
||||
next++;
|
||||
}
|
||||
xyz_is >> symbol;
|
||||
@ -1558,15 +1693,9 @@ int cvm::load_coords_xyz(char const *filename,
|
||||
return (cvm::get_error() ? COLVARS_ERROR : COLVARS_OK);
|
||||
}
|
||||
|
||||
// static pointers
|
||||
std::vector<colvar *> colvarmodule::colvars;
|
||||
std::vector<colvarbias *> colvarmodule::biases;
|
||||
size_t colvarmodule::n_abf_biases = 0;
|
||||
size_t colvarmodule::n_rest_biases = 0;
|
||||
size_t colvarmodule::n_histo_biases = 0;
|
||||
size_t colvarmodule::n_meta_biases = 0;
|
||||
colvarproxy *colvarmodule::proxy = NULL;
|
||||
|
||||
// shared pointer to the proxy object
|
||||
colvarproxy *colvarmodule::proxy = NULL;
|
||||
|
||||
// static runtime data
|
||||
cvm::real colvarmodule::debug_gradients_step_size = 1.0e-07;
|
||||
@ -1575,14 +1704,9 @@ long colvarmodule::it = 0;
|
||||
long colvarmodule::it_restart = 0;
|
||||
size_t colvarmodule::restart_out_freq = 0;
|
||||
size_t colvarmodule::cv_traj_freq = 0;
|
||||
size_t colvarmodule::depth_s = 0;
|
||||
std::vector<size_t> colvarmodule::depth_v(0);
|
||||
bool colvarmodule::b_analysis = false;
|
||||
std::list<std::string> colvarmodule::index_group_names;
|
||||
std::list<std::vector<int> > colvarmodule::index_groups;
|
||||
bool colvarmodule::use_scripted_forces = false;
|
||||
bool colvarmodule::scripting_after_biases = true;
|
||||
std::string colvarmodule::output_prefix = "";
|
||||
bool colvarmodule::use_scripted_forces = false;
|
||||
bool colvarmodule::scripting_after_biases = true;
|
||||
|
||||
// i/o constants
|
||||
size_t const colvarmodule::it_width = 12;
|
||||
|
||||
@ -11,7 +11,7 @@
|
||||
#define COLVARMODULE_H
|
||||
|
||||
#ifndef COLVARS_VERSION
|
||||
#define COLVARS_VERSION "2016-12-27"
|
||||
#define COLVARS_VERSION "2017-03-09"
|
||||
#endif
|
||||
|
||||
#ifndef COLVARS_DEBUG
|
||||
@ -161,12 +161,37 @@ public:
|
||||
/// dt)
|
||||
static real debug_gradients_step_size;
|
||||
|
||||
/// Prefix for all output files for this run
|
||||
static std::string output_prefix;
|
||||
private:
|
||||
|
||||
/// Prefix for all output files for this run
|
||||
std::string cvm_output_prefix;
|
||||
|
||||
public:
|
||||
/// Accessor for the above
|
||||
static inline std::string &output_prefix()
|
||||
{
|
||||
colvarmodule *cv = colvarmodule::main();
|
||||
return cv->cvm_output_prefix;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
/// Array of collective variables
|
||||
static std::vector<colvar *> colvars;
|
||||
std::vector<colvar *> colvars;
|
||||
|
||||
/// Array of collective variables
|
||||
std::vector<colvar *> colvars_active;
|
||||
|
||||
/// Collective variables to be calculated on different threads;
|
||||
/// colvars with multple items (e.g. multiple active CVCs) are duplicated
|
||||
std::vector<colvar *> colvars_smp;
|
||||
/// Indexes of the items to calculate for each colvar
|
||||
std::vector<int> colvars_smp_items;
|
||||
|
||||
public:
|
||||
|
||||
/// Array of collective variables
|
||||
std::vector<colvar *> *variables();
|
||||
|
||||
/* TODO: implement named CVCs
|
||||
/// Array of named (reusable) collective variable components
|
||||
@ -177,26 +202,31 @@ public:
|
||||
}
|
||||
*/
|
||||
|
||||
/// Collective variables with the active flag on
|
||||
std::vector<colvar *> *variables_active();
|
||||
|
||||
/// Collective variables to be calculated on different threads;
|
||||
/// colvars with multple items (e.g. multiple active CVCs) are duplicated
|
||||
std::vector<colvar *> colvars_smp;
|
||||
std::vector<colvar *> *variables_active_smp();
|
||||
|
||||
/// Indexes of the items to calculate for each colvar
|
||||
std::vector<int> colvars_smp_items;
|
||||
std::vector<int> *variables_active_smp_items();
|
||||
|
||||
/// Array of collective variable biases
|
||||
static std::vector<colvarbias *> biases;
|
||||
/// \brief Number of ABF biases initialized (in normal conditions
|
||||
/// should be 1)
|
||||
static size_t n_abf_biases;
|
||||
/// \brief Number of metadynamics biases initialized (in normal
|
||||
/// conditions should be 1)
|
||||
static size_t n_meta_biases;
|
||||
/// \brief Number of restraint biases initialized (no limit on the
|
||||
/// number)
|
||||
static size_t n_rest_biases;
|
||||
/// \brief Number of histograms initialized (no limit on the
|
||||
/// number)
|
||||
static size_t n_histo_biases;
|
||||
std::vector<colvarbias *> biases;
|
||||
|
||||
/// Energy of built-in and scripted biases, summed per time-step
|
||||
real total_bias_energy;
|
||||
|
||||
private:
|
||||
|
||||
/// Array of active collective variable biases
|
||||
std::vector<colvarbias *> biases_active_;
|
||||
|
||||
public:
|
||||
|
||||
/// Array of active collective variable biases
|
||||
std::vector<colvarbias *> *biases_active();
|
||||
|
||||
/// \brief Whether debug output should be enabled (compile-time option)
|
||||
static inline bool debug()
|
||||
@ -205,10 +235,7 @@ public:
|
||||
}
|
||||
|
||||
/// \brief How many objects are configured yet?
|
||||
inline size_t size() const
|
||||
{
|
||||
return colvars.size() + biases.size();
|
||||
}
|
||||
size_t size() const;
|
||||
|
||||
/// \brief Constructor \param config_name Configuration file name
|
||||
/// \param restart_name (optional) Restart file name
|
||||
@ -230,9 +257,12 @@ public:
|
||||
/// \brief Parse a "clean" config string (no comments)
|
||||
int parse_config(std::string &conf);
|
||||
|
||||
|
||||
// Parse functions (setup internal data based on a string)
|
||||
|
||||
/// Allow reading from Windows text files using using std::getline
|
||||
/// (which can still be used when the text is produced by Colvars itself)
|
||||
static std::istream & getline(std::istream &is, std::string &line);
|
||||
|
||||
/// Parse the few module's global parameters
|
||||
int parse_global_params(std::string const &conf);
|
||||
|
||||
@ -242,14 +272,33 @@ public:
|
||||
/// Parse and initialize collective variable biases
|
||||
int parse_biases(std::string const &conf);
|
||||
|
||||
/// \brief Add new configuration during parsing (e.g. to implement
|
||||
/// back-compatibility); cannot be nested, i.e. conf should not contain
|
||||
/// anything that triggers another call
|
||||
int append_new_config(std::string const &conf);
|
||||
|
||||
private:
|
||||
|
||||
/// Auto-generated configuration during parsing (e.g. to implement
|
||||
/// back-compatibility)
|
||||
std::string extra_conf;
|
||||
|
||||
/// Parse and initialize collective variable biases of a specific type
|
||||
template <class bias_type>
|
||||
int parse_biases_type(std::string const &conf, char const *keyword, size_t &bias_count);
|
||||
int parse_biases_type(std::string const &conf, char const *keyword);
|
||||
|
||||
/// Test error condition and keyword parsing
|
||||
/// on error, delete new bias
|
||||
bool check_new_bias(std::string &conf, char const *key);
|
||||
|
||||
public:
|
||||
|
||||
/// Return how many biases have this feature enabled
|
||||
static int num_biases_feature(int feature_id);
|
||||
|
||||
/// Return how many biases are defined with this type
|
||||
static int num_biases_type(std::string const &type);
|
||||
|
||||
private:
|
||||
/// Useful wrapper to interrupt parsing if any error occurs
|
||||
int catch_input_errors(int result);
|
||||
@ -449,13 +498,13 @@ public:
|
||||
|
||||
|
||||
/// \brief Names of groups from a Gromacs .ndx file to be read at startup
|
||||
static std::list<std::string> index_group_names;
|
||||
std::list<std::string> index_group_names;
|
||||
|
||||
/// \brief Groups from a Gromacs .ndx file read at startup
|
||||
static std::list<std::vector<int> > index_groups;
|
||||
std::list<std::vector<int> > index_groups;
|
||||
|
||||
/// \brief Read a Gromacs .ndx file
|
||||
static int read_index_file(char const *filename);
|
||||
int read_index_file(char const *filename);
|
||||
|
||||
|
||||
/// \brief Create atoms from a file \param filename name of the file
|
||||
@ -515,13 +564,13 @@ protected:
|
||||
/// Output restart file
|
||||
colvarmodule::ofstream restart_out_os;
|
||||
|
||||
protected:
|
||||
private:
|
||||
|
||||
/// Counter for the current depth in the object hierarchy (useg e.g. in output)
|
||||
static size_t depth_s;
|
||||
size_t depth_s;
|
||||
|
||||
/// Thread-specific depth
|
||||
static std::vector<size_t> depth_v;
|
||||
std::vector<size_t> depth_v;
|
||||
|
||||
public:
|
||||
|
||||
@ -552,6 +601,10 @@ public:
|
||||
/// from the hosting program; it is static in order to be accessible
|
||||
/// from static functions in the colvarmodule class
|
||||
static colvarproxy *proxy;
|
||||
|
||||
/// \brief Accessor for the above
|
||||
static colvarmodule *main();
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
@ -503,7 +503,7 @@ int colvarparse::check_keywords(std::string &conf, char const *key)
|
||||
|
||||
std::string line;
|
||||
std::istringstream is(conf);
|
||||
while (std::getline(is, line)) {
|
||||
while (cvm::getline(is, line)) {
|
||||
if (line.size() == 0)
|
||||
continue;
|
||||
if (line.find_first_not_of(white_space) ==
|
||||
@ -539,10 +539,9 @@ int colvarparse::check_keywords(std::string &conf, char const *key)
|
||||
|
||||
|
||||
std::istream & colvarparse::getline_nocomments(std::istream &is,
|
||||
std::string &line,
|
||||
char const delim)
|
||||
std::string &line)
|
||||
{
|
||||
std::getline(is, line, delim);
|
||||
cvm::getline(is, line);
|
||||
size_t const comment = line.find('#');
|
||||
if (comment != std::string::npos) {
|
||||
line.erase(comment);
|
||||
|
||||
@ -304,8 +304,7 @@ public:
|
||||
/// \brief Works as std::getline() but also removes everything
|
||||
/// between a comment character and the following newline
|
||||
static std::istream & getline_nocomments(std::istream &is,
|
||||
std::string &s,
|
||||
char const delim = '\n');
|
||||
std::string &s);
|
||||
|
||||
/// Check if the content of the file has matching braces
|
||||
bool brace_check(std::string const &conf,
|
||||
|
||||
@ -336,8 +336,6 @@ public:
|
||||
/// Are total forces being used?
|
||||
virtual bool total_forces_enabled() const
|
||||
{
|
||||
cvm::error("Error: total forces are currently not implemented.\n",
|
||||
COLVARS_NOT_IMPLEMENTED);
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
#include <string.h>
|
||||
|
||||
#include "colvarscript.h"
|
||||
#include "colvardeps.h"
|
||||
|
||||
|
||||
colvarscript::colvarscript(colvarproxy *p)
|
||||
@ -221,6 +222,16 @@ int colvarscript::run(int argc, char const *argv[]) {
|
||||
}
|
||||
}
|
||||
|
||||
if (cmd == "addenergy") {
|
||||
if (argc == 3) {
|
||||
colvars->total_bias_energy += strtod(argv[2], NULL);
|
||||
return COLVARS_OK;
|
||||
} else {
|
||||
result = "Wrong arguments to command \"addenergy\"\n" + help_string();
|
||||
return COLVARSCRIPT_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
result = "Syntax error\n" + help_string();
|
||||
return COLVARSCRIPT_ERROR;
|
||||
}
|
||||
@ -263,10 +274,11 @@ int colvarscript::proc_colvar(int argc, char const *argv[]) {
|
||||
}
|
||||
|
||||
if (subcmd == "delete") {
|
||||
if (cv->biases.size() > 0) {
|
||||
result = "Cannot delete a colvar currently used by biases, delete those biases first";
|
||||
return COLVARSCRIPT_ERROR;
|
||||
size_t i;
|
||||
for (i = 0; i < cv->biases.size(); i++) {
|
||||
delete cv->biases[i];
|
||||
}
|
||||
cv->biases.resize(0);
|
||||
// colvar destructor is tasked with the cleanup
|
||||
delete cv;
|
||||
// TODO this could be done by the destructors
|
||||
@ -338,9 +350,8 @@ int colvarscript::proc_colvar(int argc, char const *argv[]) {
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
if (subcmd == "state") {
|
||||
cv->print_state();
|
||||
return COLVARS_OK;
|
||||
if ((subcmd == "get") || (subcmd == "set") || (subcmd == "state")) {
|
||||
return proc_features(cv, argc, argv);
|
||||
}
|
||||
|
||||
result = "Syntax error\n" + help_string();
|
||||
@ -379,11 +390,6 @@ int colvarscript::proc_bias(int argc, char const *argv[]) {
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
if (subcmd == "state") {
|
||||
b->print_state();
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
// Subcommands for MW ABF
|
||||
if (subcmd == "bin") {
|
||||
int r = b->current_bin();
|
||||
@ -420,6 +426,10 @@ int colvarscript::proc_bias(int argc, char const *argv[]) {
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
if ((subcmd == "get") || (subcmd == "set") || (subcmd == "state")) {
|
||||
return proc_features(b, argc, argv);
|
||||
}
|
||||
|
||||
if (argc >= 4) {
|
||||
std::string param = argv[3];
|
||||
if (subcmd == "count") {
|
||||
@ -441,6 +451,83 @@ int colvarscript::proc_bias(int argc, char const *argv[]) {
|
||||
}
|
||||
|
||||
|
||||
int colvarscript::proc_features(colvardeps *obj,
|
||||
int argc, char const *argv[]) {
|
||||
// size was already checked before calling
|
||||
std::string subcmd = argv[2];
|
||||
|
||||
if (argc == 3) {
|
||||
if (subcmd == "state") {
|
||||
// TODO make this returned as result?
|
||||
obj->print_state();
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
// get and set commands require more arguments
|
||||
result = "Syntax error\n" + help_string();
|
||||
return COLVARSCRIPT_ERROR;
|
||||
}
|
||||
|
||||
if ((subcmd == "get") || (subcmd == "set")) {
|
||||
std::vector<colvardeps::feature *> &features = obj->features();
|
||||
std::string const req_feature(argv[3]);
|
||||
colvardeps::feature *f = NULL;
|
||||
int fid = 0;
|
||||
for (fid = 0; fid < int(features.size()); fid++) {
|
||||
if (features[fid]->description ==
|
||||
colvarparse::to_lower_cppstr(req_feature)) {
|
||||
f = features[fid];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (f == NULL) {
|
||||
|
||||
result = "Error: feature \""+req_feature+"\" does not exist.\n";
|
||||
return COLVARSCRIPT_ERROR;
|
||||
|
||||
} else {
|
||||
|
||||
if (! obj->is_available(fid)) {
|
||||
result = "Error: feature \""+req_feature+"\" is unavailable.\n";
|
||||
return COLVARSCRIPT_ERROR;
|
||||
}
|
||||
|
||||
if (subcmd == "get") {
|
||||
result = cvm::to_str(obj->is_enabled(fid) ? 1 : 0);
|
||||
return COLVARS_OK;
|
||||
}
|
||||
|
||||
if (subcmd == "set") {
|
||||
if (argc == 5) {
|
||||
std::string const yesno =
|
||||
colvarparse::to_lower_cppstr(std::string(argv[4]));
|
||||
if ((yesno == std::string("yes")) ||
|
||||
(yesno == std::string("on")) ||
|
||||
(yesno == std::string("1"))) {
|
||||
obj->enable(fid);
|
||||
return COLVARS_OK;
|
||||
} else if ((yesno == std::string("no")) ||
|
||||
(yesno == std::string("off")) ||
|
||||
(yesno == std::string("0"))) {
|
||||
// TODO disable() function does not exist yet,
|
||||
// dependencies will not be resolved
|
||||
// obj->disable(fid);
|
||||
obj->set_enabled(fid, false);
|
||||
return COLVARS_OK;
|
||||
}
|
||||
}
|
||||
result = "Syntax error\n" + help_string();
|
||||
return COLVARSCRIPT_ERROR;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
result = "Syntax error\n" + help_string();
|
||||
return COLVARSCRIPT_ERROR;
|
||||
}
|
||||
|
||||
|
||||
std::string colvarscript::help_string()
|
||||
{
|
||||
std::string buf;
|
||||
@ -459,6 +546,7 @@ Input and output:\n\
|
||||
load <file name> -- load a state file (requires configuration)\n\
|
||||
save <file name> -- save a state file (requires configuration)\n\
|
||||
update -- recalculate colvars and biases\n\
|
||||
addenergy <E> -- add <E> to the total bias energy\n\
|
||||
printframe -- return a summary of the current frame\n\
|
||||
printframelabels -- return labels to annotate printframe's output\n";
|
||||
|
||||
@ -478,12 +566,17 @@ Accessing collective variables:\n\
|
||||
colvar <name> addforce <F> -- apply given force on colvar <name>\n\
|
||||
colvar <name> getconfig -- return config string of colvar <name>\n\
|
||||
colvar <name> cvcflags <fl> -- enable or disable cvcs according to 0/1 flags\n\
|
||||
colvar <name> get <f> -- get the value of the colvar feature <f>\n\
|
||||
colvar <name> set <f> <val> -- set the value of the colvar feature <f>\n\
|
||||
\n\
|
||||
Accessing biases:\n\
|
||||
bias <name> energy -- return the current energy of bias <name>\n\
|
||||
bias <name> update -- recalculate bias <name>\n\
|
||||
bias <name> delete -- delete bias <name>\n\
|
||||
bias <name> getconfig -- return config string of bias <name>\n";
|
||||
bias <name> getconfig -- return config string of bias <name>\n\
|
||||
bias <name> get <f> -- get the value of the bias feature <f>\n\
|
||||
bias <name> set <f> <val> -- set the value of the bias feature <f>\n\
|
||||
";
|
||||
|
||||
return buf;
|
||||
}
|
||||
|
||||
@ -51,6 +51,10 @@ private:
|
||||
/// Run subcommands on bias
|
||||
int proc_bias(int argc, char const *argv[]);
|
||||
|
||||
/// Run subcommands on base colvardeps object (colvar, bias, ...)
|
||||
int proc_features(colvardeps *obj,
|
||||
int argc, char const *argv[]);
|
||||
|
||||
/// Builds and return a short help
|
||||
std::string help_string(void);
|
||||
};
|
||||
|
||||
93
python/examples/matplotlib_plot.py
Executable file
93
python/examples/matplotlib_plot.py
Executable file
@ -0,0 +1,93 @@
|
||||
#!/usr/bin/env python -i
|
||||
# preceding line should have path for Python on your machine
|
||||
|
||||
# matplotlib_plot.py
|
||||
# Purpose: plot Temp of running LAMMPS simulation via matplotlib
|
||||
# Syntax: plot.py in.lammps Nfreq Nsteps compute-ID
|
||||
# in.lammps = LAMMPS input script
|
||||
# Nfreq = plot data point every this many steps
|
||||
# Nsteps = run for this many steps
|
||||
# compute-ID = ID of compute that calculates temperature
|
||||
# (or any other scalar quantity)
|
||||
|
||||
from __future__ import print_function
|
||||
import sys
|
||||
sys.path.append("./pizza")
|
||||
import matplotlib
|
||||
matplotlib.use('tkagg')
|
||||
import matplotlib.pyplot as plt
|
||||
|
||||
# parse command line
|
||||
|
||||
argv = sys.argv
|
||||
if len(argv) != 5:
|
||||
print("Syntax: plot.py in.lammps Nfreq Nsteps compute-ID")
|
||||
sys.exit()
|
||||
|
||||
infile = sys.argv[1]
|
||||
nfreq = int(sys.argv[2])
|
||||
nsteps = int(sys.argv[3])
|
||||
compute = sys.argv[4]
|
||||
|
||||
me = 0
|
||||
# uncomment if running in parallel via Pypar
|
||||
#import pypar
|
||||
#me = pypar.rank()
|
||||
#nprocs = pypar.size()
|
||||
|
||||
from lammps import lammps
|
||||
lmp = lammps()
|
||||
|
||||
# run infile all at once
|
||||
# assumed to have no run command in it
|
||||
|
||||
lmp.file(infile)
|
||||
lmp.command("thermo %d" % nfreq)
|
||||
|
||||
# initial 0-step run to generate initial 1-point plot
|
||||
|
||||
lmp.command("run 0 pre yes post no")
|
||||
value = lmp.extract_compute(compute,0,0)
|
||||
ntimestep = 0
|
||||
xaxis = [ntimestep]
|
||||
yaxis = [value]
|
||||
|
||||
# create matplotlib plot
|
||||
# just proc 0 handles plotting
|
||||
|
||||
if me == 0:
|
||||
fig = plt.figure()
|
||||
line, = plt.plot(xaxis, yaxis)
|
||||
plt.xlim([0, nsteps])
|
||||
plt.title(compute)
|
||||
plt.xlabel("Timestep")
|
||||
plt.ylabel("Temperature")
|
||||
plt.show(block=False)
|
||||
|
||||
# run nfreq steps at a time w/out pre/post, query compute, refresh plot
|
||||
import time
|
||||
|
||||
while ntimestep < nsteps:
|
||||
lmp.command("run %d pre no post no" % nfreq)
|
||||
ntimestep += nfreq
|
||||
value = lmp.extract_compute(compute,0,0)
|
||||
xaxis.append(ntimestep)
|
||||
yaxis.append(value)
|
||||
if me == 0:
|
||||
line.set_xdata(xaxis)
|
||||
line.set_ydata(yaxis)
|
||||
ax = plt.gca()
|
||||
ax.relim()
|
||||
ax.autoscale_view(True, True, True)
|
||||
fig.canvas.draw()
|
||||
|
||||
lmp.command("run 0 pre no post yes")
|
||||
|
||||
# uncomment if running in parallel via Pypar
|
||||
#print("Proc %d out of %d procs has" % (me,nprocs), lmp)
|
||||
#pypar.finalize()
|
||||
|
||||
if sys.version_info[0] == 3:
|
||||
input("Press Enter to exit...")
|
||||
else:
|
||||
raw_input("Press Enter to exit...")
|
||||
@ -146,6 +146,8 @@ d.extra(data) extract bond/tri/line list from data
|
||||
# History
|
||||
# 8/05, Steve Plimpton (SNL): original version
|
||||
# 12/09, David Hart (SNL): allow use of NumPy or Numeric
|
||||
# 03/17, Richard Berger (Temple U): improve Python 3 compatibility,
|
||||
# simplify read_snapshot by using reshape
|
||||
|
||||
# ToDo list
|
||||
# try to optimize this line in read_snap: words += f.readline().split()
|
||||
@ -224,7 +226,7 @@ class dump:
|
||||
self.flist = []
|
||||
for word in words: self.flist += glob.glob(word)
|
||||
if len(self.flist) == 0 and len(list) == 1:
|
||||
raise StandardError("no dump file specified")
|
||||
raise Exception("no dump file specified")
|
||||
|
||||
if len(list) == 1:
|
||||
self.increment = 0
|
||||
@ -299,7 +301,7 @@ class dump:
|
||||
|
||||
def next(self):
|
||||
|
||||
if not self.increment: raise StandardError("cannot read incrementally")
|
||||
if not self.increment: raise Exception("cannot read incrementally")
|
||||
|
||||
# read next snapshot in current file using eof as pointer
|
||||
# if fail, try next file
|
||||
@ -344,13 +346,13 @@ class dump:
|
||||
try:
|
||||
snap = Snap()
|
||||
item = f.readline()
|
||||
snap.time = int(f.readline().split()[0]) # just grab 1st field
|
||||
snap.time = int(f.readline().decode().split()[0]) # just grab 1st field
|
||||
item = f.readline()
|
||||
snap.natoms = int(f.readline())
|
||||
snap.natoms = int(f.readline().decode())
|
||||
|
||||
snap.aselect = np.zeros(snap.natoms)
|
||||
|
||||
item = f.readline()
|
||||
item = f.readline().decode()
|
||||
words = f.readline().split()
|
||||
snap.xlo,snap.xhi = float(words[0]),float(words[1])
|
||||
words = f.readline().split()
|
||||
@ -358,7 +360,7 @@ class dump:
|
||||
words = f.readline().split()
|
||||
snap.zlo,snap.zhi = float(words[0]),float(words[1])
|
||||
|
||||
item = f.readline()
|
||||
item = f.readline().decode()
|
||||
if len(self.names) == 0:
|
||||
words = item.split()[2:]
|
||||
if len(words):
|
||||
@ -372,24 +374,22 @@ class dump:
|
||||
else: self.names[words[i]] = i
|
||||
|
||||
if snap.natoms:
|
||||
words = f.readline().split()
|
||||
words = f.readline().decode().split()
|
||||
ncol = len(words)
|
||||
for i in range(1,snap.natoms):
|
||||
words += f.readline().split()
|
||||
words += f.readline().decode().split()
|
||||
floats = map(float,words)
|
||||
if oldnumeric: atoms = np.zeros((snap.natoms,ncol),np.Float)
|
||||
else: atoms = np.zeros((snap.natoms,ncol),np.float)
|
||||
start = 0
|
||||
stop = ncol
|
||||
for i in range(snap.natoms):
|
||||
atoms[i] = floats[start:stop]
|
||||
start = stop
|
||||
stop += ncol
|
||||
else: atoms = None
|
||||
snap.atoms = atoms
|
||||
if oldnumeric:
|
||||
atom_data = np.array(list(floats),np.Float)
|
||||
else:
|
||||
atom_data = np.array(list(floats),np.float)
|
||||
|
||||
snap.atoms = atom_data.reshape((snap.natoms, ncol))
|
||||
else:
|
||||
snap.atoms = None
|
||||
return snap
|
||||
except:
|
||||
return 0
|
||||
return None
|
||||
|
||||
# --------------------------------------------------------------------
|
||||
# decide if snapshot i is scaled/unscaled from coords of first and last atom
|
||||
@ -417,7 +417,7 @@ class dump:
|
||||
|
||||
def map(self,*pairs):
|
||||
if len(pairs) % 2 != 0:
|
||||
raise StandardError("dump map() requires pairs of mappings")
|
||||
raise Exception("dump map() requires pairs of mappings")
|
||||
for i in range(0,len(pairs),2):
|
||||
j = i + 1
|
||||
self.names[pairs[j]] = pairs[i]-1
|
||||
@ -734,7 +734,7 @@ class dump:
|
||||
for snap in self.snaps:
|
||||
if not snap.tselect: continue
|
||||
if snap.nselect != len(vec):
|
||||
raise StandardError("vec length does not match # of selected atoms")
|
||||
raise Exception("vec length does not match # of selected atoms")
|
||||
atoms = snap.atoms
|
||||
m = 0
|
||||
for i in range(snap.natoms):
|
||||
@ -800,7 +800,7 @@ class dump:
|
||||
|
||||
def atom(self,n,*list):
|
||||
if len(list) == 0:
|
||||
raise StandardError("no columns specified")
|
||||
raise Exception("no columns specified")
|
||||
columns = []
|
||||
values = []
|
||||
for name in list:
|
||||
@ -816,7 +816,7 @@ class dump:
|
||||
for i in range(snap.natoms):
|
||||
if atoms[i][id] == n: break
|
||||
if atoms[i][id] != n:
|
||||
raise StandardError("could not find atom ID in snapshot")
|
||||
raise Exception("could not find atom ID in snapshot")
|
||||
for j in range(ncol):
|
||||
values[j][m] = atoms[i][columns[j]]
|
||||
m += 1
|
||||
@ -831,7 +831,7 @@ class dump:
|
||||
snap = self.snaps[self.findtime(n)]
|
||||
|
||||
if len(list) == 0:
|
||||
raise StandardError("no columns specified")
|
||||
raise Exception("no columns specified")
|
||||
columns = []
|
||||
values = []
|
||||
for name in list:
|
||||
@ -957,9 +957,9 @@ class dump:
|
||||
# --------------------------------------------------------------------
|
||||
|
||||
def findtime(self,n):
|
||||
for i in range(self.nsnaps):
|
||||
if self.snaps[i].time == n: return i
|
||||
raise StandardError("no step %d exists" % n)
|
||||
for i, snap in enumerate(self.snaps):
|
||||
if snap.time == n: return i
|
||||
raise Exception("no step %d exists" % n)
|
||||
|
||||
# --------------------------------------------------------------------
|
||||
# return maximum box size across all selected snapshots
|
||||
@ -1008,7 +1008,7 @@ class dump:
|
||||
nbonds = int(f.readline())
|
||||
item = f.readline()
|
||||
if not re.search("BONDS",item):
|
||||
raise StandardError("could not read bonds from dump file")
|
||||
raise Exception("could not read bonds from dump file")
|
||||
|
||||
words = f.readline().split()
|
||||
ncol = len(words)
|
||||
@ -1031,7 +1031,7 @@ class dump:
|
||||
self.bondflag = 1
|
||||
self.bondlist = bondlist
|
||||
except:
|
||||
raise StandardError("could not read from bond dump file")
|
||||
raise Exception("could not read from bond dump file")
|
||||
|
||||
# request bonds from data object
|
||||
|
||||
@ -1047,7 +1047,7 @@ class dump:
|
||||
self.bondflag = 1
|
||||
self.bondlist = bondlist
|
||||
except:
|
||||
raise StandardError("could not extract bonds from data object")
|
||||
raise Exception("could not extract bonds from data object")
|
||||
|
||||
# request tris/lines from cdata object
|
||||
|
||||
@ -1061,7 +1061,7 @@ class dump:
|
||||
self.lineflag = 1
|
||||
self.linelist = lines
|
||||
except:
|
||||
raise StandardError("could not extract tris/lines from cdata object")
|
||||
raise Exception("could not extract tris/lines from cdata object")
|
||||
|
||||
# request tris from mdump object
|
||||
|
||||
@ -1070,10 +1070,10 @@ class dump:
|
||||
self.triflag = 2
|
||||
self.triobj = arg
|
||||
except:
|
||||
raise StandardError("could not extract tris from mdump object")
|
||||
raise Exception("could not extract tris from mdump object")
|
||||
|
||||
else:
|
||||
raise StandardError("unrecognized argument to dump.extra()")
|
||||
raise Exception("unrecognized argument to dump.extra()")
|
||||
|
||||
# --------------------------------------------------------------------
|
||||
|
||||
|
||||
@ -638,7 +638,7 @@ class gl:
|
||||
fraction*(self.scale_stop - self.scale_start)
|
||||
self.viewupright()
|
||||
|
||||
if n == nstart or self.panflag: self.center = compute_center(box)
|
||||
if n == nstart or self.panflag: self.center = compute_center(box)
|
||||
|
||||
if bonds: self.bonds_augment(bonds)
|
||||
|
||||
|
||||
@ -54,6 +54,7 @@ index,time,flag = p.iterator(1)
|
||||
|
||||
# History
|
||||
# 8/05, Steve Plimpton (SNL): original version
|
||||
# 3/17, Richard Berger (Temple U): improve Python 3 compatibility
|
||||
|
||||
# ToDo list
|
||||
# for generic PDB file (no template) from a LJ unit system,
|
||||
@ -68,6 +69,12 @@ index,time,flag = p.iterator(1)
|
||||
# Imports and external programs
|
||||
|
||||
import sys, types, glob, urllib
|
||||
PY3 = sys.version_info[0] == 3
|
||||
|
||||
if PY3:
|
||||
string_types = str,
|
||||
else:
|
||||
string_types = basestring
|
||||
|
||||
# Class definition
|
||||
|
||||
@ -77,7 +84,7 @@ class pdbfile:
|
||||
|
||||
def __init__(self,*args):
|
||||
if len(args) == 1:
|
||||
if type(args[0]) is types.StringType:
|
||||
if type(args[0]) is string_types:
|
||||
filestr = args[0]
|
||||
self.data = None
|
||||
else:
|
||||
|
||||
@ -42,7 +42,7 @@ lmp = lammps()
|
||||
|
||||
lmp.file(infile)
|
||||
lmp.command("thermo %d" % nfreq)
|
||||
lmp.command("dump python all cfg %d tmp.cfg.* id type xs ys zs" % nfreq)
|
||||
lmp.command("dump python all cfg %d tmp.cfg.* mass type xs ys zs id" % nfreq)
|
||||
|
||||
# initial 0-step run to generate dump file and image
|
||||
|
||||
|
||||
@ -73,7 +73,7 @@ lmp = lammps()
|
||||
|
||||
lmp.file(infile)
|
||||
lmp.command("thermo %d" % nfreq)
|
||||
lmp.command("dump python all cfg %d tmp.cfg.* id type xs ys zs" % nfreq)
|
||||
lmp.command("dump python all cfg %d tmp.cfg.* mass type xs ys zs id" % nfreq)
|
||||
|
||||
# initial 0-step run to generate initial 1-point plot, dump file, and image
|
||||
|
||||
|
||||
@ -190,12 +190,15 @@ class lammps(object):
|
||||
# send a list of commands
|
||||
|
||||
def commands_list(self,cmdlist):
|
||||
args = (c_char_p * len(cmdlist))(*cmdlist)
|
||||
cmds = [x.encode() for x in cmdlist if type(x) is str]
|
||||
args = (c_char_p * len(cmdlist))(*cmds)
|
||||
self.lib.lammps_commands_list(self.lmp,len(cmdlist),args)
|
||||
|
||||
# send a string of commands
|
||||
|
||||
def commands_string(self,multicmd):
|
||||
if type(multicmd) is str:
|
||||
multicmd = multicmd.encode()
|
||||
self.lib.lammps_commands_string(self.lmp,c_char_p(multicmd))
|
||||
|
||||
# extract global info
|
||||
@ -359,19 +362,27 @@ class lammps(object):
|
||||
# e.g. for Python list or NumPy, etc
|
||||
# ditto for gather_atoms() above
|
||||
|
||||
def create_atoms(self,n,id,type,x,v):
|
||||
def create_atoms(self,n,id,type,x,v,image=None,shrinkexceed=False):
|
||||
if id:
|
||||
id_lmp = (c_int * n)()
|
||||
id_lmp[:] = id
|
||||
else: id_lmp = id
|
||||
else:
|
||||
id_lmp = id
|
||||
|
||||
if image:
|
||||
image_lmp = (c_int * n)()
|
||||
image_lmp[:] = image
|
||||
else:
|
||||
image_lmp = image
|
||||
|
||||
type_lmp = (c_int * n)()
|
||||
type_lmp[:] = type
|
||||
self.lib.lammps_create_atoms(self.lmp,n,id_lmp,type_lmp,x,v)
|
||||
self.lib.lammps_create_atoms(self.lmp,n,id_lmp,type_lmp,x,v,image_lmp,shrinkexceed)
|
||||
|
||||
|
||||
# document this?
|
||||
|
||||
@property
|
||||
def uses_exceptions(self):
|
||||
""" Return whether the LAMMPS shared library was compiled with C++ exceptions handling enabled """
|
||||
try:
|
||||
if self.lib.lammps_has_error:
|
||||
return True
|
||||
|
||||
4
src/.gitignore
vendored
4
src/.gitignore
vendored
@ -328,6 +328,8 @@
|
||||
/fix_eos_table.h
|
||||
/fix_evaporate.cpp
|
||||
/fix_evaporate.h
|
||||
/fix_filter_corotate.cpp
|
||||
/fix_filter_corotate.h
|
||||
/fix_viscosity.cpp
|
||||
/fix_viscosity.h
|
||||
/fix_ehex.cpp
|
||||
@ -653,6 +655,8 @@
|
||||
/pair_hbond_dreiding_lj.h
|
||||
/pair_hbond_dreiding_morse.cpp
|
||||
/pair_hbond_dreiding_morse.h
|
||||
/pair_kolmogorov_crespi_z.cpp
|
||||
/pair_kolmogorov_crespi_z.h
|
||||
/pair_lcbop.cpp
|
||||
/pair_lcbop.h
|
||||
/pair_line_lj.cpp
|
||||
|
||||
@ -64,7 +64,7 @@ void AngleCharmmKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -64,7 +64,7 @@ void AngleClass2Kokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -64,7 +64,7 @@ void AngleHarmonicKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -60,7 +60,7 @@ void BondClass2Kokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -69,7 +69,7 @@ void BondFENEKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -61,7 +61,7 @@ void BondHarmonicKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -93,6 +93,9 @@ CommKokkos::~CommKokkos()
|
||||
|
||||
void CommKokkos::init()
|
||||
{
|
||||
maxsend = BUFMIN;
|
||||
maxrecv = BUFMIN;
|
||||
|
||||
grow_send_kokkos(maxsend+bufextra,0,Host);
|
||||
grow_recv_kokkos(maxrecv,Host);
|
||||
|
||||
|
||||
@ -69,7 +69,7 @@ void DihedralCharmmKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = 0;
|
||||
|
||||
// insure pair->ev_tally() will use 1-4 virial contribution
|
||||
|
||||
@ -69,7 +69,7 @@ void DihedralClass2Kokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -69,7 +69,7 @@ void DihedralOPLSKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -82,7 +82,7 @@ void FixQEqReaxKokkos<DeviceType>::init()
|
||||
|
||||
FixQEqReax::init();
|
||||
|
||||
neighflag = lmp->kokkos->neighflag;
|
||||
neighflag = lmp->kokkos->neighflag_qeq;
|
||||
int irequest = neighbor->nrequest - 1;
|
||||
|
||||
neighbor->requests[irequest]->
|
||||
|
||||
@ -71,7 +71,7 @@ void ImproperClass2Kokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -71,7 +71,7 @@ void ImproperHarmonicKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
eflag = eflag_in;
|
||||
vflag = vflag_in;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -119,6 +119,8 @@ KokkosLMP::KokkosLMP(LAMMPS *lmp, int narg, char **arg) : Pointers(lmp)
|
||||
// default settings for package kokkos command
|
||||
|
||||
neighflag = FULL;
|
||||
neighflag_qeq = FULL;
|
||||
neighflag_qeq_set = 0;
|
||||
exchange_comm_classic = 0;
|
||||
forward_comm_classic = 0;
|
||||
exchange_comm_on_host = 0;
|
||||
@ -152,6 +154,8 @@ void KokkosLMP::accelerator(int narg, char **arg)
|
||||
// defaults
|
||||
|
||||
neighflag = FULL;
|
||||
neighflag_qeq = FULL;
|
||||
neighflag_qeq_set = 0;
|
||||
int newtonflag = 0;
|
||||
double binsize = 0.0;
|
||||
exchange_comm_classic = forward_comm_classic = 0;
|
||||
@ -169,6 +173,19 @@ void KokkosLMP::accelerator(int narg, char **arg)
|
||||
neighflag = HALF;
|
||||
} else if (strcmp(arg[iarg+1],"n2") == 0) neighflag = N2;
|
||||
else error->all(FLERR,"Illegal package kokkos command");
|
||||
if (!neighflag_qeq_set) neighflag_qeq = neighflag;
|
||||
iarg += 2;
|
||||
} else if (strcmp(arg[iarg],"neigh/qeq") == 0) {
|
||||
if (iarg+2 > narg) error->all(FLERR,"Illegal package kokkos command");
|
||||
if (strcmp(arg[iarg+1],"full") == 0) neighflag_qeq = FULL;
|
||||
else if (strcmp(arg[iarg+1],"half") == 0) {
|
||||
if (num_threads > 1 || ngpu > 0)
|
||||
neighflag_qeq = HALFTHREAD;
|
||||
else
|
||||
neighflag_qeq = HALF;
|
||||
} else if (strcmp(arg[iarg+1],"n2") == 0) neighflag_qeq = N2;
|
||||
else error->all(FLERR,"Illegal package kokkos command");
|
||||
neighflag_qeq_set = 1;
|
||||
iarg += 2;
|
||||
} else if (strcmp(arg[iarg],"binsize") == 0) {
|
||||
if (iarg+2 > narg) error->all(FLERR,"Illegal package kokkos command");
|
||||
|
||||
@ -23,6 +23,8 @@ class KokkosLMP : protected Pointers {
|
||||
public:
|
||||
int kokkos_exists;
|
||||
int neighflag;
|
||||
int neighflag_qeq;
|
||||
int neighflag_qeq_set;
|
||||
int exchange_comm_classic;
|
||||
int forward_comm_classic;
|
||||
int exchange_comm_on_host;
|
||||
|
||||
@ -92,7 +92,7 @@ void PairBuckCoulCutKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -111,7 +111,7 @@ void PairBuckCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -81,7 +81,7 @@ void PairBuckKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -80,7 +80,7 @@ void PairCoulCutKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -87,7 +87,7 @@ void PairCoulDebyeKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -80,7 +80,7 @@ void PairCoulDSFKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -104,7 +104,7 @@ void PairCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -75,7 +75,7 @@ void PairCoulWolfKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -74,7 +74,7 @@ void PairEAMAlloyKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -74,7 +74,7 @@ void PairEAMFSKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -69,7 +69,7 @@ void PairEAMKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -112,7 +112,7 @@ void PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::compute(int eflag_in, int
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -112,7 +112,7 @@ void PairLJCharmmCoulCharmmKokkos<DeviceType>::compute(int eflag_in, int vflag_i
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -112,7 +112,7 @@ void PairLJCharmmCoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -89,7 +89,7 @@ void PairLJClass2CoulCutKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -97,7 +97,7 @@ void PairLJClass2CoulLongKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -89,7 +89,7 @@ void PairLJClass2Kokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
@ -89,7 +89,7 @@ void PairLJCutCoulCutKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
|
||||
|
||||
if (neighflag == FULL) no_virial_fdotr_compute = 1;
|
||||
|
||||
if (eflag || vflag) ev_setup(eflag,vflag);
|
||||
if (eflag || vflag) ev_setup(eflag,vflag,0);
|
||||
else evflag = vflag_fdotr = 0;
|
||||
|
||||
// reallocate per-atom arrays if necessary
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user