Visualisation and Plotting¶
Fleur specific Plotting¶
Plotting routine for fleur density of states and bandstructures
- masci_tools.vis.fleur.plot_fleur_bands(bandsdata, bandsattributes, spinpol=True, only_spin=None, backend=None, weight=None, **kwargs)[source]¶
Plot the bandstructure previously extracted from a banddos.hdf via the
HDF5Reader
This routine expects datasets and attributes read in with a FleurBands recipe from
recipes
or something producing equivalent data- Parameters
bandsdata – dataset dict produced by the FleurBands recipe
attributes – attributes dict produced by the FleurBands recipe
spinpol – bool, if True (default) use the plot for spin-polarized bands if the data is spin-polarized
only_spin – optional str, if given only the specified spin components are plotted
backend – specify which plotting library to use (‘matplotlib’ or ‘bokeh’)
weight – str, name of the weight (without spin suffix _up or _dn) you want to emphasize
- All other Kwargs are passed on to the underlying plot routines
Matplotlib:
plot_bands()
,plot_spinpol_bands()
Bokeh:
bokeh_bands()
,bokeh_spinpol_bands()
- masci_tools.vis.fleur.plot_fleur_bands_characterize(bandsdata, bandsattributes, weight_names, weight_colors, spinpol=True, only_spin=None, backend=None, **kwargs)[source]¶
Plot the bandstructure previously extracted from a banddos.hdf via the
HDF5Reader
with points colored according to the maximum weight from a selection of weights. Can be used to show what character dominates each bandThis routine expects datasets and attributes read in with a FleurBands recipe from
recipes
or something producing equivalent data- Parameters
bandsdata – dataset dict produced by the FleurBands recipe
attributes – attributes dict produced by the FleurBands recipe
weight_names – list of str with the names of the weights that should be considered in the characterization
weight_color – list of colors associated with each weight. If spin-polarized bandstructures should be shown with different colors the list should be twice as long as the weights
spinpol – bool, if True (default) use the plot for spin-polarized bands if the data is spin-polarized
only_spin – optional str, if given only the specified spin components are plotted
backend – specify which plotting library to use (‘matplotlib’ or ‘bokeh’)
All other Kwargs are passed on to
plot_fleur_bands()
- masci_tools.vis.fleur.plot_fleur_dos(dosdata, attributes, spinpol=True, only_spin=None, multiply_by_equiv_atoms=True, plot_keys=None, show_total=True, show_interstitial=True, show_sym=False, show_atoms='all', show_lresolved=None, key_mask=None, backend=None, **kwargs)[source]¶
Plot the density of states previously extracted from a banddos.hdf via the
HDF5Reader
This routine expects datasets and attributes read in with the FleurDOS (Or related DOS modes) recipe from
recipes
or something producing equivalent dataThe limits for the axes can be specified either with
x
andy
orenergy
anddos
. Mixing the two options is not possible- Parameters
dosdata – dataset dict produced by the FleurDOS recipe
attributes – attributes dict produced by the FleurDOS recipe
spinpol – bool, if True (default) use the plot for spin-polarized dos if the data is spin-polarized
only_spin – optional str, if given only the specified spin components are plotted
backend – specify which plotting library to use (‘matplotlib’ or ‘bokeh’)
Arguments for selecting the DOS components to plot: :type plot_keys:
- param plot_keys
optional str list of str, defines the labels you want to plot
- All other Kwargs are passed on to the underlying plot routines
Matplotlib:
plot_dos()
,plot_spinpol_dos()
Bokeh:
bokeh_dos()
,bokeh_spinpol_dos()
- masci_tools.vis.fleur.sum_weights_over_atoms(data, attributes, atoms_to_sum, entry_name)[source]¶
Create sums of atom components over specified atoms. They are entered with the same suffixes as in the original data, but with the given entry_name as prefix
- Parameters
data – datasets dict produced by the HDF5Reader with a recipe for DOS or bandstructure
attributes – attributes dict produced by the HDF5Reader with a recipe for DOS or bandstructure
atoms_to_sum – list of ints for the atoms, which should be summed
entry_name – str prefix to be entered for the summed entries
- Returns
dict with the summed entries
KKR specific Plotting¶
Tool to plot a Fermi surface calculated with the qdos mode of KKR
- masci_tools.vis.kkr_plot_FS_qdos.FSqdos2D(p0='./', s=20, reload_data=False, clrbar=True, atoms=None, ax=None, nosave=False, noalat=False, cmap=<matplotlib.colors.LinearSegmentedColormap object>, noplot=False, return_data=False, pclrmesh=False, logscale=True, ef=None)[source]¶
plotting routine for dos files
dispersionplot function for plotting KKR bandstructures (i.e. qdos) files
- masci_tools.vis.kkr_plot_bandstruc_qdos.dispersionplot(p0='./', data_all=None, totonly=True, s=20, ls_ef=':', lw_ef=1, units='eV_rel', noefline=False, color='', reload_data=False, clrbar=True, logscale=True, nosave=False, atoms=None, ratios=False, atoms2=None, noscale=False, newfig=False, cmap=None, alpha=1.0, qcomponent=-2, clims=None, xscale=1.0, raster=True, atoms3=None, alpha_reverse=False, return_data=False, xshift=0.0, yshift=0.0, plotmode='pcolor', ptitle=None, ef=None, as_e_dimension=None, scale_alpha_data=False, shading='gouraud', verbose=False)[source]¶
plotting routine for qdos files - dispersion (E vs. q)
- masci_tools.vis.kkr_plot_bandstruc_qdos.load_data(p0='./', reload_data=False, nosave=False, atoms=None, ratios=False, atoms2=None, atoms3=None, ef=None, verbose=False)[source]¶
load the qdos data
Plotting function for KKR dos from files
- masci_tools.vis.kkr_plot_dos.dosplot(p0='./', totonly=True, color='', label='', marker='', lw=2, ms=5, ls='-', ls_ef=':', lw_ef=1, units='Ry', noefline=False, interpol=False, allatoms=False, onespin=False, atoms=None, lmdos=False, lm=None, nofig=False, scale=1.0, shift=0, normalized=False, xyswitch=False, efcolor='', return_data=False, xscale=1.0, xshift=0.0, yshift=0.0, filled=False, spins=2)[source]¶
plotting routine for dos files
Tool to visualize the KKR shapefunctions
- masci_tools.vis.kkr_plot_shapefun.change_zoom(ax, zoom_range, center=None)[source]¶
Change the zoom of a 3d plot
- masci_tools.vis.kkr_plot_shapefun.plot_shapefun(pos, out, mode)[source]¶
Creates a simple matplotlib image to show the shapefunctions given it’s positions in the unit cell, the atoms’s vertices in ut and the plotting mode
- Author
Philipp Ruessmann
- Parameters
pos – positions of the centers of the cells
verts – array of vertices of the shapefunction (outlines of shapes)
mode – ‘all’ or ‘single’ determines whether or not all shapes are combined in a single figure or plotted as individual figures
- Returns ax
return the axis in which the plot was done (useful to pass to ‘change_zoom’ and ‘zoom_in’ functions of this module
- masci_tools.vis.kkr_plot_shapefun.zoom_in(ax, atm, pos, zoom_range=10)[source]¶
Zoom into shapefun of a single atom
- Author
Philipp Ruessmann
- Parameters
ax – axis in which shapefun plot is found
atm – atom index whose shapefunction is zoomed
pos – array of positions of centers of the shapes (needed to shift center of zommed region to correct atom
zoom_range – range of the zoomed region (optional, defaults to 10)
General Plotting¶
Here basic functionality is provided for setting default parameters for plotting and ensuring consistent values for these
- masci_tools.vis.parameters.NestedPlotParameters(plotter_object)[source]¶
Contextmanager for nested plot function calls Will reset function defaults and parameters to previous values after exiting
- class masci_tools.vis.parameters.Plotter(default_parameters, general_keys=None, key_descriptions=None, type_kwargs_mapping=None, kwargs_postprocess_rename=None, **kwargs)[source]¶
Base class for handling parameters for plotting methods. For different plotting backends a subclass can be created to represent the specific parameters of the backend.
- Parameters
Kwargs in the __init__ method are forwarded to
Plotter.set_defaults()
to change the current defaults away from the hardcoded parameters.The Plotter class creates a hierarchy of dictionaries for lookups on this object utilizing the ChainMap from the collections module.
- The hierarchy is as follows (First entries take precedence over later entries):
parameters: set by
set_parameters()
(usually arguments passed into function)user defaults: set by
set_defaults()
function defaults: set by
set_defaults()
with default_type=’function’global defaults: Hardcoded as fallback
Only the parameters can represent parameters for multiple sets of plot calls. All others are used as fallback for specifying non-specified values for single plots
The current parameters can be accessed by bracket indexing the class. A example of this is shown below.
parameter_dict = {'fontsize': 16, 'linestyle': '-'} params = Plotter(parameter_dict) #Accessing a parameter print(params['fontsize']) # 16 #Modifying a parameter params['fontsize'] = 20 print(params['fontsize']) # 20 #Creating a parameter set for multiple plots #1. Set the properties to the correct values params.single_plot = False params.num_plots = 3 #2. Now we can set a property either by providing a list or a integer indexed dict # Both of the following examples set the linestyle of the second and third plot to '--' params['linestyle'] = [None, '--', '--'] params['linestyle'] = {1: '--', 2: '--'} # Not specified values are replaced with the default value for a single plot print(params['linestyle']) # ['-', '--', '--'] #In lists properties can also be indexed via tuples print(params[('linestyle', 0)]) # '-' print(params[('linestyle', 1)]) # '--' #Changes to the parameters and properties are reset params.reset_parameters() print(params['linestyle']) # '-'
- add_parameter(name, default_from=None, default_val=None)[source]¶
Add a new parameter to the parameters dictionary.
- static convert_to_complete_list(given_value, single_plot, num_plots, default=None, key='')[source]¶
Converts given value to list with length num_plots with None for the non-specified values
- Parameters
given_value (
Any
) – value passed in, for multiple plots either list or dict with integer keyssingle_plot (
bool
) – bool, if True only a single parameter is allowednum_plots (
int
) – int, if single_plot is False this defines the number of plotsdefault (
Optional
[Any
]) – default value for unspecified entrieskey (
str
) – str of the key to process
- Return type
- static dict_of_lists_to_list_of_dicts(dict_of_lists, single_plot, num_plots, repeat_after=None, ignore_repeat=None)[source]¶
Converts dict of lists and single values to list of length num_plots or single dict for single_plot=True
- expand_parameters(original_length, **kwargs)[source]¶
Expand parameters to a bigger number of plots. New length has to be a multiple of original length. Only lists of length <= orginal_length are expanded. Also expands function defaults
- get_multiple_kwargs(keys, ignore=None)[source]¶
Get multiple parameters and return them in a dictionary
- is_general(key)[source]¶
Return, whether the key is general (meaning only related to the whole plots)
- plot_kwargs(plot_type='default', ignore=None, extra_keys=None, post_process=True, list_of_dicts=True, **kwargs)[source]¶
Creates a dict or list of dicts (for multiple plots) with the defined parameters for the plotting calls of different types
- Parameters
plot_type (
str
) – type of plotignore (
Union
[str
,list
[str
],None
]) – str or list of str (optional), defines keys to ignore in the creation of the dictextra_keys (
Optional
[set
[str
]]) – optional set for additional keys to retrievepost_process (
bool
) – bool, if True the parameters are cleaned up for inserting them directly into bokeh plotting functions
- Return type
Kwargs are used to replace values by custom parameters:
Example for using a custom markersize:
p = Plotter(type_kwargs_mapping={'default': {'marker'}}) p.add_parameter('marker_custom', default_from='marker') p.plot_kwargs(marker='marker_custom')
This code snippet will return the standard parameters for a plot, but the value for the marker will be taken from the key marker_custom
- remove_added_parameters()[source]¶
Remove the parameters added via
Plotter.add_parameter()
- Return type
- reset_defaults()[source]¶
Resets the defaults to the hardcoded defaults in _PLOT_DEFAULTS.
- Return type
- reset_parameters()[source]¶
Reset the parameters to the current defaults. The properties single_plot and num_plots are also set to default values
- Return type
- save_defaults(filename='plot_defaults.json', save_complete=False)[source]¶
Save the current defaults to a json file.
- set_defaults(continue_on_error=False, default_type='global', **kwargs)[source]¶
Set the current defaults. This method will only work if the parameters are not changed from the defaults. Otherwise a error is raised. This is because after changing the defaults the changes will be propagated to the parameters to ensure consistency.
- Parameters
continue_on_error (
bool
) – bool, if True unknown key are simply skipped- Default_type
either ‘global’ or ‘function’. Specifies, whether to set the global defaults (not reset after function) or the function defaults
- Return type
Kwargs are used to set the defaults.
- set_parameters(continue_on_error=False, **kwargs)[source]¶
Set the current parameters.
- Parameters
continue_on_error (
bool
) – bool, if True unknown key are simply skipped and returned- Return type
Kwargs are used to set the defaults.
- masci_tools.vis.parameters.ensure_plotter_consistency(plotter_object)[source]¶
Decorator for plot functions to ensure that the Parameters are reset even if an error occurs in the function Additionally checks are performed that the parameters are reset after execution and the defaults are never changed in a plot function
This module contains classes and functions to make plotting functions more flexible with respect to the used data. This way plotting functions can both allow the flexible usage of lists, arrays directly or dataframes together with the keys that should be used
- class masci_tools.vis.data.ColumnDataSourceWrapper(wrapped)[source]¶
Wrapper around
bokeh.models.ColumnDataSource
to give it a__getitem__
and__setitem__
methodUsed in the
PlotDataIterator
for easier handling of these types
- class masci_tools.vis.data.PlotData(data, use_column_source=False, same_length=False, strict_data_keys=False, copy_data=False, **kwargs)[source]¶
Class for iterating over the data in a dict or dataframe with automatic filling in of single defined keys to get a list of keys to extract.
The iteration allows for implicit definition of data for multiple plot sets, without excessive copying of the given data
Usage Example
from masci_tools.vis.data import PlotData import numpy as np #Let's say we have one energy grid and a couple of functions #defined on this energy grid. #We collect these in a dict x = np.linspace(-10,10,100) data = {'x': x, 'y1': np.sin(x), 'y2':np.cos(x), 'y3', x**2} p = PlotData(data, x='x', y=['y1', 'y2', 'y3']) #If we now iterate over this object it will result in the data #for y being returned together with the x data (The same would work the other way around) for entry in p: print(entry.x) #'x' entry print(entry.y) #'y1' then 'y2' and finally 'y3' #Additionally data for z, color and size can be defined
- Parameters
data – object or list of objects which can be bracket indexed with the given keys e.g. dicts, pandas dataframes, …
- Same_length
bool if True and any sources are dicts it will be checked for same dimensions in (ALL) entries (not only for keys plotted against each other)
- Strict_data_keys
bool if True no new data keys are allowed to be entered via
copy_data()
Kwargs are used to specify the columns in a namedtuple If a list is given for any of the keys the data will be expanded to a list of namedtuple with the same length
- add_data_key(data_key, keys=None)[source]¶
Add a new column of data keys
- Parameters
data_key – string of the new data key to add
keys – None, Index into data or list of index into the data to initialize the values to
- apply(data_key, lambda_func, apply_to_whole_array=True, **kwargs)[source]¶
Apply a function to a given data column for all entries
Warning
This operation is done in-place. Meaning if there are multiple data entries pointing to the same data set and only one should be modified by this method, the data needs to be copied beforehand using
copy_data()
- Parameters
data_key – name of the data key to apply the function
lambda_func – function to apply to the data
- copy_data(data_key_from, data_key_to, prefix=None, rename_original=False, force=False)[source]¶
Copy the data for a given data key to another one
- Parameters
data_key_from – data key to copy from
data_key_to – data key to copy to
prefix – optional prefix to use for the renamed data entries. Can be used to avoid name clashes. If not given the data keys are used
rename_original – optional bool (default False). If True the original entries are renamed instead of the ones under
data_key_to
- property data_keys¶
Return the registered data keys for this instance
- distinct_datasets(data_key)[source]¶
Return how many different data sets are present for the given data key
- Parameters
data_key – The data key to analyse
- Returns
int of the number of different datasets
- get_function_result(data_key, func, list_return=False, as_numpy_array=False, **kwargs)[source]¶
Apply a function to a given data column for all entries and return the results
- Parameters
data_key – name of the data key to apply the function to
func – function to apply to the data to get the results if func is a string then it will be used to get the attribute with the corresponding name from the source and call it
- get_keys(data_key)[source]¶
Get the keys for a given data column for all entries
- Parameters
data_key – name of the data key to return the keys
- Returns
list of keys, corresponding to the entries for the given data in the sources
- get_mask(mask, data_key=None)[source]¶
Get mask list for use with the Data in this instance
- Parameters
mask – either list of callable, if it is callable it is used in
get_function_result()
together with thedata_key
argumentdata_key – str to be used for the data key if mask is a callable
:param
- get_values(data_key)[source]¶
Get the values for a given data column for all entries
- Parameters
data_key – name of the data key to return the values
- Returns
list of values, corresponding to the entries for the given data in the sources
- group_data(by, **kwargs)[source]¶
Group the data by the given data_key(s) or other arguments for groupby
Note
This function will convert the data arguments to
pd.Dataframe
objects- Parameters
by – str or list of str of the data_keys to sort by or other valid arguments for by in
pd.Dataframe.groupby()
Kwargs are passed on to
pd.Dataframe.groupby()
- items(first=False, mappable=False)[source]¶
Iterate over PlotData items. Returns the key and corresponding source for the data
- Parameters
first – bool, if True only the first entry is returned
mappable – bool, if True only the data ColumnDataSources are wrapped to be mappable
- keys(first=False)[source]¶
Iterate over PlotData keys. Returns the keys for the corresponding sources
- Parameters
first – bool, if True only the first entry is returned
- mask_data(mask, data_key=None, replace_value=None)[source]¶
Apply a given mask to the data inplace.
Note
This function will convert the data arguments to
pd.Dataframe
objects- Parameters
mask – mask rgument passed to
get_mask()
data_key – data_key argument used by
get_mask()
- max(data_key, separate=False, mask=None, mask_data_key=None)[source]¶
Get the maximum value for a given data column for all entries
- Parameters
data_key – name of the data key to determine the maximum
separate – bool if True the maximum will be determined and returned for all entries separately
mask – optional mask to select specific rows from the data entries
mask_data_key – optional data key to be used when
mask
is a function
- Returns
maximum value for all entries either combined or as a list
- min(data_key, separate=False, mask=None, mask_data_key=None)[source]¶
Get the minimum value for a given data column for all entries
- Parameters
data_key – name of the data key to determine the minimum
separate – bool if True the minimum will be determined and returned for all entries separately
mask – optional mask to select specific rows from the data entries
mask_data_key – optional data key to be used when
mask
is a function
- Returns
minimum value for all entries either combined or as a list
- shift_data(data_key, shifts, shifted_data_key=None, separate_data=True, negative=False)[source]¶
Apply shifts to a given data column for all entries
- Parameters
data_key – name of the data key to shift
shifts – float or array of floats with the shifts to apply
shifted_data_key – optional string, if given the data will be copied to this data key
separate_data – bool, if True and shifted_data_key is not given the data will be copied to itself (This separates the data for all columns)
negative – bool if True the shifts are applied with a minus sign
- sort_data(by_data_keys, **kwargs)[source]¶
Sort the data by the given data_key(s)
Note
This function will convert the data arguments to
pd.Dataframe
objectsNote
If there are multiple plot sets and only one data source. This function will expand the data to be one data source sorted according to the data_keys for each plot
- Parameters
by_data_keys – str or list of str of the data_keys to sort by
Kwargs are passed on to
pd.Dataframe.sort_values()
- class masci_tools.vis.data.PlotDataIterator(plot_data, mode='values', mappable=False)[source]¶
Class containing the iteration behaviour over the
PlotData
class. Can be used in three modes:keys: Returns the keys to be entered in the corresponding data sources for each entry
values: Returns the data for each entry
items: Returns the keys and the data sources in a tuple
The keys and values are always returned in a
namedtuple
with fields corresponding to the set data keys
- masci_tools.vis.data.normalize_list_or_array(data, key, out_data, flatten_np=False, forbid_split_up=False)[source]¶
Split up a given list/numpy array or pd.Series to be used in the plotting methods
- Parameters
data – The (array-like) data to be normalized
key – key under which to enter the new data
out_data – dict containing previously normalized data
flatten_np – bool, if True multidimensional numpy arrays are flattened
forbid_split_up – bool, if True multidimensional arrays are not split up
- The rules are the following:
if
data
is a multidimensional array (list of lists, etc.) and it is not forbidden by the given argument the first dimension of the array is iterated over and interpreted as separate entries (if the data was previously split up into multiple sets a length check is performed)if
data
is a one-dimensional array and of a different length than the number of defined data sets it is added to all previously existing entriesif
data
is a one-dimensional array and of the same length as the number of defined data sets each entry is added to the corresponding data set
- Returns
list of dicts or dict containing the nomralized data
- masci_tools.vis.data.process_data_arguments(data=None, single_plot=False, use_column_source=False, flatten_np=False, forbid_split_up=None, same_length=False, copy_data=False, **kwargs)[source]¶
Initialize PlotData from np.arrays or lists of np.arrays or lists or a already given data argument, i.e. mapping
- Parameters
data – either None or Mapping to be used as the data in the PlotData class
single_plot – bool, if True only a single dataset is allowed
use_column_source – bool, if True all data arguments are converted to ColumnDataSource of bokeh
flatten_np – bool, if True multidimensional numpy arrays are flattened (Only if data not given)
forbid_split_up – set of keys for which not to split up multidimensional arrays
same_length – bool if True and any sources are dicts it will be checked for same dimensions in (ALL) entries (not only for keys plotted against each other)
copy_data – bool, if True the data argument will be copied
Kwargs define which keys belong to which data entries if data is given or they contain the data to be normalized
The following two example calls will both create a PlotData object with the same two plot data sets with the entries
x
andy
:import numpy as np x = np.linspace(-10,10,100) y1 = y**2 y2 = np.sin(x) #Use a predefined data argument (a dict in this case) and the keys in the kwargs p = process_data_arguments({'x': x, 'y1': y1, 'y2': y2}, x='x', y=['y1','y2']) #Let the function normalize the given arrays p = process_data_arguments=(x=x,y=[y1, y2])
- Returns
A
PlotData
object corresponding to the given data
Collection of routines to be reused in plotting routines
- masci_tools.vis.helpers.exclude_points(plot_data, *data_keys, limits, padding=0.1)[source]¶
Exclude points outside the given limits
- Parameters
plot_data (
PlotData
) – PlotData instance containing all the data for plotsdata_keys (
str
) – str of the keys to consider for excluding pointslimits (
Optional
[dict
[str
,tuple
[float
,float
]]]) – dict of the set plot limitspadding (
float
) – float, determines how far beyond the plot limits a point has to lie to be excluded (default 10%)
- Return type
- masci_tools.vis.helpers.get_special_kpoint_ticks(kpoints, math_mode='$')[source]¶
Process the high symmetry kpoints and ggf. replace with appropiate latex symbol
Gamma/G is replaced with $Gamma$
- masci_tools.vis.helpers.mpl_single_line_or_area(axis, entry, source, area=False, area_vertical=False, area_enclosing_line=True, advance_color_cycle=False, area_line_alpha=1.0, **kwargs)[source]¶
Create a scatterplot, lineplot or area plot for the given entry on the matplotlib axis
- Parameters
axis – Axes to plot on
entry – namedtuple of the entries to plot
source – mapping containing the data to plot
area – bool, if True fill_betweenx/y will be used to create an area plot
area_vertical – bool, if True fill_betweeny will be used
area_enclosing_line – bool if True the area plot will have another line plot around the edge
advance_color_cycle – bool, if True the matplotlib color cycle will be advanced no matter what else is specified
area_line_alpha – if an area plot is done this is the alpha parameter (transparency)
Kwargs are passed to the respective plotting routines
This modules provides common plotting functions dispatching to different plotting backends. At the moment the following backends are used:
matplotlib
(‘mpl’, ‘matplotlib’)bokeh
(‘bokeh’)
The underlying plotting routines collected here should have the same signature for the data arguments; keyword arguments can be different.
- class masci_tools.vis.common.PlotBackend(value)[source]¶
Enumeration containing the possible names for each plotting backend Initialize using the
from_str()
methodAt the moment the following are supported (case-insensitive)
matplotlib
: either ‘mpl’ or ‘matplotlib’bokeh
: ‘bokeh’
- static default()[source]¶
Return a
PlotBackend
instance corresponding to the current default backend
- static from_str(label)[source]¶
Initialize the
PlotBackend
from a given string- Parameters
label – str to use to initialize the backend if it is None the default is returned
- Returns
PlotBackend
instance corresponding to the label
- masci_tools.vis.common.bands(kpath, eigenvalues, backend=None, data=None, **kwargs)[source]¶
Plot the provided data for a bandstructure (non spin-polarized) Non-weighted, weighted, as a line plot or scatter plot, color-mapped or fixed colors are all possible options
- Parameters
kpath – data for the kpoints path (flattened to 1D)
eigenvalues – data for the eigenvalues
data – source for the data of the plot (optional) (pandas Dataframe for example)
backend – name of the backend to use (uses a default if None is given)
Kwargs are passed on to the backend plotting functions:
matplotlib
:plot_bands()
bokeh
:bokeh_bands()
- Returns
Figure object for the used plotting backend
- masci_tools.vis.common.dos(energy_grid, dos_data, backend=None, data=None, **kwargs)[source]¶
Plot the provided data as a density of states (not spin-polarized). Can be done horizontally or vertical via the switch xyswitch
- Parameters
energy_grid – data for the energy grid of the DOS
dos_data – data for all the DOS components to plot
data – source for the data of the plot (optional) (pandas Dataframe for example)
backend – name of the backend to use (uses a default if None is given)
Kwargs are passed on to the backend plotting functions:
matplotlib
:plot_dos()
bokeh
:bokeh_dos()
- Returns
Figure object for the used plotting backend
- masci_tools.vis.common.get_help(key, backend=None)[source]¶
Get a help string for a given parameter.
- Parameters
key – name of the parameter to get the parameter for
backend – For which backend to get the description of the parameter
- masci_tools.vis.common.get_plotter(backend=None)[source]¶
Get the instance of the
Plotter
subclass used for the given plotting backend- Parameters
backend – For which backend to get the Plotter instance
- masci_tools.vis.common.line(xdata, ydata, backend=None, data=None, **kwargs)[source]¶
Plot the provided data as a line plot. Multiple data sets are possible
- Parameters
xdata – data for the x-axis
xdata – data for the y-axis
data – source for the data of the plot (optional) (pandas Dataframe for example)
backend – name of the backend to use (uses a default if None is given)
Kwargs are passed on to the backend plotting functions:
matplotlib
:multiple_scatterplots()
bokeh
:bokeh_line()
- Returns
Figure object for the used plotting backend
- masci_tools.vis.common.load_defaults(backend=None, filename='plot_defaults.json')[source]¶
Load defaults for the plot parameters from a file and set the contained defaults.
- Parameters
backend – For which backend to save the parameters
filename – str of the filename to load the defaults from
- masci_tools.vis.common.reset_defaults(backend=None)[source]¶
Reset the defaults for theplot parameters to the original state.
- Parameters
backend – For which backend to reset the parameters
- masci_tools.vis.common.save_defaults(backend=None, filename='plot_defaults.json', save_complete=False)[source]¶
Save the defaults for the plot parameters.
- Parameters
backend – For which backend to save the parameters
filename – str of the filename to save the defaults to
save_complete – bool, if True also the hardcoded defaults are included
- masci_tools.vis.common.scatter(xdata, ydata, backend=None, data=None, **kwargs)[source]¶
Plot the provided data as a scatter plot. Varying size and color are possible. Multiple data sets are possible
- Parameters
xdata – data for the x-axis
xdata – data for the y-axis
data – source for the data of the plot (optional) (pandas Dataframe for example)
backend – name of the backend to use (uses a default if None is given)
Kwargs are passed on to the backend plotting functions:
matplotlib
:multi_scatter_plot()
bokeh
:bokeh_multi_scatter()
- Returns
Figure object for the used plotting backend
- masci_tools.vis.common.set_default_backend(backend)[source]¶
Sets the default backend used when no explicit backend is specified.
- Parameters
backend – Name of the backend to use
- masci_tools.vis.common.set_defaults(backend=None, **kwargs)[source]¶
Sets defaults for the plot parameters.
- Parameters
backend – For which backend to set the parameters
The Kwargs are used to set the parameters of the specified backend
- masci_tools.vis.common.show_defaults(backend=None)[source]¶
Show the current set defaults for the plot parameters.
- Parameters
backend – For which backend to show the parameters
- masci_tools.vis.common.spinpol_bands(kpath, eigenvalues_up, eigenvalues_dn, backend=None, data=None, **kwargs)[source]¶
Plot the provided data for a bandstructure (spin-polarized) Non-weighted, weighted, as a line plot or scatter plot, color-mapped or fixed colors are all possible options
- Parameters
kpath – data for the kpoints path (flattened to 1D)
eigenvalues_up – data for the eigenvalues for spin-up
eigenvalues_dn – data for the eigenvalues for spin-down
data – source for the data of the plot (optional) (pandas Dataframe for example)
backend – name of the backend to use (uses a default if None is given)
Kwargs are passed on to the backend plotting functions:
matplotlib
:plot_spinpol_bands()
bokeh
:bokeh_spinpol_bands()
- Returns
Figure object for the used plotting backend
- masci_tools.vis.common.spinpol_dos(energy_grid, dos_data_up, dos_data_dn, backend=None, data=None, **kwargs)[source]¶
Plot the provided data as a density of states (spin-polarized). Can be done horizontally or vertical via the switch xyswitch
- Parameters
energy_grid – data for the energy grid of the DOS
dos_data_up – data for all the DOS components to plot for spin-up
dos_data_dn – data for all the DOS components to plot for spin-down
data – source for the data of the plot (optional) (pandas Dataframe for example)
backend – name of the backend to use (uses a default if None is given)
Kwargs are passed on to the backend plotting functions:
matplotlib
:plot_spinpol_dos()
bokeh
:bokeh_spinpol_dos()
- Returns
Figure object for the used plotting backend
Matplotlib¶
This module contains a subclass of Plotter
for the matplotlib library
- class masci_tools.vis.matplotlib_plotter.MatplotlibPlotter(**kwargs)[source]¶
Class for plotting parameters and standard code snippets for plotting with the matplotlib backend.
Kwargs in the __init__ method are forwarded to setting default values for the instance
For specific documentation about the parameter/defaults handling refer to
Plotter
.Below the current defined default values are shown:
Plot Parameters¶ Name
Description
Default value
title_fontsize
Fontsize for the title of the figure
16
figure_kwargs
Arguments passed to plt.figure when creating the figure. Includes things like figsize, dpi, background color, …
{'figsize': (8, 6), 'dpi': 100, 'facecolor': 'w', 'edgecolor': 'k', 'constrained_layout': True}
alpha
Float specifying the transparency of the title
1
axis_linewidth
Linewidth of the lines for the axis
1.5
use_axis_formatter
If True the labels will always not be formatted with an additive constant at the top
False
set_powerlimits
If True the threshold for switching to scientific notation is adjusted to 0,3
True
xticks
Positions of the ticks on the x axis
No Default
xticklabels
Labels for the ticks on the x-axis
No Default
yticks
Positions for the ticks on the y-axis
No Default
yticklabels
Labels for the ticks on the y-axis
No Default
invert_xaxis
If True the direction of the x-axis is inverted
False
invert_yaxis
If True the direction of the y-axis is inverted
False
color_cycle
If set this will override the default color cycle of matplotlib. Can be given as name of a colormap cycle or list of colors
No Default
color_cycle_always_advance
Always advance the color cycle even if the color was specified
False
sub_colormap
If a colormap is used this can be used to cut out a part of the colormap. For example (0.5,1.0) will only use the upper half of the colormap
No Default
linewidth
Linewidth for the plot(s)
2.0
linestyle
Linestyle for the plot(s)
-
marker
Shape of the marker to use for the plot(s)
o
markersize
Size of the markers to use in the plot(s)
4.0
color
Color to use in the plot(s)
No Default
zorder
z-position to use for the plot(s) (Is used to define fore- and background)
No Default
repeat_parameters
If set as integer the parameters for single plots (except labels) will be repeated after the given number of plots. Only implemented for multiple_scatterplots
No Default
edgecolor
Edgecolor to use in the plot(s)
No Default
facecolor
Facecolor to use in the plot(s)
No Default
plot_label
Label to use in the plot(s) for the legend
No Default
area_plot
If True fill_between(x) will be used to produce the plot(s)
False
area_vertical
Determines, whether to use fill_between or fill_betweenx for area plots
False
area_enclosing_line
If True a enclosing line will be drawn around the area
True
area_alpha
Transparency to use for the area in the area plot(s)
1.0
area_linecolor
Color for the enclosing line in the area plot(s)
No Default
plot_alpha
Transparency to use for the plot(s)
1.0
cmap
Colormap to use for scatter/pcolormesh or 3D plots
viridis
norm
If set this norm will be used to normalize data for the colormapping
No Default
shading
Shading to use for pcolormesh plots
gouraud
rasterized
Rasterize the pcolormesh when drawing vector graphics.
True
scale
Dict specifying the scales of the axis, e.g
{'y': 'log'}
will create a logarithmic scale on the y-axisNo Default
limits
Dict specifying the limits of the axis, e.g
{'x': (-5,5)}
No Default
labelfontsize
Fontsize for the labels on the axis
15
lines
Dict specifying straight help-lines to draw. For example
{'vertical': 0, 'horizontal': [-1,1]}
will draw a vertical line at 0 and two horizontal at -1 and 1No Default
line_options
Color, width, and more options for the help-lines
{'linestyle': '--', 'color': 'k', 'linewidth': 1.0}
font_options
Default font options that can be used for text annotations
{'family': 'serif', 'color': 'black', 'weight': 'normal', 'size': 16}
tick_paramsx
Parameters for major ticks on the x-axis (Size, fontsize, …)
{'size': 4.0, 'width': 1.0, 'labelsize': 14, 'length': 5, 'labelrotation': 0}
tick_paramsy
Parameters for major ticks on the y-axis (Size, fontsize, …)
{'size': 4.0, 'width': 1.0, 'labelsize': 14, 'length': 5, 'labelrotation': 0}
tick_paramsx_minor
Parameters for minor ticks on the x-axis (Size, fontsize, …)
{'size': 2.0, 'width': 1.0, 'labelsize': 0, 'length': 2.5}
tick_paramsy_minor
Parameters for minor ticks on the y-axis (Size, fontsize, …)
{'size': 2.0, 'width': 1.0, 'labelsize': 0, 'length': 2.5}
colorbar
If True and the function implements color mapping, a colorbar is shown
True
colorbar_options
Parameters for displaying the colorbar (Fontsize, …)
{'pad': 0.05}
legend
If True a legend for the plot is shown
False
legend_show_data_labels
If True the column names from the data argument are shown if not overwritten
False
legend_remove_duplicates
If True duplicate legend labels are removed
False
legend_options
Parameters for displaying the legend (Fontsize, location, …)
{'fontsize': 'large', 'linewidth': 3.0, 'loc': 'best', 'fancybox': True}
save_plots
if True the plots will be saved to file
False
save_format
Formats to save the plots to, can be single or list of formats
png
save_options
Additional options for saving the plots to file
{'transparent': True}
tightlayout
If True the tight layout will be used (NOT IMPLEMENTED)
False
show
If True plt.show will be called at the end of the routine
True
save_raw_plot_data
If True the data for the plot is saved to file (NOT IMPLEMENTED)
False
raw_plot_data_format
Format in which to save the data for the plot (NOT IMPLEMENTED)
txt
- draw_lines(ax)[source]¶
Draw horizontal and vertical lines specified in the lines argument
- Parameters
ax – Axes object on which to perform the operation
- plot_kwargs(plot_type='default', ignore=None, extra_keys=None, post_process=True, list_of_dicts=True, **kwargs)[source]¶
Creates a dict or list of dicts (for multiple plots) with the defined parameters for the plotting calls of matplotlib
- Parameters
ignore – str or list of str (optional), defines keys to ignore in the creation of the dict
extra_keys – optional set for additional keys to retrieve
post_process – bool, if True the parameters are cleaned up for inserting them directly into matplotlib plitting functions
Kwargs are used to replace values by custom parameters:
Example for using a custom markersize:
p = MatplotlibPlotter() p.add_parameter('marker_custom', default_from='marker') p.plot_kwargs(marker='marker_custom')
This code snippet will return the standard parameters for a plot, but the value for the marker will be taken from the key marker_custom
- prepare_plot(title=None, xlabel=None, ylabel=None, zlabel=None, axis=None, minor=False, projection=None)[source]¶
Prepares the figure of a matplotlib plot, setting the labels/titles, ticks, …
- Parameters
title – str for the title of the figure
xlabel – str for the label on the x-axis
ylabel – str for the label on the y-axis
zlabel – str for the label on the z-axis
axis – matplotlib axes object, optional, if given the operations are performed on the object otherwise a new figure and subplot are created
minor – bool, if True minor tick parameters are set
projection – str, passed on to the add_subplot call
- Returns
the created or modified axis object
- save_plot(saveas)[source]¶
Save the current figure or show the current figure
- Parameters
saveas – str, filename for the resulting file
- set_limits(ax)[source]¶
Set limits of the axis
- Parameters
ax – Axes object on which to perform the operation
- set_scale(ax)[source]¶
Set scale of the axis (for example ‘log’)
- Parameters
ax – Axes object on which to perform the operation
- show_colorbar(ax)[source]¶
Print a colorbar for the plot
- Parameters
ax – Axes object on which to perform the operation
- show_legend(ax, leg_elems=None)[source]¶
Print a legend for the plot
- Parameters
ax – Axes object on which to perform the operation
- static truncate_colormap(cmap, minval=0.0, maxval=1.0, n=256)[source]¶
Cut off parts of colormap
- Parameters
cmap – cmap to truncate
minval – minimum value of new colormap
maxval – maximum value of new colormap
n – number of colors in new colormap
- Returns
colormap truncated to only hold colors between minval and maxval from old colormap
In this module are plot routines collected to create default plots out of certain output nodes from certain workflows with matplot lib.
Comment: Do not use any aiida methods, otherwise the methods in here can become tricky to use inside a virtual environment. Make the user extract thing out of aiida objects before hand or write something on top. Since usually parameter nodes, or files are plotted, parse a dict or filepath.
Each of the plot_methods can take keyword arguments to modify parameters of the plots There are keywords that are handled by a special class for defaults. All other arguments will be passed on to the matplotlib plotting calls
For the definition of the defaults refer to MatplotlibPlotter
- masci_tools.vis.plot_methods.CDF_voigt_profile(x, fwhm_g, fwhm_l, mu)[source]¶
Cumulative distribution function of a voigt profile implementation of formula found here: https://en.wikipedia.org/wiki/Voigt_profile # TODO: is there an other way then to calc 2F2? # or is there an other way to calc the integral of wofz directly, or use different error functions.
- class masci_tools.vis.plot_methods.PDF(pdf, size=(200, 200))[source]¶
Display a PDF file inside a Jupyter notebook.
- masci_tools.vis.plot_methods.asymmetric_lorentz(x, fwhm, mu, alpha=1.0, beta=1.5)[source]¶
asymmetric lorentz function
L^alpha for x<=mu L^beta for x>mu See casexps LA
- masci_tools.vis.plot_methods.asymmetric_lorentz_gauss_conv(x, mu, fwhm_l, fwhm_g, alpha=1.0, beta=1.5)[source]¶
asymmetric Lorentzian with Gauss convoluted
- masci_tools.vis.plot_methods.asymmetric_lorentz_gauss_sum(x, mu, fwhm_l, fwhm_g, alpha=1.0, beta=1.5)[source]¶
asymmetric Lorentzian with Gauss convoluted
- masci_tools.vis.plot_methods.barchart(positions, heights, *, width=0.35, xlabel='x', ylabel='y', title='', bottom=None, alignment='vertical', saveas='barchart', bar_type='stacked', axis=None, xerr=None, yerr=None, data=None, copy_data=False, **kwargs)[source]¶
Create a standard bar chart plot (this should be flexible enough) to do all the basic bar chart plots.
- Parameters
positions – arraylike data for the positions of the bars
heights – arraylike data for the heights of the bars
data – source for the data of the plot (optional) (pandas Dataframe for example)
width – float determines the width of the bars
axis – Axes object where to add the plot
title – str, Title of the plot
xlabel – str, label for the x-axis
ylabel – str, label for the y-axis
saveas – str, filename for the saved plot
xerr – optional data for errorbar in x-direction
yerr – optional data for errorbar in y-direction
bottom – bottom values for the lowest end of the bars
bar_type – type of the barchart plot. Either
stacked
,grouped
orindependent
alignment – which direction the bars should be plotted (
horizontal
orvertical
)copy_data – bool, if True the data argument will be copied
Kwargs will be passed on to
masci_tools.vis.matplotlib_plotter.MatplotlibPlotter
. If the arguments are not recognized they are passed on to the matplotlib function barTODO: grouped barchart (meaning not stacked)
- masci_tools.vis.plot_methods.colormesh_plot(xdata, ydata, cdata, *, xlabel='', ylabel='', title='', data=None, saveas='colormesh', axis=None, copy_data=False, **kwargs)[source]¶
Create plot with pcolormesh
- Parameters
xdata – arraylike, data for the x coordinate
ydata – arraylike, data for the y coordinate
cdata – arraylike, data for the color values with a colormap
data – source for the data of the plot (optional) (pandas Dataframe for example)
xlabel – str, label written on the x axis
ylabel – str, label written on the y axis
title – str, title of the figure
saveas – str specifying the filename (without file format)
axis – Axes object, if given the plot will be applied to this object
copy_data – bool, if True the data argument will be copied
Kwargs will be passed on to
masci_tools.vis.matplotlib_plotter.MatplotlibPlotter
. If the arguments are not recognized they are passed on to the matplotlib function pcolormesh
- masci_tools.vis.plot_methods.construct_corelevel_spectrum(coreleveldict, natom_typesdict, exp_references=None, scale_to=-1, fwhm_g=0.6, fwhm_l=0.1, energy_range=None, xspec=None, energy_grid=0.2, peakfunction='voigt', alpha_l=1.0, beta_l=1.5)[source]¶
Constructrs a corelevel spectrum from a given corelevel dict
- Params
- Returns
list: [xdata_spec, ydata_spec, ydata_single_all, xdata_all, ydata_all, xdatalabel]
- masci_tools.vis.plot_methods.default_histogram(*args, **kwargs)[source]¶
Create a standard looking histogram (DEPRECATED)
- masci_tools.vis.plot_methods.doniach_sunjic(x, scale=1.0, E_0=0, gamma=1.0, alpha=0.0)[source]¶
Doniach Sunjic asymmetric peak function. tail to higher binding energies.
param x: list values to evaluate this function param scale: multiply the function with this factor param E_0: position of the peak param gamma, ‘lifetime’ broadening param alpha: ‘asymmetry’ parametera
See Doniach S. and Sunjic M., J. Phys. 4C31, 285 (1970) or http://www.casaxps.com/help_manual/line_shapes.htm
- masci_tools.vis.plot_methods.gauss_one(x, fwhm, mu)[source]¶
Returns a Lorentzian line shape at x with FWHM fwhm and mean mu
- masci_tools.vis.plot_methods.gaussian(x, fwhm, mu)[source]¶
Returns Gaussian line shape at x with FWHM fwhm and mean mu
- masci_tools.vis.plot_methods.get_mpl_help(key)[source]¶
Print the description of the given key in the matplotlib backend
Available defaults can be seen in
MatplotlibPlotter
- masci_tools.vis.plot_methods.histogram(xdata, density=False, histtype='bar', align='mid', orientation='vertical', log=False, axis=None, title='hist', xlabel='bins', ylabel='counts', saveas='histogram', return_hist_output=False, data=None, copy_data=False, **kwargs)[source]¶
Create a standard looking histogram
- Parameters
xdata – arraylike, Data for the histogram
data – source for the data of the plot (optional) (pandas Dataframe for example)
density – bool, if True the histogram is normed and a normal distribution is plotted with the same mu and sigma as the data
histtype – str, type of the histogram
align – str, defines where the bars for the bins are aligned
orientation – str, is the histogram vertical or horizontal
log – bool, if True a logarithmic scale is used for the counts
axis – Axes object where to add the plot
title – str, Title of the plot
xlabel – str, label for the x-axis
ylabel – str, label for the y-axis
saveas – str, filename for the saved plot
return_hist_output – bool, if True the data output from hist will be returned
copy_data – bool, if True the data argument will be copied
Kwargs will be passed on to
masci_tools.vis.matplotlib_plotter.MatplotlibPlotter
. If the arguments are not recognized they are passed on to the matplotlib function hist
- masci_tools.vis.plot_methods.hyp2f2(a, b, z)[source]¶
Calculation of the 2F2() hypergeometric function, since it is not part of scipy with the identity 2. from here: https://en.wikipedia.org/wiki/Generalized_hypergeometric_function a, b,z array like inputs TODO: not clear to me how to do this… the identity is only useful if we mange the adjust the arguments in a way that we can use them… also maybe go for the special case we need first: 1,1,3/2;2;-z2
- masci_tools.vis.plot_methods.load_mpl_defaults(filename='plot_mpl_defaults.json')[source]¶
Load defaults for the matplotlib backend from a json file.
- Parameters
filename – filename,from where the defaults should be taken
- masci_tools.vis.plot_methods.lorentzian(x, fwhm, mu)[source]¶
Returns a Lorentzian line shape at x with FWHM fwhm and mean mu
- masci_tools.vis.plot_methods.lorentzian_one(x, fwhm, mu)[source]¶
Returns a Lorentzian line shape at x with FWHM fwhm and mean mu
- masci_tools.vis.plot_methods.multi_scatter_plot(xdata, ydata, *, size_data=None, color_data=None, xlabel='', ylabel='', title='', data=None, saveas='mscatterplot', axis=None, copy_data=False, exclude_points_outside_plot_area=False, **kwargs)[source]¶
Create a scatter plot with varying marker size Info: x, y, size and color data must have the same dimensions.
- Parameters
xdata – str or arraylike, data for the x coordinate
ydata – str or arraylike, data for the y coordinate
size_data – str or arraylike, data for the markersizes (optional)
color_data – str or arraylike, data for the color values with a colormap (optional)
data – source for the data of the plot (optional) (pandas Dataframe for example)
xlabel – str, label written on the x axis
ylabel – str, label written on the y axis
title – str, title of the figure
data – Mapping giving the data for the plots (required if data arguments are str)
saveas – str specifying the filename (without file format)
axis – Axes object, if given the plot will be applied to this object
xerr – optional data for errorbar in x-direction
yerr – optional data for errorbar in y-direction
copy_data – bool, if True the data argument will be copied
Kwargs will be passed on to
masci_tools.vis.matplotlib_plotter.MatplotlibPlotter
. If the arguments are not recognized they are passed on to the matplotlib function scatter
- masci_tools.vis.plot_methods.multiaxis_scatterplot(xdata, ydata, *, axes_loc, xlabel='', ylabel='', title='', num_cols=1, num_rows=1, saveas='mscatterplot', **kwargs)[source]¶
Create a scatter plot with multiple axes.
- Parameters
xdata – list of arraylikes, passed on to the plotting functions for each axis (x-axis)
ydata – list of arraylikes, passed on to the plotting functions for each axis (y-axis)
axes_loc – list of tuples of two integers, location of each axis
xlabel – str or list of str, labels for the x axis
ylabel – str or list of str, labels for the y-axis
title – str or list of str, titles for the subplots
num_rows – int, how many rows of axis are created
num_cols – int, how many columns of axis are created
saveas – str filename of the saved file
- Special Kwargs:
- param subplot_params
dict with integer keys, can contain all valid kwargs for
multiple_scatterplots()
with the integer key denoting to which subplot the changes are applied- param axes_kwargs
dict with integer keys, additional arguments to pass on to subplot2grid for the creation of each axis (e.g colspan, rowspan)
Other Kwargs will be passed on to all
multiple_scatterplots()
calls (If they are not overwritten by parameters in subplot_params).
- masci_tools.vis.plot_methods.multiple_scatterplots(xdata, ydata, *, xlabel='', ylabel='', title='', data=None, saveas='mscatterplot', axis=None, xerr=None, yerr=None, area_curve=0, copy_data=False, exclude_points_outside_plot_area=False, **kwargs)[source]¶
Create a standard scatter plot with multiple sets of data (this should be flexible enough) to do all the basic plots.
- Parameters
xdata – str or arraylike, data for the x coordinate
ydata – str or arraylike, data for the y coordinate
xlabel – str, label written on the x axis
ylabel – str, label written on the y axis
data – source for the data of the plot (optional) (pandas Dataframe for example)
title – str, title of the figure
data – Mapping giving the data for the plots (required if xdata and ydata are str)
saveas – str specifying the filename (without file format)
axis – Axes object, if given the plot will be applied to this object
xerr – optional data for errorbar in x-direction
yerr – optional data for errorbar in y-direction
area_curve – if an area plot is made this arguments defines the other enclosing line defaults to 0
copy_data – bool, if True the data argument will be copied
Kwargs will be passed on to
masci_tools.vis.matplotlib_plotter.MatplotlibPlotter
. If the arguments are not recognized they are passed on to the matplotlib functions (errorbar or fill_between)
- masci_tools.vis.plot_methods.multiplot_moved(xdata, ydata, *, xlabel='', ylabel='', title='', data=None, scale_move=1.0, min_add=0, saveas='mscatterplot', copy_data=False, **kwargs)[source]¶
Plots all the scatter plots above each other. It adds an arbitrary offset to the ydata to do this and calls multiple_scatterplots. Therefore you might not want to show the yaxis ticks
- Parameters
xdata – arraylike, data for the x coordinate
ydata – arraylike, data for the y coordinate
data – source for the data of the plot (optional) (pandas Dataframe for example)
xlabel – str, label written on the x axis
ylabel – str, label written on the y axis
title – str, title of the figure
scale_move – float, max*scale_move determines size of the shift
min_add – float, minimum shift
saveas – str specifying the filename (without file format)
copy_data – bool, if True the data argument will be copied
Kwargs are passed on to the
multiple_scatterplots()
call
- masci_tools.vis.plot_methods.plot_bands(kpath, bands, *, data=None, size_data=None, color_data=None, special_kpoints=None, e_fermi=0, xlabel='', ylabel='$E-E_F$ [eV]', title='', saveas='bandstructure', markersize_min=0.5, markersize_scaling=5.0, scale_color=True, separate_bands=False, line_plot=False, band_index=None, copy_data=False, **kwargs)[source]¶
Plot the provided data for a bandstrucuture (non spin-polarized). Can be used to illustrate weights on bands via size_data
- Parameters
kpath – arraylike data for the kpoint data
bands – arraylike data for the eigenvalues
size_data – arraylike data the weights to emphasize (optional)
color_data – str or arraylike, data for the color values with a colormap (optional)
data – source for the data of the plot (optional) (pandas Dataframe for example)
title – str, Title of the plot
xlabel – str, label for the x-axis
ylabel – str, label for the y-axis
saveas – str, filename for the saved plot
e_fermi – float (default 0), place the line for the fermi energy at this value
special_kpoints – list of tuples (str, float), place vertical lines at the given values and mark them on the x-axis with the given label
markersize_min – minimum value used in scaling points for weight
markersize_scaling – factor used in scaling points for weight
scale_color – bool, if True (default) the weight will be additionally shown via a colormapping
line_plot – bool, if True the bandstructure will be plotted with lines Here no weights are supported
separate_bands – bool, if True the bandstructure will be separately plotted for each band allows more specific parametrization
band_index – data for which eigenvalue belongs to which band (needed for line_plot and separate_bands)
copy_data – bool, if True the data argument will be copied
All other Kwargs are passed on to the
multi_scatter_plot()
call
- masci_tools.vis.plot_methods.plot_colortable(colors, title, sort_colors=False, emptycols=0)[source]¶
Plot a legend of named colors.
Reference: https://matplotlib.org/3.1.0/gallery/color/named_colors.html
- masci_tools.vis.plot_methods.plot_convergence(iteration, distance, total_energy, *, data=None, saveas_energy='energy_convergence', saveas_distance='distance_convergence', axis_energy=None, axis_distance=None, xlabel='Iteration', ylabel_energy='Total energy difference [Htr]', ylabel_distance='Distance [me/bohr^3]', title_energy='Total energy difference over scf-Iterations', title_distance='Convergence (log)', copy_data=False, drop_last_iteration=False, **kwargs)[source]¶
Plot the total energy differences versus the scf iteration and plot the distance of the density versus iterations.
- Parameters
iteration – data for the number of iterations
distance – data of distances
total_energy – data of total energies
data – source for the data of the plot (optional) (pandas Dataframe for example)
xlabel – str, label for the x-axis of both plots
saveas_energy – str, filename for the energy convergence plot
axis_energy – Axes object for the energy convergence plot
title_energy – str, title for the energy convergence plot
ylabel_energy – str, label for the y-axis for the energy convergence plot
saveas_distance – str, filename for the distance plot
axis_distance – Axes object for the distance plot
title_distance – str, title for the distance plot
ylabel_distance – str, label for the y-axis for the distance plot
copy_data – bool if True the data argument is copied
drop_last_iteration – bool if True the last iteration is dropped for the distance plot
Other Kwargs will be passed on to all
multiple_scatterplots()
calls
- masci_tools.vis.plot_methods.plot_convergence_results(iteration, distance, total_energy, *, saveas1='t_energy_convergence', axis1=None, saveas2='distance_convergence', axis2=None, **kwargs)[source]¶
DEPRECATED Plot the total energy versus the scf iteration and plot the distance of the density versus iterations.
- Parameters
iteration – array for the number of iterations
distance – array of distances
total_energy – array of total energies
saveas1 – str, filename for the energy convergence plot
axis1 – Axes object for the energy convergence plot
saveas2 – str, filename for the distance plot
axis2 – Axes object for the distance plot
Other Kwargs will be passed on to all
single_scatterplot()
calls
- masci_tools.vis.plot_methods.plot_convergence_results_m(iterations, distances, total_energies, *, modes, nodes=None, saveas1='t_energy_convergence', saveas2='distance_convergence', axis1=None, axis2=None, **kwargs)[source]¶
DEPRECATED Plot the total energy versus the scf iteration and plot the distance of the density versus iterations.
- Parameters
iterations – array for the number of iterations
distances – array of distances
total_energies – array of total energies
modes – list of convergence modes (if ‘force’ is in the list the last distance is removed)
saveas1 – str, filename for the energy convergence plot
axis1 – Axes object for the energy convergence plot
saveas2 – str, filename for the distance plot
axis2 – Axes object for the distance plot
Other Kwargs will be passed on to all
multiple_scatterplots()
calls
- masci_tools.vis.plot_methods.plot_convex_hull2d(hull, *, title='Convex Hull', xlabel='Atomic Percentage', ylabel='Formation energy / atom [eV]', saveas='convex_hull', axis=None, **kwargs)[source]¶
Plot method for a 2d convex hull diagram
- Parameters
hull – pyhull.Convexhull #scipy.spatial.ConvexHull
axis – Axes object where to add the plot
title – str, Title of the plot
xlabel – str, label for the x-axis
ylabel – str, label for the y-axis
saveas – str, filename for the saved plot
- Function specific parameters:
- param marker_hull
defaults to marker, marker type for the hull plot
- param markersize_hull
defaults to markersize, markersize for the hull plot
- param color_hull
defaults to color, color for the hull plot
Kwargs will be passed on to
masci_tools.vis.matplotlib_plotter.MatplotlibPlotter
. If the arguments are not recognized they are passed on to the matplotlib functions plot
- masci_tools.vis.plot_methods.plot_corelevel_spectra(coreleveldict, natom_typesdict, exp_references=None, scale_to=-1, show_single=True, show_ref=True, energy_range=None, title='', fwhm_g=0.6, fwhm_l=0.1, energy_grid=0.2, peakfunction='voigt', linestyle_spec='-', marker_spec='o', color_spec='k', color_single='g', xlabel='Binding energy [eV]', ylabel='Intensity [arb] (natoms*nelectrons)', saveas=None, xspec=None, alpha_l=1.0, beta_l=1.0, **kwargs)[source]¶
Plotting function of corelevel in the form of a spectrum.
Convention: Binding energies are positive!
- Args:
coreleveldict: dict of corelevels with a list of corelevel energy of atomstypes # (The given corelevel accounts for a weight (number of electrons for full occupied corelevel) in the plot.) natom_typesdict: dict with number of atom types for each entry
- Kwargs:
exp_references: dict with experimental references, will be ploted as vertical lines show_single (bool): plot all single peaks. scale_to float: the maximum ‘intensity’ will be scaled to this value (useful for experimental comparisons) title (string): something for labeling fwhm (float): full width half maximum of peaks (gauss, lorentz or voigt_profile) energy_grid (float): energy resolution linetyp_spec : linetype for spectrum peakfunction (string): what the peakfunction should be {‘voigt’, ‘pseudo-voigt’, ‘lorentz’, ‘gaus’}
- example:
coreleveldict = {u’Be’: {‘1s1/2’ : [-1.0220669053033051, -0.3185614920138805,-0.7924091040092139]}} n_atom_types_Be12Ti = {‘Be’ : [4,4,4]}
- masci_tools.vis.plot_methods.plot_corelevels(coreleveldict, compound='', axis=None, saveas='scatterplot', **kwargs)[source]¶
Plotting function to visualize corelevels and corelevel shifts
- masci_tools.vis.plot_methods.plot_dos(energy_grid, dos_data, *, data=None, saveas='dos_plot', energy_label='$E-E_F$ [eV]', dos_label='DOS [1/eV]', title='Density of states', xyswitch=False, e_fermi=0, copy_data=False, **kwargs)[source]¶
Plot the provided data for a density of states (not spin-polarized). Can be done horizontally or vertical via the switch xyswitch
- Parameters
energy_grid – arraylike data for the energy grid of the DOS
dos_data – arraylike data for all the DOS components to plot
data – source for the data of the plot (optional) (pandas Dataframe for example)
title – str, Title of the plot
energy_label – str, label for the energy-axis
dos_label – str, label for the DOS-axis
saveas – str, filename for the saved plot
e_fermi – float (default 0), place the line for the fermi energy at this value
xyswitch – bool if True, the enrgy axis will be plotted vertically
copy_data – bool, if True the data argument will be copied
All other Kwargs are passed on to the
multiple_scatterplots()
call
- masci_tools.vis.plot_methods.plot_lattice_constant(scaling, total_energy, *, fit_data=None, data=None, relative=True, ref_const=None, title='Equation of states', saveas='lattice_constant', axis=None, copy_data=False, **kwargs)[source]¶
Plot a lattice constant versus Total energy Plot also the fit. On the x axis is the scaling, it
- Parameters
scaling – arraylike, data for the scaling factor
total_energy – arraylike, data for the total energy
fit_data – arraylike, optional data of fitted data
relative – bool, scaling factor given (True), or lattice constants given?
ref_const – float (optional), or list of floats, lattice constant for scaling 1.0
data – source for the data of the plot (optional) (pandas Dataframe for example)
copy_data – bool if True the data argument will be copied
- Function specific parameters:
- param marker_fit
defaults to marker, marker type for the fit data
- param markersize_fit
defaults to markersize, markersize for the fit data
- param linewidth_fit
defaults to linewidth, linewidth for the fit data
- param plotlabel_fit
str label for the fit data
Other Kwargs will be passed on to
multiple_scatterplots()
- masci_tools.vis.plot_methods.plot_one_element_corelv(corelevel_dict, element, compound='', axis=None, saveas='scatterplot', **kwargs)[source]¶
This routine creates a plot which visualizes all the binding energies of one element (and currently one corelevel) for different atomtypes.
- example:
corelevels = {‘W’ : {‘4f7/2’ : [123, 123.3, 123.4 ,123.1], ‘4f5/2’ : [103, 103.3, 103.4, 103.1]}, ‘Be’ : {‘1s’: [118, 118.2, 118.4, 118.1, 118.3]}}
- masci_tools.vis.plot_methods.plot_relaxation_results()[source]¶
Plot from the result node of a relaxation workflow, All forces of every atom type versus relaxation cycle. Average force of all atom types versus relaxation cycle. Absolute relaxation in Angstroem of every atom type. Relative realxation of every atom type to a reference structure. (if none given use the structure from first relaxation cycle as reference)
- masci_tools.vis.plot_methods.plot_residuen(xdata, fitdata, realdata, *, errors=None, xlabel='Energy [eV]', ylabel='cts/s [arb]', title='Residuen', saveas='residuen', hist=True, return_residuen_data=True, **kwargs)[source]¶
Calculates and plots the residuen for given xdata fit results and the real data.
If hist=True also the normed residual distribution is ploted with a normal distribution.
- Parameters
xdata – arraylike data for the x-coordinate
fitdata – arraylike fitted data for the y-coordinate
realdata – arraylike data to plot residuen against the fit
errors – dict, can be used to provide errordata for the x and y direction
xlabel – str, label for the x-axis
ylabel – str, label for the y-axis
title – str, title for the plot
saveas – str, filename for the saved plot
hist – bool, if True a normed residual distribution is ploted with a normal distribution.
return_residuen_data – bool, if True in addition to the produced axis object also the residuen data is returned
- Special Kwargs:
- param hist_kwargs
dict, these arguments will be passed on to the
histogram()
call (if hist=True)
Other Kwargs will be passed on to all
single_scatterplot()
call
- masci_tools.vis.plot_methods.plot_spectral_function(kpath, energy_grid, spectral_function, *, data=None, special_kpoints=None, e_fermi=0, xlabel='', ylabel='$E-E_F$ [eV]', title='', saveas='spectral_function', copy_data=False, **kwargs)[source]¶
Create a colormesh plot of a spectral function
- Parameters
kpath – data for the kpoint coordinates
energy_grid – data for the energy grid
spectral_function – 2D data for the spectral function
data – source for the data of the plot (optional) (pandas Dataframe for example)
title – str, Title of the plot
xlabel – str, label for the x-axis
ylabel – str, label for the y-axis
saveas – str, filename for the saved plot
e_fermi – float (default 0), place the line for the fermi energy at this value
special_kpoints – list of tuples (str, float), place vertical lines at the given values and mark them on the x-axis with the given label
copy_data – bool, if True the data argument will be copied
All other Kwargs are passed on to the
colormesh_plot()
call
- masci_tools.vis.plot_methods.plot_spinpol_bands(kpath, bands_up, bands_dn, *, size_data=None, color_data=None, data=None, show_spin_pol=True, special_kpoints=None, e_fermi=0, xlabel='', ylabel='$E-E_F$ [eV]', title='', saveas='bandstructure', markersize_min=0.5, markersize_scaling=5.0, scale_color=True, line_plot=False, separate_bands=False, band_index=None, copy_data=False, **kwargs)[source]¶
Plot the provided data for a bandstrucuture (spin-polarized). Can be used to illustrate weights on bands via size_data
- Parameters
kpath – arraylike data for the kpoint data
bands_up – arraylike data for the eigenvalues (spin-up)
bands_dn – arraylike data for the eigenvalues (spin-dn)
size_data – arraylike data the weights to emphasize BOTH SPINS (optional)
data – source for the data of the plot (optional) (pandas Dataframe for example)
title – str, Title of the plot
xlabel – str, label for the x-axis
ylabel – str, label for the y-axis
saveas – str, filename for the saved plot
e_fermi – float (default 0), place the line for the fermi energy at this value
special_kpoints – list of tuples (str, float), place vertical lines at the given values and mark them on the x-axis with the given label
markersize_min – minimum value used in scaling points for weight
markersize_scaling – factor used in scaling points for weight
show_spin_pol – bool, if True (default) the two different spin channels will be shown in blue and red by default
scale_color – bool, if True (default) the weight will be additionally shown via a colormapping
line_plot – bool, if True the bandstructure will be plotted with lines Here no weights are supported
separate_bands – bool, if True the bandstructure will be separately plotted for each band allows more specific parametrization
band_index – data for which eigenvalue belongs to which band (needed for line_plot and separate_bands)
copy_data – bool, if True the data argument will be copied
All other Kwargs are passed on to the
multi_scatter_plot()
call
- masci_tools.vis.plot_methods.plot_spinpol_dos(energy_grid, spin_up_data, spin_dn_data, *, data=None, saveas='spinpol_dos_plot', energy_label='$E-E_F$ [eV]', dos_label='DOS [1/eV]', title='Density of states', xyswitch=False, e_fermi=0, spin_dn_negative=True, spin_arrows=True, copy_data=False, **kwargs)[source]¶
Plot the provided data for a density of states (spin-polarized). Can be done horizontally or vertical via the switch xyswitch
- Parameters
energy_grid – arraylike data for the energy grid of the DOS
spin_up_data – arraylike data for all the DOS spin-up components to plot
spin_dn_data – arraylike data for all the DOS spin-down components to plot
data – source for the data of the plot (optional) (pandas Dataframe for example)
title – str, Title of the plot
energy_label – str, label for the energy-axis
dos_label – str, label for the DOS-axis
saveas – str, filename for the saved plot
e_fermi – float (default 0), place the line for the fermi energy at this value
xyswitch – bool if True, the enrgy axis will be plotted vertically
energy_grid_dn – arraylike data for the energy grid of the DOS of the spin-down component (optional)
spin_dn_negative – bool, if True (default) the spin-down components are plotted downwards
spin_arrows – bool, if True (default) small arrows will be plotted on the left side of the plot indicating the spin directions (if spin_dn_negative is True)
copy_data – bool, if True the data argument will be copied
All other Kwargs are passed on to the
multiple_scatterplots()
call
- masci_tools.vis.plot_methods.pseudo_voigt_profile(x, fwhm_g, fwhm_l, mu, mix=0.5)[source]¶
Linear combination of gaussian and loretzian instead of convolution
- Args:
x: array of floats fwhm_g: FWHM of gaussian fwhm_l: FWHM of Lorentzian mu: Mean mix: ratio of gauss to lorentz, mix* gauss, (1-mix)*Lorentz
- masci_tools.vis.plot_methods.reset_mpl_plot_defaults()[source]¶
Reset the defaults for matplotib backend to the hardcoded defaults
Available defaults can be seen in
MatplotlibPlotter
- masci_tools.vis.plot_methods.save_mpl_defaults(filename='plot_mpl_defaults.json', save_complete=False)[source]¶
Save the current defaults for the matplotlib backend to a json file.
- Parameters
filename – filename, where the defaults should be stored
save_complete – bool if True not only the overwritten user defaults but also the unmodified hardcoded defaults are stored
- masci_tools.vis.plot_methods.set_mpl_plot_defaults(**kwargs)[source]¶
Set defaults for matplotib backend according to the given keyword arguments
Available defaults can be seen in
MatplotlibPlotter
- masci_tools.vis.plot_methods.show_mpl_plot_defaults()[source]¶
Show the currently set defaults for matplotib backend to the hardcoded defaults
Available defaults can be seen in
MatplotlibPlotter
- masci_tools.vis.plot_methods.single_scatterplot(xdata, ydata, *, xlabel='', ylabel='', title='', data=None, saveas='scatterplot', axis=None, xerr=None, yerr=None, area_curve=0, copy_data=False, **kwargs)[source]¶
Create a standard scatter plot (this should be flexible enough) to do all the basic plots.
- Parameters
xdata – str or arraylike, data for the x coordinate
ydata – str or arraylike, data for the y coordinate
data – source for the data of the plot (optional) (pandas Dataframe for example)
xlabel – str, label written on the x axis
ylabel – str, label written on the y axis
title – str, title of the figure
data – Mapping giving the data for the plot (required if xdata and ydata are str)
saveas – str specifying the filename (without file format)
axis – Axes object, if given the plot will be applied to this object
xerr – optional data for errorbar in x-direction
yerr – optional data for errorbar in y-direction
area_curve – if an area plot is made this arguments defines the other enclosing line defaults to 0
copy_data – bool, if True the data argument will be copied
Kwargs will be passed on to
masci_tools.vis.matplotlib_plotter.MatplotlibPlotter
. If the arguments are not recognized they are passed on to the matplotlib functions (errorbar or fill_between)
- masci_tools.vis.plot_methods.surface_plot(xdata, ydata, zdata, *, xlabel='', ylabel='', zlabel='', title='', data=None, saveas='surface_plot', axis=None, copy_data=False, **kwargs)[source]¶
Create a standard surface plot
- Parameters
xdata – arraylike, data for the x coordinate
ydata – arraylike, data for the y coordinate
zdata – arraylike, data for the z coordinate
data – source for the data of the plot (optional) (pandas Dataframe for example)
xlabel – str, label written on the x axis
ylabel – str, label written on the y axis
zlabel – str, label written on the z axis
title – str, title of the figure
axis – Axes object, if given the plot will be applied to this object
saveas – str specifying the filename (without file format)
copy_data – bool, if True the data argument will be copied
Kwargs will be passed on to
masci_tools.vis.matplotlib_plotter.MatplotlibPlotter
. If the arguments are not recognized they are passed on to the matplotlib function plot_surface
- masci_tools.vis.plot_methods.voigt_profile(x, fwhm_g, fwhm_l, mu)[source]¶
Return the Voigt line shape at x with Lorentzian component FWHM fwhm_l and Gaussian component FWHM fwhm_g and mean mu. There is no closed form for the Voigt profile, but it is related to the real part of the Faddeeva function (wofz), which is used here.
- masci_tools.vis.plot_methods.waterfall_plot(xdata, ydata, zdata, *, xlabel='', ylabel='', zlabel='', title='', data=None, saveas='waterfallplot', axis=None, copy_data=False, **kwargs)[source]¶
Create a standard waterfall plot
- Parameters
xdata – arraylike, data for the x coordinate
ydata – arraylike, data for the y coordinate
zdata – arraylike, data for the z coordinate
data – source for the data of the plot (optional) (pandas Dataframe for example)
xlabel – str, label written on the x axis
ylabel – str, label written on the y axis
zlabel – str, label written on the z axis
title – str, title of the figure
axis – Axes object, if given the plot will be applied to this object
saveas – str specifying the filename (without file format)
copy_data – bool, if True the data argument will be copied
Kwargs will be passed on to
masci_tools.vis.matplotlib_plotter.MatplotlibPlotter
. If the arguments are not recognized they are passed on to the matplotlib function scatter3D
Bokeh¶
Here the masci_tools.vis.parameters.Plotter
subclass for the bokeh plotting backend
is defined with default values and many helper methods
- class masci_tools.vis.bokeh_plotter.BokehPlotter(**kwargs)[source]¶
Class for plotting parameters and standard code snippets for plotting with the bokeh backend.
Kwargs in the __init__ method are forwarded to setting default values for the instance
For specific documentation about the parameter/defaults handling refer to
Plotter
.Below the current defined default values are shown:
Plot Parameters¶ Name
Description
Default value
figure_kwargs
Parameters for creating the bokeh figure. Includes things like axis type (x and y), tools plot width/height
{'tools': 'pan,poly_select,tap,wheel_zoom,box_zoom,redo,undo,reset,save,crosshair,zoom_out,zoom_in', 'y_axis_type': 'linear', 'x_axis_type': 'linear', 'active_inspect': None, 'toolbar_location': 'right'}
additional_tools
tools to add to the tools already specified in
figure_kwargs
(Has to be in the same format)No Default
show_tooltips
Switch whether to add hover tooltips
True
global_tooltips
Switch whether to add individual (for each renderer) or global hover tooltips.
False
format_tooltips
Switch whether to enable the processing of formatted strings in tooltips.
True
tooltips
List of tuples specifying the tooltips. For more information refer to the bokeh documentation. Strings can contain format specifiers with the data keys of the function e.g.
'@ ``{x}
‘. Here the `` ``{x}
`` will be replaced by the entry for x. If there are formatting specifications for bokeh they need to be escaped with double curly braces orformat_tooltips=False
.[('X', '@{x}'), ('Y', '@{y}')]
additional_tooltips
Tooltips to add to the already defined
tooltips
(See above)No Default
axis_linewidth
Linewidth for the lines of the axis
2
label_fontsize
Fontsize for the labels of the axis
18pt
tick_label_fontsize
fontsize for the ticks on the axis
16pt
background_fill_color
Color of the background of the plot
#ffffff
x_axis_formatter
If set this formatter will be used for the ticks on the x-axis
No Default
y_axis_formatter
If set this formatter will be used for the ticks on the y-axis
No Default
x_ticks
Tick specification for the x-axis
No Default
x_ticklabels_overwrite
Overrides the labels for the ticks on the x-axis
No Default
y_ticks
Tick specification for the y-axis
No Default
y_ticklabels_overwrite
Overrides the labels for the ticks on the y-axis
No Default
x_range_padding
Specifies the amount of padding on the edges of the x-axis
No Default
y_range_padding
Specifies the amount of padding on the edges of the y-axis
No Default
limits
Dict specifying the limits of the axis, e.g
{'x': (-5,5)}
No Default
legend_location
Location of the legend inside the plot area
top_right
legend_click_policy
Policy for what happens when labels are clicked in the legend
hide
legend_orientation
Orientation of the legend
vertical
legend_font_size
Fontsize for the labels inside the legend
14pt
legend_outside_plot_area
If True the legend will be placed outside of the plot area
False
color_palette
Color palette to use for the plot(s)
No Default
color
Specific colors to use for the plot(s)
No Default
legend_label
Labels to use for the legend of the plot(s)
No Default
alpha
Transparency to use for the plot(s)
1.0
name
Name used for identifying elements in the plot (not shown only internally)
No Default
line_color
Color to use for line plot(s)
No Default
line_alpha
Transparency to use for line plot(s)
1.0
line_dash
Dash styles to use for line plot(s)
No Default
line_width
Line width to use for line plot(s)
2.0
marker
Type of marker to use for scatter plot(s)
circle
marker_size
Marker size to use for scatter plot(s)
6
area_plot
If True h(v)area will be used to produce the plot(s)
False
area_vertical
Determines, whether to use harea (False) or varea (True) for area plots
False
fill_alpha
Transparency to use for the area in area plot(s)
1.0
fill_color
Color to use for the area in area plot(s)
No Default
level
Can be used to specified, which elements are fore- or background
No Default
straight_lines
Dict specifying straight help-lines to draw. For example
{'vertical': 0, 'horizontal': [-1,1]}
will draw a vertical line at 0 and two horizontal at -1 and 1No Default
straight_line_options
Color, width, and more options for the help-lines
{'line_color': 'black', 'line_width': 1.0, 'line_dash': 'dashed'}
text_font_size
fontsize for the text glyphs in the plot
10pt
text_font_style
fontstyle for the text glyphs in the plot
normal
text_color
text color for the text glyphs in the plot
black
text_align
text alignment for the text glyphs in the plot
left
text_baseline
text baseline for the text glyphs in the plot
middle
save_plots
If True plots will be saved to file (Configuration beforehand is needed)
False
save_format
Formats to save the plots to, can be single or list of formats (html, png or svg)
html
show
If True bokeh.io.show will be called after the plotting routine
True
- add_tooltips(fig, renderers, columns=None, toggleable=False)[source]¶
Add Hover tooltips to the given renderers and figure
- Parameters
fig – bokeh figure to apply changes to
renderers – bokeh renderers to activate the tooltips for
columns – namedtuple containing the data keys used for evtl. formatting
toggleable – bool, if True these tooltips will be toggleable in the toolbar
- draw_straight_lines(fig)[source]¶
Draw horizontal and vertical lines specified in the lines argument
- Parameters
fig – bokeh figure on which to perform the operation
- prepare_figure(title, xlabel, ylabel, figure=None)[source]¶
Create a bokeh figure according to the set parameters or modify an existing one
- Parameters
title – title of the figure
xlabel – label on the x-axis
ylabel – label on the y-axis
figure – bokeh figure, optional, if given the operations are performed on the object otherwise a new figure is created
- Returns
the created or modified bokeh figure
- save_plot(figure, saveas)[source]¶
Show/save the bokeh figure
- Parameters
figure – bokeh figure on which to perform the operation
- set_color_palette_by_num_plots()[source]¶
Set the colormap for the configured number of plots according to the set colormap or color
copied from https://github.com/PatrikHlobil/Pandas-Bokeh/blob/master/pandas_bokeh/plot.py credits to PatrikHlobil modified for use in this Plotter class
Here are general and special bokeh plots to use
- masci_tools.vis.bokeh_plots.bokeh_bands(kpath, bands=None, *, data=None, size_data=None, color_data=None, xlabel='', ylabel='$$E-E_F [eV]$$', title='', special_kpoints=None, markersize_min=3.0, markersize_scaling=10.0, saveas='bands_plot', scale_color=True, separate_bands=False, line_plot=False, band_index=None, copy_data=False, **kwargs)[source]¶
Create an interactive bandstructure plot (non-spinpolarized) with bokeh Can make a simple plot or weight the size and color of the points against a given weight
- Parameters
kpath – arraylike or key data for the kpoint data
bands – arraylike or key data for the eigenvalues
size_data – arraylike or key data the weights to emphasize (optional)
color_data – str or arraylike, data for the color values with a colormap (optional)
data – source for the bands data (optional) of the plot (pandas Dataframe for example)
xlabel – label for the x-axis (default no label)
ylabel – label for the y-axis
title – title of the figure
special_kpoints – list of tuples (str, float), place vertical lines at the given values and mark them on the x-axis with the given label
e_fermi – float, determines, where to put the line for the fermi energy
markersize_min – minimum value used in scaling points for weight
markersize_scaling – factor used in scaling points for weight
outfilename – filename of the output file
scale_color – bool, if True (default) the weight will be additionally shown via a colormapping
line_plot – bool, if True the bandstructure will be plotted with lines Here no weights are supported
separate_bands – bool, if True the bandstructure will be separately plotted for each band allows more specific parametrization
band_index – data for which eigenvalue belongs to which band (needed for line_plot and separate_bands)
copy_data – bool, if True the data argument will be copied
Kwargs will be passed on to
bokeh_multi_scatter()
orbokeh_line()
- masci_tools.vis.bokeh_plots.bokeh_dos(energy_grid, dos_data=None, *, data=None, energy_label='$$E-E_F [eV]$$', dos_label='DOS [1/eV]', title='Density of states', xyswitch=False, e_fermi=0, saveas='dos_plot', copy_data=False, **kwargs)[source]¶
Create an interactive dos plot (non-spinpolarized) with bokeh Both horizontal or vertical orientation are possible
- Parameters
energy_grid – arraylike or key data for the energy grid
spin_up_data – arraylike or key data for the DOS
data – source for the DOS data (optional) of the plot (pandas Dataframe for example)
energy_label – label for the energy-axis
dos_label – label for the dos-axis
title – title of the figure
xyswitch – bool if True, the energy will be plotted along the y-direction
e_fermi – float, determines, where to put the line for the fermi energy
outfilename – filename of the output file
copy_data – bool, if True the data argument will be copied
Kwargs will be passed on to
bokeh_line()
- masci_tools.vis.bokeh_plots.bokeh_line(x, y=None, *, data=None, figure=None, xlabel='x', ylabel='y', title='', saveas='line', plot_points=False, area_curve=0, copy_data=False, set_default_legend=True, **kwargs)[source]¶
Create an interactive multi-line plot with bokeh
- Parameters
x – arraylike or key for data for the x-axis
y – arraylike or key for data for the y-axis
data – source for the data of the plot (optional) (pandas Dataframe for example)
xlabel – label for the x-axis
ylabel – label for the y-axis
title – title of the figure
figure – bokeh figure (optional), if provided the plot will be added to this figure
outfilename – filename of the output file
plot_points – bool, if True also plot the points with a scatterplot on top
copy_data – bool, if True the data argument will be copied
set_default_legend – bool if True the data names are used to generate default legend labels
Kwargs will be passed on to
masci_tools.vis.bokeh_plotter.BokehPlotter
. If the arguments are not recognized they are passed on to the bokeh function line
- masci_tools.vis.bokeh_plots.bokeh_multi_scatter(x, y=None, *, data=None, figure=None, xlabel='x', ylabel='y', title='', saveas='scatter', copy_data=False, set_default_legend=True, **kwargs)[source]¶
Create an interactive scatter (muliple data sets possible) plot with bokeh
- Parameters
x – arraylike or key for data for the x-axis
y – arraylike or key for data for the y-axis
data – source for the data of the plot (pandas Dataframe for example)
xlabel – label for the x-axis
ylabel – label for the y-axis
title – title of the figure
figure – bokeh figure (optional), if provided the plot will be added to this figure
outfilename – filename of the output file
copy_data – bool, if True the data argument will be copied
set_default_legend – bool if True the data names are used to generate default legend labels
Kwargs will be passed on to
masci_tools.vis.bokeh_plotter.BokehPlotter
. If the arguments are not recognized they are passed on to the bokeh function scatter
- masci_tools.vis.bokeh_plots.bokeh_scatter(x, y=None, *, xlabel='x', ylabel='y', title='', figure=None, data=None, saveas='scatter', copy_data=False, **kwargs)[source]¶
Create an interactive scatter plot with bokeh
- Parameters
x – arraylike or key for data for the x-axis
y – arraylike or key for data for the y-axis
data – source for the data of the plot (pandas Dataframe for example)
xlabel – label for the x-axis
ylabel – label for the y-axis
title – title of the figure
figure – bokeh figure (optional), if provided the plot will be added to this figure
outfilename – filename of the output file
copy_data – bool, if True the data argument will be copied
Kwargs will be passed on to
masci_tools.vis.bokeh_plotter.BokehPlotter
. If the arguments are not recognized they are passed on to the bokeh function scatter
- masci_tools.vis.bokeh_plots.bokeh_spectral_function(kpath, energy_grid, spectral_function, *, data=None, special_kpoints=None, e_fermi=0, xlabel='', ylabel='$$E-E_F [eV]$$', title='', saveas='spectral_function', copy_data=False, figure=None, **kwargs)[source]¶
Create a colormesh plot of a spectral function
- Parameters
kpath – data for the kpoint coordinates
energy_grid – data for the energy grid
spectral_function – 2D data for the spectral function
data – source for the data of the plot (optional) (pandas Dataframe for example)
title – str, Title of the plot
xlabel – str, label for the x-axis
ylabel – str, label for the y-axis
saveas – str, filename for the saved plot
e_fermi – float (default 0), place the line for the fermi energy at this value
special_kpoints – list of tuples (str, float), place vertical lines at the given values and mark them on the x-axis with the given label
copy_data – bool, if True the data argument will be copied
All other Kwargs are passed on to the image call of bokeh
- masci_tools.vis.bokeh_plots.bokeh_spinpol_bands(kpath, bands_up=None, bands_dn=None, *, size_data=None, color_data=None, data=None, xlabel='', ylabel='$$E-E_F [eV]$$', title='', special_kpoints=None, markersize_min=3.0, markersize_scaling=10.0, saveas='bands_plot', scale_color=True, line_plot=False, separate_bands=False, band_index=None, copy_data=False, **kwargs)[source]¶
Create an interactive bandstructure plot (spinpolarized) with bokeh Can make a simple plot or weight the size and color of the points against a given weight
- Parameters
kpath – arraylike or key data for the kpoint data
bands_up – arraylike or key data for the eigenvalues spin-up
bands_dn – arraylike or key data for the eigenvalues spin-dn
size_data – arraylike or key data the weights to emphasize (optional)
color_data – str or arraylike, data for the color values with a colormap (optional)
data – source for the bands data (optional) of the plot (pandas Dataframe for example)
xlabel – label for the x-axis (default no label)
ylabel – label for the y-axis
title – title of the figure
special_kpoints – list of tuples (str, float), place vertical lines at the given values and mark them on the x-axis with the given label
e_fermi – float, determines, where to put the line for the fermi energy
markersize_min – minimum value used in scaling points for weight
markersize_scaling – factor used in scaling points for weight
outfilename – filename of the output file
scale_color – bool, if True (default) the weight will be additionally shown via a colormapping
line_plot – bool, if True the bandstructure will be plotted with lines Here no weights are supported
separate_bands – bool, if True the bandstructure will be separately plotted for each band allows more specific parametrization
band_index – data for which eigenvalue belongs to which band (needed for line_plot and separate_bands)
copy_data – bool, if True the data argument will be copied
Kwargs will be passed on to
bokeh_multi_scatter()
orbokeh_line()
- masci_tools.vis.bokeh_plots.bokeh_spinpol_dos(energy_grid, spin_up_data=None, spin_dn_data=None, *, data=None, spin_dn_negative=True, energy_label='$$E-E_F [eV]$$', dos_label='DOS [1/eV]', title='Density of states', xyswitch=False, e_fermi=0, spin_arrows=True, saveas='dos_plot', copy_data=False, **kwargs)[source]¶
Create an interactive dos plot (spinpolarized) with bokeh Both horizontal or vertical orientation are possible
- Parameters
energy_grid – arraylike or key data for the energy grid
spin_up_data – arraylike or key data for the DOS spin-up
spin_dn_data – arraylike or key data for the DOS spin-dn
data – source for the DOS data (optional) of the plot (pandas Dataframe for example)
spin_dn_negative – bool, if True (default), the spin down components are plotted downwards
energy_label – label for the energy-axis
dos_label – label for the dos-axis
title – title of the figure
xyswitch – bool if True, the energy will be plotted along the y-direction
e_fermi – float, determines, where to put the line for the fermi energy
spin_arrows – bool, if True (default) small arrows will be plotted on the left side of the plot indicating the spin directions (if spin_dn_negative is True)
outfilename – filename of the output file
copy_data – bool, if True the data argument will be copied
Kwargs will be passed on to
bokeh_line()
- masci_tools.vis.bokeh_plots.get_bokeh_help(key)[source]¶
Print the description of the given key in the bokeh backend
Available defaults can be seen in
BokehPlotter
- masci_tools.vis.bokeh_plots.load_bokeh_defaults(filename='plot_bokeh_defaults.json')[source]¶
Load defaults for the bokeh backend from a json file.
- Parameters
filename – filename,from where the defaults should be taken
- masci_tools.vis.bokeh_plots.matrix_plot(text_values, x_axis_data, y_axis_data, positions=None, *, color_data=None, secondary_color_data=None, x_offset=-0.47, log_scale=False, color_map=None, data=None, copy_data=False, title='', xlabel='x', ylabel='y', saveas='matrix_plot.html', blank_outsiders='both', blank_color='#c4c4c4', figure=None, categorical_axis=False, categorical_sort_key=None, block_size=0.95, block_size_pixel=100, **kwargs)[source]¶
Plot function for an interactive periodic table plot. Heat map and hover tool. source must be a pandas dataframe containing, atom period and group, atomic number and symbol
- Parameters
values – data for the text inside each elements box
positions – y positions relative to the middle of the box for each value
color_data – data to display as a heatmap
color_map – color palette to use for the heatmap (default matplotlib plasma)
log_scale – bool, if True the heatmap is done logarithmically
data – source for the data of the plot (optional) (pandas Dataframe for example)
title – str, Title of the plot
saveas – str, filename for the saved plot
blank_outsiders – either ‘both’, ‘min’, ‘max’ or None, determines, which points outside the color range to color with a default blank color
blank_color – color to replace values outside the color range by
include_legend – if True an additional entry with labels explaing each value entry is added
figure – bokeh figure (optional), if provided the plot will be added to this figure
Additional kwargs are passed on to the label creation for the element box The kwargs legend_options and colorbar_options can be used to overwrite default values for these regions of the plot
- masci_tools.vis.bokeh_plots.periodic_table_plot(values, positions=None, *, color_data=None, log_scale=False, color_map=None, data=None, copy_data=False, title='', saveas='periodictable.html', blank_outsiders='both', blank_color='#c4c4c4', include_legend=True, figure=None, **kwargs)[source]¶
Plot function for an interactive periodic table plot. Heat map and hover tool. source must be a pandas dataframe containing, atom period and group, atomic number and symbol
- Parameters
values – data for the text inside each elements box
positions – y positions relative to the middle of the box for each value
color_data – data to display as a heatmap
color_map – color palette to use for the heatmap (default matplotlib plasma)
log_scale – bool, if True the heatmap is done logarithmically
data – source for the data of the plot (optional) (pandas Dataframe for example)
title – str, Title of the plot
saveas – str, filename for the saved plot
blank_outsiders – either ‘both’, ‘min’, ‘max’ or None, determines, which points outside the color range to color with a default blank color
blank_color – color to replace values outside the color range by
include_legend – if True an additional entry with labels explaing each value entry is added
figure – bokeh figure (optional), if provided the plot will be added to this figure
Additional kwargs are passed on to the label creation for the element box The kwargs legend_options and colorbar_options can be used to overwrite default values for these regions of the plot
- masci_tools.vis.bokeh_plots.plot_convergence(iteration, distance, total_energy, *, data=None, saveas_energy='energy_convergence', saveas_distance='distance_convergence', figure_energy=None, figure_distance=None, xlabel='Iteration', ylabel_energy='Total energy difference [Htr]', ylabel_distance='Distance [me/bohr^3]', title_energy='Total energy difference over scf-Iterations', title_distance='Convergence (log)', copy_data=False, drop_last_iteration=False, **kwargs)[source]¶
Plot the total energy differences versus the scf iteration and plot the distance of the density versus iterations.
- Parameters
iteration – data for the number of iterations
distance – data of distances
total_energy – data of total energies
data – source for the data of the plot (optional) (pandas Dataframe for example)
xlabel – str, label for the x-axis of both plots
saveas_energy – str, filename for the energy convergence plot
figure_energy – Axes object for the energy convergence plot
title_energy – str, title for the energy convergence plot
ylabel_energy – str, label for the y-axis for the energy convergence plot
saveas_distance – str, filename for the distance plot
figure_distance – Axes object for the distance plot
title_distance – str, title for the distance plot
ylabel_distance – str, label for the y-axis for the distance plot
copy_data – bool if True the data argument is copied
drop_last_iteration – bool if True the last iteration is dropped for the distance plot
Other Kwargs will be passed on to all
bokeh_line()
calls
- masci_tools.vis.bokeh_plots.plot_convergence_results(iteration, distance, total_energy, *, saveas='convergence', **kwargs)[source]¶
Plot the total energy versus the scf iteration and plot the distance of the density versus iterations. Uses bokeh_line and bokeh_scatter
- Parameters
iteration – list of Int
distance – list of floats
show – bool, if True call show
- Total_energy
list of floats
Kwargs will be passed on to
bokeh_line()
- Returns grid
bokeh grid with figures
- masci_tools.vis.bokeh_plots.plot_convergence_results_m(iterations, distances, total_energies, *, link=False, nodes=None, modes=None, plot_label=None, saveas='convergence', **kwargs)[source]¶
Plot the total energy versus the scf iteration and plot the distance of the density versus iterations in a bokeh grid for several SCF results.
- Parameters
distances – list of lists of floats
iterations – list of lists of Int
link – bool, optional default=False:
nodes – list of node uuids or pks important for links
saveas1 – str, optional default=’t_energy_convergence’, save first figure as
saveas2 – str, optional default=’distance_convergence’, save second figure as
figure_kwargs – dict, optional default={‘width’: 600, ‘height’: 450}, gets parsed to bokeh_line
kwargs – further key-word arguments for bokeh_line
- Total_energies
list of lists of floats
- Returns grid
bokeh grid with figures
- masci_tools.vis.bokeh_plots.plot_lattice_constant(scaling, total_energy, *, fit_data=None, data=None, figure=None, relative=True, ref_const=None, title='Equation of states', saveas='lattice_constant', copy_data=False, **kwargs)[source]¶
Plot a lattice constant versus Total energy Plot also the fit. On the x axis is the scaling, it
- Parameters
scaling – arraylike, data for the scaling factor
total_energy – arraylike, data for the total energy
fit_data – arraylike, optional data of fitted data
relative – bool, scaling factor given (True), or lattice constants given?
ref_const – float (optional), or list of floats, lattice constant for scaling 1.0
data – source for the data of the plot (optional) (pandas Dataframe for example)
copy_data – bool if True the data argument will be copied
figure – bokeh figure (optional), if provided the plot will be added to this figure
- Function specific parameters:
- param marker_fit
defaults to marker, marker type for the fit data
- param marker_size_fit
defaults to marker_size, markersize for the fit data
- param line_width_fit
defaults to line_width, linewidth for the fit data
- param legend_label_fit
str label for the fit data
Other Kwargs will be passed on to
bokeh_line()
- masci_tools.vis.bokeh_plots.reset_bokeh_plot_defaults()[source]¶
Reset the defaults for bokeh backend to the hardcoded defaults
Available defaults can be seen in
BokehPlotter
- masci_tools.vis.bokeh_plots.save_bokeh_defaults(filename='plot_bokeh_defaults.json', save_complete=False)[source]¶
Save the current defaults for the matplotlib backend to a json file.
- Parameters
filename – filename, where the defaults should be stored
save_complete – bool if True not only the overwritten user defaults but also the unmodified hardcoded defaults are stored
- masci_tools.vis.bokeh_plots.set_bokeh_plot_defaults(**kwargs)[source]¶
Set defaults for bokeh backend according to the given keyword arguments
Available defaults can be seen in
BokehPlotter
- masci_tools.vis.bokeh_plots.show_bokeh_plot_defaults()[source]¶
Show the currently set defaults for bokeh backend
Available defaults can be seen in
BokehPlotter
Calculation tools¶
This file contains a class to compute the crystalfield coefficients from convoluting the charge density with the potential which produces the crystalfield. This is both compatible with the Yttrium-Analogue approximation and self-consitent calculation of the potential
- class masci_tools.tools.cf_calculation.CFCalculation(*, radial_points=4000, reference_radius='pot', coefficient_cutoff=0.001, **kwargs)[source]¶
Class for calculating Crystal Field coefficients using the procedure described in C.E. Patrick, J.B. Staunton: J. Phys.: Condens. Matter 31, 305901 (2019)
- Using the formula:
The read in quantities are interpolated from logarithmic meshes to equidistant meshes
The function constructs an equidistant mesh between 0 and the muffin tin radius defined in self.reference_radius and with self.radial_points points
- Parameters
radial_points (
int
) – int, number of radial points in the interpolated meshreference_radius (
Union
[float
,Literal
['pot'
,'cdn'
]]) – stror float; Either ‘pot’ or ‘cdn’ or explicit number. Defines which muffin-tin radius is used for the equidistant mesh. IMPORTANT! If txt files are used the muffin-tin radius has to be provided explicitlycoefficient_cutoff (
Optional
[float
]) – float Defines minimum value that cf coefficients have to have to be considered non-zero
- property denNorm¶
Returns the density normalization
DEPRECATED: Use density_normalization instead
- classmethod from_arrays(charge_density, potentials, radial_mesh, **kwargs)[source]¶
Create a CFCalculation instance from arrays
Warning
Using this classmethod will not check that the charge density and potential have the same bravais matrix
- Parameters
- Return type
Other Kwargs are passed on to the constructor
- get_charge_density(interpolated=True)[source]¶
Return the charge density and the corresponding radial mesh
- get_coefficients(convention='Stevens', table_fmt=None)[source]¶
Performs the integration to obtain the crystal field coefficients If the data was not already interpolated, the interpolation will be performed beforehand
Parameters: :type convention:
Literal
['Stevens'
,'Wybourne'
]- param convention
str of the convention to use (Stevens or Wybourne)
- Return type
- Returns
list of CFCoefficient objects (namedtuple), with all the necessary information
- get_potentials(spin, interpolated=True, only_nonzero=True, complex_data=True)[source]¶
Return the potentials and the corresponding radial mesh
- Parameters
spin (
Literal
['up'
,'down'
]) – which spin to returninterpolated (
bool
) – bool, if True the interpolated mesh and potentials are returnedonly_nonzero (
bool
) – bool, if True only the potentials corresponding to a non-zero coefficient are returnedcomplex_data (
bool
) – bool, if False only the real part of the potentials is returned
- Return type
- property nonzero_coefficients_lm: list[tuple[int, int]]¶
Return the lm indices of coefficients that are bigger than the set cutoff
- performIntegration(convert=True)[source]¶
DEPRECATED: Use get_coefficients instead
Performs the integration to obtain the crystal field coefficients If the data was not already interpolated, the interpolation will be performed beforehand
Parameters: :type convert:
- param convert
bool, converts to Steven’s coefficients (if True)
- Returns
list of CFCoefficient objects (namedtuple), with all the necessary information
- read_charge_density(file, atom_type=None, header=0, atomic_cdn=True)[source]¶
Reads in the normed charge density for the CF coefficient calculation If hdf files are given also the muffin tin radius is read in
- Return type
Parameters: :type file:
Union
[str
,bytes
,Path
,PathLike
,IO
[Any
],File
]- param file
Expects string filename for the charge density to read in The function expects either HDF files or txt files with the format (rmesh,cdn). The charge density should be given as r^2n(r) and normed to 1
kwargs: :type atom_type:
Optional
[int
]- param atom_type
int, Defines the atom_type to read in (only for HDF files)
- read_potential(*files, lm_indices=None, atom_type=None, header=0, complex_data=True)[source]¶
Reads in the potentials for the CF coefficient calculation If hdf files are given also the muffin tin radius is read in
- Parameters
args – Expects string filenames for the potentials to read in The function expects either HDF files or txt files with the format (rmesh,vlmup,vlmdn)
lm_indices (
Optional
[list
[tuple
[int
,int
]]]) – list of tuples, Defines the l and m indices for the given txt filesatom_type (
Optional
[int
]) – int, Defines the atomType to read in (only for HDF files)header (
int
) – int, Define how many lines to skip in the beginning of txt filecomplex_data (
bool
) – bool, Define if the data in the text file is complex
- Return type
- Raises:
ValueError: lm indices list length has to match number of files read in
- class masci_tools.tools.cf_calculation.CFCoefficient(l: int, m: int, spin_up: float | complex, spin_down: float | complex, unit: str, convention: str)[source]¶
Namedtuple representing an individual crystal field coefficient
- masci_tools.tools.cf_calculation.plot_crystal_field_calculation(cfcalc, *, saveas='crystal_field_calc', potential_title='Potential', density_title='Density', xlabel='$R$ (Bohr)', potential_ylabel='$Vpot$ (Hartree)', density_ylabel='Density', density_kwargs=None, potential=True, density=True, axis_potential=None, axis_density=None, **kwargs)[source]¶
Plot the given potentials and charge densities used in the given
CFCalculation
- Parameters
cfcalc – CFcalculation containing the data to plot
saveas – str, Define the filename to save the figure
potential_title – Title for the potential subplot
density_title – Title for the charge density subplot
xlabel – label for the x axis of both subplots
potential_ylabel – label for the y axis of the potential subplot
density_ylabel – label for the y axis f the charge density subplot
density_kwargs – dict with keyword argument passed to the plotting of the density
figure – Use this preexisting matplotlib figure to produce the plots
All other Kwargs are passed on to the
multiple_scatterplots()
calls for plotting the potentials
- masci_tools.tools.cf_calculation.plot_crystal_field_potential(cfcoeffs, *, saveas='crystal_field_potential_areaplot', spin='avg', phi=0.0, figure=None, **kwargs)[source]¶
Plots the angular dependence of the calculated CF potential as well as a plane defined by phi.
- Parameters
cfcoeffs – list of CFCoefficients to construct the potential
saveas – str, defines the filename to save the figure
spin – str; Either ‘up’, ‘dn’ or ‘avg’. Which spin direction to plot (‘avg’-> (‘up’+’dn’)/2.0)
phi – float, defines the phi angle of the plane
- Raises
AssertionError – When coefficients are provided as wrong types or in the wrong convention
ValueError – When coefficients are provided in the wrong convention
This module contains utility and functions to work with Green’s functions calculated
and written to greensf.hdf
files by fleur
- class masci_tools.tools.greensfunction.GreensFunction(element, data, attributes)[source]¶
Class for working with Green’s functions calculated by the fleur code
- Parameters
element (
GreensfElement
) –GreensfElement
namedtuple containing the information about the elementdata (
dict
[str
,Any
]) – datasets dict produced by one of the hdf recipes for reading Green’s functionsattributes (
dict
[str
,Any
]) – attributes dict produced by one of the hdf recipes for reading Green’s functions
- energy_dependence(*, m=None, mp=None, spin=None, imag=True, both_contours=False)[source]¶
Select data with energy dependence
- Parameters
m (
Optional
[int
]) – optional integer magnetic quantum number between -l and lmp (
Optional
[int
]) – optional integer magnetic quantum number between -lp and lpspin (
Optional
[int
]) – optional integer spin between 1 and nspinsboth_contours (
bool
) – bool id True the data is not added for both energy contoursimag (
bool
) – bool if True and both_contours is False the imaginary part:math:frac{1}{2i}left[Gleft(zright)-Gleft(z^astright)right] is returned otherwise the real part
- Return type
- Returns
numpy array with the selected data
- classmethod fromFile(file, index=None, **selection_params)[source]¶
Classmethod for creating a
GreensFunction
instance directly from a hdf file- Parameters
- Return type
If index is not given Keyword arguments with the keys being the names of the fields of
GreensfElement
can be given to select the right Green’s function. The specification has to match only one element in the file
- get_coefficient(name, spin=None, radial=False)[source]¶
Get the coefficient with the given name from the data attribute
- Parameters
name (
Literal
['sphavg'
,'uu'
,'ud'
,'du'
,'dd'
,'ulou'
,'uulo'
,'ulod'
,'dulo'
,'uloulo'
]) – name of the coefficientradial (
bool
) – if the Green’s function is stored by coefficient and radial is True it is multiplied by the corresponding radial function otherwise the scalar product is multipliedspin (
Optional
[int
]) – integer index of the spin to retrieve
- Return type
- Returns
numpy.ndarray for the given coefficient and spin
- property nspins: int¶
Return the number of spins of the current element. If mperp is True for the element it is 4 otherwise it is determined by the spins attribute
- occupation(spin=None)[source]¶
Calculate the 0-th moment of the green’s function
Note
Only if the energy contour ends at the fermi energy/is correlty weighted to produce occupations, will this function produce occupations
- to_global_frame()[source]¶
Rotate the Green’s function into the global real space and spin space frame
- Return type
- to_local_frame()[source]¶
Rotate the Green’s function into the local real space and spin space frame
- Return type
- static to_m_index(m)[source]¶
Convert between magnetic quantum numbers between -l and l to 0 and 2l+1 for easier indexing
- static to_spin_indices(spin)[source]¶
Convert between spin index (0 to 3) to the corresponding two spin indices (0 or 1)
- class masci_tools.tools.greensfunction.GreensfElement(l: int, lp: int, atomType: int, atomTypep: int, sphavg: bool, onsite: bool, kresolved: bool, contour: int, nLO: int, atomDiff: np.ndarray)[source]¶
Namedtuple representing the high-level information about the Green’s functions, i.e. what kind, which atoms, which orbitals
- class masci_tools.tools.greensfunction.colors[source]¶
Color strings for coloring terminal output
You may need to change color settings in iPython
- masci_tools.tools.greensfunction.intersite_shell_indices(elements, reference_atom, show=False, max_shells=None)[source]¶
Construct the green’s function pairs to calculate the Jij exchange constants for a given reference atom from a list of
GreensfElement
- Parameters
elements (
list
[GreensfElement
]) – list of GreenfElements to usereference_atom (
int
) – integer of the atom to calculate the Jij’s for (correspinds to the i)show (
bool
) – if True the elements belonging to a shell are printed in a shellmax_shells (
Optional
[int
]) – optional int, if given only the first max_shells shells are constructed
- Return type
- Returns
list of tuples with distance and all indices of pairs in the shell
- masci_tools.tools.greensfunction.intersite_shells(greensfunctions, reference_atom, show=False, max_shells=None)[source]¶
Construct the green’s function pairs to calculate the Jij exchange constants for a given reference atom from a list of given
GreensFunction
- Parameters
greensfunctions (
list
[GreensFunction
]) – List of Greens Function to usereference_atom (
int
) – integer of the atom to calculate the Jij’s for (correspinds to the i)show (
bool
) – if True the elements belonging to a shell are printed in a shellmax_shells (
Optional
[int
]) – optional int, if given only the first max_shells shells are constructed
- Return type
Generator
[tuple
[floating
[Any
],GreensFunction
,GreensFunction
],None
,None
]- Returns
flat iterator with distance and the two corresponding
GreensFunction
instances for each Jij calculation
- masci_tools.tools.greensfunction.intersite_shells_from_file(hdffile, reference_atom, show=False, max_shells=None)[source]¶
Construct the green’s function pairs to calculate the Jij exchange constants for a given reference atom from a given
greensf.hdf
file- Parameters
hdffile (
Union
[str
,bytes
,Path
,PathLike
,IO
[Any
]]) – filepath or file handle to a greensf.hdf filereference_atom (
int
) – integer of the atom to calculate the Jij’s for (correspinds to the i)show (
bool
) – if True the elements belonging to a shell are printed in a shellmax_shells (
Optional
[int
]) – optional int, if given only the first max_shells shells are constructed
- Return type
Generator
[tuple
[floating
[Any
],GreensFunction
,GreensFunction
],None
,None
]- Returns
flat iterator with distance and the two corresponding
GreensFunction
instances for each Jij calculation
- masci_tools.tools.greensfunction.listElements(hdffile, show=False)[source]¶
Find the green’s function elements contained in the given
greens.hdf
file
- masci_tools.tools.greensfunction.printElements(elements, index=None, mark=None)[source]¶
Print the given list of
GreensfElement
in a nice table- Parameters
elements (
list
[GreensfElement
]) – list ofGreensfElement
to be printedindex (
Optional
[list
[int
]]) – optional list of indices to show instead of the default index in the listmark (
Optional
[list
[int
]]) – optional list of int with elements to emphasize with an arrow and color
- Return type
- masci_tools.tools.greensfunction.select_element_indices(elements, show=False, **selection_params)[source]¶
Select
GreensfElement
objects from a list based on constraints on their values- Parameters
elements (
list
[GreensfElement
]) – list ofGreensfElement
to choose fromshow (
bool
) – bool if True the found elements will be printed
The Keyword arguments correspond to the names of the fields and their desired value
- masci_tools.tools.greensfunction.select_elements(greensfunctions, show=False, **selection_params)[source]¶
Select
GreensFunction
objects from a list based on constraints on the values of their underlyingGreensfElement
- Parameters
greensfunctions (
list
[GreensFunction
]) – list ofGreensFunction
to choose fromshow (
bool
) – bool if True the found elements will be printed
The Keyword arguments correspond to the names of the fields and their desired value
- Return type
- Returns
iterator over the matching
GreensFunction
- masci_tools.tools.greensfunction.select_elements_from_file(hdffile, show=False, **selection_params)[source]¶
Construct the green’s function matching specified criteria from a given
greensf.hdf
file- Parameters
The Keyword arguments correspond to the names of the fields and their desired value
- Return type
- Returns
iterator over the matching
GreensFunction
This module collects functions for calculating properties with the greens functions calculated by Fleur. At the moment the following are implemented:
Calculating Heisenberg J_0 (spin stiffness) from onsite Green’s functions
Calculating Heisenberg J_ij exchange constants from intersite Green’s functions
Calculating the hybridization function from onsite Greens functions
- masci_tools.tools.greensf_calculations.calculate_heisenberg_j0(greensfunction, onsite_delta, show=False)[source]¶
Calculate spin stiffness J_0 for the given green’s function using the formula
- Parameters
greensfunction (
GreensFunction
) –GreensFunction
to use for the calculationonsite_delta (
float
) – onsite exchange splitting to use for the calculationshow (
bool
) – bool if True additional information about the used Greens functions is printed out
- Return type
- Returns
the value of the spin stiffness in meV
- masci_tools.tools.greensf_calculations.calculate_heisenberg_jij(hdffileORgreensfunctions, reference_atom, onsite_delta, max_shells=None)[source]¶
Calculate the Heisenberg exchange constants form Green’s functions using the formula
- Parameters
hdffileORgreensfunctions (
Union
[str
,bytes
,Path
,PathLike
,IO
[Any
],list
[GreensFunction
]]) – either pat/file-like object for thegreensf.hdf
file to use or list ofGreensFunction
reference_atom (
int
) – integer index of the atom to calculate the Jijs fromonsite_delta (
ndarray
) – List of floats containing the onsite exchange splitting for each atom type and l-channelmax_shells (
Optional
[int
]) – optional int, if given only the first max_shells shells are constructed
- Return type
- Returns
pandas DataFrame containing all the Jij constants
- masci_tools.tools.greensf_calculations.calculate_heisenberg_tensor(hdffileORgreensfunctions, reference_atom, onsite_delta, max_shells=None)[source]¶
Calculate the Heisenberg exchange tensor
from Green’s functions using the formula
for all
.
- Parameters
hdffileORgreensfunctions (
Union
[str
,bytes
,Path
,PathLike
,IO
[Any
],list
[GreensFunction
]]) – either pat/file-like object for thegreensf.hdf
file to use or list ofGreensFunction
reference_atom (
int
) – integer index of the atom to calculate the Jijs fromonsite_delta (
ndarray
) – List of floats containing the onsite exchange splitting for each atom type and l-channelmax_shells (
Optional
[int
]) – optional int, if given only the first max_shells shells are constructed
- Return type
- Returns
pandas DataFrame containing all the J_xx, J_xy, etc. constants
- masci_tools.tools.greensf_calculations.calculate_hybridization(greensfunction)[source]¶
Calculate the hybridization function as
- Return type
- Returns
numpy array of the hybridization function
- masci_tools.tools.greensf_calculations.decompose_jij_tensor(jij_tensor, moment_direction)[source]¶
Decompose the Heisenberg tensor as calculated by
calculate_heisenberg_tensor()
into three partsIsotropic
Symmetric traceless
Antisymmetric
IO helper functions and file parsers¶
KKR related IO¶
In this module you find the kkrparams class that helps defining the KKR input parameters Also some defaults for the parameters are defined.
- class masci_tools.io.kkr_params.kkrparams(**kwargs)[source]¶
Class for creating and handling the parameter input for a KKR calculation Optional keyword arguments are passed to init and stored in values dictionary.
Example usage: params = kkrparams(LMAX=3, BRAVAIS=array([[1,0,0], [0,1,0], [0,0,1]]))
- Alternatively values can be set afterwards either individually with
params.set_value(‘LMAX’, 3)
- or multiple keys at once with
params.set_multiple_values(EMIN=-0.5, EMAX=1)
Other useful functions
print the description of a keyword: params.get_description([key]) where [key] is a string for a keyword in params.values
print a list of mandatory keywords: params.get_all_mandatory()
print a list of keywords that are set including their value: params.get_set_values()
- change_XC_val_kkrimp(val)[source]¶
Convert integer value of KKRhost KEXCOR input to KKRimp XC string input.
- fill_keywords_to_inputfile(is_voro_calc=False, output='inputcard', no_check=False, verbose=False)[source]¶
Fill new inputcard with keywords/values automatically check for input consistency (can be disabled by the no_check input) if is_voro_calc==True change mandatory list to match voronoi code, default is KKRcode
- classmethod get_KKRcalc_parameter_defaults(silent=False)[source]¶
set defaults (defined in header of this file) and returns dict, kkrparams_version
- get_description(key=None, search=None)[source]¶
Returns description of keyword ‘key’ If ‘key’ is None, print all descriptions of all available keywords If ‘search’ is not None, print all keys+descriptions where the search string is found
- get_dict(group=None, subgroup=None)[source]¶
Returns values dictionary.
Prints values belonging to a certain group only if the ‘group’ argument is one of the following: ‘lattice’, ‘chemistry’, ‘accuracy’, ‘external fields’, ‘scf cycle’, ‘other’
Additionally the subgroups argument allows to print only a subset of all keys in a certain group. The following subgroups are available.
in ‘lattice’ group ‘2D mode’, ‘shape functions’
in ‘chemistry’ group ‘Atom types’, ‘Exchange-correlation’, ‘CPA mode’, ‘2D mode’
in ‘accuracy’ group ‘Valence energy contour’, ‘Semicore energy contour’, ‘CPA mode’, ‘Screening clusters’, ‘Radial solver’, ‘Ewald summation’, ‘LLoyd’
- read_keywords_from_inputcard(inputcard='inputcard', verbose=False)[source]¶
Read list of keywords from inputcard and extract values to keywords dict
- Example usage
p = kkrparams(); p.read_keywords_from_inputcard(‘inputcard’)
- Note
converts ‘<RBLEFT>’, ‘<RBRIGHT>’, ‘ZPERIODL’, and ‘ZPERIODR’ automatically to Ang. units!
- set_multiple_values(**kwargs)[source]¶
Set multiple values (in example value1 and value2 of keywords ‘key1’ and ‘key2’) given as key1=value1, key2=value2
- static split_kkr_options(valtxt)[source]¶
Split keywords after fixed length of 8 :type valtxt: :param valtxt: list of strings or single string :returns: List of keywords of maximal length 8
Reading of shpefun files of KKR
- masci_tools.io.kkr_read_shapefun_info.read_shapefun(path='.')[source]¶
Read vertices of shapefunctions with Zoom into shapefun of a single atom
- Author
Philipp Ruessmann
- Parameters
path – path where voronoi output is found (optional, defaults to ‘./’)
- Returns pos
positions of the centers of the shapefunctions
- Returns out
dictionary of the vertices of the shapefunctions
Here I collect all functions needed to parse the output of a KKR calculation. These functions do not need aiida and are therefore separated from the actual parser file where parse_kkr_outputfile is called
- masci_tools.io.parsers.kkrparser_functions.check_error_category(err_cat, err_msg, out_dict)[source]¶
Check if parser error of the non-critical category (err_cat != 1) are actually consistent and may be discarded.
- Parameters
err_cat – the error-category of the error message to be investigated
err_msg – the error-message
out_dict – the dict of results obtained from the parser function
- Returns
True/False if message is an error or warning
- masci_tools.io.parsers.kkrparser_functions.get_kmeshinfo(outfile_0init, outfile_000)[source]¶
Extract kmesh info from output.0.txt and output.000.txt
- masci_tools.io.parsers.kkrparser_functions.get_lattice_vectors(outfile_0init)[source]¶
read direct and reciprocal lattice vectors in internal units (useful for qdos generation)
- masci_tools.io.parsers.kkrparser_functions.get_natom(outfile_0init)[source]¶
extract NATYP value from output.0.txt
- masci_tools.io.parsers.kkrparser_functions.get_noco_rms(outfile, debug=False)[source]¶
Get average noco rms error
- masci_tools.io.parsers.kkrparser_functions.get_nspin(outfile_0init)[source]¶
extract NSPIN value from output.0.txt
- masci_tools.io.parsers.kkrparser_functions.get_orbmom(outfile, natom)[source]¶
read orbmom info from outfile and return array (iteration, atom)=orbmom
- masci_tools.io.parsers.kkrparser_functions.get_rms(outfile, outfile2, debug=False)[source]¶
Get rms error per atom (both values for charge and spin) and total (i.e. average) value
- masci_tools.io.parsers.kkrparser_functions.get_single_particle_energies(outfile_000)[source]¶
extracts single particle energies from outfile_000 (output.000.txt) returns the valence contribution of the single particle energies
- masci_tools.io.parsers.kkrparser_functions.get_spinmom_per_atom(outfile, natom, nonco_out_file=None)[source]¶
Extract spin moment information from outfile and nonco_angles_out (if given)
- masci_tools.io.parsers.kkrparser_functions.parse_array_float(outfile, searchstring, splitinfo, replacepair=None, debug=False)[source]¶
Search for keyword searchstring in outfile and extract array of results
Returns: array of results
- masci_tools.io.parsers.kkrparser_functions.parse_kkr_outputfile(out_dict, outfile, outfile_0init, outfile_000, timing_file, potfile_out, nonco_out_file, outfile_2='output.2.txt', skip_readin=False, debug=False)[source]¶
Parser method for the kkr outfile. It returns a dictionary with results
- masci_tools.io.parsers.kkrparser_functions.use_BdG(outfile_0init)[source]¶
extract BdG run info from output.0.txt
- masci_tools.io.parsers.kkrparser_functions.use_newsosol(outfile_0init)[source]¶
extract NEWSOSOL info from output.0.txt
Everything that is needed to parse the output of a voronoi calculation.
- masci_tools.io.parsers.voroparser_functions.check_voronoi_output(potfile, outfile, delta_emin_safety=0.1)[source]¶
Read output from voronoi code and create guess of energy contour
- masci_tools.io.parsers.voroparser_functions.get_valence_min(outfile='out_voronoi')[source]¶
Construct minimum of energy contour (between valence band bottom and core states)
- masci_tools.io.parsers.voroparser_functions.parse_voronoi_output(out_dict, outfile, potfile, atominfo, radii, inputfile, debug=False)[source]¶
Parse output of voronoi calculation and return (success, error_messages_list, out_dict)
Tools for the impurity calculation plugin and its workflows
- class masci_tools.io.parsers.kkrimp_parser_functions.KkrimpParserFunctions[source]¶
Class of parser functions for KKRimp calculation
- Usage
success, msg_list, out_dict = parse_kkrimp_outputfile().parse_kkrimp_outputfile(out_dict, files)
- parse_kkrimp_outputfile(out_dict, file_dict, debug=False)[source]¶
Main parser function for kkrimp, read information from files in file_dict and fills out_dict :type out_dict: :param out_dict: dictionary that is filled with parsed output of the KKRimp calculation :type file_dict: :param file_dict: dictionary of files that are parsed :returns: success (bool), msg_list(list of error/warning messages of parser), out_dict (filled dict of parsed output) :note: file_dict should contain the following keys
‘outfile’, the std_out of the KKRimp calculation
‘out_log’, the out_log.000.txt file
‘out_pot’, the output potential
‘out_enersp_at’, the out_energysp_per_atom_eV file
‘out_enertot_at’, the out_energytotal_per_atom_eV file
‘out_timing’, the timing file
‘kkrflex_llyfac’, the file for the Lloyd factor
‘kkrflex_angles’, the nonco_angles file for the KKRimp calculation
‘out_spinmoms’, the output spin moments file
‘out_orbmoms’, the output orbital moments file