The aim of this package is handling of experimental data and models:

- Reading and analyzing experimental data with associated attributes as temperature, wavevector, comment, ….
- Multidimensional fitting taking the attributes (as fixed parameters) into account.
- Providing useful models (mainly for neutron and xray scattering), but there is no limitation.
- Plotting with paper ready quality (preferred in xmgrace, matplotlib possible ).
- Easy model building for non programmers.
- Python scripts to document data evaluation and used modelling.
Main concept
- Data organisation
- Read/Write data
- Fitting
fit()
for detailed description.- Plotting
- Models
some special functions:
scatteringLengthDensityCalc()
-> electron density, coh and inc neutron scattering length, masswaterXrayScattering()
-> Absolute scattering of water with components (salt, buffer)waterdensity()
-> temperature dependent density of water (H2O/D2O) with inorganic subtstancesRMSA()
-> rescaled MSA structure factor for dilute charged colloidal dispersionsmultiShellSphere()
-> formfactor of multi shell spherical particlesmultiShellCylinder()
-> formfactor of multi shell cylinder particlesorientedCloudScattering()
-> 2D scattering of an oriented cloud of scatterersfiniteZimm()
-> Zimm model with internal friction -> intermediate scattering functionsedimentationProfile()
-> approximate solution to the Lamm equation of sedimenting particleshydrodynamicFunct()
-> hydrodynamic function from hydrodynamic pair interactionsmear()
-> smearing for SANS (Pedersen), SAXS (line collimation) or by explicit Gaussiandesmear()
-> desmearing according to the Lake algorithm for the above
Example see example_simple_diffusion.py and other Examples
# import jscatter and numpy
import numpy as np
import jscatter as js
# read the data (16 sets) with attributes as q, Dtrans .... in to dataList
i5=js.dL('./exampleData/iqt_1hho.dat')
# define a model for the fit
diffusion=lambda A,D,t,elastic,wavevector=0:A*np.exp(-wavevector**2*D*t)+elastic
# do the fit
i5.fit(model=diffusion, # the fit function
freepar={'D':[0.08],'A':0.98}, # start parameters, "[]" -> independent fit
fixpar={'elastic':0.0}, # fixed parameters
mapNames={'t':'X','wavevector':'q'}) # map names from the model to names from the data
# single valued start parameters are the same for all dataArrays
# list start parameters indicate independent fitting
# the command line shows progress and the final result, which is found in .lastfit
# open a plot with fixed size
p=js.grace(1.2,0.8)
# plot the data with Q values in legend as symbols
p.plot(i5,symbol=[-1,0.4,-1],legend='Q=$q')
# plot fit results in lastfit as lines without symbol or legend
p.plot(i5.lastfit,symbol=0,line=[1,1,-1])
# make a nice plot if needed
p.yaxis(min=0.02,max=1.1,scale='log',charsize=1.5,label='I(Q,t)/I(Q,0)')
p.xaxis(min=0,max=130,charsize=1.5,label='t / ns')
p.legend(x=110,y=0.9,charsize=1)
p.title('I(Q,t) as measured by Neutron Spinecho Spectroscopy',size=1.3)
p.text('for diffusion a single exp. decay',x=60,y=0.35,rot=360-20,color=4)
p.text(r'f(t)=A*e\S-Q\S2\N\SDt',x=100,y=0.025,rot=0,charsize=1.5)

