sas.sascalc.data_util package

Submodules

sas.sascalc.data_util.calcthread module

class sas.sascalc.data_util.calcthread.CalcCommandline(n=20000)

Test method

complete(total=0.0)

update(i=0)

class sas.sascalc.data_util.calcthread.CalcDemo(completefn=None, updatefn=None, yieldtime=0.01, worktime=0.01, exception_handler=None)

Bases: sas.sascalc.data_util.calcthread.CalcThread

Example of a calculation thread.

compute(n)

class sas.sascalc.data_util.calcthread.CalcThread(completefn=None, updatefn=None, yieldtime=0.01, worktime=0.01, exception_handler=None)

Threaded calculation class. Inherit from here and specialize the compute() method to perform the appropriate operations for the class.

If you specialize the __init__ method be sure to call CalcThread.__init__, passing it the keyword arguments for yieldtime, worktime, update and complete.

When defining the compute() method you need to include code which allows the GUI to run. They are as follows:

self.isquit()          # call frequently to check for interrupts
self.update(kw=...)    # call when the GUI could be updated
self.complete(kw=...)  # call before exiting compute()

The update() and complete() calls accept field=value keyword arguments which are passed to the called function. complete() should be called before exiting the GUI function. A KeyboardInterrupt event is triggered if the GUI signals that the computation should be halted.

The following documentation should be included in the description of the derived class.

The user of this class will call the following:

thread = Work(...,kw=...)  # prepare the work thread.
thread.queue(...,kw=...)   # queue a work unit
thread.requeue(...,kw=...) # replace work unit on the end of queue
thread.reset(...,kw=...)   # reset the queue to the given work unit
thread.stop()              # clear the queue and halt
thread.interrupt()         # halt the current work unit but continue
thread.ready(delay=0.)     # request an update signal after delay
thread.isrunning()         # returns true if compute() is running

Use queue() when all work must be done. Use requeue() when intermediate work items don’t need to be done (e.g., in response to a mouse move event). Use reset() when the current item doesn’t need to be completed before the new event (e.g., in response to a mouse release event). Use stop() to halt the current and pending computations (e.g., in response to a stop button).

The methods queue(), requeue() and reset() are proxies for the compute() method in the subclass. Look there for a description of the arguments. The compute() method can be called directly to run the computation in the main thread, but it should not be called if isrunning() returns true.

The constructor accepts additional keywords yieldtime=0.01 and worktime=0.01 which determine the cooperative multitasking behaviour. Yield time is the duration of the sleep period required to give other processes a chance to run. Work time is the duration between sleep periods.

Notifying the GUI thread of work in progress and work complete is done with updatefn=updatefn and completefn=completefn arguments to the constructor. Details of the parameters to the functions depend on the particular calculation class, but they will all be passed as keyword arguments. Details of how the functions should be implemented vary from framework to framework.

For wx, something like the following is needed:

import wx, wx.lib.newevent
(CalcCompleteEvent, EVT_CALC_COMPLETE) = wx.lib.newevent.NewEvent()

# methods in the main window class of your application
def __init__():
    ...
    # Prepare the calculation in the GUI thread.
    self.work = Work(completefn=self.CalcComplete)
    self.Bind(EVT_CALC_COMPLETE, self.OnCalcComplete)
    ...
    # Bind work queue to a menu event.
    self.Bind(wx.EVT_MENU, self.OnCalcStart, id=idCALCSTART)
    ...

def OnCalcStart(self,event):
    # Start the work thread from the GUI thread.
    self.work.queue(...work unit parameters...)

def CalcComplete(self,**kwargs):
    # Generate CalcComplete event in the calculation thread.
    # kwargs contains field1, field2, etc. as defined by
    # the Work thread class.
    event = CalcCompleteEvent(**kwargs)
    wx.PostEvent(self, event)

def OnCalcComplete(self,event):
    # Process CalcComplete event in GUI thread.
    # Use values from event.field1, event.field2 etc. as
    # defined by the Work thread class to show the results.
    ...

complete(**kwargs)

Update the GUI with the completed results from a work unit.

compute(*args, **kwargs)

Perform a work unit. The subclass will provide details of the arguments.

exception()

An exception occurred during computation, so call the exception handler if there is one. If not, then log the exception and continue.

interrupt()

Stop the current work item. To clear the work queue as well call the stop() method.

isquit()

Check for interrupts. Should be called frequently to provide user responsiveness. Also yields to other running threads, which is required for good performance on OS X.

isrunning()

queue(*args, **kwargs)

Add a work unit to the end of the queue. See the compute() method for details of the arguments to the work unit.

ready(delay=0.0)

Ready for another update after delay=t seconds. Call this for threads which can show intermediate results from long calculations.

requeue(*args, **kwargs)

Replace the work unit on the end of the queue. See the compute() method for details of the arguments to the work unit.

reset(*args, **kwargs)

Clear the queue and start a new work unit. See the compute() method for details of the arguments to the work unit.

stop()

Clear the queue and stop the thread. New items may be queued after stop. To stop just the current work item, and continue the rest of the queue call the interrupt method

update(**kwargs)

Update GUI with the lastest results from the current work unit.

sas.sascalc.data_util.err1d module

Error propogation algorithms for simple arithmetic

Warning: like the underlying numpy library, the inplace operations may return values of the wrong type if some of the arguments are integers, so be sure to create them with floating point inputs.

sas.sascalc.data_util.err1d.add(X, varX, Y, varY)

Addition with error propagation

sas.sascalc.data_util.err1d.add_inplace(X, varX, Y, varY)

In-place addition with error propagation

sas.sascalc.data_util.err1d.div(X, varX, Y, varY)

Division with error propagation

sas.sascalc.data_util.err1d.div_inplace(X, varX, Y, varY)

In-place division with error propagation

sas.sascalc.data_util.err1d.exp(X, varX)

Exponentiation with error propagation

sas.sascalc.data_util.err1d.log(X, varX)

Logarithm with error propagation

sas.sascalc.data_util.err1d.mul(X, varX, Y, varY)

Multiplication with error propagation

sas.sascalc.data_util.err1d.mul_inplace(X, varX, Y, varY)

In-place multiplication with error propagation

sas.sascalc.data_util.err1d.pow(X, varX, n)

X**n with error propagation

sas.sascalc.data_util.err1d.pow_inplace(X, varX, n)

In-place X**n with error propagation

sas.sascalc.data_util.err1d.sub(X, varX, Y, varY)

Subtraction with error propagation

sas.sascalc.data_util.err1d.sub_inplace(X, varX, Y, varY)

In-place subtraction with error propagation

sas.sascalc.data_util.formatnum module

Format values and uncertainties nicely for printing.

format_uncertainty_pm() produces the expanded format v +/- err.

format_uncertainty_compact() produces the compact format v(##), where the number in parenthesis is the uncertainty in the last two digits of v.

format_uncertainty() uses the compact format by default, but this can be changed to use the expanded +/- format by setting format_uncertainty.compact to False.

The formatted string uses only the number of digits warranted by the uncertainty in the measurement.

If the uncertainty is 0 or not otherwise provided, the simple %g floating point format option is used.

Infinite and indefinite numbers are represented as inf and NaN.

Example:

>>> v,dv = 757.2356,0.01032
>>> print format_uncertainty_pm(v,dv)
757.236 +/- 0.010
>>> print format_uncertainty_compact(v,dv)
757.236(10)
>>> print format_uncertainty(v,dv)
757.236(10)
>>> format_uncertainty.compact = False
>>> print format_uncertainty(v,dv)
757.236 +/- 0.010

UncertaintyFormatter() returns a private formatter with its own formatter.compact flag.

sas.sascalc.data_util.formatnum.format_uncertainty_pm(value, uncertainty)

Given value v and uncertainty dv, return a string v +/- dv.

sas.sascalc.data_util.formatnum.format_uncertainty_compact(value, uncertainty)

Given value v and uncertainty dv, return the compact representation v(##), where ## are the first two digits of the uncertainty.

sas.sascalc.data_util.nxsunit module

Define unit conversion support for NeXus style units.

The unit format is somewhat complicated. There are variant spellings and incorrect capitalization to worry about, as well as forms such as “mili*metre” and “1e-7 seconds”.

This is a minimal implementation of units including only what I happen to need now. It does not support the complete dimensional analysis provided by the package udunits on which NeXus is based, or even the units used in the NeXus definition files.

Unlike other units packages, this package does not carry the units along with the value but merely provides a conversion function for transforming values.

Usage example:

import nxsunit
u = nxsunit.Converter('mili*metre')  # Units stored in mm
v = u(3000,'m')  # Convert the value 3000 mm into meters

NeXus example:

# Load sample orientation in radians regardless of how it is stored.
# 1. Open the path
file.openpath('/entry1/sample/sample_orientation')
# 2. scan the attributes, retrieving 'units'
units = [for attr,value in file.attrs() if attr == 'units']
# 3. set up the converter (assumes that units actually exists)
u = nxsunit.Converter(units[0])
# 4. read the data and convert to the correct units
v = u(file.read(),'radians')

This is a standalone module, not relying on either DANSE or NeXus, and can be used for other unit conversion tasks.

Note: minutes are used for angle and seconds are used for time. We cannot tell what the correct interpretation is without knowing something about the fields themselves. If this becomes an issue, we will need to allow the application to set the dimension for the unit rather than inferring the dimension from an example unit.

class sas.sascalc.data_util.nxsunit.Converter(name)

Bases: object

Unit converter for NeXus style units.

dims = [{'kilometre': 1000.0, 'centi*Metre': 0.01, 'mili*meter': 0.001, 'gigameter': 1000000000.0, 'meter': 1, 'milli*meter': 0.001, 'kiloMetres': 1000.0, 'centiMeters': 0.01, 'picometers': 1e-12, 'centimeter': 0.01, 'picometre': 1e-12, 'centiMetre': 0.01, 'picoMeter': 1e-12, 'teraMetres': 1000000000000.0, 'kiloMetre': 1000.0, 'nanometre': 1e-09, 'pico*meter': 1e-12, 'nanoMeters': 1e-09, 'centi*metre': 0.01, 'mili*Meter': 0.001, 'micrometers': 1e-06, 'micron': 1e-06, 'picoMetre': 1e-12, 'centimetre': 0.01, 'micrometre': 1e-06, 'dm': 0.1, 'pico*Meter': 1e-12, 'miliMeter': 0.001, 'kilo*metre': 1000.0, 'gigaMeters': 1000000000.0, 'petaMeters': 1000000000000000.0, 'kilometres': 1000.0, 'megametre': 1000000.0, 'milli*metre': 0.001, 'megaMeters': 1000000.0, 'deci*Meter': 0.1, 'milimeter': 0.001, 'micro*Metre': 1e-06, 'microMeter': 1e-06, 'teraMeters': 1000000000000.0, 'kilo*meter': 1000.0, 'deciMeter': 0.1, 'millimeters': 0.001, 'femtometer': 1e-15, 'Gm': 1000000000.0, 'deci*metre': 0.1, 'femtometre': 1e-15, 'Angstrom': 1e-10, 'petametre': 1000000000000000.0, 'giga*metre': 1000000000.0, 'nanometers': 1e-09, 'deciMetre': 0.1, 'microMeters': 1e-06, 'metres': 1, 'kilo*Meter': 1000.0, 'meters': 1, 'gigametres': 1000000000.0, 'nanometer': 1e-09, 'terametre': 1000000000000.0, 'Pm': 1000000000000000.0, 'petameter': 1000000000000000.0, 'centi*Meter': 0.01, 'decimetre': 0.1, 'femto*metre': 1e-15, 'gigameters': 1000000000.0, 'decimeters': 0.1, 'kilometer': 1000.0, 'petameters': 1000000000000000.0, 'femto*meter': 1e-15, 'microMetre': 1e-06, 'centi*meter': 0.01, 'Mm': 1000000.0, 'megametres': 1000000.0, 'kiloMeter': 1000.0, 'mega*meter': 1000000.0, 'kilometers': 1000.0, 'nanoMetres': 1e-09, 'peta*Metre': 1000000000000000.0, 'megameter': 1000000.0, 'mili*metre': 0.001, 'tera*metre': 1000000000000.0, 'kilo*Metre': 1000.0, 'gigametre': 1000000000.0, 'metre': 1, 'Angstroms': 1e-10, 'Meters': 1, 'femtoMetres': 1e-15, 'peta*metre': 1000000000000000.0, 'micro*Meter': 1e-06, 'centiMeter': 0.01, 'picometer': 1e-12, 'millimetres': 0.001, 'terametres': 1000000000000.0, 'milliMetre': 0.001, 'cm': 0.01, 'microMetres': 1e-06, 'gigaMetre': 1000000000.0, 'milimetres': 0.001, 'tera*meter': 1000000000000.0, 'deciMeters': 0.1, 'nano*meter': 1e-09, 'milimetre': 0.001, 'megaMetres': 1000000.0, 'millimetre': 0.001, 'gigaMeter': 1000000000.0, 'nano*Meter': 1e-09, 'peta*Meter': 1000000000000000.0, 'nanometres': 1e-09, 'teraMetre': 1000000000000.0, 'giga*Meter': 1000000000.0, 'pm': 1e-12, 'petaMetres': 1000000000000000.0, 'milli*Metre': 0.001, 'centiMetres': 0.01, 'picometres': 1e-12, 'Metres': 1, 'deci*meter': 0.1, 'micro*metre': 1e-06, 'tera*Meter': 1000000000000.0, 'femtoMeters': 1e-15, 'deciMetres': 0.1, 'peta*meter': 1000000000000000.0, 'femtometres': 1e-15, 'gigaMetres': 1000000000.0, 'milliMetres': 0.001, 'giga*Metre': 1000000000.0, 'microns': 1e-06, 'Ang': 1e-10, 'mega*metre': 1000000.0, 'mm': 0.001, 'miliMetres': 0.001, 'um': 1e-06, 'terameter': 1000000000000.0, 'kiloMeters': 1000.0, 'miliMeters': 0.001, 'megaMetre': 1000000.0, 'pico*metre': 1e-12, 'mega*Metre': 1000000.0, 'femtoMetre': 1e-15, 'micrometer': 1e-06, 'decimeter': 0.1, 'Tm': 1000000000000.0, 'teraMeter': 1000000000000.0, 'km': 1000.0, 'femtoMeter': 1e-15, 'mili*Metre': 0.001, 'petaMetre': 1000000000000000.0, 'petametres': 1000000000000000.0, 'nm': 1e-09, 'pico*Metre': 1e-12, 'micrometres': 1e-06, 'deci*Metre': 0.1, 'femtometers': 1e-15, 'milliMeter': 0.001, 'miliMetre': 0.001, 'centimeters': 0.01, 'picoMeters': 1e-12, 'nanoMeter': 1e-09, 'A': 1e-10, 'petaMeter': 1000000000000000.0, 'megameters': 1000000.0, 'nano*Metre': 1e-09, 'femto*Metre': 1e-15, 'Metre': 1, 'terameters': 1000000000000.0, 'millimeter': 0.001, 'nanoMetre': 1e-09, 'milliMeters': 0.001, 'femto*Meter': 1e-15, 'micro*meter': 1e-06, 'fm': 1e-15, 'milimeters': 0.001, 'centimetres': 0.01, 'picoMetres': 1e-12, 'megaMeter': 1000000.0, 'nano*metre': 1e-09, 'm': 1, 'Meter': 1, 'milli*Meter': 0.001, 'decimetres': 0.1, 'mega*Meter': 1000000.0, 'tera*Metre': 1000000000000.0, 'giga*meter': 1000000000.0}, {'nanoseconds': 1e-09, 'deciSeconds': 0.1, 'femtoSeconds': 1e-15, 'kiloseconds': 1000.0, 'millisecond': 0.001, 'centi*second': 0.01, 'nanoSeconds': 1e-09, 'day': 86400, 'teraseconds': 1000000000000.0, 'kiloSeconds': 1000.0, 'weeks': 604800, 'kilo*second': 1000.0, 'peta*second': 1000000000000000.0, 'nanoSecond': 1e-09, 'decisecond': 0.1, 'centiSecond': 0.01, 'picosecond': 1e-12, 'ds': 0.1, 'petaSecond': 1000000000000000.0, 'mega*second': 1000000.0, 'Gs': 1000000000.0, 'megaSeconds': 1000000.0, 'mili*Second': 0.001, 'gigaseconds': 1000000000.0, 'Ps': 1000000000000000.0, 'teraSecond': 1000000000000.0, 'deci*Second': 0.1, 'giga*second': 1000000000.0, 'second': 1, 'nano*Second': 1e-09, 'gigaSeconds': 1000000000.0, 'centiSeconds': 0.01, 'picoseconds': 1e-12, 'Seconds': 1, 'milli*Second': 0.001, 'deciSecond': 0.1, 'centi*Second': 0.01, 'petasecond': 1000000000000000.0, 'ps': 1e-12, 'seconds': 1, 'hours': 3600, 'Ms': 1000000.0, 'mili*second': 0.001, 'kilo*Second': 1000.0, 'days': 86400, 'terasecond': 1000000000000.0, 'microSecond': 1e-06, 'giga*Second': 1000000000.0, 's': 1, 'femtoseconds': 1e-15, 'nano*second': 1e-09, 'kilosecond': 1000.0, 'cs': 0.01, 'miliSecond': 0.001, 'milliSeconds': 0.001, 'kiloSecond': 1000.0, 'femto*Second': 1e-15, 'deciseconds': 0.1, 'pico*second': 1e-12, 'milliseconds': 0.001, 'gigaSecond': 1000000000.0, 'femtosecond': 1e-15, 'megaseconds': 1000000.0, 'teraSeconds': 1000000000000.0, 'mega*Second': 1000000.0, 'petaseconds': 1000000000000000.0, 'hour': 3600, 'milli*second': 0.001, 'us': 1e-06, 'ms': 0.001, 'milliSecond': 0.001, 'miliSeconds': 0.001, 'petaSeconds': 1000000000000000.0, 'megaSecond': 1000000.0, 'Ts': 1000000000000.0, 'femto*second': 1e-15, 'tera*Second': 1000000000000.0, 'micro*Second': 1e-06, 'miliseconds': 0.001, 'peta*Second': 1000000000000000.0, 'gigasecond': 1000000000.0, 'nanosecond': 1e-09, 'milisecond': 0.001, 'ns': 1e-09, 'week': 604800, 'centiseconds': 0.01, 'fs': 1e-15, 'picoSeconds': 1e-12, 'microsecond': 1e-06, 'microSeconds': 1e-06, 'pico*Second': 1e-12, 'femtoSecond': 1e-15, 'deci*second': 0.1, 'megasecond': 1000000.0, 'ks': 1000.0, 'Second': 1, 'tera*second': 1000000000000.0, 'centisecond': 0.01, 'picoSecond': 1e-12, 'micro*second': 1e-06, 'microseconds': 1e-06}, {'arcminute': 0.016666666666666666, 'rad': 57.29577951308232, 'arcsec': 0.0002777777777777778, 'degree': 1, 'arcminutes': 0.016666666666666666, 'radians': 57.29577951308232, 'arcsecond': 0.0002777777777777778, 'arcmin': 0.016666666666666666, 'degrees': 1, 'radian': 57.29577951308232, 'deg': 1, 'minutes': 0.016666666666666666, 'minute': 0.016666666666666666, 'arcseconds': 0.0002777777777777778}, {'pico*hertz': 1e-12, 'mili*Hertz': 0.001, 'fHz': 1e-15, 'nanoHertzs': 1e-09, 'kiloHertzs': 1000.0, 'milli*Hertz': 0.001, 'pico*Hertz': 1e-12, 'miliHertz': 0.001, 'GHz': 1000000000.0, 'hertzs': 1, 'centiHertzs': 0.01, 'picohertzs': 1e-12, 'petahertz': 1000000000000000.0, 'mega*hertz': 1000000.0, 'microHertzs': 1e-06, 'PHz': 1000000000000000.0, 'teraHertzs': 1000000000000.0, 'dHz': 0.1, 'megaHertzs': 1000000.0, 'THz': 1000000000000.0, 'petaHertz': 1000000000000000.0, 'mega*Hertz': 1000000.0, 'centihertz': 0.01, 'kilo*Hertz': 1000.0, 'picoHertz': 1e-12, 'miliHertzs': 0.001, 'femto*hertz': 1e-15, 'petaHertzs': 1000000000000000.0, 'nanohertzs': 1e-09, 'centi*Hertz': 0.01, 'nano*hertz': 1e-09, 'giga*Hertz': 1000000000.0, 'peta*Hertz': 1000000000000000.0, 'kilo*hertz': 1000.0, 'Hz': 1, 'centi*hertz': 0.01, 'nano*Hertz': 1e-09, 'megaHertz': 1000000.0, 'decihertzs': 0.1, 'microhertzs': 1e-06, 'terahertzs': 1000000000000.0, 'megahertzs': 1000000.0, 'tera*Hertz': 1000000000000.0, 'terahertz': 1000000000000.0, 'gigahertz': 1000000000.0, 'milliHertz': 0.001, 'milliHertzs': 0.001, 'kHz': 1000.0, 'MHz': 1000000.0, 'decihertz': 0.1, 'gigaHertz': 1000000000.0, 'kiloHertz': 1000.0, 'deci*Hertz': 0.1, 'deciHertzs': 0.1, 'microhertz': 1e-06, 'Hertz': 1, 'milihertzs': 0.001, 'millihertzs': 0.001, 'rpm': 0.016666666666666666, 'hertz': 1, 'pHz': 1e-12, 'femtohertz': 1e-15, 'picoHertzs': 1e-12, 'milli*hertz': 0.001, 'gigahertzs': 1000000000.0, 'femtohertzs': 1e-15, 'micro*hertz': 1e-06, 'milihertz': 0.001, 'nanohertz': 1e-09, 'picohertz': 1e-12, 'deci*hertz': 0.1, 'femtoHertz': 1e-15, 'micro*Hertz': 1e-06, 'nanoHertz': 1e-09, 'rpms': 0.016666666666666666, 'kilohertzs': 1000.0, 'nHz': 1e-09, 'megahertz': 1000000.0, 'Hertzs': 1, 'femto*Hertz': 1e-15, 'giga*hertz': 1000000000.0, 'tera*hertz': 1000000000000.0, 'centiHertz': 0.01, 'peta*hertz': 1000000000000000.0, 'uHz': 1e-06, 'mHz': 0.001, 'petahertzs': 1000000000000000.0, 'deciHertz': 0.1, 'cHz': 0.01, 'centihertzs': 0.01, 'kilohertz': 1000.0, 'gigaHertzs': 1000000000.0, 'femtoHertzs': 1e-15, 'mili*hertz': 0.001, 'microHertz': 1e-06, 'teraHertz': 1000000000000.0, 'millihertz': 0.001}, {'milicelciuss': 0.001, 'celcius': 1, 'gigacelcius': 1000000000.0, 'gigaKelvin': 1000000000.0, 'decikelvin': 0.1, 'milli*kelvin': 0.001, 'teraCelciuss': 1000000000000.0, 'giga*kelvin': 1000000000.0, 'giga*Celcius': 1000000000.0, 'nanoKelvins': 1e-09, 'nanoCelciuss': 1e-09, 'gigacelciuss': 1000000000.0, 'kilo*Celcius': 1000.0, 'centi*Kelvin': 0.01, 'milli*celcius': 0.001, 'milliKelvin': 0.001, 'microCelcius': 1e-06, 'nanokelvin': 1e-09, 'femto*kelvin': 1e-15, 'megaCelcius': 1000000.0, 'pico*celcius': 1e-12, 'mega*Kelvin': 1000000.0, 'teraCelcius': 1000000000000.0, 'kiloCelciuss': 1000.0, 'deci*Kelvin': 0.1, 'pico*Kelvin': 1e-12, 'GC': 1000000000.0, 'deciCelciuss': 0.1, 'microkelvin': 1e-06, 'GK': 1000000000.0, 'megaCelciuss': 1000000.0, 'milli*Celcius': 0.001, 'dK': 0.1, 'gigaCelciuss': 1000000000.0, 'femtocelciuss': 1e-15, 'mili*Kelvin': 0.001, 'dC': 0.1, 'TC': 1000000000000.0, 'milli*Kelvin': 0.001, 'microcelciuss': 1e-06, 'megakelvin': 1000000.0, 'nano*Kelvin': 1e-09, 'petaKelvin': 1000000000000000.0, 'kilo*celcius': 1000.0, 'petacelciuss': 1000000000000000.0, 'deciKelvins': 0.1, 'milikelvins': 0.001, 'picocelcius': 1e-12, 'femtoKelvin': 1e-15, 'centiCelcius': 0.01, 'mega*kelvin': 1000000.0, 'microKelvins': 1e-06, 'milliCelciuss': 0.001, 'peta*Kelvin': 1000000000000000.0, 'pico*kelvin': 1e-12, 'kK': 1000.0, 'decikelvins': 0.1, 'deci*celcius': 0.1, 'microKelvin': 1e-06, 'PK': 1000000000000000.0, 'megacelciuss': 1000000.0, 'C': 1, 'picokelvin': 1e-12, 'centiKelvin': 0.01, 'femto*Celcius': 1e-15, 'K': 1, 'megakelvins': 1000000.0, 'miliKelvins': 0.001, 'kiloKelvin': 1000.0, 'PC': 1000000000000000.0, 'microCelciuss': 1e-06, 'milliKelvins': 0.001, 'mili*Celcius': 0.001, 'petaCelcius': 1000000000000000.0, 'peta*Celcius': 1000000000000000.0, 'Celcius': 1, 'petakelvin': 1000000000000000.0, 'MC': 1000000.0, 'micro*celcius': 1e-06, 'gigaCelcius': 1000000000.0, 'MK': 1000000.0, 'terakelvin': 1000000000000.0, 'kiloKelvins': 1000.0, 'cC': 0.01, 'petakelvins': 1000000000000000.0, 'kiloCelcius': 1000.0, 'nanoCelcius': 1e-09, 'pico*Celcius': 1e-12, 'peta*celcius': 1000000000000000.0, 'kilocelcius': 1000.0, 'micro*Celcius': 1e-06, 'nano*celcius': 1e-09, 'miliKelvin': 0.001, 'deci*Celcius': 0.1, 'mega*Celcius': 1000000.0, 'petacelcius': 1000000000000000.0, 'pC': 1e-12, 'tera*Celcius': 1000000000000.0, 'petaKelvins': 1000000000000000.0, 'megaKelvin': 1000000.0, 'tera*Kelvin': 1000000000000.0, 'pK': 1e-12, 'centiKelvins': 0.01, 'picokelvins': 1e-12, 'megacelcius': 1000000.0, 'milicelcius': 0.001, 'cK': 0.01, 'teracelcius': 1000000000000.0, 'deciCelcius': 0.1, 'Kelvin': 1, 'picoCelciuss': 1e-12, 'centicelciuss': 0.01, 'kilokelvin': 1000.0, 'petaCelciuss': 1000000000000000.0, 'centi*Celcius': 0.01, 'Kelvins': 1, 'giga*celcius': 1000000000.0, 'centikelvins': 0.01, 'picoKelvins': 1e-12, 'kilocelciuss': 1000.0, 'centicelcius': 0.01, 'mC': 0.001, 'decicelcius': 0.1, 'millicelciuss': 0.001, 'nano*Celcius': 1e-09, 'mK': 0.001, 'centiCelciuss': 0.01, 'microcelcius': 1e-06, 'uK': 1e-06, 'kelvins': 1, 'teraKelvin': 1000000000000.0, 'micro*Kelvin': 1e-06, 'uC': 1e-06, 'miliCelciuss': 0.001, 'picoKelvin': 1e-12, 'centikelvin': 0.01, 'femtocelcius': 1e-15, 'gigakelvin': 1000000000.0, 'deciKelvin': 0.1, 'teracelciuss': 1000000000000.0, 'giga*Kelvin': 1000000000.0, 'celciuss': 1, 'tera*kelvin': 1000000000000.0, 'nanocelciuss': 1e-09, 'nK': 1e-09, 'femtoCelcius': 1e-15, 'nC': 1e-09, 'picocelciuss': 1e-12, 'gigakelvins': 1000000000.0, 'nanokelvins': 1e-09, 'kilo*Kelvin': 1000.0, 'terakelvins': 1000000000000.0, 'megaKelvins': 1000000.0, 'femto*celcius': 1e-15, 'deci*kelvin': 0.1, 'milikelvin': 0.001, 'gigaKelvins': 1000000000.0, 'femtokelvins': 1e-15, 'femtoCelciuss': 1e-15, 'fC': 1e-15, 'TK': 1000000000000.0, 'Celciuss': 1, 'teraKelvins': 1000000000000.0, 'mili*celcius': 0.001, 'picoCelcius': 1e-12, 'micro*kelvin': 1e-06, 'kC': 1000.0, 'decicelciuss': 0.1, 'microkelvins': 1e-06, 'centi*kelvin': 0.01, 'kelvin': 1, 'mili*kelvin': 0.001, 'femtoKelvins': 1e-15, 'kilokelvins': 1000.0, 'milliCelcius': 0.001, 'millikelvin': 0.001, 'peta*kelvin': 1000000000000000.0, 'nanoKelvin': 1e-09, 'femto*Kelvin': 1e-15, 'nanocelcius': 1e-09, 'nano*kelvin': 1e-09, 'femtokelvin': 1e-15, 'mega*celcius': 1000000.0, 'millicelcius': 0.001, 'kilo*kelvin': 1000.0, 'tera*celcius': 1000000000000.0, 'millikelvins': 0.001, 'centi*celcius': 0.01, 'fK': 1e-15, 'miliCelcius': 0.001}, {'femtoCoulomb': 1e-15, 'gigacoulombs': 1000000000.0, 'megaCoulombs': 1000000.0, 'deci*coulomb': 0.1, 'kilocoulomb': 1000.0, 'deciCoulombs': 0.1, 'femto*Coulomb': 1e-15, 'millicoulomb': 0.001, 'deci*Coulomb': 0.1, 'peta*Coulomb': 1000000000000000.0, 'mili*coulomb': 0.001, 'GC': 1000000000.0, 'petaCoulombs': 1000000000000000.0, 'megacoulomb': 1000000.0, 'miliCoulomb': 0.001, 'dC': 0.1, 'mili*Coulomb': 0.001, 'milliCoulombs': 0.001, 'picoCoulomb': 1e-12, 'gigaCoulomb': 1000000000.0, 'giga*coulomb': 1000000000.0, 'tera*coulomb': 1000000000000.0, 'microcoulombs': 1e-06, 'centiCoulombs': 0.01, 'picocoulombs': 1e-12, 'mega*Coulomb': 1000000.0, 'petaCoulomb': 1000000000000000.0, 'miliCoulombs': 0.001, 'PC': 1000000000000000.0, 'kiloCoulombs': 1000.0, 'femtocoulombs': 1e-15, 'petacoulombs': 1000000000000000.0, 'nano*coulomb': 1e-09, 'C': 1, 'teraCoulombs': 1000000000000.0, 'decicoulombs': 0.1, 'nano*Coulomb': 1e-09, 'deciCoulomb': 0.1, 'MC': 1000000.0, 'milliCoulomb': 0.001, 'picocoulomb': 1e-12, 'centiCoulomb': 0.01, 'teracoulombs': 1000000000000.0, 'decicoulomb': 0.1, 'kilo*Coulomb': 1000.0, 'pC': 1e-12, 'kilocoulombs': 1000.0, 'centicoulomb': 0.01, 'micro*Coulomb': 1e-06, 'femto*coulomb': 1e-15, 'nanocoulomb': 1e-09, 'cC': 0.01, 'pico*coulomb': 1e-12, 'nanocoulombs': 1e-09, 'centicoulombs': 0.01, 'milli*coulomb': 0.001, 'nanoCoulomb': 1e-09, 'mC': 0.001, 'picoCoulombs': 1e-12, 'pico*Coulomb': 1e-12, 'kiloCoulomb': 1000.0, 'femtoCoulombs': 1e-15, 'uC': 1e-06, 'gigacoulomb': 1000000000.0, 'giga*Coulomb': 1000000000.0, 'milli*Coulomb': 0.001, 'peta*coulomb': 1000000000000000.0, 'megacoulombs': 1000000.0, 'mega*coulomb': 1000000.0, 'megaCoulomb': 1000000.0, 'petacoulomb': 1000000000000000.0, 'nC': 1e-09, 'teracoulomb': 1000000000000.0, 'coulombs': 1, 'gigaCoulombs': 1000000000.0, 'microCoulombs': 1e-06, 'tera*Coulomb': 1000000000000.0, 'teraCoulomb': 1000000000000.0, 'centi*Coulomb': 0.01, 'millicoulombs': 0.001, 'milicoulomb': 0.001, 'TC': 1000000000000.0, 'kC': 1000.0, 'milicoulombs': 0.001, 'Coulomb': 1, 'microCoulomb': 1e-06, 'centi*coulomb': 0.01, 'nanoCoulombs': 1e-09, 'microAmp*hour': 0.0036, 'femtocoulomb': 1e-15, 'coulomb': 1, 'kilo*coulomb': 1000.0, 'microcoulomb': 1e-06, 'fC': 1e-15, 'Coulombs': 1, 'micro*coulomb': 1e-06}, {'10^-6 Angstrom^-2': 1e-06, 'Angstrom^-2': 1, '10-6 Angstrom-2': 1e-06, 'Angstrom-2': 1}, {'invAng': 1, 'n_m^-1': 0.1, '10-3 Angstrom-1': 0.001, 'invA': 1, 'n_m-1': 0.1, '1/nm': 0.1, '1/cm': 1e-08, '10^-3 Angstrom^-1': 0.001, 'nm^-1': 0.1, '1/A': 1, 'nm-1': 0.1, 'invAngstroms': 1}]

scale(units='')

scalebase = 1

scalemap = None

unknown = {'': 1, None: 1, 'a.u.': 1, '???': 1}

sas.sascalc.data_util.odict module

A dict that keeps keys in insertion order

class sas.sascalc.data_util.odict.OrderedDict(init_val=(), strict=False)

Bases: dict

A class of dictionary that keeps the insertion order of keys.

All appropriate methods return keys, items, or values in an ordered way.

All normal dictionary methods are available. Update and comparison is restricted to other OrderedDict objects.

Various sequence methods are available, including the ability to explicitly mutate the key ordering.

__contains__ tests:

>>> d = OrderedDict(((1, 3),))
>>> 1 in d
1
>>> 4 in d
0

__getitem__ tests:

>>> OrderedDict(((1, 3), (3, 2), (2, 1)))[2]
1
>>> OrderedDict(((1, 3), (3, 2), (2, 1)))[4]
Traceback (most recent call last):
KeyError: 4

__len__ tests:

>>> len(OrderedDict())
0
>>> len(OrderedDict(((1, 3), (3, 2), (2, 1))))
3

get tests:

>>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
>>> d.get(1)
3
>>> d.get(4) is None
1
>>> d.get(4, 5)
5
>>> d
OrderedDict([(1, 3), (3, 2), (2, 1)])

has_key tests:

>>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
>>> d.has_key(1)
1
>>> d.has_key(4)
0

clear()

>>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
>>> d.clear()
>>> d
OrderedDict([])

copy()

>>> OrderedDict(((1, 3), (3, 2), (2, 1))).copy()
OrderedDict([(1, 3), (3, 2), (2, 1)])

index(key)

Return the position of the specified key in the OrderedDict.

>>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
>>> d.index(3)
1
>>> d.index(4)
Traceback (most recent call last):
ValueError: list.index(x): x not in list

insert(index, key, value)

Takes index, key, and value as arguments.

Sets key to value, so that key is at position index in the OrderedDict.

>>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
>>> d.insert(0, 4, 0)
>>> d
OrderedDict([(4, 0), (1, 3), (3, 2), (2, 1)])
>>> d.insert(0, 2, 1)
>>> d
OrderedDict([(2, 1), (4, 0), (1, 3), (3, 2)])
>>> d.insert(8, 8, 1)
>>> d
OrderedDict([(2, 1), (4, 0), (1, 3), (3, 2), (8, 1)])

items()

items returns a list of tuples representing all the (key, value) pairs in the dictionary.

>>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
>>> d.items()
[(1, 3), (3, 2), (2, 1)]
>>> d.clear()
>>> d.items()
[]

iteritems()

>>> ii = OrderedDict(((1, 3), (3, 2), (2, 1))).iteritems()
>>> ii.next()
(1, 3)
>>> ii.next()
(3, 2)
>>> ii.next()
(2, 1)
>>> ii.next()
Traceback (most recent call last):
StopIteration

iterkeys()

>>> ii = OrderedDict(((1, 3), (3, 2), (2, 1))).iterkeys()
>>> ii.next()
1
>>> ii.next()
3
>>> ii.next()
2
>>> ii.next()
Traceback (most recent call last):
StopIteration

itervalues()

>>> iv = OrderedDict(((1, 3), (3, 2), (2, 1))).itervalues()
>>> iv.next()
3
>>> iv.next()
2
>>> iv.next()
1
>>> iv.next()
Traceback (most recent call last):
StopIteration

keys()

Return a list of keys in the OrderedDict.

>>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
>>> d.keys()
[1, 3, 2]

pop(key, *args)

No dict.pop in Python 2.2, gotta reimplement it

>>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
>>> d.pop(3)
2
>>> d
OrderedDict([(1, 3), (2, 1)])
>>> d.pop(4)
Traceback (most recent call last):
KeyError: 4
>>> d.pop(4, 0)
0
>>> d.pop(4, 0, 1)
Traceback (most recent call last):
TypeError: pop expected at most 2 arguments, got 3

popitem(i=-1)

Delete and return an item specified by index, not a random one as in dict. The index is -1 by default (the last item).

>>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
>>> d.popitem()
(2, 1)
>>> d
OrderedDict([(1, 3), (3, 2)])
>>> d.popitem(0)
(1, 3)
>>> OrderedDict().popitem()
Traceback (most recent call last):
KeyError: 'popitem(): dictionary is empty'
>>> d.popitem(2)
Traceback (most recent call last):
IndexError: popitem(): index 2 not valid

rename(old_key, new_key)

Rename the key for a given value, without modifying sequence order.

For the case where new_key already exists this raise an exception, since if new_key exists, it is ambiguous as to what happens to the associated values, and the position of new_key in the sequence.

>>> od = OrderedDict()
>>> od['a'] = 1
>>> od['b'] = 2
>>> od.items()
[('a', 1), ('b', 2)]
>>> od.rename('b', 'c')
>>> od.items()
[('a', 1), ('c', 2)]
>>> od.rename('c', 'a')
Traceback (most recent call last):
ValueError: New key already exists: 'a'
>>> od.rename('d', 'b')
Traceback (most recent call last):
KeyError: 'd'

reverse()

Reverse the order of the OrderedDict.

>>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
>>> d.reverse()
>>> d
OrderedDict([(2, 1), (3, 2), (1, 3)])

setdefault(key, defval=None)

>>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
>>> d.setdefault(1)
3
>>> d.setdefault(4) is None
True
>>> d
OrderedDict([(1, 3), (3, 2), (2, 1), (4, None)])
>>> d.setdefault(5, 0)
0
>>> d
OrderedDict([(1, 3), (3, 2), (2, 1), (4, None), (5, 0)])

setitems(items)

This method allows you to set the items in the dict.

It takes a list of tuples - of the same sort returned by the items method.

>>> d = OrderedDict()
>>> d.setitems(((3, 1), (2, 3), (1, 2)))
>>> d
OrderedDict([(3, 1), (2, 3), (1, 2)])

setkeys(keys)

setkeys all ows you to pass in a new list of keys which will replace the current set. This must contain the same set of keys, but need not be in the same order.

If you pass in new keys that don’t match, a KeyError will be raised.

>>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
>>> d.keys()
[1, 3, 2]
>>> d.setkeys((1, 2, 3))
>>> d
OrderedDict([(1, 3), (2, 1), (3, 2)])
>>> d.setkeys(['a', 'b', 'c'])
Traceback (most recent call last):
KeyError: 'Keylist is not the same as current keylist.'

setvalues(values)

You can pass in a list of values, which will replace the current list. The value list must be the same len as the OrderedDict.

(Or a ValueError is raised.)

>>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
>>> d.setvalues((1, 2, 3))
>>> d
OrderedDict([(1, 1), (3, 2), (2, 3)])
>>> d.setvalues([6])
Traceback (most recent call last):
ValueError: Value list is not the same length as the OrderedDict.

sort(*args, **kwargs)

Sort the key order in the OrderedDict.

This method takes the same arguments as the list.sort method on your version of Python.

>>> d = OrderedDict(((4, 1), (2, 2), (3, 3), (1, 4)))
>>> d.sort()
>>> d
OrderedDict([(1, 4), (2, 2), (3, 3), (4, 1)])

update(from_od)

Update from another OrderedDict or sequence of (key, value) pairs

>>> d = OrderedDict(((1, 0), (0, 1)))
>>> d.update(OrderedDict(((1, 3), (3, 2), (2, 1))))
>>> d
OrderedDict([(1, 3), (0, 1), (3, 2), (2, 1)])
>>> d.update({4: 4})
Traceback (most recent call last):
TypeError: undefined order, cannot get items from dict
>>> d.update((4, 4))
Traceback (most recent call last):
TypeError: cannot convert dictionary update sequence element "4" to a 2-item sequence

values(values=None)

Return a list of all the values in the OrderedDict.

Optionally you can pass in a list of values, which will replace the current list. The value list must be the same len as the OrderedDict.

>>> d = OrderedDict(((1, 3), (3, 2), (2, 1)))
>>> d.values()
[3, 2, 1]

class sas.sascalc.data_util.odict.SequenceOrderedDict(init_val=(), strict=True)

Bases: sas.sascalc.data_util.odict.OrderedDict

Experimental version of OrderedDict that has a custom object for keys, values, and items.

These are callable sequence objects that work as methods, or can be manipulated directly as sequences.

Test for keys, items and values.

>>> d = SequenceOrderedDict(((1, 2), (2, 3), (3, 4)))
>>> d
SequenceOrderedDict([(1, 2), (2, 3), (3, 4)])
>>> d.keys
[1, 2, 3]
>>> d.keys()
[1, 2, 3]
>>> d.setkeys((3, 2, 1))
>>> d
SequenceOrderedDict([(3, 4), (2, 3), (1, 2)])
>>> d.setkeys((1, 2, 3))
>>> d.keys[0]
1
>>> d.keys[:]
[1, 2, 3]
>>> d.keys[-1]
3
>>> d.keys[-2]
2
>>> d.keys[0:2] = [2, 1]
>>> d
SequenceOrderedDict([(2, 3), (1, 2), (3, 4)])
>>> d.keys.reverse()
>>> d.keys
[3, 1, 2]
>>> d.keys = [1, 2, 3]
>>> d
SequenceOrderedDict([(1, 2), (2, 3), (3, 4)])
>>> d.keys = [3, 1, 2]
>>> d
SequenceOrderedDict([(3, 4), (1, 2), (2, 3)])
>>> a = SequenceOrderedDict()
>>> b = SequenceOrderedDict()
>>> a.keys == b.keys
1
>>> a['a'] = 3
>>> a.keys == b.keys
0
>>> b['a'] = 3
>>> a.keys == b.keys
1
>>> b['b'] = 3
>>> a.keys == b.keys
0
>>> a.keys > b.keys
0
>>> a.keys < b.keys
1
>>> 'a' in a.keys
1
>>> len(b.keys)
2
>>> 'c' in d.keys
0
>>> 1 in d.keys
1
>>> [v for v in d.keys]
[3, 1, 2]
>>> d.keys.sort()
>>> d.keys
[1, 2, 3]
>>> d = SequenceOrderedDict(((1, 2), (2, 3), (3, 4)), strict=True)
>>> d.keys[::-1] = [1, 2, 3]
>>> d
SequenceOrderedDict([(3, 4), (2, 3), (1, 2)])
>>> d.keys[:2]
[3, 2]
>>> d.keys[:2] = [1, 3]
Traceback (most recent call last):
KeyError: 'Keylist is not the same as current keylist.'

>>> d = SequenceOrderedDict(((1, 2), (2, 3), (3, 4)))
>>> d
SequenceOrderedDict([(1, 2), (2, 3), (3, 4)])
>>> d.values
[2, 3, 4]
>>> d.values()
[2, 3, 4]
>>> d.setvalues((4, 3, 2))
>>> d
SequenceOrderedDict([(1, 4), (2, 3), (3, 2)])
>>> d.values[::-1]
[2, 3, 4]
>>> d.values[0]
4
>>> d.values[-2]
3
>>> del d.values[0]
Traceback (most recent call last):
TypeError: Can't delete items from values
>>> d.values[::2] = [2, 4]
>>> d
SequenceOrderedDict([(1, 2), (2, 3), (3, 4)])
>>> 7 in d.values
0
>>> len(d.values)
3
>>> [val for val in d.values]
[2, 3, 4]
>>> d.values[-1] = 2
>>> d.values.count(2)
2
>>> d.values.index(2)
0
>>> d.values[-1] = 7
>>> d.values
[2, 3, 7]
>>> d.values.reverse()
>>> d.values
[7, 3, 2]
>>> d.values.sort()
>>> d.values
[2, 3, 7]
>>> d.values.append('anything')
Traceback (most recent call last):
TypeError: Can't append items to values
>>> d.values = (1, 2, 3)
>>> d
SequenceOrderedDict([(1, 1), (2, 2), (3, 3)])

>>> d = SequenceOrderedDict(((1, 2), (2, 3), (3, 4)))
>>> d
SequenceOrderedDict([(1, 2), (2, 3), (3, 4)])
>>> d.items()
[(1, 2), (2, 3), (3, 4)]
>>> d.setitems([(3, 4), (2 ,3), (1, 2)])
>>> d
SequenceOrderedDict([(3, 4), (2, 3), (1, 2)])
>>> d.items[0]
(3, 4)
>>> d.items[:-1]
[(3, 4), (2, 3)]
>>> d.items[1] = (6, 3)
>>> d.items
[(3, 4), (6, 3), (1, 2)]
>>> d.items[1:2] = [(9, 9)]
>>> d
SequenceOrderedDict([(3, 4), (9, 9), (1, 2)])
>>> del d.items[1:2]
>>> d
SequenceOrderedDict([(3, 4), (1, 2)])
>>> (3, 4) in d.items
1
>>> (4, 3) in d.items
0
>>> len(d.items)
2
>>> [v for v in d.items]
[(3, 4), (1, 2)]
>>> d.items.count((3, 4))
1
>>> d.items.index((1, 2))
1
>>> d.items.index((2, 1))
Traceback (most recent call last):
ValueError: list.index(x): x not in list
>>> d.items.reverse()
>>> d.items
[(1, 2), (3, 4)]
>>> d.items.reverse()
>>> d.items.sort()
>>> d.items
[(1, 2), (3, 4)]
>>> d.items.append((5, 6))
>>> d.items
[(1, 2), (3, 4), (5, 6)]
>>> d.items.insert(0, (0, 0))
>>> d.items
[(0, 0), (1, 2), (3, 4), (5, 6)]
>>> d.items.insert(-1, (7, 8))
>>> d.items
[(0, 0), (1, 2), (3, 4), (7, 8), (5, 6)]
>>> d.items.pop()
(5, 6)
>>> d.items
[(0, 0), (1, 2), (3, 4), (7, 8)]
>>> d.items.remove((1, 2))
>>> d.items
[(0, 0), (3, 4), (7, 8)]
>>> d.items.extend([(1, 2), (5, 6)])
>>> d.items
[(0, 0), (3, 4), (7, 8), (1, 2), (5, 6)]

sas.sascalc.data_util.ordereddict module

Backport from python2.7 to python <= 2.6.

class sas.sascalc.data_util.ordereddict.OrderedDict(*args, **kwds)

Bases: dict

clear()

copy()

classmethod fromkeys(iterable, value=None)

items()

keys()

pop(key, default=<object object at 0x0000000008D6E860>)

popitem()

setdefault(key, default=None)

update(other=(), **kwds)

values()

sas.sascalc.data_util.ordereddicttest module

class sas.sascalc.data_util.ordereddicttest.TestOrderedDict(methodName='runTest')

Bases: unittest.case.TestCase

test_clear()

test_copying()

test_delitem()

test_equality()

test_init()

test_iterators()

test_pop()

test_popitem()

test_reinsert()

test_repr()

test_setdefault()

test_setitem()

test_update()

sas.sascalc.data_util.pathutils module

Utilities for path manipulation. Not to be confused with the pathutils module from the pythonutils package (http://groups.google.com/group/pythonutils).

sas.sascalc.data_util.pathutils.relpath(p1, p2)

Compute the relative path of p1 with respect to p2.

sas.sascalc.data_util.qsmearing module

Handle Q smearing

class sas.sascalc.data_util.qsmearing.PySmear(resolution, model, offset=None)

Bases: object

Wrapper for pure python sasmodels resolution functions.

apply(iq_in, first_bin=0, last_bin=None)

Apply the resolution function to the data. Note that this is called with iq_in matching data.x, but with iq_in[first_bin:last_bin] set to theory values for these bins, and the remainder left undefined. The first_bin, last_bin values should be those returned from get_bin_range. The returned value is of the same length as iq_in, with the range first_bin:last_bin set to the resolution smeared values.

get_bin_range(q_min=None, q_max=None)

For a given q_min, q_max, find the corresponding indices in the data. Returns first, last. Note that these are indexes into q from the data, not the q_calc needed by the resolution function. Note also that these are the indices, not the range limits. That is, the complete range will be q[first:last+1].

class sas.sascalc.data_util.qsmearing.PySmear2D(data=None, model=None)

Bases: object

Q smearing class for SAS 2d pinhole data

get_value()

Over sampling of r_nbins times phi_nbins, calculate Gaussian weights, then find smeared intensity

set_accuracy(accuracy='Low')

Set accuracy.

Parameters:accuracy – string

set_data(data=None)

Set data.

Parameters:data – DataLoader.Data_info type

set_index(index=None)

Set index.

Parameters:index – 1d arrays

set_model(model=None)

Set model.

Parameters:model – sas.models instance

set_smearer(smearer=True)

Set whether or not smearer will be used

Parameters:smearer – smear object

sas.sascalc.data_util.qsmearing.pinhole_smear(data, model=None)

sas.sascalc.data_util.qsmearing.slit_smear(data, model=None)

sas.sascalc.data_util.qsmearing.smear_selection(data, model=None)

Creates the right type of smearer according to the data. The canSAS format has a rule that either slit smearing data OR resolution smearing data is available.

For the present purpose, we choose the one that has none-zero data. If both slit and resolution smearing arrays are filled with good data (which should not happen), then we choose the resolution smearing data.

Parameters:

• data – Data1D object
• model – sas.model instance

sas.sascalc.data_util.registry module

File extension registry.

This provides routines for opening files based on extension, and registers the built-in file extensions.

class sas.sascalc.data_util.registry.ExtensionRegistry(**kw)

Bases: object

Associate a file loader with an extension.

Note that there may be multiple loaders for the same extension.

Example:

registry = ExtensionRegistry()

# Add an association by setting an element
registry['.zip'] = unzip

# Multiple extensions for one loader
registry['.tgz'] = untar
registry['.tar.gz'] = untar

# Generic extensions to use after trying more specific extensions; 
# these will be checked after the more specific extensions fail.
registry['.gz'] = gunzip

# Multiple loaders for one extension
registry['.cx'] = cx1
registry['.cx'] = cx2
registry['.cx'] = cx3

# Show registered extensions
print registry.extensions()

# Can also register a format name for explicit control from caller
registry['cx3'] = cx3
print registry.formats()

# Retrieve loaders for a file name
registry.lookup('hello.cx') -> [cx3,cx2,cx1]

# Run loader on a filename
registry.load('hello.cx') ->
    try:
        return cx3('hello.cx')
    except:
        try:
            return cx2('hello.cx')
        except:
            return cx1('hello.cx')

# Load in a specific format ignoring extension
registry.load('hello.cx',format='cx3') ->
    return cx3('hello.cx')

extensions()

Return a sorted list of registered extensions.

formats()

Return a sorted list of the registered formats.

load(path, format=None)

Call the loader for the file type of path.

Raises ValueError if no loader is available. Raises KeyError if format is not available. May raise a loader-defined exception if loader fails.

lookup(path)

Return the loader associated with the file type of path.

Raises ValueError if file type is not known.

sas.sascalc.data_util.registry.test()

sas.sascalc.data_util.uncertainty module

Uncertainty propagation class for arithmetic, log and exp.

Based on scalars or numpy vectors, this class allows you to store and manipulate values+uncertainties, with propagation of gaussian error for addition, subtraction, multiplication, division, power, exp and log.

Storage properties are determined by the numbers used to set the value and uncertainty. Be sure to use floating point uncertainty vectors for inplace operations since numpy does not do automatic type conversion. Normal operations can use mixed integer and floating point. In place operations such as a *= b create at most one extra copy for each operation. By contrast, c = a*b uses four intermediate vectors, so shouldn’t be used for huge arrays.

class sas.sascalc.data_util.uncertainty.Uncertainty(x, variance=None)

Bases: object

dx

standard deviation

exp()

log()

sas.sascalc.data_util.uniquelist module

sas.sascalc.data_util.uniquelist.main()

sas.sascalc.data_util.uniquelist.test()

sas.sascalc.data_util.uniquelist.uniquelist(inputlist, hash=None)

remove redunduant elements from the give list and return a list of unique elements.

inputlist: input list hash: use this function to make the items in the list hashable.

Implementation details:

This function is order-preserving.

Module contents