invariant

sans.invariant.invariant

This module implements invariant and its related computations.

author:Gervaise B. Alina/UTK author:Mathieu Doucet/UTK author:Jae Cho/UTK

class sans.invariant.invariant.Extrapolator

Extrapolate I(q) distribution using a given model

__init__()

Determine a and b given a linear equation y = ax + b

If a model is given, it will be used to linearize the data before the extrapolation is performed. If None, a simple linear fit will be done.

Parameters:

• data – data containing x and y such as y = ax + b
• model – optional Transform object

__module__ = 'sans.invariant.invariant'

fit()

Fit data for y = ax + b return a and b

Parameters:

• power – a fixed, otherwise None
• qmin – Minimum Q-value
• qmax – Maximum Q-value

class sans.invariant.invariant.Guinier

Bases: sans.invariant.invariant.Transform

class of type Transform that performs operations related to guinier function

__class__

alias of type

__delattr__

x.__delattr__(‘name’) <==> del x.name

__dict__ = <dictproxy object at 0x0202B090>

__getattribute__

x.__getattribute__(‘name’) <==> x.name

__hash__

x.__hash__() <==> hash(x)

__init__()

__module__ = 'sans.invariant.invariant'

static __new__(S, ...) → a new object with type S, a subtype of T

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

x.__repr__() <==> repr(x)

__setattr__

x.__setattr__(‘name’, value) <==> x.name = value

__str__

x.__str__() <==> str(x)

__weakref__

list of weak references to the object (if defined)

_guinier()

Retrive the guinier function after apply an inverse guinier function to x Compute a F(x) = scale* e-((radius*x)**2/3).

Parameters:

• x – a vector of q values
• scale – the scale value
• radius – the guinier radius value

Returns:

F(x)

evaluate_model()

return F(x)= scale* e-((radius*x)**2/3)

evaluate_model_errors()

Returns the error on I(q) for the given array of q-values

Parameters:x – array of q-values

extract_model_parameters()

assign new value to the scale and the radius

get_allowed_bins()

Goes through the data points and returns a list of boolean values to indicate whether each points is allowed by the model or not.

Parameters:data – Data1D object

linearize_data()

Linearize data so that a linear fit can be performed. Filter out the data that can’t be transformed.

Parameters:data – LoadData1D instance

linearize_q_value()

Transform the input q-value for linearization

Parameters:value – q-value Returns:q*q

class sans.invariant.invariant.InvariantCalculator

Bases: object

Compute invariant if data is given. Can provide volume fraction and surface area if the user provides Porod constant and contrast values.

Precondition :the user must send a data of type DataLoader.Data1D the user provide background and scale values. Note :Some computations depends on each others.

__class__

alias of type

__delattr__

x.__delattr__(‘name’) <==> del x.name

__dict__ = <dictproxy object at 0x0202B2F0>

__getattribute__

x.__getattribute__(‘name’) <==> x.name

__hash__

x.__hash__() <==> hash(x)

__init__()

Initialize variables.

Parameters:

• data – data must be of type DataLoader.Data1D
• background – Background value. The data will be corrected before processing
• scale – Scaling factor for I(q). The data will be corrected before processing

__module__ = 'sans.invariant.invariant'

static __new__(S, ...) → a new object with type S, a subtype of T

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

x.__repr__() <==> repr(x)

__setattr__

x.__setattr__(‘name’, value) <==> x.name = value

__str__

x.__str__() <==> str(x)

__weakref__

list of weak references to the object (if defined)

_fit()

fit data with function using data = self._get_data() fx = Functor(data , function) y = data.y slope, constant = linalg.lstsq(y,fx)

Parameters:

• qmin – data first q value to consider during the fit
• qmax – data last q value to consider during the fit

:param power : power value to consider for power-law :param function: the function to use during the fit

Return a:the scale of the function Return b:the other parameter of the function for guinier will be radius for power_law will be the power value

_get_data()

Note :this function must be call before computing any type of invariant Returns:new data = self._scale *data - self._background

_get_extrapolated_data()

Returns:extrapolate data create from data

_get_qstar()

Compute invariant for pinhole data. This invariant is given by:

q_star = x0**2 *y0 *dx0 +x1**2 *y1 *dx1 
            + ..+ xn**2 *yn *dxn    for non smeared data
            
