`pyviblib.calc.common`¶

Commonly used routines¶

Functions¶

normalize_set()

normalize a set of vectors

orthogonalize_set()

orthogonalize a set of vectors

contract()

double contract of two arrays

contract_t()

double contract a second-rank tensor

rotate_t()

rotate a second-rank tensor

norm()

norm of an array

cosine()

cosine between two arrays

mass_center()

coordinates of the mass center

inertia_tensor()

inertia tensor

rotmatrix_axis()

matrix for rotation about an arbitrary axis

quat2matrix()

left rotation matrix from a normalized quaternion

calc_dcm()

direction cosine matrix

levi_civita()

antisymmetric unit tensor of Levi-Civita

is_even_permutation()

determine whether a permutation is even

kronecker()

kronecker symbol

decompose()

decompose a 3x3 matrix

decompose_t()

decompose a second-rank tensor

crossproduct()

cross product of two vectors

spatproduct()

scalar triple product of three vectors

angle_vectors()

angle between vectors

distance()

distance between two points

angle()

angle between three points

dihedral()

dihedral angle between four points

make_gcm()

generate a group coupling matrix (GCM)

make_gcp()

generate group contribution patterns (GCPs)

boltzmann_distr()

Boltzmann energy distribution of molecules

signum()

signum

fitgauss_params()

fitting a Lorentz function with Gaussian functions

voigt_norm()

normalized approximate Voigt profile

boltzmann_factor()

Boltzmann correction

savitzky_golay()

smooth data with the Savitzky-Golay algorithm

apply_corr()

apply a correction of a given order to a one-dimensional array

Author:	Maxim Fedorovsky

pyviblib.calc.common.normalize_set(set_in, set_out=None, base=1)¶

Normalize a set of vectors.

Parameters:	set_in – vectors to be normalized (ndarrays), the start index is given by the base keyword argument set_out – where the result is to be stored, unless given, use set_in, the caller is responsible for memory allocation base – base index

pyviblib.calc.common.orthogonalize_set(set_in, make_orthonormal=True, set_out=None, base=1)¶

Orthogonalize a set of vectors using the Gram-Schmidt algorithm.

Parameters:	set_in – vectors to be normalized (ndarrays), the start index is given by the base keyword argument set_out – where the result is to be stored, unless given, use set_in, the caller is responsible for memory allocation make_orthonormal – whether the result set is to be normalized base – base index

pyviblib.calc.common.contract(ar1, ar2)¶

Double contract two arrays.

The double contraction of two arbitrary second-rank tensors $T_1$ and $T_2$ is given by:

$T_1 : T_2 = \sum_{\mu, \nu} T_{1 \mu \nu} T_{2 \mu \nu}$

Parameters:	ar1 (ndarray) – first array ar2 (ndarray) – second array

pyviblib.calc.common.contract_t(tens)¶

Double contract the elements of a second-rank tensor with themselves.

Parameter:	tens – second-rank tensor (one-based ndarray), shape: (1 + N, 4, 1 + N, 4) with N being the number of atoms
Returns:	a tuple with the total contraction and the isotropic, anisotropic and antisymmetric contributions.

pyviblib.calc.common.rotate_t(tens, rotmat)¶

Rotate a second-rank tensor.

Each dinuclear term $ab$ of such a tensor $T$ is rotated with a rotation matrix $C$ as follows:

$C T_{ab} C^T$

Parameters:	tens – second-rank tensor to be rotated (one-based ndarray) shape: (1 + N, 4, 1 + N, 4) with N being the number of atoms rotmat – left rotation matrix (one-based ndarray with shape (4, 4))

pyviblib.calc.common.norm(ar_)¶

Calculate the norm of an array.

The norm is considered to be the square root of the double contraction of the array with itself. The array can be multi-dimensional such as e.g. tensors.

Parameter:	ar (ndarray) – array

See also

contract()

pyviblib.calc.common.cosine(tens1, tens2)¶

Calculate the cosinus between two arrays.

Teh cosine is considered to be the result of the double contraction of the arrays divided by the product of their norms.

Parameters:	tens1 (ndarray) – first array tens2 (ndarray) – second array

pyviblib.calc.common.mass_center(coords, masses, atom_list=None)¶

Calculate the mass center.

Parameters:	coords – coordinates (one-based ndarray), shape: (1 + N, 4) with N being the number of atoms masses – masses (one-based ndarray), shape: (1 + N,) atom_list – list of atoms involved, use all atoms if None

pyviblib.calc.common.inertia_tensor(coords, masses, atom_list=None, move2mass_center=True)¶

Calculate the inertia tensor.

Parameters:	coords – coordinates (one-based ndarray), shape: (1 + N, 4) with N being the number of atoms masses – masses (one-based ndarray), shape: (1 + N,) atom_list – list of atoms involved, use all atoms if None move2mass_center – whether to move to the center of gravity of the atoms
Returns:	inertia tensor as a null-based two-dimensional ndarray

pyviblib.calc.common.rotmatrix_axis(axis, phi)¶

Generate a matrix of rotation about an arbitrary axis.

Parameters:	axis – axis about which the rotation is being done (null-based ndarray) phi – angle in grad

The result rotation matrix is a one-based two-dimensional ndarray.

pyviblib.calc.common.quat2matrix(quat)¶

Generate a left rotation matrix from a normalized quaternion.

Parameter:	quat (null-based array of the length 4) – normalized quaternion

The result matrix is a one-based two-dimensional ndarray.

pyviblib.calc.common.calc_dcm(frame_ref1, frame_ref2)¶

Calculate the direction cosine matrix between two coordinates systems.

Parameters:	frame_ref1 (null-based ndarray with shape (3, 3)) – first frame of reference frame_ref2 (null-based ndarray with shape (3, 3)) – second frame of reference

The result matrix is a one-based two-dimensional ndarray.

pyviblib.calc.common.levi_civita()¶

Antisymmetric unit tensor of Levi-Civita.

             /- +1 if (i,j,k) is an even permutation of (1,2,3)
eps(i,j,k) = |  -1 if (i,j,k) is an odd  permutation of (1,2,3)
             \-  0 if at lease two indices are equal

The result tensor is a one-based three-dimensional ndarray.

pyviblib.calc.common.is_even_permutation(perm)¶

Determine whether a permutation is even.

An even permutation is a permutation that can be produced by an even number of exchanges.

Parameter:	perm (tuple) – permutation

pyviblib.calc.common.kronecker(i, j)¶

Kronecker symbol.

             /- 1 if i = j
delta(i,j) = |
             \- 0 otherwise

Parameters:	i – first index j – second index

pyviblib.calc.common.decompose(mat_)¶

Decompose a matrix into the isotropic, anisotropic & antisymmetric part.

$M &= M^{is} + M^{anis} + M^a \\ M^{is}_{i,j} &= \frac{Tr(M)}{3} \delta_{i,j} \\ M^{anis}_{i,j} &= \frac{\left(M_{i,j}+M_{i,j}\right)}{2}-M^{is}_{i,j}\\ M^a_{i,j} &= \frac{\left(M_{i,j} - M_{i,j}\right)}{2}$

Parameter:	mat (one-based ndarray with shape (4, 4)) – matrix to be decomposed ()
Returns:	tuple with the isotropic, anisotropic and antisymmetric parts

pyviblib.calc.common.decompose_t(tens)¶

Decompose a second-rank tensor into the isotropic, anisotropic and antisymmetric part.

Parameter:	tens – second-rank tensor to be decomposed (one-based ndarray) shape: (1 + N, 4, 1 + N, 4) with N being the number of atoms
Returns:	tuple with the parts

See also

decompose()

pyviblib.calc.common.crossproduct(ar1, ar2, base=1)¶

Calculate the cross-product of two vectors.

Parameters:	ar1 (ndarray) – first vector ar2 (ndarray) – second vector base – base index of ar1 and ar2

pyviblib.calc.common.spatproduct(ar1, ar2, ar3, base=1)¶

Calculate the scalar triple product of three vectors.

Parameters:	ar1 (ndarray) – first vector ar2 (ndarray) – second vector ar3 (ndarray) – second vector base – base index of ar1, ar2 and ar3

pyviblib.calc.common.angle_vectors(ar1, ar2, base=1)¶

Calculate the angle between two vectors.

Parameters:	ar1 (ndarray) – first vector ar2 (ndarray) – second vector base – base index of ar1 and ar2
Returns:	the angle in grad

pyviblib.calc.common.distance(ar1, ar2, base=1)¶

Calculate the distance between two points.

Parameters:	ar1 (ndarray) – first vector ar2 (ndarray) – second vector base – base index of ar1 and ar2

pyviblib.calc.common.angle(ar1, ar2, ar3, base=1)¶

Calculate the angle between three points.

Parameters:	ar1 (ndarray) – first vector ar2 (ndarray) – second vector ar3 (ndarray) – second vector base – base index of ar1, ar2 and ar3
Returns:	the angle in grad

pyviblib.calc.common.dihedral(ar1, ar2, ar3, ar4, base=1)¶

Calculate the dihedral angle between four points.

Parameters:	ar1 (ndarray) – first vector ar2 (ndarray) – second vector ar3 (ndarray) – second vector ar4 (ndarray) – second vector base – base index of ar1, ar2, ar3 and ar4
Returns:	the dihedral angle in grad

pyviblib.calc.common.make_gcm(mat_, groups)¶

Generate a group coupling matrix (GCM).

The GCM is obtained by separately adding up intra-group mono- and di-nuclear terms, and inter-group di-nuclear terms.

For details refer to W. Hug. Chem. Phys., 264(1):53-69, 2001.

Parameters:	mat (one-based two-dimensional ndarray) – matrix groups (list) – groups, atom indices are one-based, example: [ [1, 2], [4, 5], [6, 3] ]
Returns:	the GCM with shape (1 + N_gr, 1 + N_gr) with N_gr being the number of groups.

pyviblib.calc.common.make_gcp(acp, groups)¶

Generate group contribution patterns (GCPs).

The GCPs are obtained by adding the contributions of atoms comprising the groups.

For details refer to W. Hug. Chem. Phys., 264(1):53-69, 2001.

Parameters:	acp – atomic contribution patterns (one-based ndarray), it can be generated e.g. with `make_acp()` groups – groups, atom indices are one-based, example: [ [1, 2], [4, 5], [6, 3] ]
Returns:	the GCP of the length 1 + N_gr with N_gr being the number of groups

pyviblib.calc.common.boltzmann_distr(energies, energy_units=0, temperature=298.14999999999998)¶

Calculate the Boltzmann energy distribution of molecules.

Parameters:	energies – array with the energies of the molecules (null-based) units of the energies are given by the energy_units keyword argument energy_units – units of the energies (default 0, i.e. hartree), possible values: 0 – hartree 1 – kJ/mol temperature – temperature in Kelvin
Returns:	null-based ndarray with the percentages of the molecules (values between 0 to 1).

pyviblib.calc.common.signum(num)¶

Signum of a number.

            /-  1  if x > 0
signum(x) = |   0  if x = 0
            \- -1 otherwise

pyviblib.calc.common.fitgauss_params(n_gauss=6)¶

Parameters of a least square fitting Gauss functions to the shape of a Lorentz function with a full width at half-maximum (FWHM) of 1.

For details refer to W. Hug and J. Haesler. Int. J. Quant. Chem. 104:695-715, 2005

Parameter:	n_gauss – number of Gauss functions, currently the supported range of values is between 3 and 8
Returns:	ndarray of the dimension (2, n_gauss), each column of which corresponds to pair (c_i, a_i).

pyviblib.calc.common.voigt_norm(arx, n_gauss, fitparams, param_k, param_b)¶

Normalized approximate Voigt profile as a combination of Gauss functions.

For details refer to W. Hug and J. Haesler. Int. J. Quant. Chem. 104:695-715, 2005

Parameters:	arx (number or an array) – value n_gauss – number of Gauss functions fitparams – fit coefficiens (c_i, a_i) returned by `fitgauss_params()` param_k – FWHM of the Lorentz curve = 2k param_b – Gaussian instrument profile

pyviblib.calc.common.boltzmann_factor(wavnu)¶

Boltzmann correction.

The correction takes into account the thermal population of vibrational states. It is applied to the Raman/ROA scattering cross-sections, since they depend on the temperature at which a sample is measured.

$\frac{1}{1 - e^{- \frac{100 hc \tilde{\nu}}{k_B T}}}$

Parameter:	wavnu – wavenumber in cm**(-1)

pyviblib.calc.common.savitzky_golay(data, order=2, nl=2, nr=2)¶

Smooth data with the Savitzky-Golay algorithm.

The returned smoothed data array has the same dimension as the original one.

Parameters:	data – y data order – order of the polynomial nl – number leftward data points nr – number rightward data points

pyviblib.calc.common.apply_corr(arr, c, order=1)¶

Apply a correction of a given order to one-dimensional array.

$\tilde{\nu}' = \sum_{i} \left( c_i \tilde{\nu}^i \right) \tilde{\nu}$

Parameters:	array – one-dimensional array to be corrected c – $c$ , must be of length 1+order order – correction order
Returns:	the corrected array as given above

Table Of Contents

Previous topic

Next topic

This Page

`pyviblib.calc.common`¶

Commonly used routines¶

Functions¶

Navigation

Table Of Contents

Previous topic

Next topic

This Page

Quick search

pyviblib.calc.common¶

Commonly used routines¶

Functions¶

Navigation

`pyviblib.calc.common`¶