{26} Tickets fixed by Developer per milestone (copy) (11881 matches)

Create a DataObject for storing a Raw file of histograms and errors into the TDS.

Create a simple converter class to read a text file into an object in the TDS.

The EvtCols example in GAUDI appears to perform both read and write functionality. Although this may not be too helpful.

Create an integration algorithm for the GAUDI framework,

This should produce a single count number for each detector.

The result will need to be stored in a suitable DataObject in the TDS.

Talk to Anders to ensure that your algorithms are comparable.

Create a converter capable of saving the results of the Integration algorithm to disk.

I suggest a simple tab separated text file format.

Detector No \t Count

You will need to speak to Dickon to get info about the DataObject

Add in the code used to build an ISIS converter for Gaudi

Investigate the use of FORTAN within the GAUDI framework. Look at wrapping fortran code within a GAUDI algoritm. Investigate issues such as accessing the data stores, creating and using data objects and passing these over to the TDS. Also look at any issues about accessing the other services.

Import as required from Gaudi

On the algorithm base class we will have to consider the interface as in GAUDI the execution was never public. For Mantid it will be.

Gaudi had sysInitialise calls Initialise sysExecute calls Execute etc.

We will probably need Initialise calls a private init Execute calls a private exec etc

The message service should not be imported straight from GAUDI. It should be reimplmented using the C++ port of Log4J (the most common logging component around). Log4Cxx is hosted by apache and there is some documentation on their site, also most of the Java documentation will apply.

There may be a need to change the messageService interface and we will have to discuss this.

Create a concrete implmentation for a 2D workspace, inheriting from the Workspace class.

This will need to store Neutron counts (double) against time bins and detector number Also the values of the time bins will need to be recorded

Error information will need to be stored in another array.

And/or clarify the role of FacilityInfo::getRemoteJobManager. EDIT: Conclusion about this is: at some point it will be removed (#11373, after or with #11392). It is being replaced with the RemoteJobManagerFactory.

In the remote algorithms, RemoteJobManager objects are being created via ConfigService::Instance().getFacility().getRemoteJobManager(name)

Follow the design/diagram on slide 19 of ​https://github.com/mantidproject/documents/blob/master/Presentations/SOS18/Mantid%20HPC%20Challenges.pptx

This new factory should behave like other factories in Mantid. It provides a Create(name) method that returns an IRemoteJobManager object (as a shared pointer).

Create a data handling command capable of saving to a (comman, tab, user specified) seperated file the contents for a workspace.

Add the Eclipse-generated makefile structure to the repository, along with a script to run the unit tests.

There is an available PC by my desk that should be suitable for this.

We should use LINUX (fedora or enterprise) for now.

We should install a continuous integration environment eg. cruisecontrol or luntbuild.

This will spot checkings to subversion and initiate a build.

The underlying compiler shoud be gcc, but the choice of build tools is flexible at the momnet, but we should aim for the same build mechanism to the available for the developers to use locally as well.

At the end of the build the unit tests need to be performed.

Should we consider SCons?

Add an AlgorithmManager class that inherits from AlgorithmFactory. The job of this class is to

• provide a facade for the factory (code should not call the Factory Direct)
• To maintain a list of all the algorithms that have been served out of the factory to allow the proper finilization and destruction.
• You may want to implement this as an instance of a DataService

Develop geometry objects sufficient to support the definition of an instrument and suffiecient operation to allow the distances and angles to be calculated between any two objects.

It will need to be able to search for a detector by detector number.

Add a method to Workspace2D to retriece the number of Histogram1D's stored in it.

As agreed and defined here http://www.mantidproject.org/Coding_Standards

This will include getting some of the required parts of Boost.python and python itself brought into ThirdParty.

As agreed and defined here http://www.mantidproject.org/Coding_Standards

As agreed and defined here http://www.mantidproject.org/Coding_Standards

Use a mapping table to allow algorithms to select which dectectors contribute to a spectra. This should allow

• 1-1
• 1-many
• many dectectors to many sectra

We need the detector groupd returned from a call to be able to support the same geometry operations (length angles etc).

Implement STL iterators for workspace objects.

Ideally these should be able to operate as well as possible on the base workspace to generically iterate over the specific workspaces.

Also look at the BOOST range Iterator to see if we can allow the user to define there own pattern of iteration.

These should be implmented as operator overloads that simply call algorithms to do the job.

We need to define a chart of what operations between which workspaces are actually valid and enforce this.

Then it is possible that the use of STL iterators and function pointers may allow this to be done in a generic manner.

This will simplify use of the logging class.

If you graphically select a large number of spectra to group together, then it seems to take a long time.

I will keep this ticket until I add a use case.

when liveDataListener is cancelled, it progress bar remains on its place telling a user that it is still collecting the data.

All following algorithms are then display their progress on this bar not indicating their completion correctly.

Checked on Windows 7 To reproduce:

Start StartLiveData set up reasonable update time and see how the progress goes Open algorithm details through Details near the bar and cancel the algorithm. The progress bar remains frozen despite message "Cancelled by User" appears

Other algorithms do not seems have this annoying feature.

Look at every bare pointer we are using and consider if it can be replaced by a scoped_ptr, shared_ptr of a refControl pointer (This may get renamed cow_ptr).

This is a hangover from GAUDI code and should be removed and replaced by throwing exceptions.

Ensure that child algorithms are created, run, results are available to the parent, and are destroyed correctly.

We need a defined format as to how we will save and load the geometry and status information of the instrument.

This will need input from Stuart and Laurent - for knowledge of the geometry tree and required properties Freddie - For how nexus stores this data

This may need the purchase of academic licenses for QT (to get the VS builds of QT).

as discussed

Inconsistent, and hard to understand controls in the SliceViewer

• The Rebin button rebins only the current slice point within the viewing extents.
• The refresh button has to be invoked every time the view is panned or zoomed.
• The auto rebin button automatically applies the refresh.
• The lock button when unlock auto rebins to the current slice point (as sliders are moved)

The point of this ticket is to get agreement of what the new behaviour should be like. I'm going to generate some mockups and share them with a few selected people from both sites. Work can then commence (probably under a separate ticket) once a specification has been agreed upon.

Look at the WorkspaceValueData diagram in MagicDraw.

This will need to be able to support GaussianErrors PoissonErrors BayesianErrors

But GaussianErrors will be the only one implmented for now.

Only shows up with gcc -finline-limit=5000

At the moment we have properties files that are all over the place, and a build system that copies every properties file from each directory into the build\tests directory in a random order with each overwriting the last (see the tests\sconscript)

This needs to be rationalised so that we have 1 directory with a properties file and all build and test running mechanisms copy the file from that location.

Theis should include the scons build and tests, the runtests.sh and runtests.bat files.

This should be a templates class to accept doubles, ints and maybe strings (not if it causes extra trouble).

The property should parse string input seperating on commas to create the seperate elements. These then need to be cast and stored in an internal vector.

Once this is completed let Dickon know as he wnats to use this in his Rebin algorithm.

It is reporting 6m ish where they should all be about 4m.

This needs to create a dead effective detector record in the detector lookup table, and also it should zero the data of the affected spectra.

Properties This should use an inout workspace property. An ArrayProperty - Distinct spectra numbers to blank. (optional) MinSpectraNo and MaxSpectraNo (optional)

The algorith should add together the array and the range specfied and mark those spectra as dead.

Choose a full instrument to model as accuratly as is reasonably possible. Create the model in xml and ensure that it can bbe loaded into Mantid.

I suggest you choose one that we have a sample data file for.

Current DiskBuffer implementation not uses the size of the object which was inserted in the buffer to estimate the free space changes when the object was deleted.

The size of the new object is used instead.

In addition to that (it looks like) the object deletion uses search in the cache to remove object from the cache. Despite search is logarithmic vrt the buffer, constant search would be more appropriate for this situation.

These things request investigation and improvement.

Involves adding the template specialisation to PropertyManager.

Go through the classes in the deprecated directory one by one. If it is really necessary integrate it into the normal mantid code (ask if not usre where). If it can be removed then delete it and fix the remaining code.

The XML classes should be removed.

Provide a seperate build.bat and sconstruct that will build just UserAlgorithms Additional example Algorithms

1. Parameters - Accessing input and out parameters
2. Iterating over a workspace values
3. Creating a new workspace after some manipulation
4. Using a sub algorithm

LoadRaw should

• Extract the intrument name from the file
• Attempt to load the file from the instrument definition directory (should be defined in the config file)
• If not present then ti should use the L2 and 2theta values available in the RAW file to place detectors in a best guess position. This will allow the units change code to work without an instrument definition.

Currently the Framework Manager accepts a parameter string into execute and create algorithm. This is formatted like this

Param1=34;Param2=Thiry;Param3=bob

This should be altered so the following is ALSO possible "34;Thirty;bob"

i.e. If the Param name is not specified it uses the ordinal position in the string and matches it to the ordinal position of the parameter.

Mantid takes ~15 minutes to build from scratch. Small changes to .h files can lead to lots of recompiling = quite painful.

Loading SANS2D event files there is no nperiods log information. This cause the reduction to fail when it asks to :

ws.getRun().getLogData('nperiods').value

Make these calls dependend on the existence of nperiods, if it does not exists, assume 1 as default.

We need to add

• the ability to create any algorithm
• The ability to set parameters on algorithms
• the ability to execute algorithms
• The ability to extract 2D workspaces (prefereable any workspace)
• Access to the data on 2D workspaces

This should be avaivable through providing a python interface to the following classes FrameworkManager Parameter IAlgorithm Algorithm Instrument Sample WorkspaceHistory AlgorithmHistory AlgorithmParameter

At the moment, the copying of workspace members (Instrument, SpectraDetectorMap, Sample, History, Unit) from input to output workspaces within algorithms is very random. Indeed, in most cases the information is lost when it probably shouldn't be. We need to develop tools (probably within the Algorithm Factory) to make it simple for an algorithm developer to get his output workspace holding the correct information.

Related to this is the issue of what happens when Input and Output workspace names are the same (or more generally if the output workspace is set to a name that already exists in the ADS). Should it just be completely overwritten (what currently happens unless an algorithm happens to checks the ADS itself) or just have its data changed?

Talk to Freddie about this

Poperties input workspace output workspace Forward Spectrum (index) Backward Spectrum (index) Alpha

The algorithm will then perform the following and output the result as a workspace2D containing a single spectrum.

For each bin

F-aB/F+aB

Where

• F=forward value
• B=Backward value
• a=alpha

For now split multiperiod data into multiple workspaces

Some sample logs are of integer-type. Enable GenerateEventsFilter to handle this type of logs, because FilterByLogValue() has been enabled to do so (ticket #6267) and thus TimeSeriesProperty.

Test Information

Find an event file containing and integer typed time-series log and try filtering based on the value of that log. Such files/logs are hard to find, but LET00006278.nxs in the systemtests/Data directory is one (integer logs in there include total_counts). ADARA HYSPEC files (HYSA) also have some integer logs.

Previously, GenerateEventsFilter will quit immediately as it detects the specified log is not of double-type.

We should add extra columns to the tables for the error values

Reproduction steps

1. open QTIplot (Mantid build)
2. In Table1, Column 1, right click “Set column values”
3. In box reading col(“1”)= (i-1)/29-0.5 -> Apply
4. Click on arrow to get col(“2”)= and type exp(-col("1")^2/0.1^2) ->Apply
5. Close dialog.
6. Right-click on col(“2”) and Plot->Scatter
7. Click on Graph window
8. Analysis-FitGaussian

Instruments should be 'Owned' by a data service (IDS) in a similar way to Workspaces.

The Load Instrument Algorithm should check that a suitable intstrument has not already been loaded with the data service before loading it fresh.

Also we need to add a fuinction to an Intrument (or workspace) to create an unique copy of the instrument for this workspace. This would:

• Copy the existing instrument to a new one (all the way down the tree)
• Register the new instrument into the IDS
• Clear the IDS when the framework manager clear command occurs
• Check that all new workspace creations in all algorithms pass on the reference to the instrument as appropriate.

Mantid need MATLAB bindings to provide high quality graphics for users who require it and who are already familiar with MATLAB

In the Algorithm Parameter setting dialog inspect they type of the parameter to select an appropriate control type for entering the data.

Suggestions

Declare Python member variables in the class for Python files in the plugins/algorithms/WorkflowAlgorithms directory.

Steps to reproduce

I put the data on
olympic\babylon5\Scratch\Paolo G. Radaelli\Mantid_test, and they are for the SXD instrument.

Execute the LOADRAW algorithm with the file name you have there and the parameters:

Spectrum_min=8201 Spectrum_max=12296 Spectrum_list=12296

Import the workspace (all spectra) and plot as 3D Wire Frame (first button on the bottom left side of the window). It takes exactly 1 min on my computer to generate the 3D plot, but then in can be manipulated very fast. The spikes you see are Bragg peaks from a single crystal of YBaCo4O7. If you zoom in you can see their shape in the TOF dimension.

BTW, if I try to run LOADRAW again the program falls over even when I cleared the memory completely.

The previous definition of HET already had detectors merged 10 to 1. This was good before but now we have a populated spectra-detector map we need it to define each individual pixel seperately.

Please ask for the details from the HET scientists and create a more accurate xml depiction. I'm not so worrired about the xml structure (i.e. banks etc, but we need the indiviual detector locations).

If you use the Remove Wrokspace button in QTIPlot the memory utilisation does not decrease.

Something must be holding a reference to the workspace and keeping the shared pointer alive.

At the moment the axis label is hard coded to be 'Time of Flight'. This needs to be read from the Axis object of the workspace. Talk to Russell to get more details.

The fits do not work as they should when error bars are plotted. I think the program is getting confused about what exactly it should fit and how it should use the errors. Without errors, it seems to work fine.

This is number 1 on the diagrams as we discussed it. The window (rather similar to the solution explorer and properties windows in Visual studio) should list all loaded workspaces and should allow the following options.

• Load workspace from file
• Display Workspace Matrix
• Delete Workspace
• Rename workspace? (Probably need to be implemented through an algorithm)
• Display workspace Properties

To create methods that will be able to return bounding box for the geometry objects.

I don't think this is new, but if your facility not ISIS none of this can be used as it's only set up for ICAT3. No matter what you put in the login box, you will get back an error without explanation. Surely we should do better in case someone does try to use it. Short-term possibilities might be one or more of the following:

• Remove the menu item entirely (or grey it out) if the facility is not set to SNS.
• Insert a check that pops up a dialog box explaining that this only works for ISIS.
• Add a statement to CatalogLogin's setOptionalMessage that this only works for ISIS.
• Add a property to CatalogLogin called 'Facility' (which will only have the option of ISIS for now).

Since there are no validators for ArrayProperties, it's possible to set SimpleRebin off without setting the 'params' property at all (i.e. it doesn't fail the property validation). This can be bad news, since you end up trying to access the first element of an empty vector.

This will need to explain the algorithm lifecycle, and describe all of the object provided within an algorithm and how to use them.

We need to aim this at people with minimal programming knowledge and include plenty of examples.

It should be written assuming that people are using the installed version of Mantid and building using the Build.bat available from the UserAlgorithms directory.

tof was an unfortunate choice of a central unit for our unit change as it is too instrument dependent. The conversions should be changed to go through wavelength instead.

The nexus routines will not always be needed and bring along a lot of other dependencies. Separate then into a different library to allow them to be optionally included as plug-ins.

You will need to talk to Freddie about how to read these. The algorithm should go in the Nexus project.

Two files have been added to Mantid\test\Nexus as test examples.

If one opens a table workspace in MantidPlot and select a column, an option allowing to sort the table according a column appears and menu with sorting option (descending/ascending, col number) pops up. This menu currently does nothing and clicking sort just blinks but does not brings any changes.

It should either:

a) Do what is says (preferable) namely sort by column.