q_star = dxl0 *x0 *y0 *dx0 +dxl1 *x1 *y1 *dx1 
            + ..+ dlxn *xn *yn *dxn    for smeared data
            
where n >= len(data.x)-1
dxl = slit height dQl
dxi = 1/2*(xi+1 - xi) + (xi - xi-1)
dx0 = (x1 - x0)/2
dxn = (xn - xn-1)/2

Parameters:data – the data to use to compute invariant. Return q_star:invariant value for pinhole data. q_star > 0

_get_qstar_uncertainty()

Compute invariant uncertainty with with pinhole data. This uncertainty is given as follow:

dq_star = math.sqrt[(x0**2*(dy0)*dx0)**2 +
     (x1**2 *(dy1)*dx1)**2 + ..+ (xn**2 *(dyn)*dxn)**2 ]

where n >= len(data.x)-1 dxi = 1/2*(xi+1 - xi) + (xi - xi-1) dx0 = (x1 - x0)/2 dxn = (xn - xn-1)/2 dyn: error on dy

Parameters:data – Note :if data doesn’t contain dy assume dy= math.sqrt(data.y)

get_data()

Returns:self._data

get_extra_data_high()

Returns the extrapolated data used for the high-Q invariant calculation. By default, the distribution will cover the data points used for the extrapolation. The number of overlap points is a parameter (npts_in). By default, the maximum q-value of the distribution will be Q_MAXIMUM, the maximum q-value used when extrapolating for the purpose of the invariant calculation.

Parameters:

• npts_in – number of data points for which the extrapolated data overlap
• q_end – is the maximum value to uses for extrapolated data
• npts – the number of points in the extrapolated distribution

get_extra_data_low()

Returns the extrapolated data used for the loew-Q invariant calculation. By default, the distribution will cover the data points used for the extrapolation. The number of overlap points is a parameter (npts_in). By default, the maximum q-value of the distribution will be the minimum q-value used when extrapolating for the purpose of the invariant calculation.

Parameters:

• npts_in – number of data points for which the extrapolated data overlap
• q_start – is the minimum value to uses for extrapolated data
• npts – the number of points in the extrapolated distribution

get_extrapolation_power()

Returns:the fitted power for power law function for a given

extrapolation range

get_qstar()

Compute the invariant of the local copy of data.

Parameters:extrapolation – string to apply optional extrapolation Return q_star:invariant of the data within data’s q range Warning :When using setting data to Data1D , the user is responsible of checking that the scale and the background are properly apply to the data

get_qstar_high()

Compute the invariant for extrapolated data at high q range.

Implementation:

data = self._get_extra_data_high() return self._get_qstar()

Return q_star:the invariant for data extrapolated at high q.

get_qstar_low()

Compute the invariant for extrapolated data at low q range.

Implementation:

data = self._get_extra_data_low() return self._get_qstar()

Return q_star:the invariant for data extrapolated at low q.

get_qstar_with_error()

Compute the invariant uncertainty. This uncertainty computation depends on whether or not the data is smeared.

Parameters:extrapolation – string to apply optional extrapolation Returns:invariant, the invariant uncertainty

get_surface()

Compute the specific surface from the data.

Implementation:

V =  self.get_volume_fraction(contrast, extrapolation)

Compute the surface given by:
  surface = (2*pi *V(1- V)*porod_const)/ q_star

Parameters:

• contrast – contrast value to compute the volume
• porod_const – Porod constant to compute the surface
• extrapolation – string to apply optional extrapolation

Returns:

specific surface

get_surface_with_error()

Compute uncertainty of the surface value as well as the surface value. The uncertainty is given as follow:

