[ase-users] IDPP method slow or not working for large system

[Jens Jørgen Mortensen]

Den 17-03-2017 kl. 09:19 skrev Garold Murdachaew:
> Hi Jens,
>
> Thank you for your prompt response! I will try your suggestion of
> running IDPP on only the subsystem and adding the fixed atoms after.
> It does seem a bit awkward though. Is there any way to improve or
> speed up the IDPP, perhaps by using a rougher solution or replacing
> the default BFGS solver by a faster solver, thus reducing the time per
> step (I believe I saw a suggestion like this on some ASE-related
> webpage) ??

Maybe introduce a cutoff distance to reduce the number of pairs. You 
could also try to run the code through Pythons profile module so that 
you can better see where the time is used.

>   Are there options to set to do this in ASE / python ?

There is the "optimizer" argument to NEB.idpp_interpolate().  It 
defaults to MDMin.

Jens Jørgen

> Thanks again and best wishes,
> Garold Murdachaew
> Chemistry, Aalto University
>
>
> On Fri, Mar 17, 2017 at 8:50 AM, Jens Jørgen Mortensen
> <jensj at fysik.dtu.dk> wrote:
>>
>> On 03/16/2017 12:06 PM, Garold Murdachaew via ase-users wrote:
>>> Dear ASE experts,
>>>
>>> I have recently started using this package and have had a good
>>> experience so I would like to thank the developers and the community
>>> for their work.
>>
>> Thanks!
>>
>>> However, I have encountered one problem and hope that some expert can
>>> provide useful advice. I am trying to use the recommended IDPP method
>>> for creating initial images for NEB calculations. The LI method
>>> (linear interpolation) works without any problems. However, the IDPP
>>> method seems very slow, running for a few hours. The attached python
>>> script (see below) uses first LI and then sets some constraints and
>>> tries to use the IDPP.  As mentioned, the script seems to run without
>>> errors but the IDPP portion seems quite slow. Is there any way to make
>>> it faster?
>>
>> It scales like (number of images * number of atoms)^2, so that is quite bad
>> for a large system like yours!  The algorithm could perhaps be optimized and
>> it would be great if someone could do that.  You could also just use the
>> linear interpolation or just wait for the IDPP to finish (you only need to
>> do it once).
>>
>>> Note that my system contains about 350 atoms but the majority of the
>>> atoms are fixed/constrained prior to the IDPP calculation.
>>
>> You could also do the IDPP on the dynamic atoms only and then add the fixed
>> ones after.
>>
>> Jens Jørgen
>>
>>> Thank you in advance,
>>> Garold
>>>
>>>
>>> ------------------------------------------------------------------------------------------------------------------
>>>
>>> from __future__ import print_function
>>> from ase import io
>>> from ase.neb import NEB
>>> from ase.calculators.emt import EMT
>>> from ase.optimize.fire import FIRE as QuasiNewton
>>> from ase.constraints import FixAtoms
>>> #
>>> # Read files and set number of frames for the neb, etc.
>>> #
>>> images_total = 8
>>> images_between = images_total - 2
>>> A, B, C = 40.0, 40.0, 25.64
>>> initial = io.read('initial.xyz')
>>> final = io.read('final.xyz')
>>> #
>>> # Do the Linear Interpolation (li), without any constraints
>>> #
>>> images_li = [initial]
>>> for i in range(images_between):
>>>       images_li.append(initial.copy())
>>> images_li.append(final)
>>> for image in images_li:
>>>       image.set_calculator(EMT())
>>>       image.set_cell([[ A,  0.,  0.], [ 0.,  B,  0.], [ 0.,  0.,  C]])
>>>       image.set_pbc((True, True, True))
>>> #
>>> neb_li = NEB(images_li)
>>> neb_li.interpolate()
>>> cnt_li = QuasiNewton(neb_li, trajectory='path_li.traj',
>>> logfile='path_li.log')
>>> #cnt_li.run(fmax=0.05)
>>> cnt_li.run(fmax=1.0e6)
>>> io.write('path_li.xyz', images_li)
>>> #
>>> # Do the IDPP Interpolation (idpp), after first setting some constraints
>>> #
>>> del initial.constraints
>>> for atom in initial:
>>>       i = atom.index
>>>       j = i + 1
>>>       if ( (j >= 1 and j <= 113) or
>>>       (j >=116 and j <= 165) or
>>>       (j == 168) or
>>>       (j >=174 and j <= 219) or
>>>       (j >=225 and j <= 336) ):
>>>           atom.tag = 2
>>>           print("Constrained: j, atom.tag =  ", j, atom.tag)
>>>       else:
>>>           atom.tag = 1
>>>           print("Free: j, atom.tag =  ", j, atom.tag)
>>> constraint = FixAtoms(mask=[atom.tag > 1 for atom in initial])
>>> images_idpp = images_li[:]
>>> for image in images_idpp:
>>>       image.set_constraint(constraint)
>>> #
>>> neb_idpp = NEB(images_idpp)
>>> neb_idpp.interpolate('idpp')
>>> cnt_idpp = QuasiNewton(neb_idpp, trajectory='path_idpp.traj',
>>> logfile='path_idpp.log')
>>> #cnt_idpp.run(fmax=0.05)
>>> cnt_idpp.run(fmax=1.0e6)
>>> io.write('path_idpp.xyz', images_idpp)
>>>
>>>
>>> ------------------------------------------------------------------------------------------------------------------
>>> _______________________________________________
>>> ase-users mailing list
>>> ase-users at listserv.fysik.dtu.dk
>>> https://listserv.fysik.dtu.dk/mailman/listinfo/ase-users
>>