LorentzModel

 
LorentzModel = class LorentzModel(NonLinearModel)
    LorentzModel(copy=None, **kwargs)
 
Lorentzian Model.
 
    f( x:p ) = p_0 * ( p_2^2 / ( ( x - p_1 )^2 + p_2^2 )
 
where
    p_0 = amplitude
    p_1 = x-shift
    p_2 = gamma ( width )
 
The parameters are initialized at [1/PI, 0.0, 1.0] where the integral
over the function equals 1.
Parameter 2 ( gamma ) is always kept stricktly positive ( >0 ).
 
This model is also known as Cauchy or Cauchy-Lorentz.
 
Notes
-----
There are other possible definitions of this model, where the integral equals 1.0.
http://en.wikipedia.org/wiki/Cauchy_distribution#Probability_density_function
 
Definitions that integrate to 1.0 are more fit as a distribution function.
See sample/CauchyErrorDistribution.
 
We choose our definition for 2 reasons.
1. to be in line with the definitions of the GaussModel, SincModel,
    VoigtModel, all KernelModels etc. In all of them the amplitude parameter,
    p_0, equals the maximum of the function. I.e. p_0 is indeed the amplitude.
2. to have maximally independent parameters, meaning that if you change one
    parameter, only that aspect changes. In the present definition this is the case.
    In the alternative definition if you change p_2, not only the width
    of the function changes, but also the amplitude.
 
Examples
--------
>>> lorentz = LorentzModel( )
>>> lorentz.setParameters( [5, 4, 1] )
>>> print( lorentz( numpy.arange(  41 , dtype=float ) / 5 ) )
 
Attributes
----------
    none in this model
 
Attributes from Model
---------------------
    npchain, parameters, stdevs, xUnit, yUnit
 
Attributes from FixedModel
--------------------------
    npmax, fixed, parlist, mlist
 
Attributes from BaseModel
--------------------------
    npbase, ndim, priors, posIndex, nonZero,
         tiny, deltaP, parNames

 
 
Alternate
---------
LorentzModel() is equivalent to KernelModel( kernel=Lorentz() ).
 
 
Method resolution order:
LorentzModel
NonLinearModel
Model
FixedModel
BaseModel
builtins.object

Constructor:
LorentzModel( copy=None, **kwargs )
Lorentzian model.
 
Number of parameters is 3.
 
Parameters
----------
copy : LorentzModel
    to be copied
fixed : None or dictionary of {int:float|Model}
    int         index of parameter to fix permanently.
    float|Model values for the fixed parameters.
    Attribute fixed can only be set in the constructor.
    See: FixedModel
Methods defined here:
baseDerivative( xdata, params )
Return the derivative df/dx at each xdata (=x).
 
Parameters
----------
xdata : array_like
    values at which to calculate the derivative
params : array_like
    values for the parameters.
baseName()
Returns a string representation of the model.
baseParameterUnit( k )
Return the unit of the indicated parameter.
 
Parameters
---------
k : int
    parameter number.
basePartial( xdata, params, parlist=None )
Returns the partials at the xdata value.
 
Parameters
----------
xdata : array_like
    values at which to calculate the partials
params : array_like
    values for the parameters.
parlist : array_like
    list of indices active parameters (or None for all)
baseResult( xdata, params )
Returns the result of the model function.
 
Parameters
----------
xdata : array_like
    values at which to calculate the result
params : array_like
    values for the parameters.
copy()
Copy method.

Methods inherited from NonLinearModel:
Methods inherited from Model:
Overloaded operators and aliases Other methods Methods inherited from FixedModel:
Methods inherited from BaseModel: