# Getting started

In order to get going with Horace we suggest that you take a little time to familiarise yourself with the program. To aid this we have created the following step-by-step guide that takes you through the process of converting SPE files into a format useable by Horace, and then shows you how to do different kinds of plot, how to manipulate your data, and finally how to simulate and fit your data. To do this we will refer to the demonstration files included in

C:\mprogs\Horace\demo\

which relate to a real experiment to investigate spin excitations in Fe using the MAPS spectrometer at ISIS.

Before starting you must first extract the data files from the supplied zip file. You should find SPE files with names MAP11014.SPE, MAP11016.SPE, ..., MAP11060.SPE, as well as a PAR file called demo_par.PAR and a PHX file called demo_phx.PHX.

## Contents

## Creating an SQW file

The first step in using Horace is to make your dataset from all of your relevant SPE files. How this works depends somewhat on the properties of your computer, specifically the amount of memory available, and is dealt with here. On most machines (on which the available RAM is <10GB) the dataset is written to a new file with the extension .SQW, and intermediate .TMP files, which contain axes projection information, are written as Horace combines the data. Once you have created your SQW file and are happy with it then you can delete these intermediate .TMP files if you wish, although it is generally a good idea to keep for a few days them unless disk space is a problem for you, in case you wish to re-generate your SQW file. For special cases where large amounts of memory are available then the creation of .TMP files is unnecessary and the SQW file can be created directly. This latter case is dealt with in the section of this manual detailing advanced use, for the rest of the following we shall assume you are running a machine with less memory.

In addition to your data there is one other file that is required – the parameter file for the instrument that you used to collect the data. This file has the extension .PAR, and is **not** the same as a PHX file. If you try to use a PHX file with Horace you will just get an error message! The .PAR file for the instrument you used to generate your data can be obtained from the instrument scientist. It is important that you have the correct version of this file for the configuration of the instrument as it was when you used it (much like for the PHX file).

Let’s now run through a simple example. To do this we’ll need some example SPE files and a PAR file. The script file containing all of the commands described below is located in
`C:\mprogs\Horace\demo\demo_make_sqw_fe.m`

First we need to tell Horace where the SPE files are, so we write:

indir='C:\mprogs\Horace\demo\';

We also need to know where the PAR file is, and where the SQW file that we’re making is going to go:

par_file='C:\mprogs\Horace\demo\demo_par.par'; sqw_file='C:\mprogs\Horace\demo\demo_fe_sqw.sqw;'

Next we need to specify the (fixed) incident energy that was used and the geometry of the spectrometer. In this case all of the data were taken using Ei=787meV on a direct geometry spectromter, so we have:

efix=787; emode=1;

If we were using an indirect geometry spectrometer then we would have written

emode=2;

We cannot combine data from different spectrometers, so `emode`

is always 1 or 2.

If we had used multiple incident energies then we would have made `efix`

a vector whose length was the number of SPE files we wish to combine and whose elements were the incident energy for each SPE file.

We now need to tell Horace the lattice parameters of the sample:

alatt=[2.87,2.87,2.87]; angdeg=[90,90,90];

`alatt`

, which can be a row vector or a column vector, gives the lattice parameters `a`

, `b`

, and `c`

.
`angdeg`

, which can also be a row vector or a column vector, gives the lattice angles `alpha`

, `beta`

, and `gamma`

.

Then we need to specify the orientation of the crystal with respect to the incident beam and the spectrometer. We do this by specifying the scattering plane with two orthogonal vectors:

u=[1,0,0]; v=[0,1,0];

The vector

defines the direction in the **u****(h,k,l)** frame of the incident beam (so in the above example the crystal's (1,0,0) direction is parallel to the incident beam). The vector

may be perpendicular to **v**

(although it does not have to be) and lies in the equatorial plane of the spectrometer (i.e. the horizontal plane on MERLIN and MAPS). Thus the cross product of **u**

and **u**

should point up/down the sample stick.
**v**

If after your experiment you realise that your crystal was not aligned how you thought it was, all is not lost! Horace allows you to specify some *virtual goniometer* angles which tell the program how to convert the supplied (incorrect) co-ordinate frame

and **u**

to the real one. Of course you should make every effort to ensure your sample was correctly aligned, in which case you write
**v**

omega=0;dpsi=0;gl=0;gs=0;

The definitions of these angles are best described with reference to the picture below:

In this diagram the nominal vectors

and **u**

are those supplied to Horace, whereas **v**

and **u'**

are the actual vectors. **v'**`gl`

and `gs`

deal with misorientation about axes which lie in the spectrometer's equatorial plane, whereas `dpsi`

deals with misorientations about a vector perpendicular to this plane. `omega`

is the angle by which the `gs`

axis is rotated compared to the nominal vector

.
**u**

In principle this means that you could put a single crystal with unknown orientation into the spectrometer and conduct your experiment. However this is not a good idea, because the direction about which you rotate your crystal may not be the optimum for you to get all of the data that you want to, since the detectors do not cover <math>4 \pi</math> steradians.

Now we’ve told Horace all about the setup of the spectrometer we can go on to specify how our experiment was conducted and which SPE files will contribute to our dataset.

Suppose, as is the case here, we want to combine 24 SPE files, and that the angle psi was different for each one. `psi`

is a vector, which in this case has 24 elements. We could write it out explicitly, however in our example we took data in equal steps of psi between 0 degrees and -23 degrees (1 degree steps), so we can use a Matlab trick:

nfiles=24; psi=linspace(0,-1*(nfiles-1),nfiles);

Horace needs to know the name of all 24 SPE files. To do this they are combined into a single object – a cell array, which is a Matlab data format you can read about in the Matlab help. In this case each element of the cell array is a string which specifies the location of our SPE files. We could write this out explicitly, however in this example the SPE files are numbered sequentially, so we can take another shortcut:

spe_file=cell(1,nfiles); for i=1:length(psi) spe_file{i}=[indir,'MAP',num2str(11012+(2*i)),'.SPE']; end

(Note that the extension `.spe;1`

is not usual, normally it would be something like `.spe`

or `.SPE`

. Notice that it does matter whether you write the extension in lower or upper case on Windows. We have found that it does matter on, for example, Red Hat Linux).

The first line creates an empty cell array the right size to take our 24 file strings. Inside the ‘for’ loop the ith element of the cell array is a string specifying where ith SPE file. So the 5th element of the cell array `spe_file`

is:

spe_file{5}='C:\mprogs\Horace\demo\demo_data\MAP11022.SPE’;

We are now ready to make our SQW file! This is done by a single function:

gen_sqw(spe_file,par_file,sqw_file,efix,emode,alatt,angdeg,u,v,psi,omega,dpsi,gl,gs);

If everything has worked then the Matlab command window will show text like this, which will be updated when each successive SPE file is read from the disk.

(Note that the above screenshot was created when processing a larger number of files from the same dataset as has been used for this demo. The only practical difference this makes is to the size of errorbars in 1d cuts, the time taken to process the data, and some of the on-screen printouts.)

Further through the process you should see something like this:

Notice that this was run on a Linux machine, hence the different style of directory name and appearance of the Matlab window.

Horace will now run for some time generating the SQW file. This can be quite a long time, and depends quite a lot on how much memory your computer has and its processor speed. It is probably best at this stage just to leave your computer to run and go for a coffee! As a rough guide 150 SPE files, each of 105MB, would be combined on a machine with 4GB of RAM (with its 3GB switch enabled) and a speed of 2.5GHz in about 2 hours.

For this demo the data files have purposely been made much smaller (by using only the low angle detector banks on MAPS, and by only including a limited number of energy bins in the SPE files). Each SPE file is about 18MB, and thus it takes about 8 minutes to process all of the data. If all is well messages will be frequently printed to the Matlab command window to let you know the status of your SQW file generation.

## Data visualisation

Now that we’ve made our SQW file the next step is to see what the data look like. The first thing to do is to tell the program where the SQW file is located:

data_source='C:\mprogs\Horace\demo\ demo_fe_sqw.sqw';

which is of course the location of the SQW file we created in the previous section.

Now we have to define the projection axes for our data visualization. The projection information is contained in a structure array, which in this case we are calling `proj_100`

. Two of the fields in this structure array are vectors. These are chosen to define the normalization (so they must be unit vectors). There are also other pieces of information that can be provided about the projection, but these will be dealt with later. So we have:

proj_100.u=[1,0,0]; proj_100.v=[0,1,0];

You can choose any (orthogonal) set of axes to make cuts and visualise your data - you are not limited to the projection axes of the crystal with respect to the spectrometer. This is one of the main advantages of using Horace to visualise your data!

Another piece of projection information that we need to know is whether the projection axes are normalised in Angstroms or reciprocal lattice units. There are 3 letters (for the 3 projection axes, the third of which is the cross product of the other two), `'r'`

is used for reciprocal lattice units and `'a’`

is used for angstroms.

proj_100.type='rrr';

Finally, we need to know if we are defining our projection axes relative to some offset. This vector has 4 components, since we could offset in energy as well as the 3 components of **Q**:

proj_100.uoffset=[0,0,0,0];

We now have all the information needed to make any kind of cut we like. Let’s start by making a 2D slice:

w100_2=cut_sqw (data_source,proj_100,[-0.2,0.2],0.05,[-0.2,0.2],[0,0,500]);

This slice has as its axes (0,1,0) and energy. The first two arguments in the function `cut_sqw`

are where the data is on the computer, and the details of the projections. The next four arguments give either the integration range or the step size of each component of Q and energy. In this example we are integrating between -0.2 and 0.2 r.l.u. in the (1,0,0) component, and between -0.2 and 0.2 in the (0,0,1) component. The slice axes are (0,0,1) whose step size is 0.05 r.l.u., and energy whose step size is the minimum possible (this would have been specified when you Homered your data). Notice that we’ve specified the energy step size differently from the (0,0,1) step size. If a scalar is used then the whole range of data along that axis will be plotted. If a vector of the form [low,step,high] is used then only data within the range low -> high will be plotted, with step size given by `step`

.

We don’t yet get a plot of this slice. All we’ve done here is create an ‘sqw’ object which contains the relevant information. However to plot it all we have to do is write:

plot(w100_2);

The ranges of the axes are not quite right, but we can easily change that:

lx 1 3 ly 0 150 lz 0 1

This makes the horizontal axis go from 1 to 3, the vertical axis from 0 to 150, and the colour scale go from 0 to 1.

If we wanted to make a 1D cut through the data then the syntax is exactly the same. For example:

w100_1=cut_sqw (data_source,proj_100,[-0.2,0.2],0.05,[-0.2,0.2],[60,70]); plot(w100_1); lx 1 3 ly 0.2 0.8

would give us a cut along the (0,k,0) axis at a constant energy of 65meV.

3D slices are also possible. To visualize these the ‘sliceomatic’ program is used. When the plot command is executed a GUI is launched that allows you to plot multiple slices through the data. For example you could plot the same slice with x and y axes of (1,0,0) and (0,1,0) at a range of energies.

It is possible to save your cuts / slices to be viewed again later. This can be done very simply in two ways. If you add an extra argument to the end of `cut_sqw`

, then the cut data are sent to a file. For our 1D cut above this would be:

cut_file = 'C:\mprogs\Horace\demo\plots\w100_1.sqw'; w100_1b=cut_sqw (data_source,proj_100,[-0.2,0.2],0.05,[-0.2,0.2],[60,70],cut_file);

Now if we want to read this in again at some later time all we need to do is type:

w100_1b = read_sqw(cut_file); plot(w100_1b); lx 1 3; ly 0.2 0.8

Alternatively you can store the cut data in the Matlab workspace, simply by typing:

w100_1b=cut_sqw (data_source,proj_100,[-0.2,0.2],0.05,[-0.2,0.2],[60,70]);

Note, however, that the variable `w100_1b`

will only be stored in the Matlab workspace, so it could easily be overwritten, or lost if you quit Matlab without saving your workspace.

As we stated above, the objects that you created using the `cut_sqw`

and `cut`

commands are all of the type ‘sqw’. These are the generic objects dealt with by Horace and can represent data that is 0 to 4- dimensional. The sqw objects contain information about the contributing pixels to the cut, which in principle allow things like resolution corrections to be done when you analyse your data. However, in some instances you may not wish to retain this information, for example if you are dealing with lots of large 4-dimensional objects and are worried about running out of memory, or if you do not intend to use the pixel information. If this is the case there are two things you can do, depending on whether you are cutting data from a file or from an object in memory. If cutting data from a file and you do not wish to retain pixel information then the syntax is

w100_2_nopixels=cut_sqw (data_source,proj_100,[-0.2,0.2],0.05,[-0.2,0.2],[0,0,500],’-nopix’);

If cutting data from an sqw object in memory then the syntax is

w100_1d=cut(w100_2,0.05,[60,70],’-nopix’);

where `w100_2`

is the 2-dimensional sqw object created earlier.

If you make a cut to create an object that is 2-dimensional, but with no pixel information, then it becomes a new type of Horace object – in this case a ‘d2d’. If the cut creates a 1-d object then it is known as a ‘d1d’, and so on. Most operations that apply to sqw objects also apply to dnd objects, albeit appropriately modified, e.g. the command `plot`

applies to both kinds of data. The most notable difference applies to simulation and fitting of data.

## Basic data manipulation

Horace allows you to manipulate your data in many different ways. The number of manipulation functions supplied with the standard download is quite small, however it is relatively easy to write your own bespoke functions – the syntax can be worked out by looking at the existing functions.

It is important to realise that there are essentially 3 different kinds of function, each with a slightly different syntax. The first set of functions, which will be described first below, are ones which take an existing data set and manipulate it in some way before returning the manipulated dataset. An example of this would be dividing the entire dataset by the Bose factor.

The second kind of function is a general function which takes a number of input vectors, corresponding to the axes of the desired output object and performs a mathematical operation on them to give an n-dimensional output. An example of this would be a function called something like `gauss_2d`

which takes two vectors that specify a grid in (**Q**,E)-space and some parameter, and returns a 2D grid with an intensity modeled by a Gaussian.

The final kind of function is a ‘proper’ model of S(**Q**,E), i.e. one which takes all of the values of **Q** and E for a particular dataset and calculates a dispersion relation, say, which is then plugged into a simple harmonic oscillator response function.

With the above caveats in mind, let’s demonstrate two different kinds of data manipulation of the first type discussed above. In the first we will simulate the background for a 2D slice by looking at the signal at high |**Q**| in a 1D cut and then replicating it into 2D and subtracting from the real data. We’ll then demonstrate correcting the data for the Bose-Einstein thermal population factor.

First create a new 2D slice and save to file:

cut_file = 'C:\mprogs\Horace\demo\ w110.sqw'; cut_sqw (data_source, proj_110, [-0.2,0.2], [1,0.05,5], [-0.2,0.2], [0,0,150], cut_file); w110 = read_sqw(cut_file);

Now make a 1D cut out of this slice along the energy axis, with the integration range along (0,1,0) of 4.8 to 5:

wbackcut = cut(w110,1,[4.8,5]);

Next make a new 2D slice by replicating the cut along one of the integration axes:

wback = replicate(wbackcut,w110); plot(wback);

This is a 2D slice that is over the same range as w110. We now subtract this from the real data:

wdiff = w110-wback; plot(wdiff);

## Simulations

It is not only possible to plot and manipulate data, it is also possible to simulate an entire dataset, or parts of a dataset. We will illustrate this option using two examples, one that gives a quartet of Gaussian profile peaks, and another that simulates the intensity from a Heisenberg ferromagnet.

It is often the case that you do not have a full model of S(**Q**,E), but rather you just want to determine how a particular peak changes with, for example, temperature or neutron energy transfer. An example would be to monitor the positions and intensities of a quartet peaks. We can generate a slice from our demo data by typing:

w_template=cut_sqw(data_source,proj_100,[-0.4,0.2],[0,0.05,3],[-0.5,0.05,3],[30,40]);

This should give a plot that looks like this:

We will now simulate this using the demonstration function `demo_4gauss`

. This is a specially written function which works only for 2D datasets (slices) where both axes are momentum. Read through the code in

C:\mprogs\Horace\functions\demo_4gauss.m

to see if you can understand how the function works… It is a far from simple task to write a function that is completely general for any dimensionality of dataset, so you typically write functions such as this that work only for a particular dimensionality. It is important, therefore, for your own book-keeping, that you give the functions sensible names that reflect both what they do and what sort of dataset they apply to.

Now let’s run the function. Instead of using `user_func`

we will use `func_eval`

. The syntax for functions called by this routine is slightly different:

w_sim= func_eval (w_template,@demo_4gauss,[6 1 1 0.1 1.25 6 1]);

The arguments in the square parentheses are the function inputs, and in this case they correspond respectively to amplitude, satellite position x-coordinate, satellite y-coordinate, central position x-coordinate, central y-coordinate, and background. In general the input to a function called by `func_eval`

can take any form (e.g. a cell array, a structure array, a string, etc.), although if you wish to pass anything other than a vector of parameters, such as that shown above, then it must be packed into a cell array.

Notice that the syntax of the input arguments is somewhat different for `func_eval`

compared to `user_func`

, since with the former we input the parameters as a vector, rather than as separate arguments. The form of the function itself is also different, since it takes some arrays of parameters and calculates an intensity at those points, rather than taking an existing intensity array and modifying it.

`func_eval`

works for both sqw and dnd objects with almost the same syntax. For sqw objects pixel information is simulated according to the intensity calculated for the data grid, whereas for dnd objects this is not required. It is also possible to simulate a dnd from a template sqw object by using an additional keyword argument of the form

dnd_sim= func_eval (w_template,@demo_4gauss,[6 1 1 0.1 1.25 6 1],’all’);

Furthermore one can use the same keyword argument on a template dnd object so that intensity is simulated over the entire data range, rather than just at the points where there are data in the template object.

There is another way of performing a simulation, using a different method and a simulation function with a slightly different input structure. In this case you are fitting a full model of S(**Q**,E), so the function we will demonstrate here is a model appropriate for spin excitations of a 3D Heisenberg ferromagnet. The function is called `FM_spinwaves_2dSlice_sqw`

, and it takes as its inputs arrays (or scalars) for all 3 components of **Q** plus energy, as well as the other function parameters (exchange constant etc.). The format of the inputs for this function are thus different from those of `demo_4gauss`

- to see the differences it is probably easiest to examine the code for the two functions side-by-side.

w_sim= sqw_eval (w_template,@FM_spinwaves_2dSlice_sqw,[300 0 2 10 2]);

In general it is better to use `func_eval`

for simple functions such as Gaussians and so on, and sqw for “proper” models of the scattering. The different syntax makes it easier to keep track of what kind of model for the scattering is being employed. As before, the keyword ‘all’ can be added to the arguments of this function, however in this case it is ignored if the object `w_template`

is an sqw object. If `w_template`

is a dnd object then as for func_eval the keyword ‘all’ ensures that data are simulated over the entire data range. As with `func_eval`

, the parameters passed to the function can either take the form of a vector of numerical parameters, or a cell array comprising any other form of input.

## Fitting

You can also use Horace to fit your data, although beware that resolution corrections are **not** at present included in this. This works in much the same way as simulating the data, albeit with a slightly different syntax. Note that, especially if you are attempting to fit a full 4D dataset, it can take quite a long time for the fit to converge. It is therefore a good idea to provide a good initial guess of the fit parameters. You can work these out by hand by simulating and then comparing the result to the data by eye.

Again, there are two different function formats that can be used, as with the simulations shown in the previous section.

Let’s begin first with the format that we used for our simulation of the scattering in the previous section. We’ll use the same function as before demo_4gauss. The syntax for fitting is as follows:

[wfit1, fitdata1] = fit_func(w_template,@demo_4gauss,[6 1 1 0.1 1.25 6 1],[1,1,1,1,0,0,1],’list’,2);

This time we get two outputs – `wout`

is the fitted spectrum and `fitdata`

is a Matlab structure array that contains the following fields:

`p`

– the parameter values`sig`

– the errors on the fit parameters (if you fixed a parameter then the error returned is 0)`corr`

– the correlation matrix for the free parameters`chisq`

– reduced <math>\chi^2</math> (the goodness of fit parameter)`pnames`

– the parameter names. This is only meaningful if you used an MFit-style function to fit the data. Otherwise the`pnames`

are just called p1, p2, etc.

The compulsory inputs are the data that you wish to fit, which in this case is the 2D slice `w_template`

, the fit function, and the parameters that will be passed to the fit function as an initial guess. You can also provide some optional extra information. The vector [1,1,1,1,0,0,1] tells the program which parameters to vary (1s) and which parameters to hold fixed (0s) – clearly this vector must be the same length as the vector specifying the guess parameters. If a fixed-parameter vector is not specified then the program assumes that all parameters can be varied. The next argument `’list’`

, which is set to a value of 2 is actually one of several `‘keyword’`

options that can be set. The full set of options is listed here. In this case, by putting 2 as the next input, we are telling the program to print to the Matlab command window a summary of the last fit iteration and the function parameters that were tried by the program. If we had put 1 as the next input then only the summary of the last fit iteration would have been displayed, and if we had put 0 then no information would be displayed. The Matlab command window for this example should look something like this:

The resulting fit looks like this:

**An important fact**: the input parameters can take two different formats. The simplest is that `p`

is a vector, each element of which is a parameter passed to the fit function. The second, more complex, option is for `p`

to be a cell array. You would use this if, for example, additional information must be passed to the function for it to work, e.g. lookup tables for a resolution approximation. Obviously the fitting routines can only cope with fitting scalar parameters (we never managed to work out how to calculate the partial derivative of a string!!), so the first cell of the cell array must be a vector of scalar parameters. If you use the option specifying which parameters are free and which are fixed, then this vector must be the same length as that which is the first element of the parameter cell array. Since variables other than scalars cannot be fitted, the `pfree`

argument is still a vector, even if the input parameters are in the form of a cell array.

There is another kind of fitting option available, which is designed specifically to work with models that provide a spectral weight S(Q,w). In order to illustrate this we generate some fake data from the simulation that we made in the previous section:

getit=get(dnd_sim); getit.s = getit.s + (rand(size(getit.s))).*getit.s; getit.e = (rand(size(getit.e))).*getit.s; w_fixup=d2d(getit); plot(w_fixup);

What we did here is converted the d2d object `dnd_sim`

into a structure array using `get`

. We then multiplied the intensity matrix by a matrix of random numbers of the same size, and added this to the intensity. A similar thing is done for the errorbars. We then turned this modified structure array into a new d2d object called `w_fixup`

. The resulting fake data look like this:

We now try fitting this using the `fit_sqw`

function as follows:

[wfit, fdata] = fit_sqw(w_fixup,@FM_spinwaves_2dSlice_sqw,[10,10,2,10,100],[1,1,1,0,1],’list’,2)

This gives a fit that looks like this:

and the Matlab command window should display something like this: