# Mode Selective Analysis¶

Mode Scanning is an extension of the frequency scanning options that were part of ADF and BAND in earlier versions of the Amsterdam Modeling Suite. It is primarily used to identify spurious imaginary modes obtained from the normal modes calculation discussed earlier. Alternatively, you can use it to improve the numerical accuracy of the normal mode properties or to obtain approximations for these properties at higher levels of theory.

Both Mode Tracking and Mode Refinement can be used to obtain select vibrational modes without construction of the (full) Hessian. In the work-flow for both of these methods, we start with e.g. a semi-empirical method such as MOPAC to get an initial approximation of the normal modes, which are used to obtain accurate approximations of the normal modes on e.g. DFT-level. While the methods appear similar, it is important to stress their differences. Here, we give our recommendations on which methods you should use. (You can read up on the details of these methods on the respective pages.)

- Mode Scanning:
- Primarily used to identify spurious imaginary modes.
- Improve numerical accuracy of normal mode properties.

- Mode Tracking:
- Calculations are conducted for each mode separately. Converges fastest for characteristic (non-highly degenerate) modes.
- Iterative approximation to the true modes. Guaranteed to give the correct normal modes if the procedure converges.
- Will not necessarily reproduce the entire spectrum as multiple guess modes can converge to the same normal mode.

- Mode Refinement:
- Refinement of entire spectral regions, but requires a sufficient number of modes in the basis for sufficient accuracy.
- 1-step refinement. No iterative improvement possible. (Unless followed by a separate Mode Tracking calculation.)
- Quality of the results depends on accuracy of the selected guess modes.

Because the Mode Refinement method uses linear combinations of the guess modes, its accuracy depends on the set of modes that is supplied.

- If we want to e.g. obtain a mode which includes a C=O stretch, then the initial set must contain a mode which has this C=O stretch, otherwise this cannot be included in the refined modes.
- If we are refining a region containing many similar modes, e.g. vibrations of aromatic ring backbones, and we only use part of this spectral region for the initial set, the set of refined modes will “drift” towards the centre of the spectral region as a results of mode-mixing. This is again an artefact of missing character in the modes.
- This mode-mixing may result in reduced accuracy for some of the modes, as this procedure minimizes the total error for all of the modes. Instead of having a couple of modes with large errors, mode-mixing tends to spread out the error across multiple normal modes. Adding 1 “bad” mode to the basis can then negatively affect your results.

Mode Tracking on the other hand uses information about the known parts of the Hessian to expand its basis iteratively:

- Missing C-O stretch character can thus be recovered in this procedure, and there is no basis dependency.
- For large regions with similar modes however, it is possible that multiple guess modes converge to the same normal mode. Running mode tracking for all modes in this region might not reproduce all unique normal modes.

Which method to use thus primarily depends on the type and number of modes you are refining:

- The advantage of Mode Refinement is the ability to refine entire spectral regions at once. If we have a good basis, Mode Refinement can be less computationally expensive than Mode Tracking. If you want to refine larger sections of the spectrum, Mode Refinement is therefore recommended. If you only want to calculate a select few modes, use Mode Tracking to avoid basis dependence and to assure accuracy of the obtained modes.
- For characteristic peaks, Mode Tracking shows very good convergence, and will thus be cheaper to use than Mode Refinement. For (semi-)degenerate modes however, Mode Refinement works better due to the poor tracking performance for these modes.

## Mode Scanning¶

Mode Scanning can be used to obtain more accurate approximations for the
properties of the vibrational normal modes. Mode Scanning is an extension of the frequency scanning options (`ScanFreq`

) that were part of ADF and BAND in
earlier versions of the Amsterdam Modeling Suite. These latter options are still available as the `ScanModes`

keyword in the `NormalModes`

block, if these are requested during a calculation.

### Theory¶

Vibrational normal modes are usually obtained as eigenvectors of the Hessian matrix. A common problem with this scheme however, is that due to numerical errors in constructing this Hessian, low-frequency vibrations may be reported to have imaginary frequencies instead. The Mode Scanning task allows for re-calculation of the frequency of these modes. This allows you to confirm whether reported imaginary frequencies are attributed to transition states or whether they are simply due to numerical errors.

Given a user-supplied mode \(Q\), the frequency is calculated from the force constant:

This is again done by numerical differentiation of the energy gradients, requiring AMS to set up 2 single point calculations per selected normal mode. Integrated IR intensities are also calculated simultaneously (if dipole moments are supported by the engine):

Where the derivative is with respect to the mass-weighted normal mode.

It is also possible to use this method to selectively re-calculate the normal mode properties for different engine settings. This has two distinct uses:

- If the modes were originally generated using a finite difference method, a
different stepsize can be used. For strong vibrations (high frequencies),
large stepsizes may cause inaccuracies due to increasing anharmonic
contributions. For weak vibrations (low frequencies) on the other hand,
stepsizes can often be too small. The displacements associated with these
vibrations are small, which can give incorrect sampling of the PES profile.
This should be compensated for by choosing a larger stepsize. The stepsize
can be set using the
`Displacement`

key. - Users can also recalculate modes using higher levels of theory. Modes generated from a full frequency analysis using e.g. DFTB can be recalculated using e.g. LDA DFT to obtain more realistic integrated IR intensities. The method used for the single point calculations can be set in the Engine block.

### Input¶

A numerical frequency calculation is performed by requesting the
`VibrationalAnalysis`

task with `Type ModeScanning`

:

```
Task VibrationalAnalysis
VibrationalAnalysis
Type ModeScanning
Displacement 0.001
NormalModes
ModeFile adf.rkf
# select all modes with imaginary frequencies
ModeSelect
ImFreq true
End
End
End
```

The Mode Scanning tasks uses only the `NormalModes`

block for its input handling. Here, `ModeFile`

specifies the AMS output file containing the normal modes for which you want to calculate the frequencies. The `ModeSelect`

block is used to specify which of the modes in this file should be recalculated, since we are often only interested in a select few of them. A more detailed overview of this block is given in the section Selecting Modes on the main page. Finally, `Displacement`

can be used to specify the stepsize (in Bohr) for the finite differences. The stepsize is provided for displacements along the Cartesian normal modes.

The Mode Scanning module is the main driving force for the Mode Tracking and Vibrational Mode Refinement tasks,
which provide more advanced options for refining not only the properties of the
modes, but also the modes themselves. Consult the relevant pages for more
information. Alternatively, a simplified version of Mode Scanning is available
which follows the old implementation in ADF and BAND (as the `ScanFreq`

option).
This version can be enabled when doing a full frequency analysis by enabling the
`Properties%NormalModes`

keyword. See the
Full Analysis page for further details.

## Mode Refinement¶

The vibrational Mode Refinement method not only refines frequencies, but also tries to correct the vibrational modes themselves. If we start from e.g. a semi-empirical method such as in MOPAC, we can get approximations for the vibrational modes. Mode Refinement then re-calculates part of the Hessian for a subset of these modes using a more accurate method such as GGA DFT, and updates the normal modes themselves to fit this more accurate method. It is intended to circumvent the expensive calculation of the Hessian if you are only interested in a (small) part of the full spectrum. This is based on the method in reference [1].

See also

The GUI tutorial on Mode Refinement.

### Theory¶

We are going to start from a set of normal modes \(b\), obtained from e.g. a semi-empirical or force-field method. First, this task runs the numerical frequency calculation for all selected normal modes, but this time using an ab initio method such as DFT. During the finite difference steps, we also calculate the projection of the Hessian onto the normal modes:

This term is calculated through finite differences on the analytical gradients of the electronic energy along the mass-weighted normal modes \(b^m\). The index \(i\) denotes the \(3N\) nuclear coordinates. These projections are then used to construct a Rayleigh matrix:

Here, \(B^m\) and \(\Sigma\) are matrices containing the \(b^m\) and \(\sigma\) vectors. The eigenvectors of \(\tilde{H}^m\) give us the coefficient series for linear combinations of the normal modes \(b^m\) such that we obtain a new set of modes \(q\):

These modes \(q\) are the closest approximation to the DFT-modes that we could obtain from a linear combination of the approximate modes \(b\). In other words: the approximate modes \(b\) are used as a basis for finding the modes from a more sophisticated theory.

### Input¶

This method inherently features a trade-off:

- The computational benefit comes from only performing the finite difference calculations for the selected modes. By only selecting a small set of modes that we are interested in, we minimize computational expense.
- The more modes we select, the larger the basis for constructing the refined modes. Running for a larger number of modes yields better results. (In the extreme case, running for all 3N modes equates to constructing the full Hessian.)

In practice, Mode Refinement requires you to select a reasonable portion of the spectrum to get accurate results. Specifically, you should select all modes in a region of the spectrum which look similar. Ring structures for instance often feature broad frequency regions with many ring distortions. Even if you are only interested in a couple of these, you should still select all modes in this region, to assure sufficient basis size. Vibrational modes involving ring substituents can however be omitted, which is where we save computation time.

If you are interested only in IR-active vibrations, you could further minimize the basis by only selecting the approximate modes which are IR-active (since adding the non-active modes to the linear expansion does not affect the IR-intensity of the refined modes). Do note that if the semi-empirical method used for calculating the approximate modes yields poor approximations for the dipole gradients, it may be safer to include also modes with very low IR intensity. This is because their low IR-activity may have only been due to the low accuracy of the approximate method.

See also

A tutorial showing this basis representability.

A Mode Refinement calculation is set up by requesting the `VibrationalAnalysis`

task with the Type `ModeRefinement`

:

```
Task VibrationalAnalysis
VibrationalAnalysis
Type ModeRefinement
Displacement 0.001
NormalModes
ModeFile adf.rkf
ModeSelect
...
End
ScanModes true
End
End
```

The details of the calculation are specified in the `NormalModes`

block.
Here, `ModeFile`

specifies the AMS output file containing the normal modes
for which you want to calculate the frequencies. The `ModeSelect`

block is
used to specify which of the modes in this file will be selected for
refinement. A more detailed overview of this block is given in the section
Selecting modes on the main page. Finally,
`Displacement`

can be used to specify the stepsize (in Bohr) for the finite
differences. The stepsize is provided for displacements along the Cartesian
normal modes.

The `ScanModes`

key in the `NormalModes`

block can be used to
automatically run a numerical frequencies calculation on
the new modes \(q\). Mode Refinement uses a linear combination of modes and
properties, all obtained through finite differences. These results may still
contain some minor errors due to the accumulation of numerical errors from the
linear expansion, or stepsize issues in the numerical frequency calculations.
While commonly not necessary, it is possible to run an additional numerical
refinement calculation on the new modes to minimize these errors. Only in
exceptional cases will these errors be significant. Running this additional
refinement step is therefore only necessary if you need complete certainty that
the results are accurate.

## Mode Tracking¶

The Mode Tracking task is an interface for mode- and intensity-tracking methods, adapted from the MoViPac suite [2]- [3]. These methods can be used to obtain select normal modes, without having to calculate the entire vibrational spectrum. It does this through an iterative procedure.

Warning

There was a bug in the Mode Tracking implementation in early versions of AMS2019, leading to unreliable convergence. The problem has been fixed in the AMS2019.103 subrelease. We advise users not to run Mode Tracking calculations with the AMS2019.101 and AMS2019.102 subreleases.

Mode Tracking starts with a numerical frequency calculation, which refines the initial guess \(b^m\) for the selected mode. The error of this mode with respect to the true Hessian eigenvector is calculated. This error is used in a (Jacobi-)Davidson algorithm to generate an additional mode. In subsequent iterations, we use these modes as approximations to the true normal modes. In this way, the error of the mode is minimized iteratively, yielding a closer approximation to true normal modes. This is how Mode Tracking differs from the Mode Refinement methods, in that it guarantees that the obtained modes are correct (assuming the procedure has converged).

See also

The GUI tutorial on Mode Tracking.

### Theory¶

During the numerical frequency calculation, we obtain also the projection of the Hessian onto this mode:

This term is calculated through finite differences on the analytical gradients of the electronic energy along the mass-weighted normal modes \(q^m\). The index \(i\) denotes the \(3N\) nuclear coordinates. From this projection a Rayleigh matrix is generated:

Here, \(B^m\) and \(\Sigma\) are matrices containing the \(b^m\) and \(\sigma\) vectors for all foregoing iterations. During each iteration \(k\), if we have not converged, we generate an updated guess vector \(b_k^m\), and so the number of vectors in the matrices above is equal to the number of iterations \(k\). The eigenvectors of \(\tilde{H}^m\) give us the coefficient series for linear combinations of the guess modes \(b^m\) such that we obtain approximations for the true normal modes:

Each iteration, we expand the vector basis \(B^m\), which allows this series expansion to come closer to the true normal modes each time. We can also calculate the error of this mode with respect to how close it is to being an eigenvalue of the real Hessian:

Here, \(\lambda\) is the corresponding eigenvalue of \(\tilde{H}^m\). \(r\) is the residual vector, giving the error for each vector element. It should be zero if the mode is an exact eigenvector of the true Hessian.

Since \(\tilde{H}^m\) may give multiple eigenvectors, several approximate
modes will be generated during those iterations. Out of these, 1 mode is
identified as the mode of interest according to the specified tracking
method. If the residual of this mode has been minimized
sufficiently, the procedure has converged. If not, we generate a new guess
vector \(b_k^m\). There are 2 algorithms for generating this new guess, set
by `UpdateMethod`

in the `ModeTracking`

block:

#### Davidson method¶

The Davidson method uses a pre-conditioner \(D\) to generate a new guess mode from the residual vector of the mode selected by the tracking method:

This preconditioner is constructed from an approximation of the Hessian:

The Davidson method works reasonably well, but can have trouble converging if the approximate modes or the Hessian are too accurate. This results as the new vectors that are generated do not necessarily extend the span of the basis. [4]

#### vdVorst-Sleijpen-Jacobi-Davidson¶

This variant of the Jacobi-Davidson scheme from Sleijpen & vdVorst [4] automatically makes the new guess vector orthogonal to the normal mode selected by the tracking method:

The new vector is therefore guaranteed to extend the span of the basis as much as possible, and thus also eliminates the aforementioned issue with the Davidson method. In general, it is therefore recommended to use this Jacobi-Davidson method since it is found to converge faster, and be more reliable, as a result of yielding better guess modes.

### Input¶

```
Task VibrationalAnalysis
VibrationalAnalysis
Type ModeTracking
...
ModeTracking
HessianGuess [Unit | File | UFF | Inline]
HessianInline # Non-standard block. See details.
...
End
HessianPath string
UpdateMethod [JD | D | I]
MaxIterations integer
...
GramSchmidt [True | False]
GramSchmidtIterations integer
GramSchmidtTolerance float
End
End
```

There are 4 methods to obtain the approximate Hessian \(H_A\), used by both
update methods. They are set by `HessianGuess`

:

`HessianGuess [Unit | File | UFF | Inline]`

`UFF`

- is the default, which generates the approximate Hessian using UFF. While this Hessian may not yield the correct modes by itself, it produces good results as a preconditioner since it correctly represents the molecular structure.
`File`

- will read the Hessian from an AMS output file, which can be
specified in
`HessianPath`

. Using a Hessian from a more advanced method will generally yield better results for the Jacobi-Davidson method. The Davidson method will however experience difficulties with convergence as the Hessian becomes too accurate. [4] `Inline`

will read a Hessian specified in the input file, in the

`HessianInline`

block. This allows you to use Hessians generated in external programs:Task VibrationalAnalysis VibrationalAnalysis Type ModeTracking ModeTracking HessianGuess Inline # Approximate Hessian for H2O: 3 x nAtoms = 9 so 9x9 Hessian HessianInline 0.62088786 0.00000000 0.00000000 -0.31044393 0.00000000 -0.21902068 -0.31044393 0.00000000 0.21902068 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.32143213 -0.15284008 0.00000000 -0.16071607 0.15284008 0.00000000 -0.16071607 -0.31044393 0.00000000 -0.15284008 0.33598889 0.00000000 0.18593038 -0.02554496 0.00000000 -0.03309030 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 -0.21902068 0.00000000 -0.16071607 0.18593038 0.00000000 0.15761846 0.03309030 0.00000000 0.00309761 -0.31044393 0.00000000 0.15284008 -0.02554496 0.00000000 0.03309030 0.33598889 0.00000000 -0.18593038 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.00000000 0.21902068 0.00000000 -0.16071607 -0.03309030 0.00000000 0.00309761 -0.18593038 0.00000000 0.15761846 End End End

`Unit`

