iFit: a simple library to analyze data
E. Farhi, ILL/DS/CS - Version 1.8-3
- Apr. 19, 2016
the iFit Data Analysis library !
"Simple methods to be used for
complex data analysis"
Main functionalities are
[ iData Load Plot Math Fit Treat
NOTICE: this release '1.8 upgrade 3'
fixes importer issues of release 1.8.
Users having installed version 1.8 are encouraged to re-install
(both source code and standalone programs)
library (pronounce [eye-fit
is a set of methods to load, analyze, plot, fit and optimize
models, and export results. iFit
is based on Matlab
can also be launched without Matlab license (stand-alone
does not currently include advanced graphical user interfaces
(GUI), and rather focuses on doing
the math right
. Any text file can be imported straight
away, and a set of binary files are supported. Any data
dimensionality can be handled, including event based data sets
(even though not all methods do work for these). Any model can
be assembled for fitting data sets.
can also be used transparently from Python
. Refer to our PyFit
The spirit of the library is to include object definitions, with
a set of methods that provide all the means to perform the usual
data analysis procedures.
- The iData object holds any data
- The iFunc object holds any
mathematical model function
A gallery of some of the things iFit can do
To install the package, refer to the Install
You need Matlab
use of the source package. The stand-alone (binary) package does
not require Matlab, but you will need the Matlab Compiler
Runtime (refer to the Install
page). The Python
interface requires either Matlab
or the iFit standalone package to be installed, as well as Python
The package is currently available from the ifit.mccode.org
packages (no need for a Matlab license) for
Linux, Windows and Mac OS X are available from the Install
page. You will then use the iFit standalone interface to the package
(a terminal/command window providing Matlab/iFit
Please register to the ifit-users
What's in the
What you will handle mainly deals with iData
objects. Please start to
read these pages first, as well as the Quick Start
page if you're in a
The iData objects (iFit/@iData): the core data set
objects have been defined in order to perform the following
- Load any text formatted file, and a
large set of binary format files
- Display object information, including metadata from the
- Plot the object Signal in a simple
view for 1D, 2D and 3D objects
- Perform mathematical operations using
objects (=-/* trigonometric projections integration
- Fit a parametrized model to the object
Signal, which makes use of the Optimizers
and Models libraries.
- Save the object into a set of output
An extended list of iData methods is
available in the Methods
addition, a few dedicated applications of these methods is
presented in the Treatment
instance for neutron scattering.
The iFunc objects (iFit/@iFunc): the core model
The iFunc objects hold models
(mathematical expressions that return a vector, matrix, ...)
value, as a function of a parameter set, and axes. You can
easily create new models, or use those from the Models page, and combine them to build
more complex models. The objects support most usual mathematical
The optimization library (iFit/Optimizers)
A set of optimization routines has
been gathered in the Optimizers
part of iFit. It enables to choose and compare how different
optimization methods can solve a problem. This library is used
transparently by the iData fits
but it may also be used independently.
A set of parametrized models is given in the Models
part of iFit in order to fit some
imported data and find best parameter sets which describe it.
These functions may be used by the fits
method. All these models are iFunc
objects. There are very advanced Models to compute for instance 4D phonon dispersions
codes, and other simpler analytical
The lower level import routines (iFit/Loaders)
The file import method used by iData
is performed on a lower level by the Loaders
part of iFit. Its purpose is to import any binary or text file,
without knowing its format. A number of post-import wrappers exist
in order to reshape the imported data to match specific needs.
These wrappers are very short to write.
If needed, other importation methods should be added there, to be
able to handle more formats. This library is used transparently by
the iData load
method, but it may also be
used independently to produce simple structures describing the
data files (even though we do not recommend this).
The documentation is given as web pages, and all methods/functions
have their own embedded help. To access it use:
A list of all available iData methods
is also available, and can be directly accesed with
The documentation currently contains the following pages:
- Changes: Version releases, Changes
and Bugs list.
- Credits: Credits, Licensing and
contributions from others.
- Fit: how to fit data sets onto
mathematical models and find the best parameter set
- iData: the description of the
fundamental data set object used in iFit, properties and how
to handle it
- iFunc: the description of the
fundamental model object used in iFit, properties and how to
- Loaders: how to import data files
into structures, which can be converted into iData afterwards.
This is a sub-library which you should only use if you need
the data NOT to be an object (but you then loose most of the
- Models: model functions that cab
be use for data fitting. A function maker tool is also
provided. Specialized models provide phonon dispersions,
Rietveld refinement, small angle scattering.
- index: This iFit Welcome page.
- iFit: the interface used in the
- Install: the installation page.
- Optimizers: the low level
- Load: how to load data set directly
as iData objects. This is what you should use.
- Math: all mathematical operations
and related data handling to apply on iData objects.
- McStas: an interface with the McStas neutron scattering
ray-tracing simulation code for simulation, scanning and
- Methods: a list of all available
methods for iData objects.
- Plot: many ways to plot the iData
- QuickStart: where you should
start (a quick tutorial).
- Save: Saving iData objects into many
- Treatment: a set of
methodologies applied to specific cases, for instance neutron
scattering (dynamic structure factors).
- PyFit: an interface which exposes
transparently all iFit methods and objects into Python/NumPy.
- Technical documentation
You may also search this whole documentation (using Google):
files are given as examples to be
used along the documentation web pages and in the Quick Start
other software and Graphical front-ends (iFit/GUI)
Specific interfaces have been written in order to use iFit
transparently for end-user applications:
- McStas: a wrapper to run
simulations or optimize McStas
compute the neutron TAS spectrometer resolution ellipsoid
Phonon dispersion from ab-initio force estimate and
- iFunc/Model Builder:
a dialogue to create iFunc fit
- iFit standalone: the prompt
interface used in the no-Matlab-license release. Can execute
any Matlab expression, scripts, handle iData and iFunc
objects, optimizers, plotting, ...
- PyFit: using iFit transparently
Ok, let's start !
To install the package, refer to the
page, you just need Matlab.
If you want a quick example, refer to the Quick Start
page. Otherwise, the
typical usage would be:
Start Matlab... or iFit stand-alone
>> addpath(genpath('/some/path/to/iFit')); % not needed for the stand-alone version
>> a = iData([ ifitpath 'Data/ILL_IN6.dat' ]);
If you do not know Matlab
you will discover that using the iFit library does not require
advanced IT knowledge. The general syntax are rather intuitive,
and all methods are able to tolerate (and correct) most of the
user mistakes. In this respect, when some of the input parameters
are missing, sensible choices can be made automatically. You can
look at the iFit
page, where a short
Matlab introduction is available.
If you have
used in the past the MFit/MView
suite, you will find that this library has the same scope, but
omitting the user interface.
If you have
used the Spec1d
, you will quickly find that the iFit
follows exactly the same
If you come
from the Python world
you will find out that the iFit syntax is pretty close. We provide
for you a Python interface to iFit which exposes all iFit objects
and methods into Python. Refer to the PyFit
Help me !
An extensive documentation is provided as web pages (such as this
one) which you access from Matlab with either
and help pages for each function/method, which you can access with
>> help iData
A Tutorial (Jan 2012)
is available as PDF presentations with exercises.
>> help iData/load
>> help iFunc
You may also search this whole documentation (using Google):
Finally, the whole Matlab documentation is available on-line for
free, especially to complement the standalone limited help system.
A list of bugs and release
history is recorded in the Changes
If you find new bugs please send them to me [farhi (at) ill.fr] with:
is the list set-up in order to exchange information (issues,
questions, announcements). Messages should be sent to email@example.com.
- your Matlab version
- the iFit version which you can get from the Matlab command version(iData)
- the script/command that reproduces the error together with any
required external data file
- a copy of the error messages produced by the script/command.
- a smile ;-)
You may register by entering your email address and press subscribe:
Credits, Links and
iFit was invented by E.
Farhi and took many years to come to you.
Substantial contributions from Y.
Debab and P. Willendrup.
If you produce scientific output using iFit, I'd appreciate if you
cite the following reference:
iFit is a product from the Computing
for Science group at the Institut
Laue-Langevin, Grenoble, France.
- E. Farhi, Y. Debab and P. Willendrup, J. Neut. Res., 17 (2013) 5. DOI:
- E. Farhi, The iFit data
analysis library, ILL, Computing for Science
See the Credits page for more
information on contributions, including licensing.
A set of links to related
packages is also included there.
If you wish to contribute, send
suggestions, scripts, and new functions/methods to [farhi (at) ill.fr]. Your
contribution will then be included in the next release, with proper
credits to the authors.
This software is experimental, and should not be considered
bullet-proof. In particular, expect many bugs - which should be
reported to me [farhi (at) ill.fr]
if you want them to be fixed quickly. Also, this prototype is known
to be slow. This will be improved gradually...