b) Should not appear at all

Some instruments have specified offsets for use in unit conversions (or perhaps just after). Unfortunately the information used to derive the offset is not enough to correct the geometry as the offset is specified as a compound correction to LsinTheta. This could be applied as a post conversion fix within the conversion algorithms or perhaps more usefully a separate algorithm.

For now you should assume the file structure is that of the .cal files available in the TEST\Data directory. DiffractionFocussing reads the same files and may be of some use.

Once this is in place DiffractionFocussing should be altered to make use of this new functionality.

Roman will be able to explain the structure of the install we use for windows and we will want a common file structure for both.

The Linux Distros we should target are Ubuntu and Fedora. If it happened to also be compatible with Mac OS X that would be a bonus.

At the moment the first workspace created from a LoadRaw is an exact memory copy of the data in the file. The idea here is to save memory by only creating a workspace type facade that loads the data from the file as it is required.

Things to consider

• Instrument and spectra-detector table etc - this associated information should be loaded in full as normal
• Loading data on demand - It will probably be necessary to load the data in 'chunks' of n spectra
• What if an algorithm tries to modify this workspace? - This workspacetype should be read only. If someone tries to modify it it should copy all of it's data into a normal Workspace2D (or ManagedWorkspace2D) to continue.

We need to split the curve fitting algorithms into a separate curve fitting library.

This entails the following:

• Create a new CurveFitting project in the mantid visual studio solution
• Copy all of the settings (for debug and release) from the algorithms project
• Remove any settings from algorithms that no longer apply (eg. GSL link lines)
• Move the cpp and h files over and alter any namespaces etc
• Edit the sconstruct file to add your project to the list (about 1/2 way down).
• Add a sconscript file (copy and edit from algorithms.
• Check it all build in VS and scons.

Please document the following algorithms on the wiki in a manner similar to http://www.mantidproject.org/Plus

• Integration
• LoadRaw
• Unwrap
• ConvertUnits
• GroupDetectors
• MarkDeadDetectors
• LoadMappingTable
• Any others that you have been involved in

Should we rename QtiPlot MantidPlot?

Otherwise it can be hard to mentally link out user interface with our project.

There are some images and icons in Mantid\images

Also this will need to update the install script to change the name of the shortcuts etc. While you are there you should add the contents of another directory to the install. QTIPLOT\colourmaps contains a selection of 3DPlot colourmap files. These should be added to the install.

This should operate as a windows service and respond to calls by LoadDAE with simple generated data responses.

At the moment this involves responding to the GETDAT request that returns the data from a single spectrum.

The data returned should alter over time to pretend to be accumulating neutron counts.

It may be worth using Paolo equation to generate the data (or a simpler one if required)

I*(exp(a/2*(a*s^{2+2*(x-c)))*erfc((a*s}2+(x-c))/sqrt(2*s^{2))+exp(b/2*(b*s}2-2*(x-c)))*erfc((b*s^{2-(x-c))/sqrt(s*s}2)))+bk

I fitted the peak near 79400 usec in spectrum 4 of the file HRP38692.RAW

The initial guesses for this peak are:

I=297 a=2. b=0.03 c=79400 s=8 bk=8

When GroupDetectors was first written it only allowed data that had raw counts, and assumed that in the calculation of the error. This calculation wasn't updated when GroupDetectors was changed to accept any workspace with common bins.

The base class should be extended to add an ExecuteAsync method. This should run the Exec method in a separate thread and communicate the result back through some callback mechanism (Boost.Signals?).

Once this works the QTIPLOT interface should be altered to use this as the primary method of running algorithms.

Please document DiffractionFocussing and the three rebins on the wiki in a manner similar to http://www.mantidproject.org/Plus

Extend the python API to include a class that inherits from Algorithm called PyAlgorithm. This should overload the init and exec methods, but in each they should only call new public abstract methods pyInit() and pyExec().

Then when you add a python wrapper for this class you should be able to inherit from this class in python.

It will probably not be possible to insert the new algorithm into the factory, but it should be able to be used directly in python.

Please document the following algorithms on the wiki in a manner similar to http://www.mantidproject.org/Plus

• LoadDAE

from brief glance on the algorithm description and my understanding of the rocking curve technique (which may be well incomplete) I was thinking that SumEventsByLogValue is used to generate parametric plots (workspaces) E.g:

If I have a log value, which describes a scanning within some angle, the angle changed as sin(W*t) with time, and the source workspace, as usual, contains events against detectors, the algorithm would sort events according to time bins, for which each angle value was recorded. The result would be the function Events_of_(rotation angle) or (more physically meaningful after re-binning and coordinate transformation) Energy transfer_of_(rotation angle). This function may be non-unique if some particular energy transfers corresponds to different angles.

The re-binning option available in the algorithm works in similar way, but allows one to work with homogeneous functions only.

Following my expectations, I was trying to rebin LET event workspace LET00006278.nxs against log value total_counts which has 230 recoded integer values in the range from 0 to 10^6.

This operation hangs up Mantid.

Reading the algorithm description carefully I have found explicit warning against doing what I did, but attempt to do that should not hang Mantid and give better estimate of the time, left to complete the operation.

Needed: 1) Attempt to rebin data against integer logs with big number of measurements should give good estimate of the job ahead. Should be a possibility to cancel the wrong intended job

Desirable: 2) Rebinning against time intervals, associated with the log. (described above)

This is questionable ticket as I am not sure if many people think the similarly to myself as above.

This is to try and help avoid illegal dependencies (e.g. using WorkspaceCreationHelper in API when it depends on DataObjects).

Allow saving of workspace data in Nexus file format.

One way might be to allow writing (and reading) of the Nexus "Processed" NXentry which assumes that the data has been reduced to a standard for such as S(Q) and no longer requires the instrument definition.

Requires getting the list of UDETS from Paolo or Laurent.

try to minus a workspace from another with different numbers of time bins

Excerpt from the log messages

Logic Error in Execution of algorithm Minus

The size of the two workspaces are not compatible for algorithm plus

This test fails as the Tau spectrum has an artefact in it that is far enough out of the comparison tolerance to fail the test.

This is straightforward for runs collected with the same setting, but becomes more complex when dealing with data collected over different frames (e.g., OSIRIS). The simplest solution is to rebin all the runs on a common wavelength scale, add them together and normalise them by the new “reconstructed” monitor. I think this could work, but it requires knowing very accurately where the monitor is relative to the detectors, and I could never do it using the engineering parameters. It would require a procedure to calibrate the monitor position exactly. It is a specific problem with OSIRIS, but we may need it on WISH on Day 1 if we have only detectors in backscattering. I suggest we implement the straightforward part (merging 2 runs with the same chopper setting) and have a separate project on the more complex version.