- uses the unit matrix. This is evidently not a good approximation for the Hessian, and is not intended to be used for proper Mode Tracking runs. However: using a poor approximation for the Hessian can result in basis vectors being generated that we would not obtain otherwise. Running Mode Tracking with this option can allow you to “probe” the vector space to obtain guesses for normal modes, which can be used as starting points for proper Mode Tracking calculations. It is however generally recommended to instead do e.g. a DFTB or UFF run if your goal is to obtain guess modes.

`UpdateMethod [JD | D | I]`

`JD`

- vdVorst-Sleijpen variant of Jacobi-Davidson (Mode tracking default).
`D`

- Davidson
`I`

- No preconditioner (VST default). This is not recommended for typical mode tracking applications, but is useful for a variation of mode tracking, Vibronic-Structure Tracking.

In later iterations, the basis \(B^m\) will become larger. In order to improve the guess modes even further, an iterative Gram-Schmidt procedure is used to orthogonalize the new guess mode to the existing basis. An iterative procedure is necessary to account for numerical noise.

`GramSchmidt [True | False]`

- Expert key. Sets whether to perform this Gram-Schmidt orthogonalization
step. It is
`True`

by default. `GramSchmidtTolerance float`

- Expert key. Sets the absolute tolerance for orthogonality of the basis. It is evaluated with respect to the norm of the overlap vector between the new guess mode and the basis of the previous iteration \(||{b_k^m}^T B^m||\).
`GramSchmidtIterations`

- Expert key. Sets the maximum number of allowed iterations during the Gram-Schmidt procedure.

The default settings for the Gram-Schmidt procedure should work for almost all systems.

`MaxIterations integer`

- Finally, the Mode Tracking input block contains the
`MaxIterations`

key. It sets the maximum allowed number of iterations that the Mode Tracking calculation may go through. If this number is reached, the calculation will stop even if convergence was not achieved. If no value is supplied, a default of \(3N/2\) will be used. This is approximately the maximum number of iterations where the procedure remains computationally competitive with the construction of the full Hessian.

#### Additional input parameters¶

```
Task VibrationalAnalysis
VibrationalAnalysis
Type ModeTracking
Displacement float
...
NormalModes
ScanModes [True | False]
...
End
End
```

`Displacement float`

- is the displacement stepsize (in Bohr) that is used for calculating frequencies, IR intensities and the Hessian projections through finite differences. The stepsize is provided for displacements along the Cartesian normal modes.
`ScanModes [True | False]`

- key (False by default) in the
`NormalModes`

vibrational analysis sub-block can be used to automatically run a numerical frequencies calculation on the new modes \(Q\) after the Mode Tracking calculation has finished. Ritz vectors are obtained here as linear combinations of the guess modes, which in turn follow from finite difference calculations. This makes it possible for numerical errors to accumulate in the normal modes. Only in exceptional cases will these errors be significant, and running this additional refinement step is therefore only necessary if you need complete certainty that the results are accurate.

### Input: Tracking methods¶

The `TrackingMethod`

parameter allows you to select what property of the
normal modes you want to track. At the end of each iteration, we obtain a set
of approximate normal modes. The tracking method identifies which of these
modes fits best for some criterion, and either returns this mode as the
calculation result, or, if convergence was not achieved, uses it to generating
a new basis mode for the next iteration. In general these methods are
distinguished in 3 categories:

```
Task VibrationalAnalysis
VibrationalAnalysis
Type ModeTracking
ModeTracking
TrackingMethod [OverlapInitial, DifferenceInitial, FreqInitial, IRInitial,
OverlapPrevious, DifferencePrevious, FreqPrevious, IRPrevious,
HighestFreq, HighestIR, LowestFreq, LowestResidual]
...
End
End
```

#### Mode Tracking¶

The original tracking methods focus on obtaining as accurate as possible a normal mode for the system. This class of tracking methods focuses either on accuracy of the mode, or obtaining modes with particular vibrational character:

`TrackingMethod [OverlapInitial, DifferenceInitial, FreqInitial, OverlapPrevious, DifferencePrevious, FreqPrevious, HighestFreq, LowestFreq, LowestResidual]`

`OverlapInitial`

