ultrapyfit.fit package

Submodules

ultrapyfit.fit.GlobalFit module

Created on Sat Mars 13 14:35:39 2021 @author: Lucas

class ultrapyfit.fit.GlobalFit.GlobalFit(x, data, exp_no, params, deconv=True, tau_inf=1000000000000.0, GVD_corrected=True, wavelength=None, **kwargs)

Bases: Minimizer, Jacobian

property allow_stop

controlles if is posible to stop the fit or not

global_fit(maxfev=None, apply_weights=False, use_jacobian=False, method='leastsq', verbose=True, **kws)

Method to fit the data to a model. Returns a modified lmfit result object.

Parameters

  • maxfev (int (default 5000)) – maximum number of iterations of the fit.

  • apply_weights (bool (default False)) – If True and weights have been defined, this will be applied in the fit (for defining weights) check the function define_weights.

  • use_jacobian (bool) – decide if generate and apply analytic jacobian matrix False will result in usage of standard numeric estimation of the jacobian matrix, which is slow. assumes that jacobian function is implemented.

  • method (default (leastsq)) – Any valid method that can be used by lmfit minimize function

  • verbose (bool (default True)) – If True, every 200 iterations the X2 will be printed out

  • kws – Any valid kwarg that can be used by lmfit minimize function

minimize(method='leastsq', params=None, max_nfev=None, use_jacobian=False, **kws)

Modified minimize function to output GloablFitResult instead of lmfit results, except for this works identically as lmfit minimize. Check lmfit minimize for more information

pre_fit()

Intended to be a method that optimized the pre_exponential factors trace by trace without optimizing the decay times (taus).

print_progress(params, iter, resid)

call back function of the minimizer, it can be used to stop the fit. If not print the number of iterations and the chi square every 200 iterations.

stop_fit()

use to stop the fit

class ultrapyfit.fit.GlobalFit.GlobalFitExponential(x, data, exp_no, params, deconv=True, tau_inf=1000000000000.0, GVD_corrected=True, wavelength=None, **kwargs)

Bases: GlobalFit

Class that does a global fit using exponential models. This class is uses by the function, globalfit_gauss_exponential and globalfit_exponential functions. A global fit evaluate the times from all the traces (taus are globally fitted), while the pre_exponential values (pre_exp) are estimated independently from each trace. The pre_exp values give later the decay associated spectra (DAS). The Class do not generates the parameters automatically.

x

x-vector, normally time vector

Type

1darray

data

array containing the data, the number of rows should be equal to the len(x)

Type

2darray

exp_no

number of exponential that will be used to fit the data.

Type

int

params

object containing the initial parameters values used to build an exponential model. These parameters are iteratively optimize to reduce the residual matrix formed by data-model (error matrix) using Levenberg-Marquardt algorithm.

Type

lmfit parameters object

deconv

If True the fitting functions will search for the deconvolution parameter (“fwhm”) in the params attribute, and the the model is a weighted sum of Gauss modified exponential functions. If False the the model is a weighted sum of exponential functions, and params should not contain the fwhm entrance.

Type

bool

tau_inf

An extra decay time use to evaluate possible photoproduct. This should be used if the signal at long delay times is not completely recovered and if deconv is set to True. If the signal at long delay times is zero tau_inf should be set to None. (only affects if deconv is True)

Type

float or int or None

GVD_corrected

Defines if the chrip or group velocity dispersion (GVD) has been corrected. If True t0 is globally optimized (faster). If False t0 is separately optimized for each trace (slower). Notice in some cases even if the chirp or GVD has been corrected, very small variations of t0 that might be imperceptible and small may generate problems in the fit, setting this parameter to False can help to acquire overcome this problem although the fit will take longer. (only affects if deconv is True)

Type

bool

weights

This dictionary controls if the fitting weights are applied, the keys are: “apply”: Bool “vector”: weighting vector. ‘type’: type of vector defined in the , ‘range’: time range according to x-vector of the weights that are

different than 1

‘value’: val weighting value

The dictionary keys can be passes as kwargs when instantiating the object

Type

dictionary

global_fit(vary_taus=True, maxfev=None, time_constraint=False, apply_weights=False, use_jacobian=False, method='leastsq', verbose=True, **kws)

Method to fit the data to a model. Returns a modified lmfit result object.

Parameters

  • vary_taus (bool or list of bool) – If True or False all taus are optimized or fixed. If a list, should be a list of bool equal with len equal to the number of taus. Each entry defines if a initial taus should be optimized or not.

  • maxfev (int (default 5000)) – maximum number of iterations of the fit.

  • time_constraint (bool (default False)) – If True and there are more than one tau to optimized force: tau2 > tau1, tau3 > tau2 and so on If self.deconv and True a Gaussian modified exponential model is applied and tau1 > fwhm.

  • apply_weights (bool (default False)) – If True and weights have been defined, this will be applied in the fit (for defining weights) check the function define_weights.

  • use_jacobian (bool) – decide if generate and apply analytic jacobian matrix False will result in usage of standard numeric estimation of the jacobian matrix, which is slow

  • method (default (leastsq)) – Any valid method that can be used by lmfit minimize function

  • verbose (bool (default True)) – If True, every 200 iterations the X2 will be printed out

  • kws – Any valid kwarg that can be used by lmfit minimize function

pre_fit()

Method that optimized the pre_exponential factors trace by trace without optimizing the decay times (taus). It is automatically ran before a global fit.

class ultrapyfit.fit.GlobalFit.GlobalFitResult(result)

Bases: object

Contain all attributes that an lmfit minimizer result has, and add some specific details of the fit to this results. These are: x: 1darray

x-vector, normally time vector

data: 2darray

Array containing the data, the number of rows should be equal to the len(x)

wavelength: 1darray

wavelength vector

details:

A dictionary containing specific details of the fit performed

add_data_details(data, details)

Add as attributes to the lmfit results object: these are the data, the time the wavelength. Also add fit details such as the number of exponential if convolve with a gaussian or not, tau_inf, maxfev and other properties that are later use by UltrafastExperiments class and other classes as ExploreResults.

add_full_data_matrix(full_matrix, full_wavelengths)

Add the full data matrix to the result. The full_data_matrix is not needed to explore the fit results it might only be needed to do the bootstrap_fit on the entire full data matrix (Check Bootstrap.generate_datasets() for more info)

get_fitted_data()

Return the fitted data of the object

get_values()

return important values from the results object

load()
save(name)
class ultrapyfit.fit.GlobalFit.GlobalFitTarget(x, data, exp_no, params, deconv=True, GVD_corrected=True, wavelength=None, **kwargs)

Bases: GlobalFit

Class that does a global target fit to a kinetic model. This class is uses a global fit evaluate the times from all the traces (kinetic constants are globally fitted), while the pre_exponential values (pre_exp) are estimated independently from each trace. The pre_exp values give later the species associated spectra (SAS). The Class do not generates the parameters automatically. .. attribute:: x

x-vector, normally time vector

type

1darray

data

array containing the data, the number of rows should be equal to the len(x)

Type

2darray

exp_no

number of exponential that will be used to fit the data.

Type

int

params

object containing the initial parameters values used to build an exponential model. These parameters are iteratively optimize to reduce the residual matrix formed by data-model (error matrix) using Levenberg-Marquardt algorithm.

Type

lmfit parameters object

deconv

If True the fitting functions will search for the deconvolution parameter (“fwhm”) in the params attribute, and the the model is a weighted sum of Gauss modified exponential functions. If False the the model is a weighted sum of exponential functions, and params should not contain the fwhm entrance.

Type

bool

GVD_corrected

Defines if the chrip or group velocity dispersion (GVD) has been corrected. If True t0 is globally optimized (faster). If False t0 is separately optimized for each trace (slower). Notice in some cases even if the chirp or GVD has been corrected, very small variations of t0 that might be imperceptible and small may generate problems in the fit, setting this parameter to False can help to acquire overcome this problem although the fit will take longer. (only affects if deconv is True)

Type

bool

weights

This dictionary controls if the fitting weights are applied, the keys are: “apply”: Bool “vector”: weighting vector. ‘type’: type of vector defined in the , ‘range’: time range according to x-vector of the weights that are

different than 1

‘value’: val weighting value The dictionary keys can be passes as kwargs when instantiating the object

Type

dictionary

pre_fit()

Method that optimized the pre_exponential factors trace by trace without optimizing the kinetic constants times. It is automatically ran before a global fit.

class ultrapyfit.fit.GlobalFit.GlobalFitWithIRF(x, data, irf, exp_no, params, wavelength=None)

Bases: GlobalFit

WARNING: Not working properly Class that does a global fit using exponential models convolved with an instrument response function (IRF) array. A global fit evaluate the times from all the traces (taus are globally fitted), while the pre_exponential values (pre_exp) are estimated independently from each trace. The Class do not generates the parameters automatically.

x

x-vector, normally time vector

Type

1darray

data

array containing the data, the number of rows should be equal to the len(x)

Type

2darray

exp_no

number of exponential that will be used to fit the data.

Type

int

params

object containing the initial parameters values used to build an exponential model. These parameters are iteratively optimize to reduce the residual matrix formed by data-model (error matrix) using Levenberg-Marquardt algorithm.

Type

lmfit parameters object

global_fit(vary_taus=True, maxfev=None, time_constraint=False, method='leastsq', **kws)

Method to fit the data to a model. Returns a modified lmfit result object.

Parameters

  • vary_taus (bool or list of bool) – If True or False all taus are optimized or fixed. If a list, should be a list of bool equal with len equal to the number of taus. Each entry defines if a initial taus should be optimized or not.

  • maxfev (int (default 5000)) – maximum number of iterations of the fit.

  • time_constraint (bool (default False)) – If True and there are more than one tau to optimized force: tau2 > tau1, tau3 > tau2 and so on If self.deconv and True a Gaussian modified exponential model is applied and tau1 > fwhm.

  • method (default (leastsq)) – Any valid method that can be used by lmfit minimize function

  • kws – Any valid kwarg that can be used by lmfit minimize function

pre_fit()

Method that optimized the pre_exponential factors trace by trace without optimizing the decay times (taus). It is automatically ran before a global fit.

class ultrapyfit.fit.GlobalFit.InputThread(function)

Bases: Thread

get_id()
run()

Method representing the thread’s activity.

You may override this method in a subclass. The standard run() method invokes the callable object passed to the object’s constructor as the target argument, if any, with sequential and keyword arguments taken from the args and kwargs arguments, respectively.

stop()

ultrapyfit.fit.GlobalFitBootstrap module

ultrapyfit.fit.GlobalParams module

Created on Fri Nov 13 18:48:51 2020

@author: 79344

class ultrapyfit.fit.GlobalParams.GlobExpParameters(number_traces: int, taus: list)

Bases: object

Class parameter generator global fitting

taus

contains the value of the decay times

Type

list

exp_no

is the number of exponential and equal to the len of taus

Type

int

number_traces

contains the number of data sets (traces) that should be globally fitted

Type

int

params

contains the parameters for the fit

Type

lmFit Parameters class

adjustParams(t0: float, vary_t0=True, fwhm=0.12, opt_fwhm=False, GVD_corrected=True, tau_inf=1000000000000.0, y0=None)

function to initialize parameters for global fitting

Parameters

  • t0 (int or float) – the t0 for the fitting

  • vary_t0 (bool (default True)) – allows to optimize t0 when the sum of exponential is convolve with a gaussian. If there is no deconvolution t0 is always fix to the given value.

  • fwhm (float or None (default 0.12)) – FWHM of the the laser pulse use in the experiment If None. the deconvolution parameters will not be added

  • opt_fwhm (bool (default False)) – allows to optimized the FWHM. Theoretically this should be measured externally and be fix (only applicable if fwhm is given)

  • GVD_corrected (bool (default True)) – If True all traces will have same t0. If False t0 is independent of the trace

  • tau_inf (int or float (default 1E12)) – allows to add a constant decay value to the parameters. This modelled photoproducts formation with long decay times If None tau_inf is not added. (only applicable if fwhm is given)

  • y0 (int or float or list/1d-array (default None)) – If this parameter is pass y0 value will be a fixed parameter to the value passed. This affects fits with and without deconvolution. For a fit with deconvolution y0 is is added to negative delay offsets. For a fit without deconvolution y0 fit the offset of the exponential. If an array is pass this should have the length of the curves that want to be fitted, and for each curve the the y0 value would be different.

class ultrapyfit.fit.GlobalParams.GlobalTargetParameters(number_traces, model=None)

Bases: object

Class parameter generator global fitting

model

contains model to be fitted

Type

model object

exp_no

is the number of exponential and equal to the len of taus

Type

int

number_traces

contains the number of data sets (traces) that should be globally fitted

Type

int

params

contains the parameters for the fit

Type

lmFit Parameters class

adjustParams(t0, vary_t0=True, fwhm=0.12, opt_fwhm=False, GVD_corrected=True, y0=None)

function to initialize parameters for global fitting

Parameters

  • t0 (int or float) – the t0 for the fitting

  • vary_t0 (bool (default True)) – allows to optimize t0 when the sum of exponential is convolve with a gaussian. If there is no deconvolution t0 is always fix to the given value.

  • fwhm (float or None (default 0.12)) – FWHM of the the laser pulse use in the experiment If None. the deconvolution parameters will not be added

  • opt_fwhm (bool (default False)) – allows to optimized the FWHM. Theoretically this should be measured externally and be fix (only applicable if fwhm is given)

  • GVD_corrected (bool (default True)) – If True all traces will have same t0. If False t0 is independent of the trace

  • y0 (int or float or list/1d-array (default None)) – If this parameter is pass y0 value will be a fixed parameter to the value passed. This affects fits with and without deconvolution. For a fit with deconvolution y0 is is added to negative delay offsets. For a fit without deconvolution y0 fit the offset of the exponential. If an array is pass this should have the length of the curves that want to be fitted, and for each curve the the y0 value would be different.

params_from_matrix(k_matrix: list, concentrations: list)

Build the k_matrix manually.

Parameters

  • k_matrix (list of lists) – Contains all the information of k, rates. This parameter should be a list of list/tuples where every sub list should be of length and with the following form: [source, destination, rate constant, vary] if destination == source, parallel decay or terminal component.

    i.e.: [1, 3, 1/0.7, True] –> component 1 gives component 3 with a rate constant of 1/0.7, and this parameter can be optimized.

  • concentrations (list) – a list containing the initial concentrations

params_from_model(model: Model)

create parameters from a Model object

ultrapyfit.fit.ModelCreator module

Created on Thu Nov 12 21:35:15 2020

@author: lucas

class ultrapyfit.fit.ModelCreator.ModelCreator(exp_no, time, tau_inf=1000000000000.0)

Bases: object

Class containing the simple exponential and sum of exponential functions (including modified Gaussian exponential). This functions are used to generate the model that is later fit to the data and the parameters optimized. The class has several static methods that returns the exponential functions from the parameters pass as well as methods that return exponential from the parameters inside an lmfit parameters object. This parameter is and lmfit object can be obtained from the GlobExpParameters class.

exp1: single exponential decay function

expN: weighted sum of exponential decay functions with an off-set

ExpGauss: exponential modified Gaussian function

ExpNGauss: weighted sum of exponential modified Gaussian decay functions with an off-set

static exp1(time, tau)

single exponential decay function

Parameters

  • time (array type) – the time vector

  • tau (float or int) – decay associated time value

Return type

1darray of size equal to time-vector

static expGauss(time, tau, sigma)

exponential modified Gaussian function

Parameters

  • time (array type) – the time vector

  • tau (float or int) – decay associated time value

  • sigma (float or int) – variance of the gaussian distribution

Return type

1darray of size equal to time-vector

static expN(time, y0, t0, values)

weighted sum of exponential decay functions with an off-set

Parameters

  • time (array type) – the time vector

  • y0 (float or int) – off-set value at the longest decay time

  • t0 (float or int) – initial time from where the exponential value will be evaluated

  • values (list of list) – values should be a list of list containing the pre_exps and decay associated time values (taus) [[0.1,8],[0.001,30]]

Return type

1darray of size equal to time-vector

expNDataset(params, i)

calculate a weighted sum of exponential decay functions with an off-set from params for data set i using simple hardwired naming convention. This function can be used for datasets having different t0.

Parameters

  • params (GlobExpParameters object) – object containing the parameters created for global fitting several decay traces

  • i (int) – number corresponding to the specific trace

Return type

1darray of size equal to time-vector

expNDatasetFast(params, i, expvects)

calculate a weighted sum of exponential modified Gaussian decay functions with an off-set from params for data set i using simple hardwired naming convention and GlobExpParameters object. This function can only be used for datasets having identical t0. (is computationally faster than expNDataset)

Parameters

  • params (GlobExpParameters object) – object containing the parameters created for global fitting several decay traces

  • i (int) – number corresponding to the specific trace

  • expvects (1darray) – sum of expN functions where time-vector should be: time-t0

Return type

1darray of size equal to expvects

expNDatasetIRF(params, i, IRF)

WARNING: Not working properly. calculate a weighted sum of exponential decay functions with an off-set from params for data set i using simple hardwired naming convention. This function can be used for datasets having different t0.

Parameters

  • params (GlobExpParameters object) – object containing the parameters created for global fitting several decay traces

  • i (int) – number corresponding to the specific trace

Return type

1darray of size equal to time-vector

static expNGauss(time, y0, t0, fwhm, values)

weighted sum of exponential modified Gaussian decay functions with an off-set

Parameters

  • time (array type) – the time vector

  • y0 (float or int) – off-set value at the shortest decay time (the off-set at long decay times can be evaluated

    adding to values a long decay associated time )

  • t0 (float or int) – initial time from where the exponential value will be evaluated

  • fwhm (float or int) – full width half maximum of the gaussian distribution

  • values (list of list) – values should be a list of list containing the pre_exps and decay associated time values (taus) [[0.1,8],[0.001,30]]

Return type

1darray of size equal to x attribute vector (time vector)

expNGaussDataset(params, i)

calculate a weighted sum of exponential modified Gaussian decay functions with an off-set from params for data set i using simple hardwired naming convention. This function can be used for datasets having different t0

Parameters

  • params (GlobExpParameters object) – object containing the parameters created for global fitting several decay traces

  • i (int) – number corresponding to the specific trace

Return type

1darray of size equal to time-vector

expNGaussDatasetFast(params, i, expvects)

calculate a weighted sum of exponential decay functions with an off-set from params for data set i using simple hardwired naming convention and GlobExpParameters object. This function can only be used for datasets having identical t0. (is computationally faster than expNGaussDataset)

Parameters

  • params (GlobExpParameters object) – object containing the parameters created for global fitting several decay traces

  • i (int) – number corresponding to the specific trace

  • expvects (1darray) – sum of expN functions where time-vector should be: time-t0

Return type

1darray of size equal to expvects

expNGaussDatasetTM(params, i, cons_eigen)

calculate kinetic reaction model from params for data set i using simple hardwired naming convention and GlobTargetParameters object. (Automatically detects id all traces have identical t0)

Parameters

  • params (GlobExpParameters object) – object containing the parameters created for global fitting several decay traces

  • i (int) – number corresponding to the specific trace

  • cons_eigen (list) – list containing eingen vectors, eigen values and eigenmatrix

Return type

1darray of size equal to expvects

ultrapyfit.fit.jacobian module

class ultrapyfit.fit.jacobian.Jacobian(exp_no, time, tau_inf=1000000000000.0)

Bases: ModelCreator

‘WARNING class under development’ Class that has functions to calculate the Jacobian matrix analitically. It can be used as an alternative in the global fit classes or method of experiment, which by default resolve the Jacobian matrix numerically. If the Jabobian is used, it can speed-up the calculation.

static erfDerrivative(z)

calculate derrivative of the error function

Parameters

z (float or array of floats) – function argument

Return type

float or array of floats

static expGaussDerrivativeSigma(time, tau, sigma)

exponential derrivative by sigma

Parameters

  • time (array type) – the time vector

  • tau (float or int) – decay associated time value

  • sigma (float or int) – variance of the gaussian distribution

Return type

1darray of size equal to time-vector

static expGaussDerrivativeT0(time, tau, sigma)

exponential derrivative by t0

Parameters

  • time (array type) – the time vector

  • tau (float or int) – decay associated time value

  • sigma (float or int) – variance of the gaussian distribution

Return type

1darray of size equal to time-vector

expNGaussDatasetJacobianByPreExp(params, lambda_i, tau_j)

calculate jacobian derrivative by pre_exp in a equivalent way to the expNGaussDataset method.

Parameters

  • params (GlobExpParameters object) – object containing the parameters created for global fitting several decay traces

  • lambda_i (int) – number corresponding to the specific trace it is from 1 to self.exp_no (like in param key)

  • tau_j (int) – number corresponding to the specific tau number it is from 1 to self.exp_no (like in param key)

Return type

1darray of size equal to time-vector

expNGaussDatasetJacobianBySigma(params, lambda_i, tau_j)

calculate jacobian derrivative by tau in a equivalent way to the expNGaussDataset method.

Parameters

  • params (GlobExpParameters object) – object containing the parameters created for global fitting several decay traces

  • lambda_i (int) – number corresponding to the specific trace it is from 1 to self.exp_no (like in param key)

  • tau_j (int) – number corresponding to the specific tau number it is from 1 to self.exp_no (like in param key)

Return type

1darray of size equal to time-vector

expNGaussDatasetJacobianByT0(params, lambda_i, tau_j)

calculate jacobian derrivative by time offset component (t0) in a equivalent way to the expNGaussDataset method.

Parameters

  • params (GlobExpParameters object) – object containing the parameters created for global fitting several decay traces

  • lambda_i (int) – number corresponding to the specific trace it is from 1 to self.exp_no (like in param key)

  • tau_j (int) – number corresponding to the specific tau number it is from 1 to self.exp_no (like in param key)

Return type

1darray of size equal to time-vector

expNGaussDatasetJacobianByTau(params, lambda_i, tau_j)

calculate jacobian derrivative by tau in a equivalent way to the expNGaussDataset method.

Parameters

  • params (GlobExpParameters object) – object containing the parameters created for global fitting several decay traces

  • lambda_i (int) – number corresponding to the specific trace it is from 1 to self.exp_no (like in param key)

  • tau_j (int) – number corresponding to the specific tau number it is from 1 to self.exp_no (like in param key)

Return type

1darray of size equal to time-vector

expNGaussDatasetJacobianByY0(params, lambda_i, tau_j)

calculate jacobian derrivative by global offset component (y0) in a equivalent way to the expNGaussDataset method.

Parameters

  • params (GlobExpParameters object) – object containing the parameters created for global fitting several decay traces

  • lambda_i (int) – number corresponding to the specific trace it is from 1 to self.exp_no (like in param key)

  • tau_j (int) – number corresponding to the specific tau number it is from 1 to self.exp_no (like in param key)

Return type

1darray of size equal to time-vector

expNGaussDatasetJacobianByYInf(params, lambda_i, tau_j)

calculate jacobian derrivative by pre_exp of inifinite component (yinf) in a equivalent way to the expNGaussDataset method.

Parameters

  • params (GlobExpParameters object) – object containing the parameters created for global fitting several decay traces

  • lambda_i (int) – number corresponding to the specific trace it is from 1 to self.exp_no (like in param key)

  • tau_j (int) – number corresponding to the specific tau number it is from 1 to self.exp_no (like in param key)

Return type

1darray of size equal to time-vector

ultrapyfit.fit.targetmodel module

class ultrapyfit.fit.targetmodel.ModPopulation(new_name)

Bases: object

countActive()
countActiveSFs()
countActiveSFsValues()
countFixed()
countOutgoingArrows()
enableDisableKs()
remove(model)
updateBranchKs()
updateState(c_edit, tau_edit, k_all_edit)
class ultrapyfit.fit.targetmodel.ModProcess(pop_source, pop_target)

Bases: object

contains(point)
getsetLocation()
paintYourself(painter)
remove(model)
updateState(k_edit, sf_edit)
class ultrapyfit.fit.targetmodel.Model

Bases: object

addPopulation(new_population)
addProcess(new_process)
checkParams(experiment)
genParameters()
static load(filename)
manualModelBuild(call_back=None, app=None)
manualModelBuild_V2()
save(filename)
class ultrapyfit.fit.targetmodel.ModelWindow(model_ref=None, call_back=None, app=None, parent=None)

Bases: QWidget

add_process_function()
button1Func()
button31Func()
countArrows(population1, population2)
delete_process()
eventFilter(self, QObject, QEvent) → bool
genParametersAndClose()
isStrNumber(s)
loadModel()
paintEvent(self, QPaintEvent)
populationEditFunc()
population_done()
processEditFunc()
process_done()
saveModel()
splitterMoved()
class ultrapyfit.fit.targetmodel.ParamControl(parent, name, callback)

Bases: QWidget

isActive()
loadState(enabled, active, fixed, value)
setActive(setactive)
setEnabled(self, bool)
class ultrapyfit.fit.targetmodel.VLayout(parent=None)

Bases: QVBoxLayout

addSeveralWidgets(lista)
addWidget(self, QWidget, stretch: int = 0, alignment: Union[Qt.Alignment, Qt.AlignmentFlag] = Qt.Alignment())
hide_all()
show_all()
ultrapyfit.fit.targetmodel.isIdentifier(identifier)

Module contents