Shortcuts:
import jscatter as js
js.showDoc() # Show html documentation in browser
exampledA=js.dA('test.dat') # shortcut to create dataArray from file
exampledL=js.dL('test.dat') # shortcut to create dataList from file
p=js.grace() # create plot
p.plot(exampledL) # plot the read dataList
Intention and Remarks
Genesis
This package was programmed because of my personal need to fit multiple datasets together which differ in attributes defined by the measurements. A very common thing that is not included in numpy/scipy or other common fit programs. What i wanted is a numpy ndarray with its matrix like functionality for evaluating my data, but including attributes related to the data e.g. from a measurement. For multiple measurements i need a list of these. ==> dataArray and dataList.
As the used models are repeatedly the same a module with physical models was growing. A lot of these models are used frequently in small angle scattering programs like SASview or SASfit. For my purpose the dynamic models as diffusion, ZIMM, ROUSE and other things like protein dynamics were missing. In some programs (under open license) the available models are complicated to use (hidden in classes), or the access (reusage) includes a special designed interface (or i dont understand how to…). Here simple Python functions are easier to use for the non-programmers as most PhD-students are. Scripting in Python with numpy/scipy they learn very fast.
Scripting over GUI
Documentation of the evaluation of scientific data is difficult in GUI based programs (sequence of clicking buttons ???). Script oriented evaluation (MATLAB, Python, Jupyter,….) allow easy repetition with stepwise improvement and at the same time document what was done.
Complex models have multiple contributions, background contribution, … which can easily be defined in a short script including a documentation. I cannot guess if the background in a measurement is const linear, parabolic or whatever and each choice is also a limitation. Therefore the intention is to supply not obvious and complex models (with a scientific reference) and allow the user to adopt them to their needs e.g. add background and amplitude or resolution convolution. Simple models are fast implemented in one line as lambda functions or more complex things in scripts.
Plotting
Matplotlib seems to be the standard for numpy/scipy users. You can use it if you want. If you try to plot fast and live (interactive) it is complicated and slow (in my opinion). Frequently i run scripts that show results of different datasets and i want to keep these for comparison open and be able to modify the plot. Some of this is possible in matplotlib but not the default. As i want to think about physics and not plotting i like more xmgrace, with a GUI interface after plotting. A simple one line command should result in a 90% finished plot, final 10% fine adjustment can be done in the GUI if needed or from additional commands. I adopted the original Graceplot module (python interface to XmGrace) to my needs and added dataArray functionality. For the errorPlot of a fit a simple matplotlib interface is included.
The nice thing about Xmgrace is that it stores the plot as ASCII text instead of the JPG or PDF. So its easy to reopen the plot and change the plot later if your supervisor/boss/reviewer asks for log-log or other colors or whatever. For data inspection zoom, hide of data, simple fitting for trends and else are possible on WYSIWYG/GUI basis. If you want to retrieve the data (or forgot to save your results separatly) they are accessible in the ASCII file. Export in scientific paper quality is possible. A simple interface for annotations, lines, …. is included. Unfortunately its only 2D but this is 99% of my work.
Speed/Libraries
The most common libraries for scientific computing in python are NUMPY and SCIPY and these are the only dependencies for jscatter. Python in combination with numpy can be quite fast if the ndarrays methods are used consequently instead of loops. E.g. the numpy.einsum function immediately uses compiled C to do the computation. (See this and look for “Why are NumPy arrays efficient”). SCIPY offers all the math needed and optimized algorithms, also from blas/lapack. To speed up if needed on a multiprocessor machine the module parallel offers an easy interface to the standard python module multiprocessing within a single command. If your model needs long computing time and needs speed up the common methods as Cython, Numba should be used in your model. As these are more difficult the advanced user may use it in their models. A nice blog about possible speedups is found at Julia vs Python. If you prefer FORTRAN with f2py an interface is generated automatically and the FORTRAN code can be used. Nevertheless the critical point in these cases is the model and not the small overhead in dataArray/dataList or fitting.
Some resources :
Development environment/ Testing
The development platform is mainly current Linux (Linux Mint/CentOs). I regularly use jscatter on macOS. I regularly use it on 12 core Linux machines on our cluster. I tested the main functionallity (e.g. all examples) on Python 3.5 and try to write 2.7/3.5 compatible code. I never use Windows (only if a manufacturer of an instrument forces me…) Basically everything should work under Windows, except things that rely on pipes as the connection to XmGrace and the DLS module which calls CONTIN through a pipe.