- is the default tracking method. Here, we choose the mode which resembles most closely the guess mode that was initially supplied \(b_1^m\). This is done by choosing the mode which has the greatest overlap with the initial guess vector. This method allows us to direct the optimization towards modes that e.g. involve particular atoms or include particular bending/stretching vibrations.
`OverlapPrevious`

- instead chooses the mode which resembles closest the
approximate mode of the previous iteration \(Q_k^m\). This procedure
allows a bit more flexibility in the optimization. Since we essentially
“forget” about earlier iterations, this procedure allows the optimization to
correct errors in the initial guess. (It is possible for instance that the
initial guess included 2 different bond stretches which do not mutually occur
in the true modes. This method will then converge quicker to a mode involving
only 1 of these stretches, whereas
`OverlapInitial`

will take a much larger number of iterations to achieve this, if it does so at all.) Do note that this means that the final mode that you obtain does not necessarily represent the mode you initially supplied. `DifferenceInitial`

- works the same as
`OverlapInitial`

, except that it chooses the mode which has the smallest norm for the difference vector between the initial mode and the approximate normal modes of this iteration. The use of the difference vector prioritizes deviations in the dominant parts of the vibrational character. E.g. if a mode consists primarily of a CO stretch, plus some minor vibrations in a carbon backbone, it may be desired to prioritize getting the correct force constant for the dominant CO stretch. This is achieved using these difference vector methods. In general, overlap methods still work well in these situations, and the use of difference methods should only be necessary in extreme cases. `DifferencePrevious`

- is also the same as
`DifferenceInitial`

except for the use of the difference vector norm as the selection criterion. `FreqInitial`

- chooses the mode with the frequency closest to that of the initial guess. This allows us to direct the tracking towards modes in a particular frequency region of the spectrum. Note that convergence for these frequency-based methods is slightly slower since the character of the mode itself is not included in the selection criteria, allowing for larger differences in the modes between iterations.
`FreqPrevious`

- is similar to
`FreqInitial`

except that we choose the mode with the frequency closest to that of the previous iteration. This allows the optimization more freedom to move away from the frequency region of the initial guess, and thus allows to correct somewhat for poor initial guesses. `HighestFreq`

- chooses the mode with the highest frequency. This method can be used if it is desired to track particular characteristic high-frequency vibrations.
`LowestResidual`

- chooses the mode which has the smallest norm for the residual vector (see the ‘Convergence’ section below.) This method only focuses on obtain the most accurate mode, regardless of vibrational character or where it lies in the spectrum. This method should generally only be used as a pre-conditioner if you have very little information on what the normal modes should look like. (Since it is basically a non-directed optimization.) This method will then try and find the normal mode closest to your guess. The approximate normal mode obtained this way will most likely not have converged yet, but should give you an indication of what the normal modes may look like. You can use these modes to refine your initial guess, and then do a new Mode Tracking run using any of the other tracking parameters to obtain the desired mode. Although this strategy is possible, it is generally recommended to use an approximate method to get an initial guess for the normal modes instead (as shown in the examples).

#### Intensity Tracking¶

This class of methods focuses on tracking modes based on their intensity in e.g. the infrared spectrum, rather than focusing on getting a mode with a particular type of vibration.

`TrackingMethod [IRInitial, IRPrevious, HighestIR]`

`IRInitial`

chooses the mode with the IR intensity closest to that of the initial guess. This constrains the optimization to modes which are IR active, a property that may be lost when using mode tracking update methods.`IRPrevious`

similarly chooses the mode with the IR intensity closest to that of the previous iteration. This allows the method some more flexibility in varying the intensity of the vibration, and thus works better if the initial guess is not that good.`HighestIR`

chooses the mode with the highest IR intensity. This option can be used to find the modes associated with sharp peaks in the IR spectrum.

With Intensity Tracking, we essentially add an additional requirement to the modes: they must have a particular IR intensity. This constrained search has different convergence characteristics than conventional mode tracking, which you should take into account when setting up the mode tracking calculations.

- The majority of modes will have near-zero IR intensity. If we use a near-zero
IR intensity mode as our initial guess, and request
`IRIntitial`

or`IRPrevious`

, then we could be tracking any of one of these. Conversely, convergence behavior will be poor since the generated basis modes are essentially random. If you are trying to obtain a high IR-intensity mode, use an IR-susceptible mode.

Note

