Welcome to Molecular Dynamics Analysis for IPython (ipyMD)!¶

Created on Thu Jul 14 14:06:40 2016

@author: cjs14

functions to calculate basic properties of the atoms

ipymd.atom_analysis.basic.density_bb(atoms_df, vectors=[[1, 0, 0], [0, 1, 0], [0, 0, 1]])[source]¶

calculate density of the bounding box (assuming all atoms are inside)

ipymd.atom_analysis.basic.lattparams_bb(vectors=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], rounded=None, cells=(1, 1, 1))[source]¶

calculate unit cell parameters of the bounding box

rounded : int

the number of decimal places to return

cells : (int,int,int)

how many unit cells the vectors represent in each direction

Returns:
Return type:	a, b, c, alpha, beta, gamma (in degrees)

ipymd.atom_analysis.basic.volume_bb(vectors=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], rounded=None, cells=(1, 1, 1))[source]¶

calculate volume of the bounding box

rounded : int

the number of decimal places to return

cells : (int,int,int)

how many unit cells the vectors represent in each direction

Returns:	volume
Return type:	float

ipymd.atom_analysis.basic.volume_points(atoms_df)[source]¶

calculate volume of the shape encompasing all atom coordinates

Created on Thu Jul 14 14:05:09 2016

@author: cjs14

functions based on nearest neighbour calculations

ipymd.atom_analysis.nearest_neighbour.bond_lengths(atoms_df, coord_type, lattice_type, max_dist=4, max_coord=16, repeat_meta=None, rounded=2, min_dist=0.01, leafsize=100)[source]¶

calculate the unique bond lengths atoms in coords_atoms, w.r.t lattice_atoms

atoms_df : pandas.Dataframe

all atoms

coord_type : string

atoms to calcualte coordination of

lattice_type : string

atoms to act as lattice for coordination

max_dist : float

maximum distance for coordination consideration

max_coord : float

maximum possible coordination number

repeat_meta : pandas.Series

include consideration of repeating boundary idenfined by a,b,c in the meta data

min_dist : float

lattice points within this distance of the atom will be ignored (assumed self-interaction)

leafsize : int

points at which the algorithm switches to brute-force (kdtree specific)

Returns:	distances – list of unique distances
Return type:	set

ipymd.atom_analysis.nearest_neighbour.cna_categories(atoms_df, accuracy=1.0, upper_bound=4, max_neighbours=24, repeat_meta=None, leafsize=100, ipython_progress=False)[source]¶

compute summed atomic environments of each atom in atoms_df

Based on Faken, Daniel and Jónsson, Hannes, ‘Systematic analysis of local atomic structure combined with 3D computer graphics’, March 1994, DOI: 10.1016/0927-0256(94)90109-0

signatures: - FCC = 12 x 4,2,1 - HCP = 6 x 4,2,1 & 6 x 4,2,2 - BCC = 6 x 6,6,6 & 8 x 4,4,4 - Diamond = 12 x 5,4,3 & 4 x 6,6,3 - Icosahedral = 12 x 5,5,5

Parameters:	accuracy (float) – 0 to 1 how accurate to fit to signature repeat_meta (pandas.Series) – include consideration of repeating boundary idenfined by a,b,c in the meta data ipython_progress (bool) – print progress to IPython Notebook
Returns:	df – copy of atoms_df with new column named cna
Return type:	pandas.Dataframe

ipymd.atom_analysis.nearest_neighbour.cna_plot(atoms_df, upper_bound=4, max_neighbours=24, repeat_meta=None, leafsize=100, barwidth=1, ipython_progress=False)[source]¶

compute summed atomic environments of each atom in atoms_df

Based on Faken, Daniel and Jónsson, Hannes, ‘Systematic analysis of local atomic structure combined with 3D computer graphics’, March 1994, DOI: 10.1016/0927-0256(94)90109-0

common signatures: - FCC = 12 x 4,2,1 - HCP = 6 x 4,2,1 & 6 x 4,2,2 - BCC = 6 x 6,6,6 & 8 x 4,4,4 - Diamond = 12 x 5,4,3 & 4 x 6,6,3 - Icosahedral = 12 x 5,5,5

Parameters:	repeat_meta (pandas.Series) – include consideration of repeating boundary idenfined by a,b,c in the meta data ipython_progress (bool) – print progress to IPython Notebook
Returns:	plot – a matplotlib plot
Return type:	matplotlib.pyplot

ipymd.atom_analysis.nearest_neighbour.cna_sum(atoms_df, upper_bound=4, max_neighbours=24, repeat_meta=None, leafsize=100, ipython_progress=False)[source]¶

compute summed atomic environments of each atom in atoms_df

Based on Faken, Daniel and Jónsson, Hannes, ‘Systematic analysis of local atomic structure combined with 3D computer graphics’, March 1994, DOI: 10.1016/0927-0256(94)90109-0

common signatures: - FCC = 12 x 4,2,1 - HCP = 6 x 4,2,1 & 6 x 4,2,2 - BCC = 6 x 6,6,6 & 8 x 4,4,4 - Diamond = 12 x 5,4,3 & 4 x 6,6,3 - Icosahedral = 12 x 5,5,5

Parameters:	repeat_meta (pandas.Series) – include consideration of repeating boundary idenfined by a,b,c in the meta data ipython_progress (bool) – print progress to IPython Notebook
Returns:	counter – a counter of cna signatures
Return type:	Counter

ipymd.atom_analysis.nearest_neighbour.common_neighbour_analysis(atoms_df, upper_bound=4, max_neighbours=24, repeat_meta=None, leafsize=100, ipython_progress=False)[source]¶

compute atomic environment of each atom in atoms_df

Based on Faken, Daniel and Jónsson, Hannes, ‘Systematic analysis of local atomic structure combined with 3D computer graphics’, March 1994, DOI: 10.1016/0927-0256(94)90109-0

ideally: - FCC = 12 x 4,2,1 - HCP = 6 x 4,2,1 & 6 x 4,2,2 - BCC = 6 x 6,6,6 & 8 x 4,4,4 - icosahedral = 12 x 5,5,5

repeat_meta : pandas.Series

include consideration of repeating boundary idenfined by a,b,c in the meta data

ipython_progress : bool

print progress to IPython Notebook

Returns:	df – copy of atoms_df with new column named cna
Return type:	pandas.Dataframe

ipymd.atom_analysis.nearest_neighbour.compare_to_lattice(atoms_df, lattice_atoms_df, max_dist=10, leafsize=100)[source]¶

calculate the minimum distance of each atom in atoms_df from a lattice point in lattice_atoms_df

atoms_df : pandas.Dataframe

atoms to calculate for

lattice_atoms_df : pandas.Dataframe

atoms to act as lattice points

max_dist : float

maximum distance for consideration in computation

leafsize : int

points at which the algorithm switches to brute-force (kdtree specific)

Returns:	distances – list of distances to nearest atom in lattice
Return type:	list

ipymd.atom_analysis.nearest_neighbour.coordination(coord_atoms_df, lattice_atoms_df, max_dist=4, max_coord=16, repeat_meta=None, min_dist=0.01, leafsize=100)[source]¶

calculate the coordination number of each atom in coords_atoms, w.r.t lattice_atoms

coords_atoms_df : pandas.Dataframe

atoms to calcualte coordination of

lattice_atoms_df : pandas.Dataframe

atoms to act as lattice for coordination

max_dist : float

maximum distance for coordination consideration

max_coord : float

maximum possible coordination number

repeat_meta : pandas.Series

include consideration of repeating boundary idenfined by a,b,c in the meta data

min_dist : float

lattice points within this distance of the atom will be ignored (assumed self-interaction)

leafsize : int

points at which the algorithm switches to brute-force (kdtree specific)

Returns:	coords – list of coordination numbers
Return type:	list

ipymd.atom_analysis.nearest_neighbour.coordination_bytype(atoms_df, coord_type, lattice_type, max_dist=4, max_coord=16, repeat_meta=None, min_dist=0.01, leafsize=100)[source]¶

returns dataframe with additional column for the coordination number of each atom of coord type, w.r.t lattice_type atoms

effectively an extension of calc_df_coordination

atoms_df : pandas.Dataframe

all atoms

coord_type : string

atoms to calcualte coordination of

lattice_type : string

atoms to act as lattice for coordination

max_dist : float

maximum distance for coordination consideration

max_coord : float

maximum possible coordination number

repeat_meta : pandas.Series

include consideration of repeating boundary idenfined by a,b,c in the meta data

min_dist : float

lattice points within this distance of the atom will be ignored (assumed self-interaction)

leafsize : int

points at which the algorithm switches to brute-force (kdtree specific)

Returns:	df – copy of atoms_df with new column named coord_{coord_type}_{lattice_type}
Return type:	pandas.Dataframe

ipymd.atom_analysis.nearest_neighbour.guess_bonds(atoms_df, covalent_radii=None, threshold=0.1, max_length=5.0, radius=0.1, transparency=1.0, color=None)[source]¶

guess bonds between atoms, based on approximate covalent radii

Parameters:	atoms_df (pandas.Dataframe) – all atoms, requires colums [‘x’,’y’,’z’,’type’, ‘color’] covalent_radii (dict or None) – a dict of covalent radii for each atom type, if None then taken from ipymd.shared.atom_data threshold (float) – include bonds with distance +/- threshold of guessed bond length (Angstrom) max_length (float) – maximum bond length to include (Angstrom) radius (float) – radius of displayed bond cylinder (Angstrom) transparency (float) – transparency of displayed bond cylinder color (str or tuple) – color of displayed bond cylinder, if None then colored by atom color
Returns:	bonds_df – a dataframe with start/end indexes relating to atoms in atoms_df
Return type:	pandas.Dataframe