dS = porod_const *2*pi[( dV -2*V*dV)/q_star
     + dq_star(v-v**2)
     
q_star: the invariant value
dq_star: the invariant uncertainty
V: the volume fraction value
dV: the volume uncertainty

Parameters:

• contrast – contrast value
• porod_const – porod constant value
• extrapolation – string to apply optional extrapolation

Return S, dS:

the surface, with its uncertainty

get_volume_fraction()

Compute volume fraction is deduced as follow:

q_star = 2*(pi*contrast)**2* volume( 1- volume)
for k = 10^(-8)*q_star/(2*(pi*|contrast|)**2)
we get 2 values of volume:
     with   1 - 4 * k >= 0
     volume1 = (1- sqrt(1- 4*k))/2
     volume2 = (1+ sqrt(1- 4*k))/2

q_star: the invariant value included extrapolation is applied
             unit  1/A^(3)*1/cm
        q_star = self.get_qstar()
        
the result returned will be 0 <= volume <= 1

Parameters:

• contrast – contrast value provides by the user of type float. contrast unit is 1/A^(2)= 10^(16)cm^(2)
• extrapolation – string to apply optional extrapolation

Returns:

volume fraction

Note :

volume fraction must have no unit

get_volume_fraction_with_error()

Compute uncertainty on volume value as well as the volume fraction This uncertainty is given by the following equation:

dV = 0.5 * (4*k* dq_star) /(2* math.sqrt(1-k* q_star))
                     
for k = 10^(-8)*q_star/(2*(pi*|contrast|)**2)

q_star: the invariant value including extrapolated value if existing
dq_star: the invariant uncertainty
dV: the volume uncertainty

The uncertainty will be set to -1 if it can’t be computed.

Parameters:

• contrast – contrast value
• extrapolation – string to apply optional extrapolation

Returns:

V, dV = volume fraction, error on volume fraction

set_extrapolation()

Set the extrapolation parameters for the high or low Q-range. Note that this does not turn extrapolation on or off.

Parameters:

• range – a keyword set the type of extrapolation . type string
• npts – the numbers of q points of data to consider for extrapolation
• function – a keyword to select the function to use for extrapolation. of type string.
• power – an power to apply power_low function

class sans.invariant.invariant.PowerLaw

Bases: sans.invariant.invariant.Transform

class of type transform that perform operation related to power_law function

__class__

alias of type

__delattr__

x.__delattr__(‘name’) <==> del x.name

__dict__ = <dictproxy object at 0x01FC3EF0>

__getattribute__

x.__getattribute__(‘name’) <==> x.name

__hash__

x.__hash__() <==> hash(x)

__init__()

__module__ = 'sans.invariant.invariant'

static __new__(S, ...) → a new object with type S, a subtype of T

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

x.__repr__() <==> repr(x)

__setattr__

x.__setattr__(‘name’, value) <==> x.name = value

__str__

x.__str__() <==> str(x)

__weakref__

list of weak references to the object (if defined)

_power_law()

F(x) = scale* (x)^(-power)

when power= 4. the model is porod else power_law

The model has three parameters: ::

1. x: a vector of q values
2. power: power of the function
3. scale : scale factor value

Parameters:x – array Returns:F(x)

evaluate_model()

given a scale and a radius transform x, y using a power_law function

evaluate_model_errors()

Returns the error on I(q) for the given array of q-values :param x: array of q-values

extract_model_parameters()

Assign new value to the scale and the power

get_allowed_bins()

Goes through the data points and returns a list of boolean values to indicate whether each points is allowed by the model or not.

Parameters:data – Data1D object

linearize_data()

Linearize data so that a linear fit can be performed. Filter out the data that can’t be transformed.

Parameters:data – LoadData1D instance

linearize_q_value()

Transform the input q-value for linearization

Parameters:value – q-value Returns:log(q)

class sans.invariant.invariant.Transform

Bases: object

Define interface that need to compute a function or an inverse function given some x, y

__class__

alias of type

__delattr__

x.__delattr__(‘name’) <==> del x.name

__dict__ = <dictproxy object at 0x02041A70>

__getattribute__

x.__getattribute__(‘name’) <==> x.name

__hash__

x.__hash__() <==> hash(x)

__init__

x.__init__(...) initializes x; see x.__class__.__doc__ for signature

__module__ = 'sans.invariant.invariant'

static __new__(S, ...) → a new object with type S, a subtype of T

__reduce__()

helper for pickle

__reduce_ex__()

helper for pickle

__repr__

x.__repr__() <==> repr(x)

__setattr__

x.__setattr__(‘name’, value) <==> x.name = value

__str__

x.__str__() <==> str(x)

__weakref__

list of weak references to the object (if defined)

evaluate_model()

Returns an array f(x) values where f is the Transform function.

evaluate_model_errors()

Returns an array of I(q) errors

extract_model_parameters()

set private member

get_allowed_bins()

Goes through the data points and returns a list of boolean values to indicate whether each points is allowed by the model or not.

Parameters:data – Data1D object

linearize_data()

Linearize data so that a linear fit can be performed. Filter out the data that can’t be transformed.

Parameters:data – LoadData1D instance

linearize_q_value()

Transform the input q-value for linearization