sisl.viz.Plot

class sisl.viz.Plot(*args, **kwargs)[source]

Bases: ShortCutable, Configurable

Parent class of all plot classes

Implements general things needed by all plots such as settings and shortcut management.

Parameters
  • root_fdf (fdfSileSiesta, optional) – Path to the fdf file that is the ‘parent’ of the results.

  • results_path (str, optional) – Directory where the files with the simulations results are located. This path has to be relative to the root fdf.

  • entry_points_order (array-like, optional) – Order with which entry points will be attempted.

  • backend (optional) – Directory where the files with the simulations results are located. This path has to be relative to the root fdf.

settings

contains the values for each setting of the plot.

Type

dict

params

for each setting, contains information about their input field.

This information might include valid values, for example.

Type

dict

paramGroups

contains the different setting groups present in the plot.

Each group is a dict like { “key”: , “name”: ,”icon”: , “description”: }

Type

tuple of dicts

...

Methods

add_shortcut(_keys, _name, func, *args[, ...])

Makes a new shortcut available to the instance.

animated(*args[, fixed, frame_names, ...])

Creates an animation out of a class

call_shortcut(keys, *args, **kwargs)

Programatic way to call a shortcut.

clone(*args, **kwargs)

Gets you and exact clone of this plot

copy()

Returns a copy of the plot

dispatch_event(event, *args, **kwargs)

Not functional yet

entry_points_help()

Generates a helpful message about the entry points of the plot class

follow(*files[, to_abs, unfollow])

Makes sure that the object knows which files to follow in order to trigger updates

from_plotly(plotly_fig)

Converts a plotly plot to a Plot object

get_class_param(key[, as_dict])

get_figure(backend[, clear_fig])

Generates a figure out of the already processed data.

get_param(key[, as_dict, params_extractor])

Gets the parameter for a given setting

get_setting(key[, copy, parse])

Gets the value for a given setting

get_settings_group(group[, steps_back])

Gets the subset of the settings that corresponds to a given group

get_sile(path, results_path, root_fdf, *args)

A wrapper around get_sile so that the reading of the file is registered

has_shortcut(keys)

Checks if a shortcut is already registered.

has_these_settings([settings])

Checks if the object settings match the provided settings

init_settings([presets])

Initializes the settings for the object.

listen([forever, show, as_animation, ...])

Listens for updates in the followed files (see the updates_available method)

merge(others[, to, extend_multiples])

Merges this plot's instance with the list of plots provided

modify_param(key, *args, **kwargs)

Modifies a given parameter

multiple(*args[, fixed, template_plot, ...])

Creates a multiple plot out of a class

plot_name()

The name of the plot.

read_data(*args[, children_sel])

remove_shortcut(keys)

Unregisters a given shortcut.

save(path)

Saves the plot so that it can be loaded in the future

set_data(*args[, children_sel])

setup_hamiltonian(**kwargs)

Sets up the hamiltonian for calculations with sisl

shortcut(keys)

Gets the dict that represents a shortcut.

shortcuts_summary([format])

Gets a formatted summary of the shortcuts.

show(*args[, listen, return_figWidget])

Displays the plot

stop_listening([fig_widget])

Makes the plot stop listening for updates

subplots(*args[, fixed, template_plot, ...])

Creates subplots where each plot has different settings

suffix()

Get the suffix that this class adds to plotting functions

undo_setting(key)

Undoes only a particular setting and leaves the others unchanged

undo_settings([steps, run_updates])

Brings the settings back a number of steps

undo_settings_group(group)

Takes the desired group of settings one step back, but the rest of the settings remain unchanged

update_settings(*args, **kwargs)

Updates the settings of this plot.

updates_available()

This function checks whether the read files have changed

get_figure_methods

read_data_methods

set_data_methods

settings

The current settings of the object

shortcuts_for_json

Returns a jsonifiable object with information of the shortcuts

__init__(*args, H=None, attrs_for_plot={}, only_init=False, presets=None, layout={}, _debug=False, **kwargs)[source]
add_shortcut(_keys, _name, func, *args, _description=None, **kwargs)

Makes a new shortcut available to the instance.

You will see that argument names here are marked with “_”, in an attempt to avoid interfering with the action function’s arguments.

Parameters
  • _keys (str) – the sequence of keys that trigger the shortcut (e.g.: ctrl+e).

  • _name (str) – a short name for the shortcut that should give a first idea of what the shortcut does.

  • func (function) – the function to execute when the shortcut is called.

  • *args – positional arguments that go to the function’s execution.

  • _description (str, optional) – a longer description of what the shortcut does, maybe including some tips and gotcha’s.

  • **kwargs – keyword arguments that go to the function’s execution.

classmethod animated(*args, fixed={}, frame_names=None, template_plot=None, **kwargs)[source]

Creates an animation out of a class

This class method returns an animation with frames belonging to a given plot class.

For example, if you run BandsPlot.animated() you will get an animation made of bands plots.

If no arguments are passed, you will get the default animation for that plot, if there is any.

Parameters
  • *args

    Depending on what you pass the arguments will be interpreted differently:
    • Two arguments:
      First: str

      Key of the setting that you want to animate.

      Second: array-like

      Values that you want the setting to have at each animation frame.

      Ex: BandsPlot.animated(“bands_file”, [“file1”, “file2”, “file3”] ) will produce an animation where each frame uses a different bands_file.

    • One argument and it is a dictionary:
      First: dict

      The keys of this dictionary will be the setting keys you want to animate and the values are of course the values for each frame for that setting.

      It works exactly as the previous case, but in this case we have multiple settings to animate.

    • One argument and it is a function:
      First: function

      With this function you can produce any settings you want without limitations.

      It will be used as the _getInitKwargsList method of the animation, so it needs to accept self (the animation object) and return a list of dictionaries which are the settings for each frame.

      the function will recieve the parameter and can act on it in any way you like. It doesn’t need to return the parameter, just modify it. In this function, you can call predefined methods of the parameter, for example.

      Ex: obj.modify_param(“length”, lambda param: param.incrementByOne() )

      given that you know that this type of parameter has this method.

  • fixed (dict, optional) – A dictionary containing values for settings that will be fixed along the animation. For the settings that you don’t specify here you will get the defaults.

  • frame_names (list of str or function, optional) –

    If it is a list of strings, each string will be used as the name for the corresponding frame.

    If it is a function, it should accept self (the animation object) and return a list of strings with the frame names. Note that you can access the plot instance responsible for each frame under self.children. The function will be run each time the figure is generated, so in this way your frame names will be dynamic.

    FRAME NAMES SHOULD BE UNIQUE, OTHERWISE THE ANIMATION WILL HAVE A WEIRD BEHAVIOR.

    If this is not provided, frame names will be generated automatically.

  • template_plot (sisl Plot, optional) –

    If provided this plot will be used as a template.

    It is important to know that it will not act only as the settings template, but it also will PROVIDE DATA FOR THE OTHER PLOTS in case the data reading settings are not animated.

    This is extremely important to provide when possible, because in some cases the data that a plot gathers can be very large and therefore it may not be even feasable to store the repeated data in terms of memory/time.

  • **kwargs

    Will be passed directly to animation initialization, so it can contain the settings for the animation, for example.

    If args are not passed and the default animation is being created. Some keyword arguments may be used by the method that generates the default animation. One recurrent example of this is the keyword wdir.

Returns

The Animation that you asked for

Return type

Animation

call_shortcut(keys, *args, **kwargs)

Programatic way to call a shortcut.

In fact, this is the method that is executed when a keypress is detected in the GUI or the jupyter notebook.

Parameters
  • keys (str) – the sequence of keys that trigger the shortcut.

  • **kwargs (*args and) –

    extra arguments that you pass to the function call.

clone(*args, **kwargs)[source]

Gets you and exact clone of this plot

You can pass extra args that will overwrite the previous parameters though, if you don’t want it to be that exact.

IMPORTANT: IT WILL INITIALIZE A NEW PLOT, THEREFORE IT WILL READ NEW DATA. IF YOU JUST WANT A COPY, USE THE copy() method.

copy()[source]

Returns a copy of the plot

If you want a plot with the exact plot configuration but newly initialized, use clone() instead.

dispatch_event(event, *args, **kwargs)[source]

Not functional yet

classmethod entry_points_help()[source]

Generates a helpful message about the entry points of the plot class

follow(*files, to_abs=True, unfollow=False)[source]

Makes sure that the object knows which files to follow in order to trigger updates

Parameters
  • *files (str) –

    a string that represents the path to the file that needs to be followed.

    You can pass as many as you want as separate arguments. Note that if you have a list of files you can pass them separately by doing follow(*my_list_of_files), you don’t need to (and you shouldn’t) build a loop :)

  • to_abs (boolean, optional) – whether the paths should be converted to absolute paths to make file following procedures more robust. It is better to leave it as True unless you have a good reason to change it.

  • unfollow (boolean, optional) – whether the previous files should be unfollowed. If set to False, we are just adding more files.

classmethod from_plotly(plotly_fig)[source]

Converts a plotly plot to a Plot object

Parameters

plotly_fig (plotly.graph_objs.Figure) – the figure that we want to convert into a sisl plot

Returns

the converted plot that contains the plotly figure.

Return type

Plot

classmethod get_class_param(key, as_dict=False)
get_figure(backend, clear_fig=True, **kwargs)[source]

Generates a figure out of the already processed data.

Parameters

clear_fig (boolean, optional) – whether the figure should be cleared before drawing.

Returns

self.figure – the plotly figure.

Return type

plotly.graph_objs.Figure

property get_figure_methods
get_param(key, as_dict=False, params_extractor=False)

Gets the parameter for a given setting

Parameters
  • key (str) – The key of the desired parameter.

  • as_dict (bool, optional) – If set to True, returns a dictionary instead of the actual parameter object.

  • params_extractor (function, optional) – A function that accepts the object (self) and returns its params (NOT A COPY OF THEM!). This will only be used in case this method is used outside the class, where objects have a different structure (e.g. QueriesInput inputField) or if there is some nested params field that the class is not aware of (although this second case is probably not advisable).

Returns

param – The parameter in the form specified by as_dict.

Return type

dict or InputField

get_setting(key, copy=True, parse=True)

Gets the value for a given setting

Parameters
  • key (str) – The key of the setting we want to get

  • copy (boolean, optional) – Whether you want a copy of the object or the actual object

  • parse (boolean, optional) – whether the setting should be parsed before returning it.

get_settings_group(group, steps_back=0)

Gets the subset of the settings that corresponds to a given group

Parameters
  • group (str) – The key of the settings group that we desire.

  • steps_back (optional, int) – If you don’t want the actual settings, but some point of the settings history, use this argument to state how many steps back you want the settings’ values.

Returns

settings_group – A subset of the settings with only those that belong to the asked group.

Return type

dict

get_sile(path, results_path, root_fdf, *args, follow=True, follow_kwargs={}, file_contents=None, **kwargs)[source]

A wrapper around get_sile so that the reading of the file is registered

It has to main functions:
  • Automatically following files that are read, so that you don’t neet to go always like:

    ` self.follow(file) sisl.get_sile(file) `

  • Infering files from a root file. For example, using the root_fdf.

Parameters
  • path (str) – the path to the file that you want to read. It can also be the setting key that you want to read.

  • *args – passed to sisl.get_sile

  • follow (boolean, optional) – whether the path should be followed.

  • follow_kwargs (dict, optional) – dictionary of keywords that are passed directly to the follow method.

  • **kwargs – passed to sisl.get_sile

has_shortcut(keys)

Checks if a shortcut is already registered.

Parameters

keys (str) – the sequence of keys that trigger the shortcut.

has_these_settings(settings={}, **kwargs)

Checks if the object settings match the provided settings

Parameters
  • settings (dict) – dictionary containing the settings keys and values

  • **kwargs – setting keys and values can also be passed as keyword arguments.

  • time (You can use settings and **kwargs at the same) –

  • merged. (they will be) –

init_settings(presets=None, **kwargs)

Initializes the settings for the object.

Parameters
  • presets (str or array-like of str) – all the presets that you want to use. Note that you can register new presets using sisl.viz.plotly.add_preset

  • **kwargs

    the values of the settings passed as keyword arguments.

    If a setting is not provided, the default value will be used.

listen(forever=True, show=True, as_animation=False, return_animation=True, return_figWidget=False, clear_previous=True, notify=False, speak=False, notify_title=None, notify_message=None, speak_message=None, fig_widget=None)[source]

Listens for updates in the followed files (see the updates_available method)

Parameters
  • forever (boolean, optional) – whether to keep listening after the first plot update

  • show (boolean, optional) – whether to show the plot at the beggining and update the layout when the plot is updated.

  • as_animation (boolean, optional) –

    will add a new frame each time the plot is updated.

    The resulting animation is returned unless return_animation is set to False. This is done because the Plot object iself is not converted to an animation. Instead, a new animation is created and if you don’t save it in a variable it will be lost, you will have no way to access it later.

    If you are seeing two figures at the beggining, it is because you are not storing the animation figure. Set the return_animation parameter to False if you understand that you are going to “lose” the animation, you will only be able to see a display of it while it is there.

  • return_animation (boolean, optional) – if as_animation is True, whether the animation should be returned. Important: see as_animation for an explanation on why this is the case

  • return_figWidget (boolean, optional) –

    it returns the figure widget that is in display in a jupyter notebook in case the plot has succeeded to display it. Note that, even if you are in a jupyter notebook, you won’t get a figure widget if you don’t have the plotly notebook extension enabled. Check <your_plot>._widgets to see if you are missing witget support.

    if return_animation is True, both the animation and the figure widget will be returned in a tuple. Although right now, this does not make much sense because figure widgets don’t support frames. You will get None.

  • clear_previous (boolean, optional) – in case show is True, whether the previous version of the plot should be hidden or kept in display.

  • notify (boolean, optional) – trigger a notification everytime the plot updates.

  • speak (boolean, optional) – trigger a spoken message everytime the plot updates.

  • notify_title (str, optional) – the title of the notification.

  • notify_message (str, optional) – the message of the notification.

  • speak_message (str, optional) – the spoken message. Feel free to get creative here!

merge(others, to='multiple', extend_multiples=True, **kwargs)[source]

Merges this plot’s instance with the list of plots provided

Parameters
  • others (array-like of Plot() or Plot()) – the plots that we want to merge with this plot instance.

  • to ({"multiple", "subplots", "animation"}, optional) – the merge method. Each option results in a different way of putting all the plots together: - “multiple”: All plots are shown in the same canvas at the same time. Useful for direct comparison. - “subplots”: The layout is divided in different subplots. - “animation”: Each plot is converted into the frame of an animation.

  • extend_multiples (boolean, optional) – if True, if MultiplePlot`s are passed, they are splitted into their children, so that the result is the merge of its children with the rest. If False, a `MultiplePlot is treated as a solid unit.

  • kwargs – extra arguments that are directly passed to MultiplePlot, Subplots or Animation initialization.

Returns

depending on the value of the to parameter.

Return type

MultiplePlot, Subplots or Animation

modify_param(key, *args, **kwargs)

Modifies a given parameter

See *args to know how can it be used.

This is a general schema of how an input field parameter looks internally, so that you can know what do you want to change:

(Note that it is very easy to modify nested values, more on this in *args explanation)

{

“key”: whatever, “name”: whatever, “default”: whatever, . . (keys that affect, let’s say, the programmatic functionality of the parameter, . they can be modified with Configurable.modify_param) . “inputField”: {

“type”: whatever, “width”: whatever, (keys that affect the inputField control that is displayed “params”: { they can be modified with Configurable.modifyInputField)

whatever

}, “style”: {

whatever

}

}

}

Parameters
  • key (str) – The key of the parameter to be modified

  • *args

    Depending on what you pass the setting will be modified in different ways:
    • Two arguments:

      the first argument will be interpreted as the attribute that you want to change, and the second one as the value that you want to set.

      Ex: obj.modify_param(“length”, “default”, 3) will set the default attribute of the parameter with key “length” to 3

      Modifying nested keys is possible using dot notation.

      Ex: obj.modify_param(“length”, “inputField.width”, 3) will modify the width key inside inputField on the schema above.

      The last key, but only the last one, will be created if it does not exist.

      Ex: obj.modify_param(“length”, “inputField.width.inWinter.duringDay”, 3) will only work if all the path before duringDay exists and the value of inWinter is a dictionary.

      Otherwise you could go like this: obj.modify_param(“length”, “inputField.width.inWinter”, {“duringDay”: 3})

    • One argument and it is a dictionary:

      the keys will be interpreted as attributes that you want to change and the values as the value that you want them to have.

      Each key-value pair in the dictionary will be updated in exactly the same way as it is in the previous case.

    • One argument and it is a function:

      the function will recieve the parameter and can act on it in any way you like. It doesn’t need to return the parameter, just modify it. In this function, you can call predefined methods of the parameter, for example.

      Ex: obj.modify_param(“length”, lambda param: param.incrementByOne() )

      given that you know that this type of parameter has this method.

  • **kwargs (optional) – They are passed directly to the Configurable.get_param method to retrieve the parameter.

Returns

The configurable object.

Return type

self

classmethod multiple(*args, fixed={}, template_plot=None, merge_method='together', **kwargs)[source]

Creates a multiple plot out of a class

This class method returns a multiple plot that contains several plots of the same class. It is a general method that serves as a common denominator for building MultiplePlot, SubPlot or Animation objects. Therefore, it is used by the animated and subplots methods

If no arguments are passed, you will get the default multiple plot for the class, if there is any.

Parameters
  • *args

    Depending on what you pass the arguments will be interpreted differently:
    • Two arguments:
      First: str

      Key of the setting that you want to be variable.

      Second: array-like

      Values that you want the setting to have in each individual plot.

      Ex: BandsPlot.multiple(“bands_file”, [“file1”, “file2”, “file3”] ) will produce a multiple plot where each plot uses a different bands_file.

    • One argument and it is a dictionary:
      First: dict

      The keys of this dictionary will be the setting keys you want to be variable and the values are of course the values for each plot for that setting.

      It works exactly as the previous case, but in this case we have multiple settings that vary.

    • One argument and it is a function:
      First: function

      With this function you can produce any settings you want without limitations.

      It will be used as the _getInitKwargsList method of the MultiplePlot object, so it needs to accept self (the MultiplePlot object) and return a list of dictionaries which are the settings for each plot.

  • fixed (dict, optional) – A dictionary containing values for settings that will be fixed for all plots. For the settings that you don’t specify here you will get the defaults.

  • template_plot (sisl Plot, optional) –

    If provided this plot will be used as a template.

    It is important to know that it will not act only as the settings template, but it will also PROVIDE DATA FOR THE OTHER PLOTS in case the data reading settings are not being varied through the different plots.

    This is extremely important to provide when possible, because in some cases the data that a plot gathers can be very large and therefore it may not be even feasable to store the repeated data in terms of memory/time.

  • merge_method ({'together', 'subplots', 'animation'}, optional) – the way in which the multiple plots are ‘related’ to each other (i.e. how they should be displayed). In most cases, instead of using this argument, you should probably use the specific method (animated or subplots). They set this argument accordingly but also do some other work to make your life easier.

  • **kwargs

    Will be passed directly to initialization, so it can contain the settings for the MultiplePlot object, for example.

    If args are not passed and the default multiple plot is being created, some keyword arguments may be used by the method that generates the default multiple plot. One recurrent example of this is the keyword wdir.

Returns

The plot that you asked for.

Return type

MultiplePlot, SubPlots or Animation

classmethod plot_name()[source]

The name of the plot. Used to be displayed in the GUI, for example

read_data(*args, children_sel=None, **kwargs)
property read_data_methods
remove_shortcut(keys)

Unregisters a given shortcut.

Parameters

keys (str) – the sequence of keys that trigger the shortcut.

save(path)[source]

Saves the plot so that it can be loaded in the future

Parameters

path (str) – The path to the file where you want to save the plot

Return type

self

set_data(*args, children_sel=None, **kwargs)
property set_data_methods
property settings

The current settings of the object

setup_hamiltonian(**kwargs)[source]

Sets up the hamiltonian for calculations with sisl

shortcut(keys)

Gets the dict that represents a shortcut.

Parameters

keys (str) – the sequence of keys that trigger the shortcut.

property shortcuts_for_json

Returns a jsonifiable object with information of the shortcuts

This is meant to be passed to the GUI, so that it knows which shortcuts are available.

shortcuts_summary(format='str')

Gets a formatted summary of the shortcuts.

show(*args, listen=False, return_figWidget=False, **kwargs)[source]

Displays the plot

Parameters
  • listen (bool, optional) – after showing, keeps listening for file changes to update the plot. This is nice for monitoring.

  • return_figureWidget (bool, optional) – if the plot is displayed in a jupyter notebook, whether you want to get the figure widget as a return so that you can act on it.

stop_listening(fig_widget=None)[source]

Makes the plot stop listening for updates

Using this method only makes sense if you have previously made the plot listen either through Plot.listen() or Plot.show(listen=True)

Parameters

fig_widget (plotly FigureWidget, optional) –

the figure widget where the plot is currently being displayed.

This is just used to reset the listening shortcut.

YOU WILL MOST LIKELY NOT USE THIS because Plot already knows where is it being displayed in normal situations.

classmethod subplots(*args, fixed={}, template_plot=None, rows=None, cols=None, arrange='rows', **kwargs)[source]

Creates subplots where each plot has different settings

Mainly, it uses the multiple method to generate them.

Parameters
  • *args

    Depending on what you pass the arguments will be interpreted differently:
    • Two arguments:
      First: str

      Key of the setting that you want to vary across subplots.

      Second: array-like

      Values that you want the setting to have in each subplot.

      Ex: BandsPlot.multiple(“bands_file”, [“file1”, “file2”, “file3”] ) will produce a layout where each subplot uses a different bands_file.

    • One argument and it is a dictionary:
      First: dict

      The keys of this dictionary will be the setting keys you want to vary across subplots and the values are of course the values for each plot for that setting.

      It works exactly as the previous case, but in this case we have multiple settings that vary.

    • One argument and it is a function:
      First: function

      With this function you can produce any settings you want without limitations.

      It will be used as the _getInitKwargsList method of the MultiplePlot object, so it needs to accept self (the MultiplePlot object) and return a list of dictionaries which are the settings for each plot.

  • fixed (dict, optional) – A dictionary containing values for settings that will be fixed for all subplots. For the settings that you don’t specify here you will get the defaults.

  • template_plot (sisl Plot, optional) –

    If provided this plot will be used as a template.

    It is important to know that it will not act only as the settings template, but it will also PROVIDE DATA FOR THE OTHER PLOTS in case the data reading settings are not being varied through the different plots.

    This is extremely important to provide when possible, because in some cases the data that a plot gathers can be very large and therefore it may not be even feasable to store the repeated data in terms of memory/time.

  • rows (int, optional) – The number of rows of the plot grid. If not provided, it will be inferred from cols and the number of plots. If neither cols or rows are provided, the arrange parameter will decide how the layout should look like.

  • cols (int, optional) – The number of columns of the subplot grid. If not provided, it will be inferred from rows and the number of plots. If neither cols or rows are provided, the arrange parameter will decide how the layout should look like.

  • arrange ({'rows', 'col', 'square'}, optional) – The way in which subplots should be aranged if the rows and/or cols parameters are not provided.

  • **kwargs

    Will be passed directly to SubPlots initialization, so it can contain the settings for it, for example.

    If args are not passed and the default multiple plot is being created, some keyword arguments may be used by the method that generates the default multiple plot. One recurrent example of this is the keyword wdir.

classmethod suffix()[source]

Get the suffix that this class adds to plotting functions

See sisl/viz/_plotables.py and particularly the register_plotable function to understand this better.

undo_setting(key)

Undoes only a particular setting and leaves the others unchanged

At the moment it is a ‘fake’ undo function, since it actually updates the settings.

Parameters

key (str) – the key of the setting that you want to undo.

undo_settings(steps=1, run_updates=True)

Brings the settings back a number of steps

Parameters
  • steps (int, optional) – the number of steps you want to go back.

  • run_updates (bool, optional) – whether we should run updates after updating the settings. If not, the settings will be updated, but you won’t see any change in the object.

undo_settings_group(group)

Takes the desired group of settings one step back, but the rest of the settings remain unchanged

At the moment it is a ‘fake’ undo function, since it actually updates the settings.

Parameters

group (str) – the key of the settings group for which you want to undo its values.

update_settings(*args, **kwargs)

Updates the settings of this plot.

Docs for Plot:

Parent class of all plot classes

Implements general things needed by all plots such as settings and shortcut management.

root_fdf: fdfSileSiesta, optional

Path to the fdf file that is the ‘parent’ of the results.

results_path: str, optional

Directory where the files with the simulations results are located. This path has to be relative to the root fdf.

entry_points_order: array-like, optional

Order with which entry points will be attempted.

backend: optional

Directory where the files with the simulations results are located. This path has to be relative to the root fdf.

settings: dict

contains the values for each setting of the plot.

params: dict

for each setting, contains information about their input field.

This information might include valid values, for example.

paramGroups: tuple of dicts

contains the different setting groups present in the plot.

Each group is a dict like { “key”: , “name”: ,”icon”: , “description”: }

Parameters
  • root_fdf (fdfSileSiesta, optional) – Path to the fdf file that is the ‘parent’ of the results.

  • results_path (str, optional) – Directory where the files with the simulations results are located. This path has to be relative to the root fdf.

  • entry_points_order (array-like, optional) – Order with which entry points will be attempted.

  • backend (optional) – Directory where the files with the simulations results are located. This path has to be relative to the root fdf.

updates_available()[source]

This function checks whether the read files have changed

For it to work properly, one should specify the files that have been read by their reading methods (usually, the entry points). This is done by using the follow() method or by reading files with self.get_sile() instead of sisl.get_sile().