ipymd.atom_analysis.nearest_neighbour.vacancy_identification(atoms_df, res=0.2, nn_dist=2.0, repeat_meta=None, remove_dups=True, color='red', transparency=1.0, radius=1, type_name='Vac', leafsize=100, n_jobs=1, ipython_progress=False)[source]¶

identify vacancies

atoms_df : pandas.Dataframe

atoms to calculate for

res : float

resolution of vacancy identification, i.e. spacing of reference lattice

nn_dist : float

maximum nearest-neighbour distance considered as a vacancy

repeat_meta : pandas.Series

include consideration of repeating boundary idenfined by a,b,c in the meta data

remove_dups : bool

only keep one vacancy site within the nearest-neighbour distance

leafsize : int

points at which the algorithm switches to brute-force (kdtree specific)

n_jobs : int, optional

Number of jobs to schedule for parallel processing. If -1 is given all processors are used.

ipython_progress : bool

print progress to IPython Notebook

Returns:	vac_df – new atom dataframe of vacancy sites as atoms
Return type:	pandas.DataFrame

Created on Tue Jul 12 20:18:04 2016

Derived from: LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator http://lammps.sandia.gov, Sandia National Laboratories Steve Plimpton, sjplimp@sandia.gov Copyright (2003) Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains certain rights in this software. This software is distributed under the GNU General Public License. https://github.com/lammps/lammps/tree/lammps-icms/src/USER-DIFFRACTION

This package contains the commands neeed to calculate x-ray and electron diffraction intensities based on kinematic diffraction theory. Detailed discription of the computation can be found in the following works:

Coleman, S.P., Spearot, D.E., Capolungo, L. (2013) Virtual diffraction analysis of Ni [010] symmetric tilt grain boundaries, Modelling and Simulation in Materials Science and Engineering, 21 055020. doi:10.1088/0965-0393/21/5/055020

Coleman, S.P., Sichani, M.M., Spearot, D.E. (2014) A computational algorithm to produce virtual x-ray and electron diffraction patterns from atomistic simulations, JOM, 66 (3), 408-416. doi:10.1007/s11837-013-0829-3

Coleman, S.P., Pamidighantam, S. Van Moer, M., Wang, Y., Koesterke, L. Spearot D.E (2014) Performance improvement and workflow development of virtual diffraction calculations, XSEDE14, doi:10.1145/2616498.2616552

@author: chris sewell

ipymd.atom_analysis.spectral.get_sf_coeffs()[source]¶

ipymd.atom_analysis.spectral.xrd_compute(atoms_df, meta_data, wlambda, min2theta=1.0, max2theta=179.0, lp=True, rspace=[1, 1, 1], manual=False, periodic=[True, True, True])[source]¶

Compute predicted x-ray diffraction intensities for a given wavelength

atoms_df : pandas.DataFrame

a dataframe of info for each atom, including columns; x,y,z,type

meta_data : pandas.Series

data of a,b,c crystal vectors (as tuples, e.g. meta_data.a = (0,0,1))

wlambda : float

radiation wavelength (length units) typical values are Cu Ka = 1.54, Mo Ka = 0.71 Angstroms

min2theta : float

minimum 2 theta range to explore (degrees)

max2theta : float

maximum 2 theta range to explore (degrees)

lp : bool

switch to apply Lorentz-polarization factor

use_triclinic : bool

use_triclinic

rspace : list of floats

parameters to adjust the spacing of the reciprocal lattice nodes in the h, k, and l directions respectively

manual : bool

use manual spacing of reciprocal lattice points based on the values of the c parameters (good for comparing diffraction results from multiple simulations, but small c required).

periodic : list of bools

whether periodic boundary in the h, k, and l directions respectively

Returns:	df – theta (in degrees), I, h, k and l for each k-point
Return type:	pandas.DataFrame

Notes

This is an implementation of the virtual x-ray diffraction pattern algorithm by Coleman et al. [ref1]

The algorithm proceeds in the following manner:

1. Define a crystal structure by position (x,y,z) and atom/ion type.
2. Define the x-ray wavelength to use
3. Compute the full reciprocal lattice mesh
4. Filter reciprocal lattice points by those in the Eswald’s sphere
5. Compute the structure factor at each reciprocal lattice point, for each atom type
6. Compute the x-ray diffraction intensity at each reciprocal lattice point
7. Group and sum intensities by angle

reciprocal points of the lattice are computed such that:

\[\mathbf{K} = {m_{1}}\cdot \mathbf{b}_{1}+{m_{2}}\cdot \mathbf{b}_{2}+{m_{3}}\cdot \mathbf{b}_{3}\]

where,

\[\begin{split}\begin{aligned} \mathbf {b_{1}} &= {\frac {\mathbf {a_{2}} \times \mathbf {a_{3}} }{\mathbf {a_{1}} \cdot (\mathbf {a_{2}} \times \mathbf {a_{3}} )}}\\ \mathbf {b_{2}} &= {\frac {\mathbf {a_{3}} \times \mathbf {a_{1}} }{\mathbf {a_{2}} \cdot (\mathbf {a_{3}} \times \mathbf {a_{1}} )}}\\ \mathbf {b_{3}} &= {\frac {\mathbf {a_{1}} \times \mathbf {a_{2}} }{\mathbf {a_{3}} \cdot (\mathbf {a_{1}} \times \mathbf {a_{2}} )}} \end{aligned}\end{split}\]

The reciprocal k-point modulii of the x-ray is calculated from Bragg’s law:

\[\left| {\mathbf{K}_{\lambda}} \right| = \frac{1}{{d_{\text{hkl}} }} = \frac{2\sin \left( \theta \right)}{\lambda }\]

This is used to construct an Eswald’s sphere, and only reciprocal lattice ponts within are retained, as illustrated:

The atomic scattering factors, fj, accounts for the reduction in diffraction intensity due to Compton scattering, with coefficients based on the electron density around the atomic nuclei.

\[f_j \left(\frac{\sin \theta}{\lambda}\right) = \left[ \sum\limits^4_i a_i \exp \left( -b_i \frac{\sin^2 \theta}{\lambda^2} \right)\right] + c = \left[ \sum\limits^4_i a_i \exp \left( -b_i \left(\frac{\left| {\mathbf{K}} \right|}{2}\right)^2 \right)\right] + c\]

The relative diffraction intensity from x-rays is computed at each reciprocal lattice point through:

\[I_x(\mathbf{K}) = Lp(\theta) \frac{F(\mathbf{K})F^*(\mathbf{K})}{N}\]

such that:

\[F ({\mathbf{K}} )= \sum\limits_{j = 1}^{N} {f_{j}.e^{\left( {2\pi i \, {\mathbf{K}} \cdot {\mathbf{r}}_{j} } \right)}} = \sum\limits_{j = 1}^{N} {f_j.\left[ \cos \left( 2\pi \mathbf{K} \cdot \mathbf{r}_j \right) + i \sin \left( 2\pi \mathbf{K} \cdot \mathbf{r}_j \right) \right]}\]

and the Lorentz-polarization factor is:

\[Lp(\theta) = \frac{1+\cos^2 (2\theta)}{\cos(\theta)\sin^2(\theta)}\]

References

[ref1]

1.Coleman, S. P., Sichani, M. M. & Spearot, D. E. A Computational Algorithm to Produce Virtual X-ray and Electron Diffraction Patterns from Atomistic Simulations. JOM 66, 408–416 (2014).

ipymd.atom_analysis.spectral.xrd_group_i(df, tstep=None, sym_equiv_hkl='none')[source]¶

group xrd intensities by theta

Parameters:	df (pandas.DataFrame) – containing columns; [‘theta’,’I’] and optional [‘h’,’k’,’l’] tstep (None or float) – if not None, group thetas within ranges i to i+tstep sym_equiv_hkl (str) – group hkl by symmetry-equivalent refelections; [‘none’,’mmm’,’m-3m’]
Returns:	df
Return type:	pandas.DataFrame

Notes

if grouping by theta step, then the theta value for each group will be the intensity weighted average

Crystal System | Laue Class | Symmetry-Equivalent Reflections | Multiplicity ————– | ———- | ——————————- | ———— Triclinic | -1 | hkl ≡ -h-k-l | 2 Monoclinic | 2/m | hkl ≡ -hk-l ≡ -h-k-l ≡ h-kl | 4 Orthorhombic | mmm | hkl ≡ h-k-l ≡ -hk-l ≡ -h-kl ≡ -h-k-l ≡ -hkl ≡ h-kl ≡ hk-l | 8 Tetragonal | 4/m | hkl ≡ -khl ≡ -h-kl ≡ k-hl ≡ -h-k-l ≡ k-h-l ≡ hk-l ≡ -kh-l | 8

4/mmm | hkl ≡ -khl ≡ -h-kl ≡ k-hl ≡ -h-k-l ≡ k-h-l ≡ hk-l ≡ -kh-l |

| ≡ khl ≡ -hkl ≡ -k-hl ≡ h-kl ≡ -k-h-l ≡ h-k-l ≡ kh-l ≡ -hk-l | 16

Cubic | m-3 | hkl ≡ -hkl ≡ h-kl ≡ hk-l ≡ -h-k-l ≡ h-k-l ≡ -hk-l ≡ -h-kl |

| ≡ klh ≡ -klh ≡ k-lh ≡ kl-h ≡ -k-l-h ≡ k-l-h ≡ -kl-h ≡ -k-lh |

| ≡ lhk ≡ -lhk ≡ l-hk ≡ lh-k ≡ -l-h-k ≡ l-h-k ≡ -lh-k ≡ -l-hk | 24