It is required for ParaView and it may solve a problem on the Mac: #6497

Stuart has already built the RHEL 6 libraries, Ubuntu is already there and the Mac can just use those directly from Qt (just needing to rebuild PyQt4 & qscintilla and maybe sip if we are moving PyQt4 versions too). That just leaves Windows.

We are planning on move to VS 2012 this release so it would be good to coincide it with that.

This correction depends on sample geometry, angle and wavelength, and should be ultimately done point by point. It is common to essentially all ISIS instruments dealing with bulk samples, and should be the subject of a common project. For the purpose of this exercise, we can use the ARIEL approach which is that of calculating a polynomial approximation for each group (the variable is wavelength). Then you apply it to the focussed data (in d-spacing) by using the average 2theta of the bank for the conversion. I can initially supply the pre-calculated polynomials just for test, and I have fairly simple routines to calculate them that can be easily ported.

This should allow two partial and non overlapping workspaces to be merged into one. For example you have processed a raw file in to halves, and then want to merge the results into a single workspace.

Pre-requisites

• workspaces come from the same instrument
• No detectors that contribute to spectra should overlap
• x units and bins must match

As discussed on 16/09/2008

Currently, the validation for a WorkspaceProperty is hard-coded. It then often turns out that you have to go checking the input workspace before you do anything else in the exec() part of an algorithm.

Document on how Nexus can store Mantid workspace and geometry information.

Which it should because we want to share the Instrument objects if they're loaded from the same XML file.

Document the following in the wiki:

• MergeRuns
• NormaliseToMonitor
• NormaliseByCurrent
• ConjoinWorkspaces
• Workspace Validators

Mark detectors with zero counts

Moves the bin boundaries by a user supplied offset

parameters

• Workspace (input/output)
• Bin offset (double) - can be negative

This will then add that offset to each bin.

Care should be taken not to end up with duplicate X vectors caused by simple adding through the cow_ptr. Perhaps you could check that the current X array is the same as the last one and then have them point to the same new vector.

QTIplot should keep a track of the last values entered for each algorithm and parameter. These should then be offered as deflauts when running the same algorithm again.

These should be maintained between user sessions.

Should they be unique per user?

Once a detector (or group of detectors) add an optin to the context menu to display the line plot of the data for that detector.

We need to allow users to install Mantidplot using the linux RPM

We need to understand how to include the matlab API in the installers and build process.

Create instrument definitions for the following instruments:

• Crisp
• Tosca (talk to Timmy Ramirez-Cuesta)
• Sandals (talk to Alan Soper)

The 'level 1' implementation of MergeRuns restricts the input workspaces to having common binning - it's really nothing more than a wrapper around the Plus algorithm, with some extra validation. To take this to level 2, it needs to be able to combine runs with different chopper settings - meaning that they cover different wavelength ranges (with some overlap). So there'll need to be some rebinning in there.