In our conventional work-flow, we recommend starting mode tracking or
refinement calculations from a set of approximate normal modes obtained from
a semi-empirical or force-field method. Note however, that these method often
do not produce accurate IR intensities. When selecting the initial guess
mode, do **not** use the `IRRange`

or related options in the `ModeSelect`

block. This will cause you to miss vibrations which were incorrectly labeled
with low IR intensity, or vice versa. Instead, rely on chemical intuition to
identify the modes which contain commonly IR active vibrational components
(such as C-O or N-H stretches). You can use ADFSpectra in the GUI to
visualize the vibrational modes, to help you in this process.

- To allow the intensity tracking procedure to converge faster, it is
recommended to use the
`IRPrevious`

tag instead of the`IRInitial`

tag. As discussed earlier, the former allows more flexibility in the optimization procedure, which counters the rigidity imposed by the intensity constraint. Intensity tracking methods often need this additional flexibility in generating guess modes to converge to the desired modes. **Poor Initial Guesses:**During each iteration, we still use the mode tracking methods to generate new basis modes. These basis modes try to expand the span of the basis with respect to the vibrational character of the modes. Note that this expansion does not guarantee that we will expand the basis specifically in the sub-span of IR-susceptible vibrations. If the initial guess for intensity tracking is correct, we already start our search in the sub-span vicinity of the normal modes. Basis expansion is then more efficient and there is a high chance that new guess modes sample the IR characteristic vibrations. For intensity tracking it is therefore discouraged to use poor initial guess modes.`HighestIR`

is considered a “pure” intensity tracking method, in that it is used specifically to target characteristics of the IR spectrum irrespective of the underlying vibrational character. Consequently, the normal mode character can vary a lot between iterations. In order to assure that the procedure converges to the desired modes, it is recommended to use sufficiently strict tolerances (see the Convergence section). If the tolerances are too lax, the program may consider the modes to be “good enough” based on residual minimization, even though there may be another mode with a higher IR intensity. For this reason it is generally recommended to use`ToleranceForNorm`

values 1 order of magnitude lower than the default, or around`0.00005`

.

#### Vibronic-Structure Tracking¶

The third and final Mode Tracking method is Vibronic-Structure Tracking. It
is a method that applies mode tracking to the
calculation of vibrationally resolved optical spectra. Vibronic-Structure Tracking
is implemented as a stand-alone application and uses `LargestDisplacement`

as
its tracking method. Details on how to use this method can be found on the Vibronic
Structure Tracking documentation page. Note that
the standard Mode Tracking sub-task does not support this tracking method.

### Input: Selecting modes¶

It is possible to track multiple modes in a single Mode Tracking calculation. The Mode Tracking task will then run the Mode Tracking algorithm for each mode in order.

The initial guess for the mode which will be tracked can be supplied in several
ways. This is governed by `ModeInputFormat`

:

```
Task VibrationalAnalysis
VibrationalAnalysis
Type ModeTracking
NormalModes
ModeInputFormat [File | Inline | Hessian]
ModeFile string
ModeInline # Non-standard block. See details.
...
End
ModeSelect
...
End
MassWeighInlineMode [True | False]
End
End
```

`ModeInputFormat [File | Inline | Hessian]`

`Inline`

will make the module read the mode from the input file. If this option is selected, you can supply the mode in the

`ModeInline`

block. It is possible to supply multiple modes by adding additional`ModeInline`

blocks. The modes are given with one line for the x,y,z-displacement per atom, and in the same order, as the`Atoms`

block in`System`

:ModeTracking TrackedMode Inline ModeInline 0.00000000 0.00000000 -0.03815965 -0.18888544 0.00000000 0.30281066 0.18888544 0.00000000 0.30281066 End ModeInline 0.00000000 0.00000000 -0.02243153 0.32132452 0.00000000 0.17800237 -0.32132452 0.00000000 0.17800237 End ... End

`File`

- will make the module read modes from an AMS or engine output file,
specified by
`ModePath`

. Modes generated using DFTB can be read from the`dftb.rkf`

file and optimised using Mode Tracking for example. When this option is selected, all the vibrational modes present in the file are read first. The`ModeSelect`

block then specifies for which of these modes you want to perform the Mode Tracking calculation. `Hessian`

- will generate modes as the eigenvectors of the approximate Hessian
selected for the preconditioner in
`HessianGuess`

. This also allows modes to be generated for Hessians obtained from external programs.`ModeSelect`

specifies which of the generated vibrational modes are selected for Mode Tracking.

- Settings for the
`ModeSelect`

block are discussed on the main page.

`MassWeighInlineMode [True | False]`

- decides whether the initial guess modes need to be
mass-weighted (default True). As discussed above, Mode Tracking uses mass-weighted normal
modes. In most cases, the normal modes are given in regular Cartesian
coordinates however. By setting
`MassWeighInlineMode true`

, these Cartesian modes are converted into mass-weighted modes by the program. If you supply a mass-weighted mode through the`ModeInline`

block however, you do not need the program to do the mass-weighing, and you should set`MassWeighInlineMode false`

.

### Input: Convergence¶

```
Task VibrationalAnalysis
VibrationalAnalysis
Type ModeTracking
ModeTracking
ToleranceForNorm float
ToleranceForResidual float
ToleranceForBasis float
End
End
```

In order to guide the Mode Tracking procedure, several convergence criteria are used:

`ToleranceForNorm float`

- is the absolute tolerance for convergence of the norm of
the residual vector. The residual vector is a vector containing the error for
each element of the normal mode, and we use the norm as a measure for the
total error. If the total error is smaller than this threshold, we consider
the mode to be a true normal mode and we stop iterating. Since the value of
this norm depends on the length of the residual vector hence the number of
atoms in the system, this tolerance is scaled internally to the number of
atoms.
`0.0005`

is used as a default value for which most systems will converge to reasonably accurate modes in not too many iterations. If you want a more accurate approximation, you can decrease this value by e.g. 1 order of magnitude. (Consider running using the default settings, and reading the norm at convergence from the logfile. The new norm can be chosen to be lower than this value to ‘force’ the method into another iteration.) `ToleranceForResidual float`

- is the absolute tolerance for the maximum component of the residual vector. Particularly in larger systems, where the vibration may be dominated by a small number of atoms, the error associated with the vibration of the majority of atoms may be small (the scaled residual norm will be small). The error for the atoms involved in the vibration may be comparatively large then, which is why we also check convergence for the maximum component of the error. Note that both the norm and this max. error are checked simultaneously. By varying strictness of the criteria for the norm and the max. error separately, you can prioritize either the total vibration or more localized character.
`ToleranceForBasis float`

- checks that the basis mode generated in the previous iteration, through the (Jacobi-)Davidson method, contributes to the approximate normal mode. Since the approximate mode is taken as a linear combination of the basis modes, its linear expansion coefficient must be larger than this tolerance.

The iterative procedure is stopped in one of two cases. Either both the residual
criteria are achieved, in which case the mode is deemed to be converged and
the program exits normally. Alternatively, the basis criterion is met in which
case a warning is broadcast indicating that the desired level of accuracy of the
mode may not have been reachd yet, but the basis has stopped expanding.
The default values for these parameters should be applicable for most
cases, but can be adjusted if needed. If stricter criteria are required, it is
recommended to adjust both `ToleranceForNorm`

and `ToleranceForResidual`

.

References

[1] | T.Q. Teodoro, M.A.J. Koenis, S.E. Galembeck, V.P. Nicu, W.J. Buma, L. Visscher, A frequency range selection method for vibrational spectra, J. Phys. Chem. Lett., 9 (23), 6878 (2018) |

[2] | T. Weymuth, M.P. Haag, K. Kiewisch, S. Luber, S. Schenk, C.R. Jacob, C. Herrmann, J. Neugebauer, M. Reiher, MoViPac: Vibrational Spectroscopy with a Robust Meta-Program for Massively Parallel Standard Inverse Calculations, Journal of Computational Chemistry 33, 2186 (2012) |

[3] | S. Luber, J.Neugebauer, M. Reiher, Intensity tracking for theoretical infrared spectroscopy of large molecules, Journal of Chemical Physics 130, 064105 (2009) |

[4] | (1, 2, 3) G.L.G. Sleijpen, H.A. van der Vorst, A Jacobi-Davidson Iteration Method for Linear Eigenvalue Problems, SIAM Journal on Matrix Analysis and Applications 17, 401 (1996) |