m-3m | hkl ≡ -hkl ≡ h-kl ≡ hk-l ≡ -h-k-l ≡ h-k-l ≡ -hk-l ≡ -h-kl |

| ≡ klh ≡ -klh ≡ k-lh ≡ kl-h ≡ -k-l-h ≡ k-l-h ≡ -kl-h ≡ -k-lh |

| ≡ lhk ≡ -lhk ≡ l-hk ≡ lh-k ≡ -l-h-k ≡ l-h-k ≡ -lh-k ≡ -l-hk |

| ≡ khl ≡ -khl ≡ k-hl ≡ kh-l ≡ -k-h-l ≡ k-h-l ≡ -kh-l ≡ -k-hl |

| ≡ lkh ≡ -lkh ≡ l-kh ≡ lk-h ≡ -l-k-h ≡ l-k-h ≡ -lk-h ≡ -l-kh |

| ≡ hlk ≡ -hlk ≡ h-lk ≡ hl-k ≡ -h-l-k ≡ h-l-k ≡ -hl-k ≡ -h-lk | 48

ipymd.atom_analysis.spectral.xrd_plot(df, icol='I_norm', imin=0.01, barwidth=1.0, hkl_num=0, hkl_trange=[0.0, 180.0], incl_multi=False, label_inline=True, label_trange=[0.0, 180.0], ax=None, **kwargs)[source]¶

create plot of xrd pattern

df : pd.DataFrame

containing columns [‘theta’,icol] and optional [‘hkl’,’multiplicity’]

icol : str

column name for intensity data

imin : float

minimum intensity to display

barwidth : float or None

if None then the barwidth will be the bin width

hkl_num : int

number of k-point values to label

hkl_trange : [float,float]

theta range within which to label peaks with k-point values

label_inline : bool

place k-point labels inline or at top of plot

label_trange : [float,float]

if not inline, theta range within which to fit k-point labels

incl_multi : bool

add multiplicity to k-point label

kwargs : optional

additional arguments for bar plot (e.g. label, color, alpha)

Returns:	plot – a plot object
Return type:	ipymd.plotting.Plotting

Created on Sun May 1 22:49:20 2016

@author: cjs14

class ipymd.data_input.base.DataInput[source]¶

Bases: object

Data is divided into two levels; atomic and meta

• atom is a series of tables, one for each timestep, containing variables (columns) for each atom (rows)
• meta is a table containing variables (columns) for each configuration (rows)

count_configs()[source]¶

return int of total number of atomic configurations

get_atom_data(config=1)[source]¶

return pandas.DataFrame of atomic data

get_meta_data(config=1)[source]¶

return pandas.Series of meta data for the atomic configuration

get_meta_data_all(incl_bb=False, **kwargs)[source]¶

return pandas.DataFrame of meta data for the atomic configuration

incl_bb : bool

whether to include bounding box coordinates in DataFrame

kwargs : dict

kew word arguments relevant to specific input data

setup_data()[source]¶

a method to setup the data and variables

Created on Wed May 18 22:24:10 2016

@author: cjs14

adapted from from http://physics.bu.edu/~erikl/research/tools/crystals/read_cif.py

class ipymd.data_input.cif.CIF[source]¶

Bases: ipymd.data_input.base.DataInput

Data is divided into two levels; atomic and meta

• atom is a series of tables, one for each timestep, containing variables (columns) for each atom (rows)
• meta is a table containing variables (columns) for each configuration (rows)

setup_data(file_path, override_abc=[], ignore_overlaps=False)[source]¶

Build a crystal from a Crystallographic Information File (.cif)

Parameters:	file_path (str) – path to file override_abc : [] or [a,b,c] if not empty, will override a, b, c length parameters given in file

Notes

here is a typical example of a CIF file:

_cell_length_a 4.916 _cell_length_b 4.916 _cell_length_c 5.4054 _cell_angle_alpha 90 _cell_angle_beta 90 _cell_angle_gamma 120 _cell_volume 113.131 _exptl_crystal_density_diffrn 2.646 _symmetry_space_group_name_H-M ‘P 32 2 1’ loop_ _space_group_symop_operation_xyz

‘x,y,z’ ‘y,x,2/3-z’ ‘-y,x-y,2/3+z’ ‘-x,-x+y,1/3-z’ ‘-x+y,-x,1/3+z’ ‘x-y,-y,-z’

loop_ _atom_site_label _atom_site_fract_x _atom_site_fract_y _atom_site_fract_z Si 0.46970 0.00000 0.00000 O 0.41350 0.26690 0.11910

Created on Mon May 16 01:23:11 2016

@author: cjs14

Adapted from chemlab which, in turn, was adapted from ASE https://wiki.fysik.dtu.dk/ase/ Copyright (C) 2010, Jesper Friis

class ipymd.data_input.crystal.Crystal[source]¶

Bases: ipymd.data_input.base.DataInput

Data is divided into two levels; atomic and meta

• atom is a series of tables, one for each timestep, containing variables (columns) for each atom (rows)
• meta is a table containing variables (columns) for each configuration (rows)

setup_data(positions, atom_type, group, cellpar=[1.0, 1.0, 1.0, 90, 90, 90], repetitions=[1, 1, 1], mass_map={}, charge_map={})[source]¶

Build a crystal from atomic positions, space group and cell parameters (in Angstroms)

Parameters:

positions (list of coordinates) – A list of the fractional atomic positions atom_type (list of atom type) – The atom types corresponding to the positions, the atoms will be translated in all the equivalent positions. group (int | str) – Space group given as its number in International Tables NB: to see mappings from Hermann–Mauguin notation, etc, use the get_spacegroup_df function in this module repetitions – Repetition of the unit cell in each direction cellpar – Unit cell parameters (in Angstroms and degrees) mass_map (dict of atom masses) – mapping of atom masses to atom types charge_map (dict of atom charges) – mapping of atom charges to atom types function was taken and adapted from the spacegroup module (This) –

:param found in ASE.: :param The module spacegroup module was originally developed by Jesper: :param Frills.:

Example

from ipymd.data_input import crystal c = crystal.Crystal([[0.0, 0.0, 0.0], [0.5, 0.5, 0.5]],

[‘Na’, ‘Cl’], 225, cellpar = [5.4, 5.4, 5.4, 90, 90, 90], repetitions = [5, 5, 5])

c.get_atom_data() c.get_simulation_box()

ipymd.data_input.crystal.get_spacegroup_df()[source]¶

dataframe of spacegroup mappings

Created on Mon May 16 01:15:56 2016

@author: cjs14

class ipymd.data_input.lammps.LAMMPS_Input[source]¶

Bases: ipymd.data_input.base.DataInput

Data is divided into two levels; atomic and meta

• atom is a series of tables, one for each timestep, containing variables (columns) for each atom (rows)
• meta is a table containing variables (columns) for each configuration (rows)

setup_data(atom_path='', atom_style='atomic')[source]¶

get data from file

Parameters:	atom_style ('atomic', 'charge') – defines how atomic data is listed: atomic; atom-ID atom-type x y z charge; atom-ID atom-type q x y z

class ipymd.data_input.lammps.LAMMPS_Output[source]¶

Bases: ipymd.data_input.base.DataInput

Data is divided into two levels; atomic and meta

• atom is a series of tables, one for each timestep, containing variables (columns) for each atom (rows)
• meta is a table containing variables (columns) for each configuration (rows)

setup_data(atom_path='', sys_path='', sys_sep=' ', atom_map={}, incl_atom_step=False, incl_sys_data=True)[source]¶

Data divided into two levels; meta and atom

atom_map : dict

mapping of atom level variable names e.g. {‘C_var[1]’:’x’}

sys_sep : str

the separator between variables in the system data file

incl_atom_time : bool

include time according to atom file in column ‘atom_step’ of meta

incl_sys_data : bool

include system data in the single step meta data

Notes

Meta level data created with fix print, e.g.;

fix sys_info all print 100 “${t} ${natoms} ${temp}” & title “time natoms temp” file system.dump screen no

Atom level data created with dump, e.g.;

dump atom_info all custom 100 atom.dump id type x y z mass q OR (file per configuration) dump atom_info all custom 100 atom_*.dump id type xs ys zs mass q

ipymd.data_input.lammps.atoi(text)[source]¶

ipymd.data_input.lammps.natural_keys(text)[source]¶

alist.sort(key=natural_keys) sorts in human order, e.g. [‘1’,‘2’,‘100’] instead of [‘1’,‘100’,‘2’] http://nedbatchelder.com/blog/200712/human_sorting.html

Created on Fri Jul 1 16:45:06 2016

@author: cjs14

class ipymd.plotting.plotter.Plotter(nrows=1, ncols=1, figsize=(5, 4))[source]¶

Bases: object

a class to deal with data plotting

figure¶

matplotlib.figure

the figure

axes¶

list or single matplotlib.axes

if more than one then returns a list (ordered in reading direction), else returns one instance

add_image(image, axes=0, interpolation='bicubic', hide_axes=True, width=1.0, height=1.0, origin=(0.0, 0.0), **kwargs)[source]¶

add image to axes

add_image_annotation(img, xy=(0, 0), arrow_xy=None, axes=0, zoom=1, xytype='axes points', arrow_xytype='data', arrowprops={'connectionstyle': 'arc3, rad=0.2', 'alpha': 0.4, 'arrowstyle': 'simple', 'facecolor': 'black'})[source]¶

add an image to the plot

coordtype:

argument	coordinate system
‘figure points’	points from the lower left corner of the figure
‘figure pixels’	pixels from the lower left corner of the figure
‘figure fraction’	0,0 is lower left of figure and 1,1 is upper right
‘axes points’	points from lower left corner of axes
‘axes pixels’	pixels from lower left corner of axes
‘axes fraction’	0,0 is lower left of axes and 1,1 is upper right
‘data’	use the axes data coordinate system

for arrowprops see http://matplotlib.org/users/annotations_guide.html#annotating-with-arrow

axes

display_plot(tight_layout=False)[source]¶

display plot in IPython

if tight_layout is True it may crop anything outside axes

figure

get_image(size=300, dpi=300, tight_layout=False)[source]¶

return as PIL image

if tight_layout is True it may crop anything outside axes

resize_axes(width=0.8, height=0.8, left=0.1, bottom=0.1, axes=0)[source]¶

resiaze axes, for instance to fit object outside of it

ipymd.plotting.plotter.animation_contourf(x_iter, y_iter, z_iter, interval=20, xlim=(0, 1), ylim=(0, 1), zlim=(0, 1.0), cmap='viridis', cbar=True, incl_controls=True, plot=None, ax=0, **plot_kwargs)[source]¶

create an animation of multiple x,y data sets

x_iter : iterable

any iterable of x data sets, e.g. [[1,2,3],[4,5,6]]

y_iter : iterable

an iterable of y data sets, e.g. [[1,2,3],[4,5,6]]

y_iter : iterable

an iterable of z(x,y) data sets, each set must be of shape (len(x), len(y))

interval : int

draws a new frame every interval milliseconds

xlim : tuple

the x_limits for the axes (ignored if using existing plotter)

ylim : tuple

the y_limits for the axes (ignored if using existing plotter)

zlim : tuple

the z_limits for the colormap

cmap : str or matplotlib.cm