Change LoadMuonNexus so that it returns bin centred workspace data if this is the content of the NeXus file. Currently converts it to use bin boundaries.

As discussed.

• Create a method on the PthyonAPI that creates a MantidPythonSimpleAPI.py library
• This should contain a method for every algorithm available in the Factory
• Each method should allow for a simple method signature based on it's parameters.
• Also include a help method help() should list all algorithms (and any other commands we add later) help("command") should provide details about that command.

Provide a tab showing a tree view of the instrument and allowing people to zoom to sections of the instrument by selecting from the tree.

The view should be placed in between the sample position and the selected item (could be a whole bank) such that the whole of the selected item takes up most of the screen.

Obviously you will have exceptions for this for the sample itself and the whole instrument.

We need to discuss how we might do this in the user interface.

The options of NormaliseToMonitor can require that bins are lopped off the start and end of a workspace. Right now, this is done via the Regroup algorithm, passing in arguments to make sure you lose the bins you don't want and keep the boundaries of the remaining bins unchanged. But this is very inefficient and could be done much better by a dedicated algorithm. Integration could also use this algorithm.

Algortihm to find peaks in a 1D spectra

1) Change the mouse sensitivity for operations on geometry viewer widget. 2) keyboard operation for transformations. 3) Fast picking using image with in geometry viewer widget.

When a test crashes (as opposed to 'just' failing), the linux buildserver reports this as a failure of the test build. The Windows buildserver doesn't pick up the failure at all. This should be rectified - apparently the place where the test output is parsed is in sendEmail.py.

If MantidPlot is opened, a raw file loaded then closed down and reopened again, the colour assignments for the backgrounds are messed up

the files are in qtiplot\colourmaps

From Spencer,

M
There is an intermitent fault (on Win7 64bit anyway) when trying to change Default Save Directory (this I use quite a lot) - it crashes Mantid.
At first I thought it was only when doing it from an Interface, but I think it also does it from the Main window icon.
And it's not just me - while demonstrating Mantid to the group's new member yesterday it crashed her Win7 64bit laptop.
Sp

Instead of grouping all the spectra that don't feature in the grouping file into a spectrum at the end of the output workspace, just discard them (and print a warning message giving the number discarded).

Currently you cannot

• load a ws1
• integrate to ws2
• divide ws1/ws2

but you should be able to

Roman should be able to tell you how to do this.

Try this Load a workspace W1 Convert units to energy into W2 (note that this works X values change) Convert units for W1 to energy into W1 X values do not change!

It seems that for large datasets spectra min and max values are ignored.

Steps to reproduce:

• LoadRaw for a maps file
• Set the max spectra value to 5000
• drag the workspace into MantidPlot
• Scroll down!

Special rendering for Cubes, Spheres,Cones and Cylinders

Create a cross correlation algorithm. This is required when determining offsets between a detector and a reference detector. This is used for example in determining a calibration table for diffraction focusing.

If the output workspace is the same as one of the input workspaces do not create a new one. It should be possible to check and do this in the Binary Operation class and therefore improve performance for all the binary operations.

We want to be able to add script menus for users.

We need them to be available on restarting the application and to understand how to add these automatically for specific lists of scripts.

Could these be added by a python script?

This applies to both the Workspace Matrix and the workspace list.

Actions on the context menu apply to the selected item, not to that clicked on.

When plotting 1D graph in MantidPlot and zooming several times, the computer hang sometimes for several minutes. Problem experienced under Linux 64 on two different computers. Probably not specific to MantidPlot but qtiplot in general. This is critical if one wants to deploy Mantid soon on several beamlines.

This happens when a mantid Workspace is dragged in the qtiplot window and some plot (1D, 2D or 3D) is active and linked to this workspace. If one closes the workspace without closing the plot window first, mantidplot terminates with segmentation fault.

in unix loadEmptyInstrument on a file and then show instrument.

ddd suggests the error is in ??ColorMap->getColor However this works with a real raw file and therefore must be something about the workspace created by LoadEmptyInstrument

If you run a very fast algorithm (such as cropworkspace) then you can get a partially filled progres window that is frozen and prevents you running any other algorithms.

This is probably a race condition.

talk to Richard Heenan

Implement and integrate CSG operations using OpenCascade library. Linux build for OpenCascade