sisl.viz.MultiplePlot
- class sisl.viz.MultiplePlot(*args, **kwargs)[source]
Bases:
Plot
General handler of a group of plots that need to be rendered together
- 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.
Methods
add_children
(*plots)Append children to the existing ones
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
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, **kwargs)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_all_plots
([update_fig, try_sharing])Initializes all child plots
init_settings
([presets])Initializes the settings for the object.
insert_childplot
(index, plot)Inserts a plot in a given position of the children list
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
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_children
(plots[, keep])Sets the children of a multiple plot
set_data
(*args[, children_sel])set_shared_attr
(key, val)Sets the value of a shared attribute
setup_hamiltonian
(**kwargs)Sets up the hamiltonian for calculations with sisl
shared_attr
(key)Gets an attribute that is located in the shared storage of the MultiplePlot
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_children_settings
([children_sel])Updates the settings of all child plots
update_settings
(*args, **kwargs)Updates the settings of this plot.
This function checks whether the read files have changed
The current settings of the object
Returns a jsonifiable object with information of the shortcuts
- add_children(*plots)[source]
Append children to the existing ones
- Parameters
*plots (Plot) – all the plots that you want to add as child plots of this one.
- 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)
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
- backends = <sisl.viz.backends._plot_backends.Backends object>
- 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)
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()
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)
Not functional yet
- entry_points = []
- classmethod entry_points_help()
Generates a helpful message about the entry points of the plot class
- follow(*files, to_abs=True, unfollow=False)
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)
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
- classmethod get_class_param(key, as_dict=False)
- get_figure(backend, **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
- 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
- Returns
settings_group – A subset of the settings with only those that belong to the asked group.
- Return type
- get_sile(path, results_path, root_fdf, *args, follow=True, follow_kwargs={}, file_contents=None, **kwargs)
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_all_plots(update_fig=True, try_sharing=True)[source]
Initializes all child plots
- Parameters
update_fig (boolean, optional) – whether we should build the figure if this step is succesful.
try_sharing (boolean, optional) –
If True, we will check if all plots have exactly the same settings to read data and, in that case, they will share attributes to avoid memory waste.
This is specially essential for plots that read big amounts of data (e.g.
GridPlot
), but also for those that take significant time to read it.
- 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.
- insert_childplot(index, plot)[source]
Inserts a plot in a given position of the children list
- Parameters
index (int) – The position where the plot should be inserted
plot (sisl Plot or plotly Figure) – The plot to insert in the list
- 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)
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)
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 orAnimation
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)
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
andsubplots
methodsIf 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
orsubplots
). 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
- classmethod plot_name()
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)
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_children(plots, keep=False)[source]
Sets the children of a multiple plot
- Parameters
plots (array-like of sisl.viz.plotly.Plot or plotly Figure) – the plots that should be set as children for the animation.
keep (boolean, optional) –
whether the existing children should be kept.
If True,
plots
is added after them.
- set_data(*args, children_sel=None, **kwargs)
- property set_data_methods
Sets the value of a shared attribute
- Parameters
key (str) – the key of the attribute that is to be set.
val (any) – the new value for the attribute
- property settings
The current settings of the object
- setup_hamiltonian(**kwargs)
Sets up the hamiltonian for calculations with sisl
Gets an attribute that is located in the shared storage of the MultiplePlot
This method will be given to all children so that they can retreive the shared attributes. This is done in
set_children
.- Parameters
key (str) – the name of the attribute that you want to retrieve
- Returns
the value that you asked for
- Return type
any
- 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)
Displays the plot
- Parameters
- stop_listening(fig_widget=None)
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)
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()
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
- 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_children_settings(children_sel=None, **kwargs)[source]
Updates the settings of all child plots
- Parameters
children_sel (array-like of int, optional) – The indices of the child plots that you want to update.
**kwargs – Keyword arguments specifying the settings that you want to update and the values you want them to have
- update_settings(*args, **kwargs)
Updates the settings of this plot.
Docs for MultiplePlot:
General handler of a group of plots that need to be rendered together
- 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.
- 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()
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().