the colormap to use (see http://matplotlib.org/examples/color/colormaps_reference.html)

incl_controls : bool

include Javascript play controls

plot : ipymd.plotting.Plotter

an existing plotter object

ax : int

the id number of the axes on which to plot (if using existing plotter)

plot_kwargs : various

key word arguments to pass to plot method, e.g. marker=’o’, color=’b’, ...

Returns:	html – a html object
Return type:	IPython.core.display.HTML

Notes

x_iter and y_iter can be yield functions such as:

def y_iter(x_iter):
    for xs in x_iter:
        yield [i**2 for i in xs]

This means that the values do not have to be necessarily pre-computed.

ipymd.plotting.plotter.animation_line(x_iter, y_iter, interval=20, xlim=(0, 1), ylim=(0, 1), incl_controls=True, plot=None, ax=0, **plot_kwargs)[source]¶

create an animation of multiple x,y data sets

x_iter : iterable

any iterable of x data sets, e.g. [[1,2,3],[4,5,6]]

y_iter : iterable

an iterable of y data sets, e.g. [[1,2,3],[4,5,6]]

interval : int

draws a new frame every interval milliseconds

xlim : tuple

the x_limits for the axes (ignored if using existing plotter)

ylim : tuple

the y_limits for the axes (ignored if using existing plotter)

incl_controls : bool

include Javascript play controls

plot : ipymd.plotting.Plotter

an existing plotter object

ax : int

the id number of the axes on which to plot (if using existing plotter)

plot_kwargs : various

key word arguments to pass to plot method, e.g. marker=’o’, color=’b’, ...

Returns:	html – a html object
Return type:	IPython.core.display.HTML

Notes

x_iter and y_iter can be yield functions such as:

def y_iter(x_iter):
    for xs in x_iter:
        yield [i**2 for i in xs]

This means that the values do not have to be necessarily pre-computed.

ipymd.plotting.plotter.animation_scatter(x_iter, y_iter, interval=20, xlim=(0, 1), ylim=(0, 1), incl_controls=True, plot=None, ax=0, **plot_kwargs)[source]¶

create an animation of multiple x,y data sets

x_iter : iterable

any iterable of x data sets, e.g. [[1,2,3],[4,5,6]]

y_iter : iterable

an iterable of y data sets, e.g. [[1,2,3],[4,5,6]]

interval : int

draws a new frame every interval milliseconds

xlim : tuple

the x_limits for the axes (ignored if using existing plotter)

ylim : tuple

the y_limits for the axes (ignored if using existing plotter)

incl_controls : bool

include Javascript play controls

plot : ipymd.plotting.Plotter

an existing plotter object

ax : int

the id number of the axes on which to plot (if using existing plotter)

plot_kwargs : various

key word arguments to pass to plot method, e.g. marker=’o’, color=’b’, ...

Returns:	html – a html object
Return type:	IPython.core.display.HTML

Notes

x_iter and y_iter can be yield functions such as:

def y_iter(x_iter):
    for xs in x_iter:
        yield [i**2 for i in xs]

This means that the values do not have to be necessarily pre-computed.

ipymd.plotting.plotter.style(style)[source]¶

A context manager to apply matplotlib style settings from a style specification.

Popular styles include; default, ggplot, xkcd, and are used in the the following manner:

with ipymd.plotting.style('default'):
    plot = ipymd.plotting.Plotter()
    plot.display_plot()

Parameters:	style (str, dict, or list) – A style specification. Valid options are: str The name of a style or a path/URL to a style file. For a list of available style names, see style.available. dict Dictionary with valid key/value pairs for matplotlib.rcParams. list A list of style specifiers (str or dict) applied from first to last in the list.

Created on Wed Jun 29 01:56:51 2016

@author: cjs14

ipymd.shared.colors.any_to_rgb(color)[source]¶

If color is an rgb tuple return it, if it is a string, parse it and return the respective rgb tuple.

ipymd.shared.colors.available_colors()[source]¶

ipymd.shared.colors.get(name)[source]¶

Given a string color, return the color as a tuple (r, g, b, a) where each value is between 0 and 255.

As for the color name follow the HTML color names <http://www.w3schools.com/tags/ref_colornames.asp> in lowescore style eg. forest_green.

ipymd.shared.colors.hsl_to_rgb(arr)[source]¶

Converts HSL color array to RGB array

H = [0..360] S = [0..1] l = [0..1]

http://en.wikipedia.org/wiki/HSL_and_HSV#From_HSL

Returns R,G,B in [0..255]

ipymd.shared.colors.html_to_rgb(colorstring)[source]¶

convert #RRGGBB to an (R, G, B) tuple

ipymd.shared.colors.mix(a, b, ratio=0.5)[source]¶

ipymd.shared.colors.parse_color(color)[source]¶

Return the RGB 0-255 representation of the current string passed.

It first tries to match the string with DVI color names.

ipymd.shared.colors.rgb_to_hsl(a)[source]¶

ipymd.shared.colors.rgb_to_hsl_hsv(a, isHSV=True)[source]¶

Converts RGB image data to HSV or HSL. :param a: 3D array. Retval of numpy.asarray(Image.open(...), int) :param isHSV: True = HSV, False = HSL :return: H,S,L or H,S,V array

ipymd.shared.colors.rgb_to_hsv(a)[source]¶

Homogeneous Transformation Matrices and Quaternions.

A library for calculating 4x4 matrices for translating, rotating, reflecting, scaling, shearing, projecting, orthogonalizing, and superimposing arrays of 3D homogeneous coordinates as well as for converting between rotation matrices, Euler angles, and quaternions. Also includes an Arcball control object and functions to decompose transformation matrices.

>>> alpha, beta, gamma = 0.123, -1.234, 2.345
>>> origin, xaxis, yaxis, zaxis = [0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]
>>> I = identity_matrix()
>>> Rx = rotation_matrix(alpha, xaxis)
>>> Ry = rotation_matrix(beta, yaxis)
>>> Rz = rotation_matrix(gamma, zaxis)
>>> R = concatenate_matrices(Rx, Ry, Rz)
>>> euler = euler_from_matrix(R, 'rxyz')
>>> numpy.allclose([alpha, beta, gamma], euler)
True
>>> Re = euler_matrix(alpha, beta, gamma, 'rxyz')
>>> is_same_transform(R, Re)
True
>>> al, be, ga = euler_from_matrix(Re, 'rxyz')
>>> is_same_transform(Re, euler_matrix(al, be, ga, 'rxyz'))
True
>>> qx = quaternion_about_axis(alpha, xaxis)
>>> qy = quaternion_about_axis(beta, yaxis)
>>> qz = quaternion_about_axis(gamma, zaxis)
>>> q = quaternion_multiply(qx, qy)
>>> q = quaternion_multiply(q, qz)
>>> Rq = quaternion_matrix(q)
>>> is_same_transform(R, Rq)
True
>>> S = scale_matrix(1.23, origin)
>>> T = translation_matrix([1, 2, 3])
>>> Z = shear_matrix(beta, xaxis, origin, zaxis)
>>> R = random_rotation_matrix(numpy.random.rand(3))
>>> M = concatenate_matrices(T, R, Z, S)
>>> scale, shear, angles, trans, persp = decompose_matrix(M)
>>> numpy.allclose(scale, 1.23)
True
>>> numpy.allclose(trans, [1, 2, 3])
True
>>> numpy.allclose(shear, [0, math.tan(beta), 0])
True
>>> is_same_transform(R, euler_matrix(axes='sxyz', *angles))
True
>>> M1 = compose_matrix(scale, shear, angles, trans, persp)
>>> is_same_transform(M, M1)
True
>>> v0, v1 = random_vector(3), random_vector(3)
>>> M = rotation_matrix(angle_between_vectors(v0, v1), vector_product(v0, v1))
>>> v2 = numpy.dot(v0, M[:3,:3].T)
>>> numpy.allclose(unit_vector(v1), unit_vector(v2))
True