A new line search algorithm (adapted from Miller & Rodney)

Explanation of Specific Points:

1. Choosing initial alpha: We want to avoid moving more than dmax in the entire linesearch
   and we want to make sure that atleast 1 move is made. The initial alpha ensures two things: the first move (alpha_init*hmaxall) will not be greater than dmax & the first move is not too small (since alpha_init is either 1.0 or 0.5*dmax/hmaxall).
2. Allowing an energy increase smaller than 1e-12: First of all, a move that increases the energy (by 1e-12) is allowed iff the gradient condition is immediately satisfied, else that move is undone. Now a small energy increase is permitted because changes in energy below some small tolerance ( I chose 1e-12) is not significant because we are working in finite precision (the number of particles is ~1e4 and we have about 14 significant figures for the energy of individual particles). The choice of 1e-12 is therefore some bound on measurable energy change of the whole system (the specific choice is a LAMMPS default value).
3. Rubberbanding: Notice that the term F_(i)/{F_(i-1) - F_(i)} = 1/(relative change in directional derivative). When linesearch routine reaches this step it means: that we just made a move which decreased the energy and the directional derivative but the directional derivative wasn't sufficiently decreased, so we want to continue moving in the search direction. Rubberbanding says: linearize the directional derivative and solve the resulting linear equation for its zero, this gives the 'z'. The bound of 4.0 is put on the boost factor('z') to avoid making alpha too large, as that'd run the risk of attempting to step outside the allowed search space.
4. Backtracking: Here we do 2 things:- undo the move made in the current iteration and compute a new value of alpha (which must be smaller than the previous alpha). Decreasing alpha by a factor of 10 was a conservative choice made by me. The MR expressions for decreasing alpha were too complicated. We could also try to linearize force at this point or fit it to a parabola of the form: f = (alpha - a)^2 + b (a,b are the parameters) and choose the new step by solving for the zero of the force equation.
   

More on Using mesoScale probes

Figure 1: Atoms coloured according to the lowest vibrational eigenvalues of mesoscale regions of various radii (given by the 'size') centred at themselves. Note the sharp transition in pictures of size 6 & greater.

How I generated these plots:
For system 2X-triple I took a region of radius = 20.0, at each atom belonging to this region a mesoscale region (of radius indicated next to each picture) was centered.
For each mesoscale region I plotted the lowest vibrational eigenvalue on the atom which was its centre.
NOTE: the hessian is negative-definite so more negative eigenvalue means more stable.
Figure 2: Lowest eigenmodes of mesoscale regions of radius 8.0 with centers displaced parallel to the critical plane with respect to the center of the defect core. The sense of arrows is arbitrary.

Probing with mesoscale regions

1) Procedure: For system 2X-triple I took a region of radius = 8.0 and moved it perpendicular and parallel to the slip from the hottest atom. For each mesoscale region I plotted the modes and delta fields and computed the lowest eigenvalue. No mesoscale region hit the surface of the crystal.

2) The plot at the top shows the meso scale regions' lowest eigenvalues. The transition at around 5-6 in the trend of eigenvalues was most interesting. A transition in the qualitative nature of the corresponding eigenmode of the mesoscale happens at the same time, which is reflected in the delta field plots.

3) I made plots of the delta curves on the slip plane for each of these mesoscale regions too. They are consistent with the information from the full delta fields.

4) Issue of bulk eigenvalue -?

News At This Point: Transliteratin Fortran code

Spent the last week working on figures for Craig's proposal. The proposal is a good summary of work done to date, except it doesn't say anything about work on the minimizer.

Now I am starting work on transliterating Ron Miller's F77 program's linesearch to C++ such that it can be seamlessly used with LAMMPS.
The relevant file is: mod_solve.f and the subroutine is cgstep().

The central idea in Ron Millers linesearch:
1)In each linesearch try to achieve:
(i) abs(final gradient)/abs(init gradient) <= 0.1, OR
(ii) detect the point where the gradient just changes sign
NOTE: gradient here means directional derivative.

2) The energy is only used to avoid increasing the function value.

3) If this direction doesn't do well for us then request a new direction, many times reset CG by using the bare gradient as the search direction.

*** The minimizer section is not yet complete ***