during a NVE simulation at each timestep one can map the configuration
of a system on a configuration of local potential energy minimum (by
using a minimization algorithm).
Starting from a given state, I would like to run a simulation and
pinpoint the instant when the system configuration maps to a new local
minimum, and dump the configurations corresponding to the starting and
the new local minima.
What I do so far is (in pseudocode) looping for a given number of steps
fix nve
run 1
write_restart finite_T
minimize
dump minimum.xyz
clear
read_restart finite_T
fix nve
run 1
minimize
dump minimum2.xyz
...
and then inspect all the .xyz files to check whether a transition has occurred.
The disadvantage is that I dump a lot of unnecessary *.xyz files, and
post-process them in order to pick the two files:
minimumN.xyz and minimum(N+1).xyz
which are two consecutive (energy minimized) configurations with the
two distinct minima that I'm interested in.
I tried to have a look at prd, but couldn't make it work for this
purpose so far. I also thought of using a compute to detect the
transition, but the problem is that I'm clearing the simulation after
minimization and then resuming the NVE run, thus losing info about the
old minimum configuration.
Has anyone a suggestion about how to do all of the above in a more clever way?
You can look at the compute event/displace command.
It is used by PRD and TAD to detect when 2 minimized
states have an atom(s) in a different position by greater
than a threshhold distance.
during a NVE simulation at each timestep one can map the configuration
of a system on a configuration of local potential energy minimum (by
using a minimization algorithm).
Starting from a given state, I would like to run a simulation and
pinpoint the instant when the system configuration maps to a new local
minimum, and dump the configurations corresponding to the starting and
the new local minima.
What I do so far is (in pseudocode) looping for a given number of steps
fix nve
run 1
write_restart finite_T
minimize
dump minimum.xyz
clear
read_restart finite_T
fix nve
run 1
minimize
dump minimum2.xyz
...
and then inspect all the .xyz files to check whether a transition has occurred.
The disadvantage is that I dump a lot of unnecessary *.xyz files, and
post-process them in order to pick the two files:
minimumN.xyz and minimum(N+1).xyz
which are two consecutive (energy minimized) configurations with the
two distinct minima that I'm interested in.
this looks hugely inefficient to me.
what keeps you from simply running an nve
trajectory, record positions at regular intervals,
calculate minimizations for each after the fact
(e.g. convert the frames into a sequence of
data files) and then run NEB calculations to
map out the potential landscape.
there is one major problem with your infinitesimal
approach (apart from the huge computational overhead):
the potential hypersurface becomes more rugged, the
closer your look, so what do you expect to learn from
such an arbitrarily detailed surface. effectively all "small"
(vs. kT) barriers are irrelevant under normal circumstances.
Still, I haven't understood how to use event/displace correctly in my case.
I would indeed like to detect if two configuration stemming from
energy minimizations starting from two consecutive nve steps do differ
(as prd and tad do).
But how to do so in a script without touching the source code?
The problem is that my first reference state would be the minimized
configuration, which I obtain by a minimize command. Then I'd like to
resume NVE dynamics _starting from the non-minimized trajectory_ run
it for a single step and by minimizing obtaining my second reference
state. And this I don't know how to do without dumping a restart file
of the non-minimized configuration, minimizing, clearing and
read_restarting. The clear operation would make me lose the
event/displace compute, so it looks like I can't use it. I don't know
if this makes sense to you.
Axel,
thanks for your suggestion. I think the only problem would be that I
wouldn't be able to say whether multiple transitions have occurred
during a given interval separating two samples, and I guess that NEB
wouldn't tell me. So if I detected a transition between two samples I
would need some bracketing procedure to see whether my system has
experienced multiple basin transitions or not.
I haven't thought about the fact that my potential energy surface
could be rugged at no matter what scale. I'd be glad if you could
suggest me some literature about this!
Suleiman,
I'm giving tad a try but I wonder whether i can use it to measure
arrival minima after transition in constant energy (NVE) trajectories
(I'd say no, but I might be wrong). Plus, the neb calculation looks
like overhead to me, as I'm interested only in the initial and final
local minima configurations (hoping that this makes sense).
Axel,
thanks for your suggestion. I think the only problem would be that I
wouldn't be able to say whether multiple transitions have occurred
during a given interval separating two samples, and I guess that NEB
wouldn't tell me. So if I detected a transition between two samples I
would need some bracketing procedure to see whether my system has
experienced multiple basin transitions or not.
sure, but that still would be _much_ less of an overhead than
starting a minimization after _every_ MD step.
I haven't thought about the fact that my potential energy surface
could be rugged at no matter what scale. I'd be glad if you could
suggest me some literature about this!
this is just plain common sense. or to express it in the
words of my PhD adviser: the closer you look, the worse it gets.
i think you first have to decide, what kind of barrier do
call significant. second, you have to keep in mind that
in a many-dimensional hypersurface local minima are
hard to detect. fast minimizer algorithms may get stuck
at saddle points in one of the many dimensions.
since your problem is of such a principal nature, i think
it would be very helpful to first explain what it is that
you want to learn from your simulation. that would make
it much easier to suggest an appropriate method. there
is a whole zoo of tools available, but most of them have
strengths and weaknesses that depend on the nature
of the problem that you want to solve.
If what you are interested in is getting from basin to basin and determine the system configuration in each state, then I am wondering why you are so concern about how you get there (that is using NVE instead of NVT).
TAD use constant temperature MD (NVT mostly) and so you will have to specify a lower temperature that you desire. You may need to determine the minimum activation energy prefactor for the useful transitions that you are interested in looking at. Therefore, before embarking on using TAD, you may have to do some preliminary calculations with your potential to get a starting value for your prefactor.
Like Axel mentioned, you may need to state what exactly you are trying to get from this calculations in order to determine what method is best suited for your system.
Re: the portion of your message to me ...
What you are asking makes sense. I haven't
thought much about comparing two states
from a script (as opposed to using PRD or
TAD to do it). Maybe there is someway
we can make the compute event/displace
command a bit more general to allow this.