| AbstractMantidLog | Class AbstractMantidLog connects to Mantid's SignalChannel Method log() receives the message from SignalChannel |
| ADD_STRUCT | Address offsets to various sections (9*4 bytes) |
| AlgButton | |
| AlgEnvHistoryGrpBox | |
| AlgExecSummaryGrpBox | |
| AlgHistoryProperties | |
| AlgHistoryTreeWidget | |
| AlgorithmDockWidget | |
| AlgorithmHistoryWindow | |
| AlgorithmMonitor | Monitor for reporting progress and canceling running algorithms |
| AlgorithmPropertiesWidgetPlugin | |
| AlgorithmSelectorWidgetPlugin | |
| BinDialog | Class to display Bin selection dialog |
| shared_ptr | |
| static_visitor | |
| BoxDetSelector | |
| CaptionLabel | |
| CollapsiblePanel | Implements a collapsible panel |
| CollapsibleStack | |
| ColorBarWidgetPlugin | |
| ColorMapWidget | Displays a color map with numeric axis and editable bounds |
| CommandHistory | A small wrapper around a QStringList to manage a command history |
| CompareFailsException | Custom exception class to signal a failure in the comparison |
| CompAssemblyActor | This class wraps the ICompAssembly into Actor |
| ComponentActor | |
| CreateMDWorkspaceAlgDialog | Code-behind for CreateMDWorkspaceAlgDialog |
| DAEP_STRUCT | DAE parameters block (64*4 bytes) |
| DDES_STRUCT | 2*4 bytes |
| DesignerPlugin | The DesignerPlugin creates a Qt designer plugin of the AlgorithmSelectorWidget |
| DetSelector | Class to pick group of detectors |
| DetXMLFile | A class for creating grouping xml files |
| DHDR_STRUCT | Data section header (32*4 bytes) |
| ErrorBarSettings | Holds the settings for how a set of error bars are to be drawn |
| FileFinderPlugin | |
| FindComponentVisitor | Finds an actor with a particular ComponentID |
| FindDialog | Specialisation of FindReplaceDialog that only does finding |
| FindReplaceDialog | Raises a dialog allowing the user to find/replace text in the editor |
| FirstTimeSetup | FirstTimeSetup dialog for MantidPlot |
| FitBrowserPlugin | |
| FitParameterTie | Class FitParameterTie is for editing parameter ties in Mantid functions |
| FlowLayout | |
| GLActor | An actor class that holds geometry objects with its position |
| GLActorCollection | An actor class collection |
| GLActorVisitor | |
| GLColor | Class handling OpenGL color for objects |
| GLObject | Interface for OpenGL object stored in a display list |
| GLTrackball | An class that implements virtual trackball using mouse interactions |
| GLViewport | ________________________________________________ Library : NTK Name : GLViewport.h Author : L.C.Chapon Date : 9 Nov 2006 Descritption : Base class for viewport with method to resize and get viewport information |
| HDR_STRUCT | Run header (80 bytes) |
| ICompAssemblyActor | This class wraps the ICompAssembly into Actor |
| ieee_double | What IEEE double precision floating point looks like |
| ieee_single | What IEEE single precision floating point looks like on local machine |
| IFunctionWrapper | IFunctionWrapper is a wrapper for IFunction pointer which is a QObject and can send and recieve signals |
| ImplicitFunctionFactory | This dynamic factory implementation generates concrete instances of ImplicitFunctions |
| ImplicitFunctionParserFactory | This dynamic factory implementation generates concrete instances of ImplicitFunctionParsers |
| ImportWorkspaceDlg | |
| InputConvertUnitsParametersDialog | Dialog for converting x-values to time of flight needed for peak selection |
| InputHistory | Keeps history of Mantid-related user input, such as algorithm parameters, etc |
| InputHistoryImpl | |
| InstrumentActor | InstrumentActor class is wrapper actor for the instrument |
| InstrumentSelectorPlugin | |
| InstrumentTreeModel | The InstrumentTreeModel is a class used by a QTreeView in order to display the components of an instrument as a hierarchical tree view |
| InstrumentTreeWidget | The InstrumentTreeWidget is a tree view of the components of an instrument |
| InstrumentWindow | This is the main window for the control of display on geometry |
| InstrumentWindowMaskTab | Implements the Mask tab in InstrumentWindow |
| InstrumentWindowPickTab | Implements the Pick tab in InstrumentWindow |
| InstrumentWindowRenderTab | Implements the Render tab in InstrumentWindow |
| Interval | The MantidWSIndexDialog class presents users with a dialog so that they may specify which workspace indices / spectra IDs are to be plotted by Mantid |
| IntervalList | |
| IntervalListValidator | |
| ISISRAW | Isis raw file |
| ISISRAW2 | Isis raw file |
| item_struct< T > | Structure to hold a dae item |
| item_struct< T >::item_t | Structure to hold a dae item |
| IVPB_STRUCT | Instrument parameter block (64*4 bytes) |
| LinePlotOptions | |
| LineViewerPlugin | |
| loadDAEDlg | |
| LOG_LINE | Log line entry |
| LOG_STRUCT | Log line entry |
| ManageCustomMenus | This class handles the "Manage Custom Menus" dialog for MantidPlot, in which users can add custom scripts or custom Qt interfaces to a menu in MantidPlot |
| Mantid::Algorithms::AbsorptionCorrection | A base class for absorption correction algorithms |
| Mantid::Algorithms::AddLogDerivative | Takes an existing sample log, and calculates its first or second derivative, and adds it as a new log |
| Mantid::Algorithms::AddSampleLog | Used to insert a single string into the sample in a workspace |
| Mantid::Algorithms::AlignDetectorInTOF | AlignDetectorInTOF : TODO: DESCRIPTION |
| Mantid::Algorithms::AlignDetectors | Performs a unit change from TOF to dSpacing, correcting the X values to account for small errors in the detector positions |
| Mantid::Algorithms::AlphaCalc | Muon algorithm for calculating the detector efficiency between two groups of detectors |
| Mantid::Algorithms::AnyShapeAbsorption | Calculates an approximation of the attenuation due to absorption and scattering in a generic sample shape |
| Mantid::Algorithms::AppendSpectra | Joins two partial, non-overlapping workspaces into one |
| Mantid::Algorithms::ApplyDeadTimeCorr | ApplyDeadTimeCorr : The dead-time is here applied according to the non-extendable paralyzable dead time model |
| Mantid::Algorithms::ApplyDetailedBalance | ApplyDetailedBalance : The algorithm calculates the imaginary part of the dynamic susceptibility chi''=Pi*(1-exp(-E/T))*S |
| Mantid::Algorithms::ApplyTransmissionCorrection | Apply angle-dependent transmission correction from zero-angle transmission measurement |
| Mantid::Algorithms::BinaryOperateMasks | BinaryOperateMasks : TODO: DESCRIPTION |
| Mantid::Algorithms::BinaryOperation | BinaryOperation supports the implementation of a binary operation on two input workspaces |
| Mantid::Algorithms::BlendSq | BlendSq : TODO: DESCRIPTION |
| Mantid::Algorithms::CalculateEfficiency | Compute relative detector pixel efficiency from flood data as part of SANS reduction |
| Mantid::Algorithms::CalculateTransmission | Calculates the transmission correction, as a function of wavelength, for a SANS instrument |
| Mantid::Algorithms::CalculateTransmissionBeamSpreader | Calculates the transmission correction, as a function of wavelength, for a SANS instrument |
| Mantid::Algorithms::CalMuonDeadTime | Algorithm for calculating Muon dead times |
| Mantid::Algorithms::CaltoDspacemap | Performs a unit change from TOF to dSpacing, correcting the X values to account for small errors in the detector positions |
| Mantid::Algorithms::ChangeBinOffset | Takes a workspace and adjusts all the time bin values by the same amount |
| Mantid::Algorithms::ChangeLogTime | |
| Mantid::Algorithms::ChangePulsetime | ChangePulsetime : TODO: DESCRIPTION |
| Mantid::Algorithms::CheckWorkspacesMatch | Compares two workspaces for equality |
| Mantid::Algorithms::ChopData | For use in TOSCA reduction |
| Mantid::Algorithms::CloneWorkspace | Creates a copy of the input workspace |
| Mantid::Algorithms::CommutativeBinaryOperation | CommutativeBinaryOperation supports commutative binary operations on two input workspaces |
| Mantid::Algorithms::ConjoinWorkspaces | Joins two partial, non-overlapping workspaces into one |
| Mantid::Algorithms::ConvertFromDistribution | Converts a histogram workspace from a distribution |
| Mantid::Algorithms::ConvertMDHistoToMatrixWorkspace | Creates a single spectrum Workspace2D with X,Y, and E copied from an first non-integrated dimension of a IMDHistoWorkspace |
| Mantid::Algorithms::ConvertSpectrumAxis | Converts the representation of the vertical axis (the one up the side of a matrix in MantidPlot) of a Workspace2D from its default of holding the spectrum number to the target unit given |
| Mantid::Algorithms::ConvertTableToMatrixWorkspace | Creates a single spectrum matrix workspace from some columns of a table workspace |
| Mantid::Algorithms::ConvertToDistribution | Makes a histogram workspace a distribution |
| Mantid::Algorithms::ConvertToEventWorkspace | Perform a conversion for a Workspace2D to an equivalent EventWorkspace |
| Mantid::Algorithms::ConvertToHistogram | Converts a histogram workspace to point data by simply taking the centre point of the bin as the new point on the X axis |
| Mantid::Algorithms::ConvertToMaskingWorkspace | ConvertToMaskingWorkspace : TODO: DESCRIPTION |
| Mantid::Algorithms::ConvertToMaskWorkspace | ConvertToMaskWorkspace : Convert a Workspace2D to a MaskWorkspace |
| Mantid::Algorithms::ConvertToMatrixWorkspace | Creates a copy of the matrix workspace representation of the input workspace |
| Mantid::Algorithms::ConvertToPointData | Converts a histogram workspace to point data by simply taking the centre point of the bin as the new point on the X axis |
| Mantid::Algorithms::ConvertUnits | Converts the units in which a workspace is represented |
| Mantid::Algorithms::CopySample | CopySample : The algorithm copies some/all the sample information from one workspace to another |
| Mantid::Algorithms::CorrectKiKf | Multiplies the workspace with k_i/k_f The initial workspace must have energy transfer units |
| Mantid::Algorithms::CorrectToFile | Required properties: |
| Mantid::Algorithms::CountEventsInPulses | CountEventsInPulses : TODO: DESCRIPTION |
| Mantid::Algorithms::CreateCalFileByNames | Create a calibration file for diffraction focussing (*.cal old Ariel format) based on list of names of the instrument tree |
| Mantid::Algorithms::CreateDummyCalFile | Create a calibration file for diffraction focussing (*.cal old Ariel format) based on list of names of the instrument tree |
| Mantid::Algorithms::CreateGroupingWorkspace | Creates a new GroupingWorkspace using an instrument from one of: an input workspace, an instrument name, or an instrument IDF file |
| Mantid::Algorithms::CreateLogPropertyTable | Copyright © 2010 ISIS Rutherford Appleton Laboratory & NScD Oak Ridge National Laboratory |
| Mantid::Algorithms::CreatePeaksWorkspace | Create an empty PeaksWorkspace |
| Mantid::Algorithms::CreatePSDBleedMask | This algorithm implements a "bleed" diagnostic for PSD detectors (i.e |
| Mantid::Algorithms::CreateSingleValuedWorkspace | Required properties: |
| Mantid::Algorithms::CreateWorkspace | CreateWorkspace Algorithm |
| Mantid::Algorithms::CropWorkspace | Extracts a 'block' from a workspace and places it in a new workspace |
| Mantid::Algorithms::CrossCorrelate | Compute the cross correlation function for a range of spectra with respect to a reference spectrum |
| Mantid::Algorithms::CuboidGaugeVolumeAbsorption | Calculates attenuation due to absorption and scattering in a generic sample, considering only the scattering within a cuboid shaped 'gauge volume' |
| Mantid::Algorithms::CylinderAbsorption | Calculates attenuation due to absorption and scattering in a cylindrical sample |
| Mantid::Algorithms::DampSq | DampSq : TODO: DESCRIPTION |
| Mantid::Algorithms::DeleteWorkspace | A simple algorithm to remove a workspace from the ADS |
| Mantid::Algorithms::DetectorDiagnostic | A base class for a detector diagnostic algorithm |
| Mantid::Algorithms::DetectorEfficiencyCor | Returns efficiency of cylindrical helium gas tube |
| Mantid::Algorithms::DetectorEfficiencyVariation | Required Properties: |
| Mantid::Algorithms::DiffractionEventCalibrateDetectors | Find the offsets for each detector |
| Mantid::Algorithms::DiffractionFocussing | This is a parent algorithm that uses several different child algorithms to perform it's task |
| Mantid::Algorithms::DiffractionFocussing2 | Algorithm to focus powder diffraction data into a number of histograms according to a grouping scheme defined in a file |
| Mantid::Algorithms::Divide | Divide performs the division of two input workspaces |
| Mantid::Algorithms::DspacemaptoCal | Performs a unit change from TOF to dSpacing, correcting the X values to account for small errors in the detector positions |
| Mantid::Algorithms::EditInstrumentGeometry | EditInstrumentGeometry : TODO: DESCRIPTION |
| Mantid::Algorithms::ElasticWindow | |
| Mantid::Algorithms::EQSANSResolution | Computes the resolution on EQSANS data Required Properties: |
| Mantid::Algorithms::EQSANSTofStructure | |
| Mantid::Algorithms::Exponential | Exponential performs the exponential function on an input workspace |
| Mantid::Algorithms::ExponentialCorrection | Corrects the data and error values on a workspace by the value of an exponential function which is evaluated at the X value of each data point: c0*exp(-c1*x) |
| Mantid::Algorithms::ExtractFFTSpectrum | This algorithm performs a Fast Fourier Transform on each spectra of the input workspace |
| Mantid::Algorithms::ExtractMask | Extract the masking from a given workspace |
| Mantid::Algorithms::ExtractMasking | ExtractMasking : TODO: DESCRIPTION |
| Mantid::Algorithms::ExtractSingleSpectrum | Copies a single spectrum from a 2D Workspace into a new workspace |
| Mantid::Algorithms::FFT | Performs a Fast Fourier Transform of data |
| Mantid::Algorithms::FFTDerivative | Calculates derivatives of the spectra in a MatrixWorkspace using a Fast Fourier Transform |
| Mantid::Algorithms::FFTSmooth | Data smoothing using the FFT algorithm and various filters |
| Mantid::Algorithms::FFTSmooth2 | Data smoothing using the FFT algorithm and various filters |
| Mantid::Algorithms::FilterBadPulses | Filters out events associated with pulses that happen when proton charge is lower than a given percentage of the average |
| Mantid::Algorithms::FilterByLogValue | Filters events in an EventWorkspace using values in a SampleLog |
| Mantid::Algorithms::FilterByTime | Filters an EventWorkspace by wall-clock time, and outputs to a new event workspace or replaces the existing one |
| Mantid::Algorithms::FilterByTime2 | FilterByTime2 : TODO: DESCRIPTION |
| Mantid::Algorithms::FilterEvents | FilterEvents : Filter Events in EventWorkspace to multiple EventsWorkspace by Splitters |
| Mantid::Algorithms::FilterEventsHighFrequency | FilterEventsHighFrequency : TODO: DESCRIPTION |
| Mantid::Algorithms::FindCenterOfMassPosition | Part of data reduction for SANS |
| Mantid::Algorithms::FindCenterOfMassPosition2 | Part of data reduction for SANS |
| Mantid::Algorithms::FindDeadDetectors | Takes a workspace as input and identifies all of the spectra that have a value across all time bins less or equal to than the threshold 'dead' value |
| Mantid::Algorithms::FindDetectorsOutsideLimits | Takes a workspace as input and identifies all spectra where the sum of the counts in all bins is outside a range |
| Mantid::Algorithms::FindPeaks | This algorithm searches for peaks in a dataset |
| Mantid::Algorithms::FlatBackground | Finds a constant value fit to an appropriate range of each desired spectrum and subtracts that value from the entire spectrum |
| Mantid::Algorithms::FlatPlateAbsorption | Calculates attenuation due to absorption and scattering in a flat plate/slab sample |
| Mantid::Algorithms::FlatWeighting | |
| Mantid::Algorithms::GaussianWeightingnD | |
| Mantid::Algorithms::GeneralisedSecondDifference | Compute the generalised second difference of a spectrum or several spectra based on the method described by M.A |
| Mantid::Algorithms::GenerateEventsFilter | GenerateEventsFilter : Generate an events-filter, i.e., a SplittersWorkspace according to user's request |
| Mantid::Algorithms::GeneratePeaks | GeneratePeaks : Generate peaks from a table workspace containing peak parameters |
| Mantid::Algorithms::GeneratePythonScript | GeneratePythonScript : TODO: DESCRIPTION |
| Mantid::Algorithms::GetDetectorOffsets | Find the offsets for each detector |
| Mantid::Algorithms::GetDetOffsetsMultiPeaks | Find the offsets for each detector |
| Mantid::Algorithms::GetEi | Requires an estimate for the initial neutron energy which it uses to search for monitor peaks and from these calculate an accurate energy |
| Mantid::Algorithms::GetEi2 | Requires an estimate for the initial neutron energy which it uses to search for monitor peaks and from these calculate an accurate energy |
| Mantid::Algorithms::GetTimeSeriesLogInformation | GetTimeSeriesLogInformation : TODO: DESCRIPTION |
| Mantid::Algorithms::GhostCorrection | Takes an EventWorkspace and performs Ghost correction for ghost peaks in some SNS area detectors, for example on PG3 |
| Mantid::Algorithms::GhostDestinationValue | Simple structure to map ghost corrections TO pixels |
| Mantid::Algorithms::GravitySANSHelper | A helper class for calculating neutron's gravitional drop |
| Mantid::Algorithms::GroupWorkspaces | Takes workspaces as input and groups the workspaces |
| Mantid::Algorithms::He3TubeEfficiency | Corrects the input workspace for helium3 tube efficiency based on an exponential parameterization |
| Mantid::Algorithms::HRPDSlabCanAbsorption | Calculates attenuation due to absorption and scattering in an HRPD 'slab' can |
| Mantid::Algorithms::IdentifyNoisyDetectors | Identifies "bad" detectors based on their standard deviation, and how this differs from the standard deviation of other detectors |
| Mantid::Algorithms::IDLRebin | IDLRebin : TODO: DESCRIPTION |
| Mantid::Algorithms::Integration | Takes a workspace as input and sums each spectrum contained within it, storing the result as a workspace of spectra with one Y & E value and two X values indicating the range which the integration covers |
| Mantid::Algorithms::InterpolatingRebin | Uses cubic splines to interpolate the mean rate of change of the integral over the inputed data bins to that for the user supplied bins |
| Mantid::Algorithms::IQTransform | This algorithm permits the linearisation of reduced SANS data by applying a chosen transformation to the input data |
| Mantid::Algorithms::LinearWeighting | |
| Mantid::Algorithms::Logarithm | Takes a workspace as input and calculates the natural logarithm of number of counts for each 1D spectrum |
| Mantid::Algorithms::MaskBins | Masks bins in a workspace |
| Mantid::Algorithms::MaskDetectorsIf | This algorithm is used to select/deselect detectors in a *.cal file |
| Mantid::Algorithms::Max | Takes a 2D workspace as input and find the maximum in each 1D spectrum |
| Mantid::Algorithms::MaxMin | Takes a 2D workspace as input and find the maximum(minimum) in each 1D spectrum |
| Mantid::Algorithms::MedianDetectorTest | Takes a workspace as input and finds all the detectors with solid angle corrected signals that deviate far enough from median value of all detectors to be suspious |
| Mantid::Algorithms::MergeRuns | Combines the data contained in an arbitrary number of input workspaces |
| Mantid::Algorithms::Min | Takes a 2D workspace as input and find the minimum in each 1D spectrum |
| Mantid::Algorithms::Minus | Minus performs the difference of two input workspaces |
| Mantid::Algorithms::ModeratorTzero | |
| Mantid::Algorithms::MonIDPropChanger | |
| Mantid::Algorithms::MonteCarloAbsorption | Calculates attenuation due to absorption and scattering in a sample + its environment using a weighted Monte Carlo |
| Mantid::Algorithms::MultipleScatteringCylinderAbsorption | Multiple scattering absorption correction, originally used to correct vanadium spectrum at IPNS |
| Mantid::Algorithms::Multiply | Multiply performs the product of two input workspaces |
| Mantid::Algorithms::MultiplyRange | An algorithm to multiply a range of bins in a workspace by the factor given |
| Mantid::Algorithms::MuonAsymmetryCalc | Takes a muon workspace as input and sums all the spectra into two spectra which represent the two detector groupings |
| Mantid::Algorithms::MuonRemoveExpDecay | Takes a muon workspace as input and removes the exponential decay from a time channel |
| Mantid::Algorithms::NormaliseByCurrent | Normalises a workspace according to the good proton charge figure taken from the raw file (and stored in the Sample object) |
| Mantid::Algorithms::NormaliseToMonitor | Normalises a 2D workspace by a specified monitor spectrum |
| Mantid::Algorithms::NormaliseToUnity | Takes a workspace as input and normalises it to 1 |
| Mantid::Algorithms::NullWeighting | |
| Mantid::Algorithms::OneMinusExponentialCor | Corrects the data and error values on a workspace by one minus the value of an exponential function which is evaluated at the X value of each data point: c1(1-exp(-c*x)) |
| Mantid::Algorithms::OptimizeExtinctionParameters | Find the offsets for each detector |
| Mantid::Algorithms::ParabolicWeighting | |
| Mantid::Algorithms::Pause | Pause a script for a given duration |
| Mantid::Algorithms::PDFFT | PDFFT : TODO: DESCRIPTION |
| Mantid::Algorithms::PlotAsymmetryByLogValue | Takes a muon workspace as input and sums all the spectra into two spectra which represent the two detector groupings |
| Mantid::Algorithms::Plus | Plus performs the difference of two input workspaces |
| Mantid::Algorithms::PointByPointVCorrection | First attempt at spectrum by spectrum division for vanadium normalisation correction |
| Mantid::Algorithms::PoissonErrors | Takes a Data workspace and an original counts workspace input and updates the error values in the data workspace to be the same fractionally as the counts workspace |
| Mantid::Algorithms::PolynomialCorrection | Corrects the data and error values on a workspace by the value of a polynomial function which is evaluated at the X value of each data point |
| Mantid::Algorithms::Power | Provides the ability to raise the values in the workspace to a specified power |
| Mantid::Algorithms::PowerLawCorrection | Corrects the data and error values on a workspace by the value of an exponential function which is evaluated at the X value of each data point: c0*x^C1 |
| Mantid::Algorithms::Q1D | Takes account of the effects of gravity for instruments where the y-axis points upwards, for example SANS instruments |
| Mantid::Algorithms::Q1D2 | Takes account of the effects of gravity for instruments where the y-axis points upwards, for example SANS instruments |
| Mantid::Algorithms::Q1DTOF | File change history is stored at: <https://svn.mantidproject.org/mantid/trunk/Code/Mantid> Code Documentation is available at: <http://doxygen.mantidproject.org> |
| Mantid::Algorithms::Q1DWeighted | Part of data reduction for SANS |
| Mantid::Algorithms::Qhelper | Helper class for the Q1D and Qxy algorithms |
| Mantid::Algorithms::Qxy | This algorithm rebins a 2D workspace in units of wavelength into 2D Q |
| Mantid::Algorithms::RadiusFilter | |
| Mantid::Algorithms::RayTracerTester | Algorithm to test ray tracer by spraying evenly spaced rays around |
| Mantid::Algorithms::ReadGroupsFromFile | Read a diffraction calibration file (*.cal) and an instrument name, and output a 2D workspace containing on the Y-axis the values of the Group each detector belongs to |
| Mantid::Algorithms::RealFFT | Performs a Fast Fourier Transform of real data |
| Mantid::Algorithms::Rebin | Takes a workspace as input and rebins the data according to the input rebin parameters |
| Mantid::Algorithms::Rebin2D | Rebins both axes of a two-dimensional workspace to the given parameters |
| Mantid::Algorithms::RebinToWorkspace | Rebins a workspace so that the binning, for all its spectra, match that of the first spectrum of a second workspace |
| Mantid::Algorithms::Rebunch | Takes a workspace as input and rebunches the data according to the input rebunch parameters |
| Mantid::Algorithms::Regroup | Takes a 2D workspace as input and regroups the data according to the input regroup parameters |
| Mantid::Algorithms::RemoveBins | Removes bins from a workspace |
| Mantid::Algorithms::RemoveLowResTOF | |
| Mantid::Algorithms::RemovePromptPulse | RemovePromptPulse : TODO: DESCRIPTION |
| Mantid::Algorithms::RenameWorkspace | Renames a workspace to a different name in the data service |
| Mantid::Algorithms::ReplaceSpecialValues | Replaces instances of NaN and infinity in the workspace with user defined numbers |
| Mantid::Algorithms::ResetNegatives | ResetNegatives : Reset negative values to something else |
| Mantid::Algorithms::ResizeRectangularDetector | ResizeRectangularDetector : TODO: DESCRIPTION |
| Mantid::Algorithms::SANSDirectBeamScaling | Computes the scaling factor to get reduced SANS data on an absolute scale |
| Mantid::Algorithms::Scale | Scales an input workspace by the given factor, which can be either multiplicative or additive |
| Mantid::Algorithms::ScaleX | Takes a workspace and adjusts all the time bin values by the same multiplicative factor |
| Mantid::Algorithms::SetUncertainties | Set the uncertainties of the data to zero |
| Mantid::Algorithms::ShiftLogTime | ShiftLogTime : TODO: DESCRIPTION |
| Mantid::Algorithms::SignalOverError | Calculate Y/E for a Workspace2D |
| Mantid::Algorithms::SmoothData | Smooths the data of the input workspace by making each point the mean average of itself and one or more points lying symmetrically either side of it |
| Mantid::Algorithms::SmoothNeighbours | Smooth neighboring pixels |
| Mantid::Algorithms::SofQW | Converts a 2D workspace that has axes of energy transfer against spectrum number to one that gives intensity as a function of momentum transfer against energy |
| Mantid::Algorithms::SofQW2 | Converts a 2D workspace that has axes of energy transfer against spectrum number to one that gives intensity as a function of momentum transfer against energy |
| Mantid::Algorithms::SofQW3 | Converts a 2D workspace that has axes of energy transfer against spectrum number to one that gives intensity as a function of momentum transfer against energy |
| Mantid::Algorithms::SolidAngle | Calculates and outputs the solid angles for each detector in the instrument |
| Mantid::Algorithms::Sort | Obsolete algorithm, renamed SortEvents |
| Mantid::Algorithms::SortEvents | Takes an EventWorkspace and sorts by TOF or frame_index |
| Mantid::Algorithms::SpatialGrouping | This algorithm creates an XML Grouping File for use in the GroupDetectors (v2) or ReadGroupsFromFile algorithms |
| Mantid::Algorithms::SphericalAbsorption | A spherical absorption correction algorithm |
| Mantid::Algorithms::StripPeaks | This algorithm calls FindPeaks as a subalgorithm and then subtracts all the peaks found from the data, leaving just the 'background' |
| Mantid::Algorithms::StripVanadiumPeaks | StripVanadiumPeaks algorithm |
| Mantid::Algorithms::StripVanadiumPeaks2 | StripVanadiumPeaks2 |
| Mantid::Algorithms::SumNeighbours | Sums neighboring pixels on rectangular detectors |
| Mantid::Algorithms::SumRowColumn | This algorithm is the equivalent of the COLETTE "DISPLAY H/V" command |
| Mantid::Algorithms::SumSpectra | Takes a workspace as input and sums all of the spectra within it maintaining the existing bin structure and units |
| Mantid::Algorithms::TOFSANSResolution | Computes the resolution on TOF SANS data Required Properties: |
| Mantid::Algorithms::Transpose | This algorithm "transposes" the bins of the input workspace into a single spectra |
| Mantid::Algorithms::UnaryOperation | UnaryOperation supports the implementation of a Unary operation on an input workspace |
| Mantid::Algorithms::UnGroupWorkspace | Takes the name of a group workspace as input and ungroups the workspaces |
| Mantid::Algorithms::Unwrap | Takes an input Workspace2D that contains 'raw' data, unwraps the data according to the reference flightpath provided and converts the units to wavelength |
| Mantid::Algorithms::UnwrapMonitor | Takes an input Workspace2D that contains 'raw' data, unwraps the data according to the reference flightpath provided and converts the units to wavelength |
| Mantid::Algorithms::UnwrapSNS | Takes an input Workspace2D that contains 'raw' data, unwraps the data according to the reference flightpath provided and converts the units to wavelength |
| Mantid::Algorithms::WeightedMean | An algorithm to calculate the weighted mean of two workspaces |
| Mantid::Algorithms::WeightingStrategy | WeightingStrategy : |
| Mantid::Algorithms::XDataConverter | This is an abstract base class for sharing methods between algorithms that operate only on X data |
| Mantid::API::Algorithm | Base class from which all concrete algorithm classes should be derived |
| Mantid::API::Algorithm::AlgorithmNotification | Base class for algorithm notifications |
| Mantid::API::Algorithm::CancelException | CancelException is thrown to cancel execution of the algorithm |
| Mantid::API::Algorithm::ErrorNotification | ErrorNotification is sent when an exception is caught during execution of the algorithm |
| Mantid::API::Algorithm::FinishedNotification | FinishedNotification is sent after the algorithm finishes its execution |
| Mantid::API::Algorithm::ProgressNotification | An algorithm can report its progress by sending ProgressNotification |
| Mantid::API::Algorithm::StartedNotification | StartedNotification is sent when the algorithm begins execution |
| Mantid::API::Algorithm_descriptor | Structure uniquely describing an algorithm with its name, category and version |
| Mantid::API::AlgorithmFactoryImpl | The AlgorithmFactory class is in charge of the creation of concrete instances of Algorithms |
| Mantid::API::AlgorithmHasProperty | A validator to check whether a given algorithm has a named property |
| Mantid::API::AlgorithmHistory | This class stores information about the Command History used by algorithms on a workspace |
| Mantid::API::AlgorithmManagerImpl | Responsible for controlling algorithm instances |
| Mantid::API::AlgorithmObserver | Observes Algorithm notifications: start,progress,finish,error |
| Mantid::API::AlgorithmProperty | Define an algorithm property that can be used to supply an algorithm object to a subsequent algorithm |
| Mantid::API::AlgorithmProxy | A proxy class that stands between the user and the actual algorithm |
| Mantid::API::AlgorithmStartingNotification | Class for when an algorithm is starting asynchronously |
| Mantid::API::AnalysisDataServiceImpl | The Analysis data service stores instances of the Workspace objects and anything that derives from template class DynamicFactory<Mantid::Kernel::IAlgorithm> |
| Mantid::API::AnalysisDataServiceImpl::GroupWorkspacesNotification | GroupWorkspaces notification is send from GroupWorkspaces algorithm |
| Mantid::API::AnalysisDataServiceImpl::UnGroupingWorkspaceNotification | UnGroupingWorkspace notification is sent from UnGroupWorkspace algorithm before the WorkspaceGroup is removed from the DataService |
| Mantid::API::ArchiveSearchFactoryImpl | Creates instances of IArchiveSearch |
| Mantid::API::AttType | Const attribute visitor returning the type of the attribute |
| Mantid::API::AttValue | Const attribute visitor returning the type of the attribute |
| Mantid::API::Axis | Class to represent the axis of a workspace |
| Mantid::API::Boolean | As TableColumn stores its data in a std::vector bool type cannot be used in the same way as the other types |
| Mantid::API::BoxController | This class is used by MDBox and MDGridBox in order to intelligently determine optimal behavior |
| Mantid::API::CatalogFactoryImpl | Creates instances of concrete Catalog |
| Mantid::API::Column | Column is the base class for columns of TableWorkspace |
| Mantid::API::ColumnFactoryImpl | The ColumnFactory class is in charge of the creation of concrete instances of columns |
| Mantid::API::ColumnVector< T > | ColumnVector gives access to the column elements without alowing its resizing |
| Mantid::API::CommonBinsValidator | A validator which provides a TENTATIVE check that a workspace contains common bins in each spectrum |
| Mantid::API::CompositeDomain | Base class for a composite domain |
| Mantid::API::CompositeDomainMD | A composite domain for MD functions |
| Mantid::API::CompositeFunction | A composite function is a function containing other functions |
| Mantid::API::ConstColumnVector< T > | ConstColumnVector gives const access to the column elements without alowing its resizing |
| Mantid::API::ConstraintFactoryImpl | The ConstraintFactory class is in charge of the creation of concrete instances of Constraints |
| Mantid::API::CoordTransform | Unique SingleValueParameter Declaration for InputNDimensions |
| Mantid::API::CostFunctionFactoryImpl | The CostFunctionFactory class is in charge of the creation of concrete instances of minimizers |
| Mantid::API::DataProcessorAlgorithm | DataProcessorAlgorithm : TODO: DESCRIPTION |
| Mantid::API::DeleterPolicy< T > | |
| Mantid::API::DeprecatedAlgorithm | Class for marking algorithms as deprecated |
| Mantid::API::DummyException | |
| Mantid::API::ElementTraits< T > | Default ElementTraits SFINAE Typetraits are used to provide the correct formatting based on the element type chosen |
| Mantid::API::ElementTraits< bool > | ElementTraits for boolean element types |
| Mantid::API::ElementTraits< double > | ElementTraits for double element types |
| Mantid::API::ElementTraits< float > | ElementTraits for float element types |
| Mantid::API::ElementTraits< size_t > | ElementTraits for boolean element types |
| Mantid::API::EnabledWhenWorkspaceIsType< T > | Show a property as enabled when the workspace pointed to by another is of a given type |
| Mantid::API::ExperimentInfo | This class is shared by a few Workspace types and holds information related to a particular experiment/run: |
| Mantid::API::Expression | This class represents an expression made up of names, binary operators and brackets |
| Mantid::API::Expression::Operators | Keeps operator that can be used in an expression |
| Mantid::API::Expression::Token | This is a struct to mark a token in a string expression |
| Mantid::API::FileFinderImpl | This class finds data files given an instrument name (optionally) and a run number |
| Mantid::API::FileProperty | A specialized class for dealing with file properties |
| Mantid::API::FrameworkManagerImpl | The main public API via which users interact with the Mantid framework |
| Mantid::API::FunctionDomain | Base class that represents the domain of a function |
| Mantid::API::FunctionDomain1D | Represent a domain for functions of one real argument |
| Mantid::API::FunctionDomain1DVector | Implements FunctionDomain1D with its own storage in form of a std::vector |
| Mantid::API::FunctionDomain1DView | 1D domain - a wrapper around an array of doubles |
| Mantid::API::FunctionDomainMD | Implements a domain for MD functions (IFunctionMD) |
| Mantid::API::FunctionFactoryImpl | The FunctionFactory class is in charge of the creation of concrete instances of fitting functions |
| Mantid::API::FunctionHandler | Classes inherited from FunctionHandler will handle the function |
| Mantid::API::FunctionProperty | A property class for functions |
| Mantid::API::FunctionValues | A class to store values calculated by a function |
| Mantid::API::HistogramValidator | A validator which checks that a workspace contains histogram data (the default) or point data as required |
| Mantid::API::IAlgorithm | IAlgorithm is the interface implemented by the Algorithm base class |
| Mantid::API::IArchiveSearch | This class is an archive searching interface |
| Mantid::API::IBackgroundFunction | An interface to a background function |
| Mantid::API::ICatalog | This class creates an interface for information catalogs to support multiple facilities |
| Mantid::API::IConstraint | An interface to a constraint |
| Mantid::API::ICostFunction | An interface for specifying the cost function to be used with Fit algorithm or minimizers, for example, the default being least squares fitting |
| Mantid::API::IDataFileChecker | Base class for data file loading algorithms.This class provides interface for data file loading algorithms to quickly check the file type by opening it and reading the first 100 bytes /extension of the file |
| Mantid::API::IDataFileChecker::file_header | A union representing the first g_hdr_bytes of a file |
| Mantid::API::IDataItem | Interface IDataItem of a Y and error value |
| Mantid::API::IEventList | IEventList : Interface to Mantid::DataObjects::EventList class, used to expose to PythonAPI |
| Mantid::API::IEventWorkspace | This class provides an interface to an EventWorkspace |
| Mantid::API::IFunction | This is an interface to a fitting function - a semi-abstarct class |
| Mantid::API::IFunction1D | This is a specialization of IFunction for functions of one real argument |
| Mantid::API::IFunction::Attribute | Attribute is a non-fitting parameter |
| Mantid::API::IFunction::AttributeVisitor< T > | Atribute visitor class |
| Mantid::API::IFunction::ConstAttributeVisitor< T > | Const version of AttributeVisitor |
| Mantid::API::IFunctionMD | This is a specialization of IFunction for functions defined on an IMDWorkspace |
| Mantid::API::IFunctionMW | This is a specialization of IFunction for functions defined on a MatrixWorkspace |
| Mantid::API::IFunctionValues | Base class for a storage of values of a function |
| Mantid::API::IFunctionWithLocation | An interface to a function with location, which here means a function for which the user may ask what is its centre and height |
| Mantid::API::ILiveListener | ILiveListener is the interface implemented by classes which connect directly to instrument data acquisition systems (DAS) for retrieval of 'live' data into Mantid |
| Mantid::API::ILocatedData | Interface ILocatedData describes a single data item of a point data dataset |
| Mantid::API::IMaskWorkspace | This class provides an interface to a MaskWorkspace |
| Mantid::API::IMDEventWorkspace | Abstract base class for multi-dimension event workspaces (MDEventWorkspace) |
| Mantid::API::IMDHistoWorkspace | Abstract interface to MDHistoWorkspace, for use in exposing to Python |
| Mantid::API::IMDIterator | This is an interface to an iterator of an IMDWorkspace |
| Mantid::API::IMDWorkspace | Basic MD Workspace Abstract Class |
| Mantid::API::ImplicitFunctionBuilder | This class is the abstract type for building IImplicitFunctions |
| Mantid::API::ImplicitFunctionFactoryImpl | |
| Mantid::API::ImplicitFunctionParameter | Abstract parameter type for use with IImplicitFunctions |
| Mantid::API::ImplicitFunctionParameterParser | |
| Mantid::API::ImplicitFunctionParameterParserFactoryImpl | |
| Mantid::API::ImplicitFunctionParser | XML Parser for function types |
| Mantid::API::ImplicitFunctionParserFactoryImpl | |
| Mantid::API::InstrumentDataServiceImpl | InstrumentDataService Class |
| Mantid::API::InstrumentValidator | A validator which checks that a workspace has a valid instrument or point data as required |
| Mantid::API::IPeak | Structure describing a single-crystal peak |
| Mantid::API::IPeakFunction | An interface to a peak function, which extend the interface of IFunctionWithLocation by adding methods to set and get peak width |
| Mantid::API::IPeaksWorkspace | Interface to the class Mantid::DataObjects::PeaksWorkspace |
| Mantid::API::ISpectrum | A "spectrum" is an object that holds the data for a particular spectrum, in particular:
- The X/Y/E arrays
- The spectrum number
- A list of detector ids associated with it
|
| Mantid::API::ISplittersWorkspace | ISplittersWorkspace : Workspace to contain splitters for event filtering |
| Mantid::API::ITableWorkspace | ITableWorkspace is an implementation of Workspace in which the data are organised in columns of same size |
| Mantid::API::IWorkspaceProperty | An interface that is implemented by WorkspaceProperty |
| Mantid::API::Jacobian | Represents the Jacobian in IFitFunction::functionDeriv |
| Mantid::API::JointDomain | An implementation of CompositeDomain |
| Mantid::API::LiveListenerFactoryImpl | The factory for creating instances of ILiveListener implementations |
| Mantid::API::LoadAlgorithmFactoryImpl | Creates instances of concrete DataFileLoder |
| Mantid::API::LocatedDataRef | Holds references to all of the data required to describe a single data item of a point dataset |
| Mantid::API::LocatedDataValue | IDataItem of a Y and error value, together with a pointer to an ErrorHelper |
| Mantid::API::LockMode | Enumeration for locking behaviour |
| Mantid::API::LoopOrientation | Describes the orientation of the looping when using a looping iterator |
| Mantid::API::m_PositionEntry | Used for storing info about "r-position", "t-position" and "p-position" parameters as all parameters are processed |
| Mantid::API::MatrixWorkspace | Base MatrixWorkspace Abstract Class |
| Mantid::API::MatrixWorkspaceMDIterator | IMDIterator-compatible implementation of an iterator through a MatrixWorkspace |
| Mantid::API::MatrixWorkspaceValidator | A validator for workspaces which can contain a number of individual validators, all of which must pass for the overall validator to do so |
| Mantid::API::MatrixWSIndexCalculator | |
| Mantid::API::MDGeometry | Describes the geometry (i.e |
| Mantid::API::MemoryInfo | Information about the memory |
| Mantid::API::MemoryManagerImpl | Responsible for memory management |
| Mantid::API::MultiDomainFunction | A composite function defined on a CompositeDomain |
| Mantid::API::MultipleExperimentInfos | Small class that allows a MDEventWorkspace or a MDHistoWorkspace to hold several ExperimentInfo classes |
| Mantid::API::MultipleFileProperty | A property to allow a user to select multiple files to load |
| Mantid::API::MWDimension | |
| Mantid::API::MWXDimension | An implementation of IMDDimension for MatrixWorkspace that points to the X vector of the first spectrum |
| Mantid::API::myContentHandler | |
| Mantid::API::NullCoordTransform | NullCoordTransform : A transform that sets the outVector to have the same values as the inputVector |
| Mantid::API::NumericAxis | Class to represent a numeric axis of a workspace |
| Mantid::API::NumericAxisValidator | A validator which checks whether the input workspace has the Numeric data in the axis |
| Mantid::API::ParameterReference | A reference to a parameter in a function |
| Mantid::API::ParameterTie | Ties fitting parameters |
| Mantid::API::ParamFunction | Implements the part of IFunction interface dealing with parameters |
| Mantid::API::PartialJacobian | A Jacobian for individual functions |
| Mantid::API::PartialJacobian1 | A Jacobian for individual functions |
| Mantid::API::Progress | Helper class for reporting progress from algorithms |
| Mantid::API::PropertyManagerDataServiceImpl | PropertyManagerDataService Class |
| Mantid::API::PropertyMode | Enumeration for a mandatory/optional property |
| Mantid::API::RawCountValidator | A validator which checks that a workspace contains raw counts in its bins |
| Mantid::API::RefAxis | A class to represent the axis of a 2D (or more) workspace where the value at a given point on the axis varies along the other dimension |
| Mantid::API::ReferenceEqual | Used to find ParameterTie for a parameter i |
| Mantid::API::Run | This class stores information regarding an experimental run as a series of log entries |
| Mantid::API::Sample | This class stores information about the sample used in particular run |
| Mantid::API::SampleEnvironment | This class stores details regarding the sample environment that was used during a specific run |
| Mantid::API::SetValue | Attribute visitor setting new value to an attribute |
| Mantid::API::SingleValueParameter< Derived, ValType > | SingleValueParameter is a templated base class implementing CRTP |
| Mantid::API::SingleValueParameterParser< SingleValueParameterType > | XML Parser for single value parameter types |
| Mantid::API::SpectraAxis | Class to represent the spectra axis of a workspace |
| Mantid::API::SpectraAxisValidator | A validator which checks whether the input workspace has the Spectra number in the axis |
| Mantid::API::SpectraDetectorMap | SpectraDetectorMap provides a multimap between Spectra number (int) and detector ID (UDET) |
| Mantid::API::TableColumnHelper | Helper class used to create ColumnVector |
| Mantid::API::TableConstColumnHelper | Helper class used to create ConstColumnVector |
| Mantid::API::TableRow | TableRow represents a row in a TableWorkspace |
| Mantid::API::TableRowHelper | Helper class used to create TableRow |
| Mantid::API::TempFunction | This is a temporary helper class to aid transition from IFitFunction to IFunction |
| Mantid::API::TextAxis | Class to represent a text axis of a workspace |
| Mantid::API::Topology | Abstract type represents topology for visualisation |
| Mantid::API::VectorParameter< Derived, ElemType > | VectorParameter is abstract type implementing curiously recurring template pattern to implement common code associated with vector storage |
| Mantid::API::VectorParameterParser< VectorValueParameterType > | XML parser for vector value (n elements) parameter types |
| Mantid::API::Workspace | Base Workspace Abstract Class |
| Mantid::API::workspace_iterator< _Iterator, _Container > | Workspace_iterator iterates over a workspace providing values as TripleRefs |
| Mantid::API::WorkspaceFactoryImpl | The WorkspaceFactory class is in charge of the creation of all types of workspaces |
| Mantid::API::WorkspaceGroup | Class to hold a set of workspaces |
| Mantid::API::WorkspaceHelpers | A collection of static functions for use with workspaces |
| Mantid::API::WorkspaceHistory | This class stores information about the Workspace History used by algorithms on a workspace and the environment history |
| Mantid::API::WorkspaceProperty< TYPE > | A property class for workspaces |
| Mantid::API::WorkspaceUnitValidator | A validator which checks that the unit of the workspace referred to by a WorkspaceProperty is the expected one |
| Mantid::Crystal::AnvredCorrection | Calculates anvred correction factors for attenuation due to absorption and scattering in a spherical sample |
| Mantid::Crystal::CalculateUMatrix | CalculateUMatrix : Algorithm to calculate the U matrix, given lattice parameters and a list of peaks |
| Mantid::Crystal::CentroidPeaks | Find the centroid of single-crystal peaks in a 2D Workspace, in order to refine their positions |
| Mantid::Crystal::FindSXPeaks | Takes a 2D workspace as input and find the FindSXPeaksimum in each 1D spectrum |
| Mantid::Crystal::FindUBUsingFFT | FindUBUsingFFT : Algorithm to calculate a UB matrix using fast Fourier transforms given a list of peaks and bounds on the lattice parameters |
| Mantid::Crystal::FindUBUsingIndexedPeaks | FindUBUsingIndexedPeaks : Algorithm to calculate a UB matrix, given a list of peaks that have already been indexed by some means |
| Mantid::Crystal::FindUBUsingLatticeParameters | FindUBUsingLatticeParameters : Algorithm to calculate a UB matrix, given lattice parameters and a list of peaks |
| Mantid::Crystal::FindUBUsingMinMaxD | FindUBUsingMinMaxD : Algorithm to calculate a UB matrix, given bounds on the lattice parameters and a list of peaks |
| Mantid::Crystal::index | Peak indexing algorithm, which works by assigning multiple possible HKL values to each peak and then culling these options by comparison with neighbouring peaks |
| Mantid::Crystal::IndexPeaks | IndexPeaks : Algorithm to use the UB saved in the sample associated with the specified PeaksWorkspace, to index the peaks in the workspace |
| Mantid::Crystal::IndexSXPeaks | |
| Mantid::Crystal::IntegratePeakTimeSlices | Integrates each time slice using the BivariateNormal formula, adding the results to the peak object |
| Mantid::Crystal::LoadHKL | LoadHKL : Load an ISAW-style .peaks file into a PeaksWorkspace |
| Mantid::Crystal::LoadIsawPeaks | LoadIsawPeaks : Load an ISAW-style .peaks file into a PeaksWorkspace |
| Mantid::Crystal::LoadIsawUB | Algorithm to load an ISAW-style ASCII UB matrix and lattice parameters file, and place its information into a workspace |
| Mantid::Crystal::MaskPeaksWorkspace | Find the offsets for each detector |
| Mantid::Crystal::NormaliseVanadium | Calculates anvred correction factors for attenuation due to absorption and scattering in a spherical sample |
| Mantid::Crystal::PeakCandidate | |
| Mantid::Crystal::PeakIntegration | Find the offsets for each detector |
| Mantid::Crystal::PeakIntensityVsRadius | Calculate the integrated intensity of peaks vs integration radius |
| Mantid::Crystal::PredictPeaks | Using a known crystal lattice and UB matrix, predict where single crystal peaks should be found in detector/TOF space |
| Mantid::Crystal::SaveHKL | |
| Mantid::Crystal::SaveIsawPeaks | Save a PeaksWorkspace to a ISAW-style ASCII .peaks file |
| Mantid::Crystal::SaveIsawUB | Algorithm to save a UB matrix and lattice parameters to an ISAW-style ASCII file |
| Mantid::Crystal::SavePeaksFile | SavePeaksFile : Save a PeaksWorkspace to a .peaks text-format file |
| Mantid::Crystal::SCDCalibratePanels | SCDCalibratePanels calibrates instrument parameters for Rectangular Detectors |
| Mantid::Crystal::SCDPanelErrors | This fit function is used for calibrating RectangularDetectors by adjusting L0, time offset, panel width, panel height, panel center and orientation(so far) |
| Mantid::Crystal::SelectCellOfType | ShowPossibleCells : Algorithm to display a list of possible conventional cells corresponding to the UB saved in the sample associated with the specified PeaksWorkspace, provided the saved UB is for a Niggli reduced cell |
| Mantid::Crystal::SelectCellWithForm | ShowPossibleCells : Algorithm to display a list of possible conventional cells corresponding to the UB saved in the sample associated with the specified PeaksWorkspace, provided the saved UB is for a Niggli reduced cell |
| Mantid::Crystal::SetGoniometer | Define the goniometer used in an experiment by giving the axes and directions of rotations |
| Mantid::Crystal::SetUB | SetUB : Algorithm to set the UB matrix, given lattice parameters and u and v vectors as defined in: http://horace.isis.rl.ac.uk/Getting_started |
| Mantid::Crystal::ShowPossibleCells | ShowPossibleCells : Algorithm to display a list of possible conventional cells corresponding to the UB saved in the sample associated with the specified PeaksWorkspace, provided the saved UB is for a Niggli reduced cell |
| Mantid::Crystal::SortHKL | Save a PeaksWorkspace to a Gsas-style ASCII .hkl file |
| Mantid::Crystal::SXPeak | Type to represent identified Single Crystal Peaks |
| Mantid::Crystal::TOFExtinction | |
| Mantid::Crystal::TransformHKL | TransformHKL : Algorithm to adjust the UB saved in the sample associated with the specified PeaksWorkspace, so the HKL values are reordered or otherwise transformed |
| Mantid::CurveFitting::Abragam | Provide Abragam fitting function for muon scientists |
| Mantid::CurveFitting::BackgroundFunction | A background function |
| Mantid::CurveFitting::BackToBackExponential | Provide BackToBackExponential peak shape function interface to IPeakFunction |
| Mantid::CurveFitting::BFGS_Minimizer | Implementing Broyden-Fletcher-Goldfarb-Shanno (BFGS) algorithm by wrapping the IFuncMinimizer interface around the GSL implementation of this algorithm |
| Mantid::CurveFitting::BivariateNormal | Provide peak shape function interface a Peak shape on one time slice of a RectangularDetector |
| Mantid::CurveFitting::BoundaryConstraint | A boundary constraint is designed to be used to set either upper or lower (or both) boundaries on a single parameter |
| Mantid::CurveFitting::Chebyshev | Implements Chebyshev polynomial expansion |
| Mantid::CurveFitting::CompositeValues | Composite values |
| Mantid::CurveFitting::Convolution | Performes convolution of two functions |
| Mantid::CurveFitting::Convolution::HalfComplex | Class for helping to read the transformed data |
| Mantid::CurveFitting::CostFuncFitting | A semi-abstract class for a cost function for fitting functions |
| Mantid::CurveFitting::CostFuncIgnorePosPeaks | Cost function which allows positive peaks to be ignored and is suitable for e.g |
| Mantid::CurveFitting::CostFuncLeastSquares | Cost function for least squares |
| Mantid::CurveFitting::DeltaFunction | Delta function |
| Mantid::CurveFitting::DerivMinimizer | A wrapper around the GSL functions implementing a minimizer using derivatives |
| Mantid::CurveFitting::DiffSphere | |
| Mantid::CurveFitting::ElasticDiffSphere | |
| Mantid::CurveFitting::EmptyValues | Base class for a storage of values of a function |
| Mantid::CurveFitting::EndErfc | Provide Errore function erfc()for calibrating the end of a tube |
| Mantid::CurveFitting::ExpDecay | Provide exponential decay function: h*exp(-(x-c)/t) |
| Mantid::CurveFitting::ExpDecayMuon | Provide exponential decay function: h*exp(-lambda.x) |
| Mantid::CurveFitting::ExpDecayOsc | Provide oscillating exponential decay function: h*exp(-lambda.x)*(cos(2pi*f*x+phi)) |
| Mantid::CurveFitting::Fit | A generic fitting algorithm |
| Mantid::CurveFitting::Fit1D | Deprecation notice: instead of using this algorithm please use the Fit algorithm instead |
| Mantid::CurveFitting::FitData | Structure to contain least squares data and used by GSL |
| Mantid::CurveFitting::FitMD | Creates FunctionDomainMD from an IMDWorkspace |
| Mantid::CurveFitting::FitMW | Creates FunctionDomain1D form a spectrum in a MatrixWorkspace |
| Mantid::CurveFitting::FlatBackground | FlatBackground : TODO: DESCRIPTION |
| Mantid::CurveFitting::FRConjugateGradientMinimizer | Implementing Fletcher-Reeves flavour of the conjugate gradient algorithm by wrapping the IFuncMinimizer interface around the GSL implementation of this algorithm |
| Mantid::CurveFitting::FuncMinimizerFactoryImpl | The FuncMinimizerFactory class is in charge of the creation of concrete instances of minimizers |
| Mantid::CurveFitting::GausDecay | Provide gaussian decay function: A*exp(-(sigma.x)^2)) |
| Mantid::CurveFitting::GausOsc | Provide gaussian decay function: A*exp(-(sigma.x)^2)) |
| Mantid::CurveFitting::Gaussian | Provide gaussian peak shape function interface to IPeakFunction |
| Mantid::CurveFitting::Gaussian1D | Deprecation notice: instead of using this algorithm please use the Fit algorithm where the Function parameter of this algorithm is used to specified the fitting function |
| Mantid::CurveFitting::GaussianLinearBG1D | Takes a histogram in a 2D workspace and fit it to a Gaussian on top of a linear background |
| Mantid::CurveFitting::GSL_FitData | Structure to contain least squares data and used by GSL |
| Mantid::CurveFitting::GSLJacobian | An implementation of Jacobian using gsl_matrix |
| Mantid::CurveFitting::GSLMatrix | A wrapper around gsl_matrix |
| Mantid::CurveFitting::GSLMatrixMult2 | |
| Mantid::CurveFitting::GSLMatrixMult3 | |
| Mantid::CurveFitting::GSLVector | A wrapper around gsl_vector |
| Mantid::CurveFitting::IDomainCreator | An base class for domain creators for use in Fit |
| Mantid::CurveFitting::IFuncMinimizer | An interface for function minimizers |
| Mantid::CurveFitting::IkedaCarpenterPV | Provide Ikeda-Carpenter-pseudo-Voigt peak shape function interface to IPeakFunction |
| Mantid::CurveFitting::InelasticDiffSphere | |
| Mantid::CurveFitting::Jacobian | An implementation of Jacobian using std::vector |
| Mantid::CurveFitting::JacobianImpl | The implementation of Jacobian |
| Mantid::CurveFitting::JacobianImpl1 | Various GSL specific functions used GSL specific minimizers |
| Mantid::CurveFitting::LevenbergMarquardtMDMinimizer | Implementing Levenberg-Marquardt algorithm |
| Mantid::CurveFitting::LevenbergMarquardtMinimizer | Implementing Levenberg-Marquardt by wrapping the IFuncMinimizer interface around the GSL implementation of this algorithm |
| Mantid::CurveFitting::Linear | Performs a least-squares fit of a spectrum to the function Y(c,x) = c0 + c1*X |
| Mantid::CurveFitting::LinearBackground | Provide linear function interface to IFunction |
| Mantid::CurveFitting::linearJ | |
| Mantid::CurveFitting::LogNormal | Provide Log Normal function: h*exp(-(log(x)-t)^2 / (2*b^2) )/x |
| Mantid::CurveFitting::Lorentzian | Provide lorentzian peak shape function interface to IPeakFunction |
| Mantid::CurveFitting::Lorentzian1D | Deprecation notice: instead of using this algorithm please use the Fit algorithm where the Function parameter of this algorithm is used to specified the fitting function |
| Mantid::CurveFitting::MultiBG | A composite function |
| Mantid::CurveFitting::MultiDomainCreator | Creates a composite domain |
| Mantid::CurveFitting::MuonFInteraction | Provide Muon F Interaction fitting function |
| Mantid::CurveFitting::PartialJacobian | A Jacobian for individual functions |
| Mantid::CurveFitting::PlotPeakByLogValue | Takes a workspace group and fits the same spectrum in all workspaces with the same function |
| Mantid::CurveFitting::PlotPeakByLogValue::InputData | Structure to identify data for fitting |
| Mantid::CurveFitting::PRConjugateGradientMinimizer | Implementing Polak-Ribiere flavour of the conjugate gradient algorithm by wrapping the IFuncMinimizer interface around the GSL implementation of this algorithm |
| Mantid::CurveFitting::ProductFunction | Allow user to create a fit function which is the product of two or more other fit functions |
| Mantid::CurveFitting::Quadratic | Provide quadratic function interface to IFunction |
| Mantid::CurveFitting::QuadraticBackground | QuadraticBackground : Quadratic background as Y = A0 + A1*X + A2*X**2 |
| Mantid::CurveFitting::Resolution | Resolution function |
| Mantid::CurveFitting::SeqDomain | An implementation of CompositeDomain |
| Mantid::CurveFitting::SimplexMinimizer | Implementing Simplex by wrapping the IFuncMinimizer interface around the GSL implementation of this algorithm |
| Mantid::CurveFitting::SplineBackground | SplineBackground |
| Mantid::CurveFitting::StaticKuboToyabe | Provide static Kubo Toyabe fitting function |
| Mantid::CurveFitting::SteepestDescentMinimizer | Implementing the steepest descent algorithm by wrapping the IFuncMinimizer interface around the GSL implementation of this algorithm |
| Mantid::CurveFitting::StretchExp | Provide Streteched Exponential fitting function: h*exp(-(x/t)^b ) |
| Mantid::CurveFitting::StretchExpMuon | Provide stetch exponential function for Muon scientists |
| Mantid::CurveFitting::Tr | |
| Mantid::CurveFitting::UserFunction | A user defined function |
| Mantid::CurveFitting::UserFunction1D | Deprecation notice: instead of using this algorithm please use the Fit algorithm where the Function parameter of this algorithm is used to specified the fitting function |
| Mantid::CurveFitting::UserFunctionMD | A user defined function |
| Mantid::CurveFitting::xnlc | |
| Mantid::DataHandling::BankPulseTimes | This class defines the pulse times for a specific bank |
| Mantid::DataHandling::CompressEvents | Compress an EventWorkspace by lumping together events with very close TOF value, while ignoring the event's pulse time |
| Mantid::DataHandling::CreateSampleShape | This class allows the shape of the sample to be defined by using the allowed XML expressions |
| Mantid::DataHandling::DasEvent | Structure that matches the form in the binary event list |
| Mantid::DataHandling::DefineGaugeVolume | This class allows the shape of the sample to be defined by using the allowed XML expressions |
| Mantid::DataHandling::DeleteTableRows | Deletes a row from a TableWorkspace |
| Mantid::DataHandling::DetermineChunking | |
| Mantid::DataHandling::FakeEventDataListener | An implementation of ILiveListener for testing purposes that fills its event workspace buffer with randomly generated events |
| Mantid::DataHandling::FileEventDataListener | An implementation of ILiveListener for testing purposes that reads from a file and serves up 'chunks' when extractBuffer() is called |
| Mantid::DataHandling::FileTypeDescriptor | Description of the ASCII data header, common for all ASCII PAR and PHX files |
| Mantid::DataHandling::FindDetectorsInShape | An algorithm for finding which detectors are contained within a user defined shape within the instrument |
| Mantid::DataHandling::FindDetectorsPar | |
| Mantid::DataHandling::GetMaskedDetectors | Retrieve the list of masked detectors from a workspace |
| Mantid::DataHandling::getWithoutMonitors< T > | To be used with std::generate to copy only those values from a dataset that don't relate to monitors |
| Mantid::DataHandling::GroupDetectors | An algorithm for grouping detectors and the spectra associated with them into a single DetectorGroup and spectrum |
| Mantid::DataHandling::GroupDetectors2 | An algorithm for grouping detectors and their associated spectra into single spectra and DetectorGroups |
| Mantid::DataHandling::GroupDetectors2::RangeHelper | Function that expands pairs of integers separated with a hyphen into a list of all the integers between those values |
| Mantid::DataHandling::IntermediateEvent | Structure used as an intermediate for parallel processing of events |
| Mantid::DataHandling::ISISDataArchive | This class is for searching the ISIS data archive |
| Mantid::DataHandling::LiveDataAlgorithm | Abstract base class with common properties for the following algorithms dealing with live data:
|
| Mantid::DataHandling::Load | Loads a workspace from a data file |
| Mantid::DataHandling::LoadAscii | Loads a workspace from an ascii file |
| Mantid::DataHandling::LoadBankFromDiskTask | This task does the disk IO from loading the NXS file, and so will be on a disk IO mutex |
| Mantid::DataHandling::LoadCalFile | Algorithm to load a 5-column ascii .cal file into up to 3 workspaces: a GroupingWorkspace, OffsetsWorkspace and/or MaskWorkspace |
| Mantid::DataHandling::LoadCanSAS1D | This algorithm loads 1 CanSAS1d xml file into a workspace |
| Mantid::DataHandling::LoadDAE | Loads data from the ISIS DATA acquisition system and stores it in a 2D workspace (Workspace2D class) |
| Mantid::DataHandling::LoadDaveGrp | Reads the DAVE grouped ASCII format into a workspace |
| Mantid::DataHandling::LoadDetectorInfo | Adjusts TOF X-values for offset times and adds or modifies values for "3He(atm)" and "wallT(m)" in the workspace's parameter map using values read in from a DAT or RAW file |
| Mantid::DataHandling::LoadDetectorInfo::detectDatForm | Holds data about the where detector information is stored in the user tables of raw files |
| Mantid::DataHandling::LoadDetectorInfo::detectorInfo | Stores the information that is to be saved in the parameter map for a detector |
| Mantid::DataHandling::LoadDetectorsGroupingFile | LoadDetectorsGroupingFile : TODO: DESCRIPTION |
| Mantid::DataHandling::LoadDspacemap | Loads a Dspacemap file (POWGEN binary, VULCAN binary or ascii format) into an OffsetsWorkspace |
| Mantid::DataHandling::LoadEmptyInstrument | Loads an instrument definition file into a workspace, with the purpose of being able to visualise an instrument without requiring to read in a ISIS raw datafile first |
| Mantid::DataHandling::LoadEventNexus | Load Event Nexus files |
| Mantid::DataHandling::LoadEventPreNexus | A data loading routine for SNS pre-nexus event files |
| Mantid::DataHandling::LoadEventPreNexus2 | A data loading routine for SNS pre-nexus event files |
| Mantid::DataHandling::LoadGroupXMLFile | |
| Mantid::DataHandling::LoadGSS | Loads a file as saved by SaveGSS |
| Mantid::DataHandling::LoadInstrument | Loads instrument data from a XML instrument description file and adds it to a workspace |
| Mantid::DataHandling::LoadInstrumentFromNexus | Attempt to load information about the instrument from a ISIS NeXus file |
| Mantid::DataHandling::LoadInstrumentFromRaw | Attempt to load information about the instrument from a ISIS raw file |
| Mantid::DataHandling::LoadIsawDetCal | Find the offsets for each detector |
| Mantid::DataHandling::LoadISISNexus | Loads a file in a Nexus format and stores it in a 2D workspace (Workspace2D class) |
| Mantid::DataHandling::LoadISISNexus2 | Loads a file in a NeXus format and stores it in a 2D workspace |
| Mantid::DataHandling::LoadLiveData | Algorithm to load a chunk of live data |
| Mantid::DataHandling::LoadLog | Load ISIS log file(s) |
| Mantid::DataHandling::LoadLogsForSNSPulsedMagnet | LoadLogsForSNSPulsedMagnet : TODO: DESCRIPTION |
| Mantid::DataHandling::LoadLogsFromSNSNexus | Load sample logs (single values and time series data) from a SNS NeXus format file |
| Mantid::DataHandling::LoadLOQDistancesFromRaw | An algorithm to extract geometry information specific to the LOQ instrument from a raw file |
| Mantid::DataHandling::LoadMappingTable | Loads the mapping table between spectra and IDetector from a raw file |
| Mantid::DataHandling::LoadMask | LoadMask : Load masking file to generate a SpecialWorkspace2D object (masking workspace) |
| Mantid::DataHandling::LoadMaskingFile | LoadMaskingFile : TODO: DESCRIPTION |
| Mantid::DataHandling::LoadMuonLog | Load ISIS Muon log data from a NeXus file |
| Mantid::DataHandling::LoadMuonNexus | Loads an file in Nexus Muon format and stores it in a 2D workspace (Workspace2D class) |
| Mantid::DataHandling::LoadMuonNexus2 | Loads an file in NeXus Muon format and stores it in a 2D workspace (Workspace2D class) |
| Mantid::DataHandling::LoadNexus | Loads a file in NeXus format and stores it in a 2D workspace (Workspace2D class) |
| Mantid::DataHandling::LoadNexusLogs | Loads the run logs from a NeXus file |
| Mantid::DataHandling::LoadNexusMonitors | Load Monitors from NeXus files |
| Mantid::DataHandling::LoadNexusProcessed | Loads a workspace from a NeXus Processed entry in a NeXus file |
| Mantid::DataHandling::LoadNXSPE | LoadNXSPE : Algorithm to load an NXSPE file into a workspace2D |
| Mantid::DataHandling::LoadParameterFile | Loads instrument parameter data from a XML instrument parameter file and adds it to a workspace |
| Mantid::DataHandling::LoadPreNexus | LoadPreNexus : Workflow algorithm to load a collection of preNeXus files |
| Mantid::DataHandling::LoadPreNexusMonitors | |
| Mantid::DataHandling::LoadPreNeXusMonitors | A data loading routine for SNS PreNeXus beam monitor (histogram) files |
| Mantid::DataHandling::LoadQKK | Loads a Quokka data file |
| Mantid::DataHandling::LoadRaw | Loads an file in ISIS RAW format and stores it in a 2D workspace (Workspace2D class) |
| Mantid::DataHandling::LoadRaw2 | Loads an file in ISIS RAW format and stores it in a 2D workspace (Workspace2D class) |
| Mantid::DataHandling::LoadRaw3 | Loads an file in ISIS RAW format and stores it in a 2D workspace (Workspace2D class) |
| Mantid::DataHandling::LoadRawBin0 | Loads bin zero for all spectra from ISIS RAW file and stores it in a 2D workspace (Workspace2D class) |
| Mantid::DataHandling::LoadRawHelper | Helper class for LoadRaw algorithms |
| Mantid::DataHandling::LoadRawSpectrum0 | Loads zeroth spectrum from ISIS RAW format file and stores it in a 2D workspace (Workspace2D class) |
| Mantid::DataHandling::LoadRKH | Loads an RKH file into a Mantid 1D workspace |
| Mantid::DataHandling::LoadSampleDetailsFromRaw | An algorithm to extract the sample details from the SPB structure within a RAW file |
| Mantid::DataHandling::LoadSassena | Load Sassena Output files |
| Mantid::DataHandling::LoadSNSEventNexus | Load SNS EventNexus files |
| Mantid::DataHandling::LoadSNSNexus | Loads a NeXus file that conforms to the TOFRaw instrument definition format and stores it in a 2D workspace |
| Mantid::DataHandling::LoadSNSspec | Loads a workspace from an SNS spec file |
| Mantid::DataHandling::LoadSPE | Loads an SPE format file into a Mantid workspace |
| Mantid::DataHandling::LoadSpec | Loads a workspace from an ascii file |
| Mantid::DataHandling::LoadSpice2D | This algorithm loads a SPICE2D file for HFIR SANS into a workspace |
| Mantid::DataHandling::LoadTOFRawNexus | Loads a NeXus file that conforms to the TOFRaw instrument definition format and stores it in a 2D workspace |
| Mantid::DataHandling::ManagedRawFileWorkspace2D | Concrete workspace implementation |
| Mantid::DataHandling::MaskDetectors | An algorithm to mask a detector, or set of detectors |
| Mantid::DataHandling::MaskDetectorsInShape | An algorithm for finding masking detectors that are contained within a user defined shape within the instrument |
| Mantid::DataHandling::Merge2WorkspaceLogs | Merge2WorkspaceLogs : TODO: DESCRIPTION |
| Mantid::DataHandling::MonitorLiveData | Algorithm that repeatedly calls LoadLiveData, at a given update frequency |
| Mantid::DataHandling::MoveInstrumentComponent | Moves an instrument component to a new position by setting corresponding parameter in ParameterMap |
| Mantid::DataHandling::NexusInfo | Structure for keeping information about a NeXus data set, such as the dimensions and type |
| Mantid::DataHandling::NexusTester | NexusTester : debugging/performance testing algorithm for nexus file loading and saving |
| Mantid::DataHandling::OrbiterDataArchive | This class is for searching the Orbiter data archive |
| Mantid::DataHandling::ProcessBankData | This task does the disk IO from loading the NXS file, and so will be on a disk IO mutex |
| Mantid::DataHandling::ProcessDasNexusLog | ProcessDasNexusLog : TODO: DESCRIPTION |
| Mantid::DataHandling::Pulse | Structure that matches the form in the new pulseid files |
| Mantid::DataHandling::RawFileInfo | An algorithm to extract pertinent information about a RAW file without loading the data |
| Mantid::DataHandling::RemoveLogs | Load ISIS log file(s) |
| Mantid::DataHandling::RenameLog | RenameLog : TODO: DESCRIPTION |
| Mantid::DataHandling::RotateInstrumentComponent | Rotates an instrument component to a new orientation by setting corresponding parameter ("rot") in ParameterMap |
| Mantid::DataHandling::SaveAscii | Saves a workspace or selected spectra in a coma-separated ascii file |
| Mantid::DataHandling::SaveCalFile | Algorithm to save a 5-column ascii .cal file from to 3 workspaces: a GroupingWorkspace, OffsetsWorkspace and/or MaskWorkspace |
| Mantid::DataHandling::SaveCanSAS1D | |
| Mantid::DataHandling::SaveCSV | Saves a 1D or 2D workspace to a CSV file |
| Mantid::DataHandling::SaveDASC | Saves a workspace into an ASCII format that can be read by the DAVE analysis software |
| Mantid::DataHandling::SaveDaveGrp | |
| Mantid::DataHandling::SaveDetectorMasks | SaveDetectorMasks : TODO: DESCRIPTION |
| Mantid::DataHandling::SaveDetectorsGrouping | SaveDetectorsGrouping : TODO: DESCRIPTION |
| Mantid::DataHandling::SaveDspacemap | Saves an OffsetsWorkspace into a POWGEN-format binary dspace map file |
| Mantid::DataHandling::SaveFocusedXYE | Saves a focused data set (usually output of a diffraction focusing routine but not exclusively) into a three column format containing X_i, Y_i, and E_i |
| Mantid::DataHandling::SaveGSS | Saves a focused data set into a three column GSAS format containing X_i, Y_i*step, and E_i*step |
| Mantid::DataHandling::SaveIsawDetCal | Saves an instrument with RectangularDetectors to an ISAW .DetCal file |
| Mantid::DataHandling::SaveISISNexus | The SaveISISNexus algorithm will convert a RAW file to a NeXus file |
| Mantid::DataHandling::SaveMask | SaveMaskingToFile : TODO: DESCRIPTION |
| Mantid::DataHandling::SaveNexus | Saves a file in NeXus format and from a 2D workspace (Workspace2D class) |
| Mantid::DataHandling::SaveNexusProcessed | Saves a workspace as a Nexus Processed entry in a Nexus file |
| Mantid::DataHandling::SaveNISTDAT | Writer for compatibility with SansView and NIST reduced data file format |
| Mantid::DataHandling::SaveNXSPE | Saves a workspace into a NeXus/HDF5 NXSPE file |
| Mantid::DataHandling::SavePAR | Saves a workspace into an ASCII PAR file |
| Mantid::DataHandling::SavePHX | Saves a workspace into an ASCII PHX file |
| Mantid::DataHandling::SaveRKH | Saves a workspace in the RKH file format |
| Mantid::DataHandling::SaveSPE | Saves a workspace into an ASCII SPE file |
| Mantid::DataHandling::SaveToSNSHistogramNexus | Save a Workspace2D or an EventWorkspace into a NeXus file whose format corresponds to that expected at the SNS |
| Mantid::DataHandling::SaveToSNSHistogramNexus::link_to_make | |
| Mantid::DataHandling::SaveVTK | Saves a 1D or 2D workspace using the vtk file format described in the "file formats" document at http://www.vtk.org/documents.php |
| Mantid::DataHandling::SetScalingPSD | Read the scaling information from a file (e.g |
| Mantid::DataHandling::SNSDataArchive | This class is for searching the SNS data archive |
| Mantid::DataHandling::StartLiveData | Algorithm that begins live data monitoring |
| Mantid::DataHandling::UpdateInstrumentFromFile | Update detector positions initially loaded in from Instrument Defintion File (IDF) from information in the provided files |
| Mantid::DataHandling::VulcanCorrectionFactor | Structure of the vulcan binary file |
| Mantid::DataObjects::AbsManagedWorkspace2D | AbsManagedWorkspace2D |
| Mantid::DataObjects::BinaryOperator | An SpecialWorkspace2D is a specialized Workspace2D where the Y value at each pixel will be used for a special meaning |
| Mantid::DataObjects::CompressedWorkspace2D | CompressedWorkspace2D |
| Mantid::DataObjects::EventList | A class for holding :
|
| Mantid::DataObjects::EventList::tofGreater< T > | Unary function for searching the event list |
| Mantid::DataObjects::EventList::tofGreaterOrEqual< T > | Unary function for searching the event list |
| Mantid::DataObjects::EventSortingTask | Task for sorting an event list |
| Mantid::DataObjects::EventWorkspace | This class is intended to fulfill the design specified in <https://svn.mantidproject.org/mantid/trunk/Documents/Design/Event WorkspaceDetailed Design Document.doc> |
| Mantid::DataObjects::EventWorkspaceHelpers | A collection of functions that help for EventWorkspaces |
| Mantid::DataObjects::EventWorkspaceMRU | This is a container for the MRU (most-recently-used) list of generated histograms |
| Mantid::DataObjects::GroupingWorkspace | A GroupingWorkspace is a subclass of Workspace2D where each spectrum has a single number entry, the value of which signifies to which group that workspace index belongs |
| Mantid::DataObjects::Histogram1D | 1D histogram implementation |
| Mantid::DataObjects::ManagedDataBlock2D | Stores a block of 2D data |
| Mantid::DataObjects::ManagedDataBlockMRUMarker | For use in the AbsManagedWorkspace2D MRU list |
| Mantid::DataObjects::ManagedHistogram1D | A "managed" version of Histogram1D where the data is loaded only when required |
| Mantid::DataObjects::ManagedWorkspace2D | The ManagedWorkspace2D allows the framework to handle 2D datasets that are too large to fit in the available system memory by making use of a temporary file |
| Mantid::DataObjects::MantidVecWithMarker | This little class holds a MantidVec of data and an index marker that is used for uniqueness |
| Mantid::DataObjects::MaskWorkspace | |
| Mantid::DataObjects::MementoTableWorkspace | Variation on the TableWorkspace with a set of pre-defined columns used to store diffs on Workspaces |
| Mantid::DataObjects::OffsetsWorkspace | An OffsetsWorkspace is a specialized Workspace2D where the Y value at each pixel is the offset to be used for correcting calculations (specifically AlignDetectors) |
| Mantid::DataObjects::Peak | Structure describing a single-crystal peak |
| Mantid::DataObjects::PeakColumn | PeakColumn : a Column sub-class used to display peak information as a TableWorkspace |
| Mantid::DataObjects::PeakComparator | Comparator class for sorting peaks by one or more criteria |
| Mantid::DataObjects::PeaksWorkspace | The class PeaksWorkspace stores information about a set of SCD peaks |
| Mantid::DataObjects::RebinnedOutput | RebinnedOutput |
| Mantid::DataObjects::SpecialWorkspace2D | |
| Mantid::DataObjects::SplittersWorkspace | SplittersWorkspace : A TableWorkspace to contain TimeSplitters |
| Mantid::DataObjects::TableColumn< Type > | Class TableColumn implements abstract class Column for any copyable data type |
| Mantid::DataObjects::TableColumn< Type >::InconvertibleToDoubleType | Helper struct helping to write a generic casting to double |
| Mantid::DataObjects::TableColumn_ptr< T > | Shared pointer to a column with aoutomatic type cast and data type check |
| Mantid::DataObjects::TableColumn_ptr< bool > | Special case of bool |
| Mantid::DataObjects::TableWorkspace | TableWorkspace is an implementation of Workspace in which the data are organised in columns of same size |
| Mantid::DataObjects::TableWorkspace::FindName | Used in std::find_if algorithm to find a Column with name name |
| Mantid::DataObjects::TofEvent | Info about a single neutron detection event: |
| Mantid::DataObjects::WeightedEvent | Info about a single neutron detection event, including a weight and error value: |
| Mantid::DataObjects::WeightedEventNoTime | Info about a single neutron detection event, including a weight and error value, but excluding the pulsetime to save memory: |
| Mantid::DataObjects::Workspace2D | Concrete workspace implementation |
| Mantid::DataObjects::WorkspaceSingleValue | Concrete workspace implementation |
| Mantid::DTriple< F, S, T > | Triple of three different things |
| Mantid::Geometry::Acomp | Holds a state point in the decision tree |
| Mantid::Geometry::Algebra | Computes Boolean algebra for simplification |
| Mantid::Geometry::BaseVisit | Adds the main |
| Mantid::Geometry::BitmapGeometryHandler | Handler for geometry objects that are rendered as bitmaps (e.g |
| Mantid::Geometry::BnId | Tri-state variable |
| Mantid::Geometry::BoolValue | Rule Status class |
| Mantid::Geometry::BoundingBox | A simple structure that defines an axis-aligned cuboid shaped bounding box for a geometrical object |
| Mantid::Geometry::CacheGeometryGenerator | Generates geometry using other geometry handlers or keeps the cache of the triangles |
| Mantid::Geometry::CacheGeometryHandler | Place holder for geometry triangulation and rendering with caching triangles |
| Mantid::Geometry::CacheGeometryRenderer | Rendering geometry using opengl from the geometry cache |
| Mantid::Geometry::CompareIMDDimension_const_sptr | |
| Mantid::Geometry::CompAssembly | Class for Assembly of geometric components |
| Mantid::Geometry::CompGrp | Compemented Grup |
| Mantid::Geometry::CompObj | Compemented Object |
| Mantid::Geometry::Component | Component is a wrapper for a Component which can modify some of its parameters, e.g |
| Mantid::Geometry::ComponentParser | This class implements the Poco SAX ContentHandler class for reading component XML |
| Mantid::Geometry::Cone | Holds a cone in vector form |
| Mantid::Geometry::ConventionalCell | Instances of this class represent information about a selected conventional cell based on a specified UB for a Niggli reduced cell |
| Mantid::Geometry::ConvexPolygon | An implementation of a convex polygon |
| Mantid::Geometry::Cylinder | Holds a cylinder as a vector form |
| Mantid::Geometry::Detector | This class represents a detector - i.e |
| Mantid::Geometry::DetectorGroup | Holds a collection of detectors |
| Mantid::Geometry::findID | Helper unary comparison type for finding IMDDimensions by a specified id |
| Mantid::Geometry::findIntegrated | Helper unary comparison type for finding non-integrated dimensions |
| Mantid::Geometry::FitParameter | Store information about a fitting parameter such as its value if it is constrained or tied |
| Mantid::Geometry::General | Holds a general quadratic surface |
| Mantid::Geometry::GeometryHandler | Place holder for geometry triangulation and rendering |
| Mantid::Geometry::GluGeometryHandler | Place holder for geometry triangulation and rendering with special cases of cube, sphere, cone and cylinder |
| Mantid::Geometry::GluGeometryRenderer | Rendering geometry using opengl utility library glu |
| Mantid::Geometry::Goniometer | Class to represent a particular goniometer setting, which is described by the rotation matrix |
| Mantid::Geometry::GoniometerAxis | Counter clockwise rotation |
| Mantid::Geometry::ICompAssembly | Class for Assembly of geometric components |
| Mantid::Geometry::IComponent | Base class for Geometric IComponent |
| Mantid::Geometry::IDetector | Interface class for detector objects |
| Mantid::Geometry::IMDDimension | The class discribes one dimension of multidimensional dataset representing an ortogonal dimension and linear axis |
| Mantid::Geometry::IMDDimensionFactory | |
| Mantid::Geometry::IndexingUtils | This class contains static utility methods for indexing peaks and finding the UB matrix |
| Mantid::Geometry::INearestNeighbours | Abstract Nearest neighbours class |
| Mantid::Geometry::INearestNeighboursFactory | INearestNeighboursFactory : Abstract class for creating INearestNeighbour products/objects |
| Mantid::Geometry::Instrument | Base Instrument Class |
| Mantid::Geometry::InstrumentDefinitionParser | Creates an instrument data from a XML instrument description file |
| Mantid::Geometry::InstrumentDefinitionParser::IdList | Structure for holding detector IDs |
| Mantid::Geometry::InstrumentDefinitionParser::SphVec | Stripped down vector that holds position in terms of spherical coordinates, Needed when processing instrument definition files that use the 'Ariel format' |
| Mantid::Geometry::InstrumentRayTracer | This class is responsible for tracking rays and accumulating a list of objects that are intersected along the way |
| Mantid::Geometry::Intersection | Combines two Rule objects in an intersection |
| Mantid::Geometry::IntersectionPoint | Stores a point of intersection along a track |
| Mantid::Geometry::IObjComponent | Object Component class, this class brings together the physical attributes of the component to the positioning and geometry tree |
| Mantid::Geometry::ISpectraDetectorMap | ISpectraDetectorMap provides an interface to define a mapping between spectrum number and detector ID(UDET) |
| Mantid::Geometry::Line | Impliments a line |
| Mantid::Geometry::LineIntersectVisit | Interset of Line with a surface |
| Mantid::Geometry::Link | For a leg of a track |
| Mantid::Geometry::Material | A material is defined as being composed of a given element, defined as a PhysicalConstants::NeutronAtom, with the following properties: |
| Mantid::Geometry::MDBoxImplicitFunction | General N-dimensional box implicit function: Defines a cuboid in N dimensions that is aligned with the axes of a MDEventWorkspace |
| Mantid::Geometry::MDDimensionExtents | Simple class that holds the extents (min/max) of a given dimension in a MD workspace or MDBox |
| Mantid::Geometry::MDGeometryBuilderXML< CheckDimensionPolicy > | |
| Mantid::Geometry::MDGeometryXMLDefinitions | This type contains definitions that will be found in the xml schema for the rebinning instructions, but must be used in code as part of the peristance/fetching routines |
| Mantid::Geometry::MDGeometryXMLParser | Handles the extraction of dimensions from a xml xml string to determine how mappings have been formed |
| Mantid::Geometry::MDHistoDimension | MDHistoDimension : |
| Mantid::Geometry::MDHistoDimensionBuilder | MDHistoDimensionBuilder : |
| Mantid::Geometry::MDImplicitFunction | An "ImplicitFunction" defining a hyper-cuboid-shaped region in N dimensions |
| Mantid::Geometry::MDPlane | A generalized description of a N-dimensional hyperplane |
| Mantid::Geometry::MDPlaneImplicitFunction | A general N-dimensional plane implicit function |
| Mantid::Geometry::NearestNeighbours | This class is used to find the nearest neighbours of a detector in the instrument geometry |
| Mantid::Geometry::NearestNeighboursFactory | NearestNeighboursFactory : Implementation of INearestNeighbours factory returning a NearestNeighbours object upon create |
| Mantid::Geometry::NoDeleting | Void deleter for shared pointers |
| Mantid::Geometry::NoDimensionPolicy | |
| Mantid::Geometry::NoIntersectionException | This header defines an implementation of the convex polygon intersection method by Michael Laszlo |
| Mantid::Geometry::ObjCompAssembly | Class for Assembly of geometric components |
| Mantid::Geometry::ObjComponent | Object Component class, this class brings together the physical attributes of the component to the positioning and geometry tree |
| Mantid::Geometry::Object | Global object for object |
| Mantid::Geometry::OCGeometryGenerator | Generates OpenCascade geometry from the ObjComponent |
| Mantid::Geometry::OCGeometryHandler | Place holder for OpenCascade library geometry triangulation and rendering |
| Mantid::Geometry::OCGeometryRenderer | Rendering geometry primitives of OpenCascade |
| Mantid::Geometry::OneToOneSpectraDetectorMap | OneToOneSpectraDetectorMap provides a simple 1:1 contiguous mapping between spectra and detectors |
| Mantid::Geometry::OrientedLattice | Class to implement UB matrix |
| Mantid::Geometry::Parameter | Base class for parameters of an instrument |
| Mantid::Geometry::ParameterFactory | Creates parameters for the instrument ParameterMap |
| Mantid::Geometry::ParameterFactory::FactoryMap | An inner class to specialise map such that it does a deep delete when s_map is destroyed |
| Mantid::Geometry::ParameterMap | ParameterMap class |
| Mantid::Geometry::ParameterType< Type > | Templated class for parameters of type Type |
| Mantid::Geometry::ParComponentFactory | A Factory for creating Parameterized component from their respective non-parameterized objects |
| Mantid::Geometry::Plane | Holds a simple Plane |
| Mantid::Geometry::PointGroup | A class containing the Point Groups for a crystal |
| Mantid::Geometry::PointGroupLaue1 | -1 (Triclinic) PointGroup |
| Mantid::Geometry::PointGroupLaue10 | 6/m (Hexagonal) PointGroup |
| Mantid::Geometry::PointGroupLaue11 | 6/mmm (Hexagonal) PointGroup |
| Mantid::Geometry::PointGroupLaue12 | M-3 (Cubic) PointGroup |
| Mantid::Geometry::PointGroupLaue13 | M-3m (Cubic) PointGroup |
| Mantid::Geometry::PointGroupLaue2 | 1 2/m 1 (Monoclinic, unique axis b) PointGroup |
| Mantid::Geometry::PointGroupLaue3 | 1 1 2/m (Monoclinic, unique axis c) PointGroup |
| Mantid::Geometry::PointGroupLaue4 | Mmm (Orthorombic) PointGroup |
| Mantid::Geometry::PointGroupLaue5 | 4/m (Tetragonal) PointGroup |
| Mantid::Geometry::PointGroupLaue6 | 4/mmm (Tetragonal) PointGroup |
| Mantid::Geometry::PointGroupLaue7 | -3 (Trigonal - Hexagonal) PointGroup |
| Mantid::Geometry::PointGroupLaue8 | -3m1 (Trigonal - Rhombohedral) PointGroup |
| Mantid::Geometry::PointGroupLaue9 | -31m (Trigonal - Rhombohedral) PointGroup |
| Mantid::Geometry::PolygonEdge | PolygonEdge Defines a directed edge between two points on a polygon |
| Mantid::Geometry::Quadratic | Holds a basic quadratic surface |
| Mantid::Geometry::Quadrilateral | Quadrilateral |
| Mantid::Geometry::RectangularDetector | RectangularDetector is a type of CompAssembly, an assembly of components |
| Mantid::Geometry::RectangularDetectorPixel | RectangularDetectorPixel: a sub-class of Detector that is one pixel inside a RectangularDetector |
| Mantid::Geometry::ReducedCell | Instances of this class represent information about reduced cell types including the transformation required to transform the reduced cell to a conventional cell |
| Mantid::Geometry::ReferenceFrame | ReferenceFrame : Holds reference frame information from the geometry description file |
| Mantid::Geometry::ReflectionCondition | A class containing the Reflection Condition for a crystal |
| Mantid::Geometry::ReflectionConditionAFaceCentred | A-face centred ReflectionCondition |
| Mantid::Geometry::ReflectionConditionAllFaceCentred | All-face centred ReflectionCondition |
| Mantid::Geometry::ReflectionConditionBFaceCentred | B-face centred ReflectionCondition |
| Mantid::Geometry::ReflectionConditionBodyCentred | Body centred ReflectionCondition |
| Mantid::Geometry::ReflectionConditionCFaceCentred | C-face centred ReflectionCondition |
| Mantid::Geometry::ReflectionConditionHexagonallyReverse | Hexagonally centred, reverse ReflectionCondition |
| Mantid::Geometry::ReflectionConditionPrimitive | Primitive ReflectionCondition |
| Mantid::Geometry::ReflectionConditionRhombohedrallyObverse | Rhombohedrally centred, obverse ReflectionCondition |
| Mantid::Geometry::ReflectionConditionRhombohedrallyReverse | Rhombohedrally centred, reverse ReflectionCondition |
| Mantid::Geometry::RotaryCounter | Simple multilevel-cyclic counter |
| Mantid::Geometry::Rule | Object generation rule tree |
| Mantid::Geometry::ScalarUtils | This class contains static utility methods for determining an orientation matrix corresponding to a conventional, given the orientation matrix corresponding to the Niggli reduced cell |
| Mantid::Geometry::ShapeFactory | Class originally intended to be used with the DataHandling 'LoadInstrument' algorithm |
| Mantid::Geometry::Sphere | Holds a Sphere as vector form |
| Mantid::Geometry::StrictDimensionPolicy | |
| Mantid::Geometry::Surface | Holds a basic quadratic surface |
| Mantid::Geometry::SurfaceFactory | Creates instances of Surfaces |
| Mantid::Geometry::SurfPoint | Surface leaf node |
| Mantid::Geometry::Torus | Holds a torus in vector form |
| Mantid::Geometry::Track | Defines a track as a start point and a direction |
| Mantid::Geometry::Union | Combines two Rule objects in an union |
| Mantid::Geometry::UnitCell | Class to implement unit cell of crystals |
| Mantid::Geometry::Vertex2D | Implements a vertex in two-dimensional space |
| Mantid::Geometry::Vertex2DIterator | A small iterator type structure |
| Mantid::Geometry::Vertex2DList | A Vertex2DList holds a unique list of Vertex2D objects and allows access via the vertex index |
| Mantid::Geometry::vtkGeometryCacheReader | Reads the Geometry Cache from the file to the Object |
| Mantid::Geometry::vtkGeometryCacheWriter | Writes the Geometry from Object to Cache |
| Mantid::Geometry::XMLlogfile | This class links parameters defined in ISIS log files to components of the instrument tree defined in the instrument definition |
| Mantid::ICat::CatalogDownloadDataFiles | CatalogDownloadDataFiles class is responsible for GetDataFile algorithms |
| Mantid::ICat::CatalogGetDataFiles | CatalogGetDataFiles is a class responsible for GetInvestigation algorithm |
| Mantid::ICat::CatalogGetDataSets | CatalogGetDataSets is a class responsible for GetDataSets algorithm |
| Mantid::ICat::CatalogListInstruments | CatalogListInstruments class is responsible for loading instruments list from ICat DB |
| Mantid::ICat::CatalogListInvestigationTypes | CatalogListInvestigationTypes class is responsible for loading investigation types from ICat server |
| Mantid::ICat::CatalogLogin | CatalogLogin class for logging into ICat DB .This class written as a Mantid algorithm |
| Mantid::ICat::CatalogLogout | This class is responsible for disconnecting from the ICat DB .This class written as a Mantid algorithm |
| Mantid::ICat::CatalogMyDataSearch | CatalogMyDataSearch is a class responsible for searching investigations of the logged in user |
| Mantid::ICat::CatalogSearch | CatalogSearch is a class responsible for SearchByRunNumber algorithm |
| Mantid::ICat::CatalogSearchParam | This class is used in ICat Search service to set all the inputs for search |
| Mantid::ICat::CErrorHandling | CErrorHandling class responsible for handling errors in Mantid-ICat Algorithms |
| Mantid::ICat::CICatHelper | CatalogSearchHelper is a utility class used in Mantid ICat3 based information catalog class to connect ICat API services using the gsoap generated proxy class and retrieve data from ICat services |
| Mantid::ICat::ICat3Catalog | This class is responsible for the implementation of ICat3 version based information catalogs |
| Mantid::ICat::SessionException | Class for Throwing Session exception in Catalog module |
| Mantid::ICat::SessionImpl | SessionImpl is a singleton class responsible for saving the session id |
| Mantid::Kernel::AbstractInstantiator< Base > | The base class for instantiators |
| Mantid::Kernel::ArrayBoundedValidator< TYPE > | ArrayBoundedValidator is a validator that requires all values in an array to be between upper or lower bounds, or both |
| Mantid::Kernel::ArrayLengthValidator< TYPE > | ArrayLenghtValidator : Validate length of an array property |
| Mantid::Kernel::ArrayProperty< T > | Support for a property that holds an array of values |
| Mantid::Kernel::BinaryFile< T > | The BinaryFile template is a helper function for loading simple binary files |
| Mantid::Kernel::BinFinder | Helper class that allows one to quickly find a bin index for many events |
| Mantid::Kernel::BoundedValidator< TYPE > | BoundedValidator is a validator that requires the values to be between upper or lower bounds, or both |
| Mantid::Kernel::Cache< KEYTYPE, VALUETYPE > | Cache is a generic caching storage class |
| Mantid::Kernel::CompositeValidator | A composite validator that can combine any 2+ arbitrary validators together |
| Mantid::Kernel::ConfigServiceImpl | The ConfigService class provides a simple facade to access the Configuration functionality of the Mantid Framework |
| Mantid::Kernel::ConfigServiceImpl::ConfigServiceNotification | This is the base class for POCO Notifications sent out from the Config Service |
| Mantid::Kernel::ConfigServiceImpl::ValueChanged | This is the class for the notification that is to be sent when a value has been changed in config service |
| Mantid::Kernel::ConfigServiceImpl::WrappedObject< T > | Inner templated class to wrap the poco library objects that have protected destructors and expose them as public |
| Mantid::Kernel::cow_ptr< DataType > | Implements a copy on write data template |
| Mantid::Kernel::CPUTimer | CPUTimer : Timer that uses the CPU time, rather than wall-clock time to measure execution time |
| Mantid::Kernel::CreateUsingNew< T > | Implementation of the SingletonHolder create policy using the new and delete operators |
| Mantid::Kernel::DataItem | This class forms the base class of any item that wishes to be stored in the analysis data service |
| Mantid::Kernel::DataService< T > | DataService is the base class for storing DataObjects |
| Mantid::Kernel::DataService< T >::AddNotification | AddNotification is sent after an new object is added to the data service |
| Mantid::Kernel::DataService< T >::AfterReplaceNotification | AfterReplaceNotification is sent after an object is replaced in the addOrReplace() function |
| Mantid::Kernel::DataService< T >::BeforeReplaceNotification | BeforeReplaceNotification is sent before an object is replaced in the addOrReplace() function |
| Mantid::Kernel::DataService< T >::ClearNotification | Clear notification is sent when the service is cleared |
| Mantid::Kernel::DataService< T >::DataServiceNotification | Base class for DataService notifications that also stores a pointer to the object |
| Mantid::Kernel::DataService< T >::NamedObjectNotification | Class for named object notifications |
| Mantid::Kernel::DataService< T >::PostDeleteNotification | PostDeleteNotification is sent after an object is deleted from the data service |
| Mantid::Kernel::DataService< T >::PreDeleteNotification | PreDeleteNotification is sent before an object is deleted from the data service |
| Mantid::Kernel::DataService< T >::RenameNotification | Rename notification is sent from Renameworkspaces algorithm after a workspace is renamed |
| Mantid::Kernel::DateAndTime | Class for holding the date and time in Mantid |
| Mantid::Kernel::DateValidator | DateValidator is a validator that validates date, format of valid date is "DD/MM/YYYY" At present, this validator is only available for properties of type std::string This class has written for validating start and end dates of ICat interface |
| Mantid::Kernel::Detail::IsEmpty< T > | Defines the concept of emptiness |
| Mantid::Kernel::Direction | Describes the direction (within an algorithm) of a Property. Used by WorkspaceProperty |
| Mantid::Kernel::DirectoryValidator | DirectoryValidator is a validator that checks that a directory path is valid |
| Mantid::Kernel::DiskBuffer | Buffer objects that need to be written out to disk so as to optimize writing operations |
| Mantid::Kernel::DllOpen | Simple class for opening shared libraries at run-time |
| Mantid::Kernel::DynamicFactory< Base > | The dynamic factory is a base dynamic factory for serving up objects in response to requests from other classes |
| Mantid::Kernel::DynamicFactory< Base >::DynamicFactoryNotification | Base class for dynamic factory notifications |
| Mantid::Kernel::DynamicFactory< Base >::UpdateNotification | A notification that the factory has been updated |
| Mantid::Kernel::EnabledWhenProperty | IPropertySettings for a property that sets it to enabled (in the GUI) when the value of another property is:
- its default (or not)
- equal to a string (or not)
|
| Mantid::Kernel::EnvironmentHistory | This class stores information about the Environment of the computer used by the framework |
| Mantid::Kernel::Exception::AbsObjMethod | Exception for a call to an abstract class function |
| Mantid::Kernel::Exception::ExistsError | Exception for when an item is already in a collection |
| Mantid::Kernel::Exception::FileError | Records the filename and the description of failure |
| Mantid::Kernel::Exception::IndexError | Exception for index errors |
| Mantid::Kernel::Exception::InstrumentDefinitionError | Exception for errors associated with the instrument definition |
| Mantid::Kernel::Exception::MisMatch< T > | Error when two numbers should be identical (or close) |
| Mantid::Kernel::Exception::NotFoundError | Exception for when an item is not found in a collection |
| Mantid::Kernel::Exception::NotImplementedError | Marks code as not implemented yet |
| Mantid::Kernel::Exception::NullPointerException | Exception thrown when an attempt is made to dereference a null pointer |
| Mantid::Kernel::Exception::OpenGLError | OpenGL Exception |
| Mantid::Kernel::FacilityInfo | A class that holds information about a facility |
| Mantid::Kernel::FileValidator | FileValidator is a validator that checks that a filepath is valid |
| Mantid::Kernel::FreeBlock | FreeBlock: a simple class that holds the position and size of block of free space in a file |
| Mantid::Kernel::FunctionTask | A FunctionTask can easily create a Task from a method pointer |
| Mantid::Kernel::Glob | This Glob class overrides the glob() method of Poco::Glob class to make it more reliable |
| Mantid::Kernel::Instantiator< C, Base > | The instantiator is a generic class for creating objects of the template type |
| Mantid::Kernel::InstrumentInfo | A class that holds information about an instrument |
| Mantid::Kernel::Interpolation | Provide interpolation over a series of points |
| Mantid::Kernel::IPropertyManager | Interface to PropertyManager |
| Mantid::Kernel::IPropertyManager::TypedValue | Utility class that enables the getProperty() method to effectively be templated on the return type |
| Mantid::Kernel::IPropertySettings | Interface for modifiers to Property's that specify if they should be enabled or visible in a GUI |
| Mantid::Kernel::ISaveable | An interface for objects that can be cached or saved to disk |
| Mantid::Kernel::IValidator | IValidator is the basic interface for all validators for properties |
| Mantid::Kernel::LibraryManagerImpl | Class for opening shared libraries |
| Mantid::Kernel::LibraryWrapper | Class for wrapping a shared library |
| Mantid::Kernel::ListAnyValidator< TYPE > | |
| Mantid::Kernel::ListAnyValidator< TYPE >::IF< U, Condition > | Templated function which substitutes different code as function of the initiated type |
| Mantid::Kernel::ListAnyValidator< TYPE >::IF< U, false > | |
| Mantid::Kernel::ListValidator< TYPE > | ListValidator is a validator that requires the value of a property to be one of a defined list of possibilities |
| Mantid::Kernel::LogFilter | This class is for filtering TimeSeriesProperty data |
| Mantid::Kernel::Logger | In charge of the publishing messages from the framework through various channels |
| Mantid::Kernel::LogParser | LogParser parses the instrument log files to select records corresponding to 'RUNNING' instrument status |
| Mantid::Kernel::MandatoryValidator< TYPE > | Validator to check that a property is not left empty |
| Mantid::Kernel::MantidVersion | Class containing static methods to return the Mantid version number and date |
| Mantid::Kernel::MaskedProperty< TYPE > | A property class for masking the properties |
| Mantid::Kernel::Matrix< T > | Numerical Matrix class |
| Mantid::Kernel::MatrixProperty< TYPE > | |
| Mantid::Kernel::MemoryStats | This class is responsible for memory statistics |
| Mantid::Kernel::MersenneTwister | This implements the the Mersenne Twister 19937 pseudo-random number generator algorithm as a specialzation of the PseudoRandomNumberGenerator interface |
| Mantid::Kernel::MRUList< T > | An MRU (most recently used) list keeps record of the last n inserted items, listing first the newer ones |
| Mantid::Kernel::MultiFileNameParsing::GenerateFileName | A functor that generates a vector of file names from the given vector of runs, and other state passed to it when constructed |
| Mantid::Kernel::MultiFileNameParsing::Parser | This class takes a string representing multiple files and parses it into a vector of vectors of file names |
| Mantid::Kernel::MultiFileNameParsing::RunRangeList | A class that holds a list of ranges of runs |
| Mantid::Kernel::MultiFileValidator | The MultiFileValidator validates a MultiFileProperty, which contains a *vector of vectors* of filenames - the meaning of which is discussed in MultiFileProperty.h |
| Mantid::Kernel::NDPseudoRandomNumberGenerator | Defines an ND pseudo-random number generator |
| Mantid::Kernel::NDRandomNumberGenerator | This class defines an interface for N dimensional random number generators |
| Mantid::Kernel::NexusTestHelper | A Helper class for easily writing nexus saving/loading tests |
| Mantid::Kernel::NullValidator | NullValidator is a validator that doesn't |
| Mantid::Kernel::ProgressBase | ProgressBase |
| Mantid::Kernel::ProgressText | ProgressText: |
| Mantid::Kernel::Property | Base class for properties |
| Mantid::Kernel::PropertyHistory | This class stores information about the parameters used by an algorithm |
| Mantid::Kernel::PropertyManager | Property manager helper class |
| Mantid::Kernel::PropertyManagerOwner | Implementation of IPropertyManager which allows sharing the same set of Properties between several instances |
| Mantid::Kernel::PropertyWithValue< TYPE > | The concrete, templated class for properties |
| Mantid::Kernel::PseudoRandomNumberGenerator | Defines a 1D pseudo-random number generator, i.e |
| Mantid::Kernel::QuasiRandomNumberSequence | Defines an interface to a quasi-random number sequence |
| Mantid::Kernel::Quat | Class for quaternions |
| Mantid::Kernel::ReadLock | Scoped, read-only lock for thread-safe access to DataItems |
| Mantid::Kernel::RebinParamsValidator | Validator to check the format of a vector providing the rebin parameters to an algorithm |
| Mantid::Kernel::RegistrationHelper | This class is simply used in the subscription of classes into the various factories in Mantid |
| Mantid::Kernel::SingletonHolder< T > | Class to manage an instance of an object as a singleton |
| Mantid::Kernel::SobolSequence | Defines a generator that produces quasi-random numbers according to a Sobol sequence http://en.wikipedia.org/wiki/Sobol_sequence |
| Mantid::Kernel::SplittingInterval | Class holding a start/end time and a destination for splitting event lists and logs |
| Mantid::Kernel::Statistics | |
| Mantid::Kernel::Task | A Task is a unit of work to be scheduled and run by a ThreadPool |
| Mantid::Kernel::ThreadPool | A Thread Pool implementation that keeps a certain number of threads running (normally, equal to the number of hardware cores available) and schedules tasks to them in the most efficient way possible |
| Mantid::Kernel::ThreadPoolRunnable | ThreadPoolRunnable : Class used by thread pool (and POCO) to run inside a thread |
| Mantid::Kernel::ThreadSafeLogIOS | The base class for ThreadSafeLogStream |
| Mantid::Kernel::ThreadSafeLogStream | The main log stream class implementing an ostream interface to a Logger |
| Mantid::Kernel::ThreadSafeLogStreamBuf | This class implements a threadsafe version of the POCO buffer interface to a Logger's stream object |
| Mantid::Kernel::ThreadScheduler | The ThreadScheduler object defines how tasks are allocated to threads and in what order |
| Mantid::Kernel::ThreadSchedulerFIFO | A First-In-First-Out Thread Scheduler |
| Mantid::Kernel::ThreadSchedulerLargestCost | A Largest Cost Thread Scheduler |
| Mantid::Kernel::ThreadSchedulerLIFO | A Last-In-First-Out Thread Scheduler |
| Mantid::Kernel::ThreadSchedulerMutexes | ThreadSchedulerMutexes : Version of a ThreadSchedulerLargestCost that also makes sure to not try to schedule two tasks with the same mutex at the same time |
| Mantid::Kernel::TimeInterval | Represents a time interval |
| Mantid::Kernel::Timer | A simple class that provides a wall-clock (not processor time) timer |
| Mantid::Kernel::TimeSeriesProperty< TYPE > | A specialised Property class for holding a series of time-value pairs |
| Mantid::Kernel::TimeSeriesPropertyStatistics | Struct holding some useful statistics for a TimeSeriesProperty |
| Mantid::Kernel::TimeValueUnit< TYPE > | Class to hold unit value (DateAndTime, T) |
| Mantid::Kernel::type_is_equal< T, U > | ListAnyValidator is a validator that requires the value of a property to be one of a defined list of possibilities |
| Mantid::Kernel::type_is_equal< T, T > | |
| Mantid::Kernel::TypedValidator< HeldType > | TypedValidator provides an layer on top of IValidator to ensure that the template TYPE is extract from the boost::any instance and passed down to the concrete validator instance |
| Mantid::Kernel::TypedValidator< boost::shared_ptr< ElementType > > | Specialization for boost::shared_ptr<T> types |
| Mantid::Kernel::Unit | The base units (abstract) class |
| Mantid::Kernel::UnitFactoryImpl | Creates instances of concrete units |
| Mantid::Kernel::Units::DeltaE | Energy transfer in milli-electronvolts |
| Mantid::Kernel::Units::DeltaE_inWavenumber | Energy transfer in units of wavenumber (cm^-1) |
| Mantid::Kernel::Units::dSpacing | D-Spacing in Angstrom |
| Mantid::Kernel::Units::Empty | Empty unit |
| Mantid::Kernel::Units::Energy | Energy in milli-electronvolts |
| Mantid::Kernel::Units::Energy_inWavenumber | Absolute energy in units of wavenumber (cm^-1) |
| Mantid::Kernel::Units::Label | Label unit |
| Mantid::Kernel::Units::Momentum | |
| Mantid::Kernel::Units::MomentumTransfer | Momentum Transfer in Angstrom^-1 |
| Mantid::Kernel::Units::QSquared | Momentum transfer squared in Angstrom^-2 |
| Mantid::Kernel::Units::TOF | Time of flight in microseconds |
| Mantid::Kernel::Units::Wavelength | Wavelength in Angstrom |
| Mantid::Kernel::UserStringParser | This class parses a given string into vector of vectors of numbers |
| Mantid::Kernel::V2D | Implements a 2-dimensional vector embedded in a 3D space, i.e |
| Mantid::Kernel::V3D | Class for 3D vectors |
| Mantid::Kernel::ValidatorAnyList< TYPE > | ValidatorAnyList is a validator that requires the value of a property to be one of a defined list of possibilities |
| Mantid::Kernel::VectorHelper::AddVariance< T > | Functor to deal with the increase in the error when adding (or substracting) a number of counts. More generally add errors in quadrature using the square of one of the errors (variance = error^2) |
| Mantid::Kernel::VectorHelper::DividesNonNull< T > | Divide functor with result reset to 0 if the denominator is null |
| Mantid::Kernel::VectorHelper::Log< T > | Log functor |
| Mantid::Kernel::VectorHelper::LogNoThrow< T > | |
| Mantid::Kernel::VectorHelper::SimpleAverage< T > | A binary functor to compute the simple average of 2 numbers |
| Mantid::Kernel::VectorHelper::Squares< T > | Square functor |
| Mantid::Kernel::VectorHelper::SumGaussError< T > | Functor used for computing the sum of the square values of a vector, using the accumulate algorithm |
| Mantid::Kernel::VectorHelper::SumSquares< T > | Functor to accumulate a sum of squares |
| Mantid::Kernel::VectorHelper::TimesSquares< T > | Functor giving the product of the squares of the arguments |
| Mantid::Kernel::VisibleWhenProperty | Same as EnabledWhenProperty, but returns the value for the isVisible() property intead of the isEnabled() property |
| Mantid::Kernel::VMDBase< TYPE > | Simple vector class for multiple dimensions (i.e |
| Mantid::Kernel::WriteLock | Scoped write-lock for thread-safe access to DataItems |
| Mantid::mathLevel::PolyBase | Holds a polynominal as a primary type |
| Mantid::MDAlgorithms::AndMD | AndMD : Perform the And boolean operation on two MDHistoWorkspaces |
| Mantid::MDAlgorithms::BinaryOperationMD | Abstract base class for binary operations on IMDWorkspaces, e.g |
| Mantid::MDAlgorithms::BooleanBinaryOperationMD | BooleanBinaryOperationMD : base class for boolean-type operations on MDHistoWorkspaces |
| Mantid::MDAlgorithms::CobaltSpinWaveDSHO | Foreground simulation using a Cobalt Spin Wave model with DSHO damping (601 in TF) Works out the cobalt acoustic and optic magnon dispersion relations given the momentum transfer in r.l.u |
| Mantid::MDAlgorithms::CompareMDWorkspaces | Compare two MDWorkspaces for equality |
| Mantid::MDAlgorithms::CompositeFunctionBuilder | This builder is for constructing composite functions |
| Mantid::MDAlgorithms::CompositeImplicitFunction | This class represents a composite implicit function used for communicating and implementing an operation against an MDWorkspace |
| Mantid::MDAlgorithms::CompositeImplicitFunctionParser | This class to parse composite type functions and generate the associated builders |
| Mantid::MDAlgorithms::ConvertToDetectorFaceMD | Convert a MatrixWorkspace containing to a MD workspace for viewing the detector face |
| Mantid::MDAlgorithms::ConvertToMD::ConvertToMDEventsParams | Structure, which provides helper variables and varions text parameters to the algorithm |
| Mantid::MDAlgorithms::ConvertToMDEvents | ConvertToMDEvents : Transfrom a workspace into MD workspace with components defined by user |
| Mantid::MDAlgorithms::ConvertToMDEventsSubalgFactory | The helper class for ConvertToMDEvents, which instantiates various subalgorithms, availible to convert a workspace into MDEvent workspace and accessed on request: It contains the map alg_id->subAlgorithm, where alg_id is provided by ConvertToMDEventsParams class |
| Mantid::MDAlgorithms::ConvertToMDEventsWS< WS, Q, MODE, CONV, Sample > | Templated interface to the workspace conversion algorithm. Every template parameter refers to different conversion possibilities |
| Mantid::MDAlgorithms::ConvertToMDEventsWS< ConvertToMD::EventWSType, Q, MODE, CONV, Sample > | The macrodefinitions for ConvertToMDEvents class, making the conversion from Events WS to the MD events WS |
| Mantid::MDAlgorithms::ConvertToMDEventsWS< ConvertToMD::Ws2DHistoType, Q, MODE, CONV, Sample > | |
| Mantid::MDAlgorithms::ConvToMDPreprocDetectors | Class to calculate/keep informaion about detector's positions, this information is used for doing various transformation of signals into reciprocal place and stored by this class for efficiency and additional convenience |
| Mantid::MDAlgorithms::CoordTransformer< Q, MODE, CONV, TYPE, Sample > | |
| Mantid::MDAlgorithms::CoordTransformer< ConvertToMD::ModQ, ConvertToMD::Elastic, CONV, TYPE, SAMPLE > | |
| Mantid::MDAlgorithms::CoordTransformer< ConvertToMD::ModQ, MODE, CONV, TYPE, SAMPLE > | Set of internal classes used by ConvertToMDEvents algorithm and responsible for conversion of input workspace data into from 1 to 4 output dimensions as function of input parameters |
| Mantid::MDAlgorithms::CoordTransformer< ConvertToMD::NoQ, MODE, CONV, TYPE, SAMPLE > | Set of internal classes used by ConvertToMDEvents algorithm and responsible for conversion of input workspace data into from 1 to 4 output dimensions as function of input parameters |
| Mantid::MDAlgorithms::CoordTransformer< ConvertToMD::Q3D, ConvertToMD::Elastic, CONV, TYPE, SAMPLE > | |
| Mantid::MDAlgorithms::CoordTransformer< ConvertToMD::Q3D, MODE, CONV, TYPE, SAMPLE > | Set of internal classes used by ConvertToMDEvents algorithm and responsible for conversion of input workspace data into from 1 to 4 output dimensions as function of input parameters |
| Mantid::MDAlgorithms::CreateMDFitWorkspace | NOTE: CURRENTLY DISABLED in CMakeLists.txt TODO: Refactor to use MDHistoWorkspace |
| Mantid::MDAlgorithms::DampedHisenbergFMSW | Damped Heisenberg ferromagnetic spin waves in simple cubic lattice ================================================================== Model has four flavours: (1) DSHO, uniform damping (TF model 111) (2) DSHO, Lovesey damping (3) Lorentzian, uniform damping (4) Lorentzian, Lovesey damping The attributes Type=DSHO|Lorentzian and Damping=Uniform|Lovesey will control this, initial just 111 |
| Mantid::MDAlgorithms::DivideMD | DivideMD : divide operation for MDWorkspaces |
| Mantid::MDAlgorithms::EqualToMD | EqualToMD : boolean operation on MDHistoWorkspaces |
| Mantid::MDAlgorithms::ExponentialMD | ExponentialMD : exponential function on MDHistoWorkspace |
| Mantid::MDAlgorithms::GreaterThanMD | GreaterThanMD : boolean operation on MDHistoWorkspaces |
| Mantid::MDAlgorithms::IConvertToMDEventsWS | Class describes the inteface to the methods, which perform conversion from usual workspaces to MDEventWorkspace |
| Mantid::MDAlgorithms::IDynamicRebinning | Class provides commont interface for various classes performing rebinning operations; |
| Mantid::MDAlgorithms::InputArgument | Local type to group min, max extents with a dimension index |
| Mantid::MDAlgorithms::InvalidParameter | Invalid parameter type |
| Mantid::MDAlgorithms::InvalidParameterParser | XML Parser for invalid parameter types |
| Mantid::MDAlgorithms::LessThanIndex | Comparitor to allow sorting by dimension index |
| Mantid::MDAlgorithms::LessThanMD | LessThanMD : boolean operation on MDHistoWorkspaces |
| Mantid::MDAlgorithms::LogarithmMD | LogarithmMD : natural logarithm of a MDHistoWorkspace |
| Mantid::MDAlgorithms::LOOP_ALGS< Q, AlgoNum > | Helper class to orginize metaloop instansiating various subalgorithms dealing with particular workspaces and implementing particular user requests |
| Mantid::MDAlgorithms::LOOP_ALGS< ConvertToMD::NoQ, 0 > | ANY_Mode (NoQ) metaloop terminator |
| Mantid::MDAlgorithms::LOOP_ALGS< NoQ, AlgoNum > | Templated metaloop specialization for noQ case |
| Mantid::MDAlgorithms::LOOP_ALGS< Q, 0 > | Q3d and ModQ metaloop terminator |
| Mantid::MDAlgorithms::MagneticFormFactor | Class to provide Magnetic form factor for Tobyfit |
| Mantid::MDAlgorithms::MaskMD | MaskMD : Mask an MDWorkspace |
| Mantid::MDAlgorithms::MergeMD | Merge several MDWorkspaces into one |
| Mantid::MDAlgorithms::MergeMDFiles | Algorithm to merge multiple MDEventWorkspaces from files that obey a common box format |
| Mantid::MDAlgorithms::MergeMDLoadToBoxTask< MDE, nd > | Task that loads all of the events from a particular block from a file that is being merged and then adds them to a particular box in the output workspace |
| Mantid::MDAlgorithms::MinusMD | MinusMD : minus operation for MDWorkspaces |
| Mantid::MDAlgorithms::MultiplyMD | MultiplyMD : multiplication operation for MDWorkspaces |
| Mantid::MDAlgorithms::NotMD | NotMD : boolean negation of a MDHistoWorkspace |
| Mantid::MDAlgorithms::NullImplicitFunction | This class represents a Null Implicit function |
| Mantid::MDAlgorithms::OrMD | OrMD : boolean operation on MDHistoWorkspaces |
| Mantid::MDAlgorithms::PlusMD | Sum two MDWorkspaces together |
| Mantid::MDAlgorithms::PowerMD | PowerMD : raise a MDHistoWorkspace to a power |
| Mantid::MDAlgorithms::QuadEnBackground | Provide Quadratic background in energy: Bg = c+eps*(l+eps*q) |
| Mantid::MDAlgorithms::RunParam | Container for run parameter data for Mantid TobyFit and the run dependent models that use these parameters |
| Mantid::MDAlgorithms::SaveZODS | Save a MDHistoWorkspace to a HDF5 format for use with the ZODS analysis software |
| Mantid::MDAlgorithms::SetMDUsingMask | Algorithm to set a MDHistoWorkspace in points determined by a mask boolean MDHistoWorkspace |
| Mantid::MDAlgorithms::SimulateMDD | SimulateMDD preforms a simulation of the data in the MDData workspace It inherits from the Algorithm class, and overrides the init() & exec() methods |
| Mantid::MDAlgorithms::SimulateResolution | Semi-abstract class for fitting with instrument resolution function |
| Mantid::MDAlgorithms::TobyFitSimulate | TobyFitSimulate performs a simulation of the data in the MDData workspace |
| Mantid::MDAlgorithms::TransformMD | Scale and/or offset the coordinates of a MDWorkspace |
| Mantid::MDAlgorithms::UnaryOperationMD | Abstract base class for unary operations (e.g |
| Mantid::MDAlgorithms::UnitsConverter< CONV, TYPE > | |
| Mantid::MDAlgorithms::UnitsConverter< ConvertToMD::ConvByTOF, TYPE > | |
| Mantid::MDAlgorithms::UnitsConverter< ConvertToMD::ConvFast, TYPE > | |
| Mantid::MDAlgorithms::UnitsConverter< ConvertToMD::ConvFromTOF, TYPE > | |
| Mantid::MDAlgorithms::Vector3DParameter< Derived, ElemType > | |
| Mantid::MDAlgorithms::Vector3DParameterParser< VectorValueParameterType > | XML parser for vector value (3 elements) parameter types |
| Mantid::MDAlgorithms::XorMD | XorMD : boolean operation on MDHistoWorkspaces |
| Mantid::MDEvents::AffineMatrixParameter | Type to wrap an affine matrix and allow serialization via xml |
| Mantid::MDEvents::AffineMatrixParameterParser | Parser for a parameter of type affinematrixparameter |
| Mantid::MDEvents::BinMD | Take a MDEventWorkspace and bin it to a dense histogram in a MDHistoWorkspace |
| Mantid::MDEvents::BinToMDHistoWorkspace | Deprecated -> BinMD |
| Mantid::MDEvents::BoxControllerSettingsAlgorithm | An abstract algorithm sub-class for algorithms that define properties for BoxController settings |
| Mantid::MDEvents::CentroidPeaksMD | Find the centroid of single-crystal peaks in a MDEventWorkspace, in order to refine their positions |
| Mantid::MDEvents::CloneMDWorkspace | Algorithm to clone a MDEventWorkspace to a new one |
| Mantid::MDEvents::ConvertToDiffractionMDWorkspace | ConvertToDiffractionMDWorkspace : Create a MDEventWorkspace with events in reciprocal space (Qx, Qy, Qz) from an input EventWorkspace |
| Mantid::MDEvents::ConvertToReflectometryQ | ConvertToReflectometryQ : Creates a 2D MD Histogram workspace with two axis qz and qx |
| Mantid::MDEvents::CoordCenterVectorParam | Unique CoordCenterVectorParam type declaration for ndimensional coordinate centers |
| Mantid::MDEvents::CoordTransformAffine | Generic class to transform from M input dimensions to N output dimensions |
| Mantid::MDEvents::CoordTransformAffineParser | A parser for processing coordinate transform xml |
| Mantid::MDEvents::CoordTransformAligned | A restricted version of CoordTransform which transforms from one set of dimensions to another, allowing: |
| Mantid::MDEvents::CoordTransformDistance | A non-linear coordinate transform that takes a point from nd dimensions and converts it to a single dimension: the SQUARE of the distance between the MDLeanEvent and a given point in up to nd dimensions |
| Mantid::MDEvents::CoordTransformDistanceParser | A parser for processing coordinate transform xml |
| Mantid::MDEvents::CreateMDWorkspace | CreateMDWorkspace : |
| Mantid::MDEvents::DimensionsToBinFromParam | Unique type declaration for which dimensions are used in the input workspace |
| Mantid::MDEvents::DimensionsUsedVectorParam | Unique DimensionsUsedVectorParam type declaration for boolean masks over dimensions |
| Mantid::MDEvents::FakeMDEventData | FakeMDEventData : Algorithm to create fake multi-dimensional event data that gets added to MDEventWorkspace, for use in testing |
| Mantid::MDEvents::FindPeaksMD | FindPeaksMD : TODO: DESCRIPTION |
| Mantid::MDEvents::IntegratePeaksMD | Integrate single-crystal peaks in reciprocal-space |
| Mantid::MDEvents::LoadMD | Load a .nxs file into a MDEventWorkspace |
| Mantid::MDEvents::LoadSQW | LoadSQW : Load an SQW file and read observations in as events to generate a IMDEventWorkspace, with events in reciprocal space (Qx, Qy, Qz) |
| Mantid::MDEvents::LoadSQW::data_positions | |
| Mantid::MDEvents::LOOP< i > | |
| Mantid::MDEvents::LOOP< 0 > | |
| Mantid::MDEvents::MDBin< MDE, nd > | MDBin : Class describing a single bin in a dense, Multidimensional histogram |
| Mantid::MDEvents::MDBox< MDE, nd > | Templated class for a multi-dimensional event "box" |
| Mantid::MDEvents::MDBoxBase< MDE, nd > | Templated super-class of a multi-dimensional event "box" |
| Mantid::MDEvents::MDBoxIterator< MDE, nd > | MDBoxIterator: iterate through MDBoxBase hierarchy down to a given maximum depth |
| Mantid::MDEvents::MDDimensionExtents | Simple class that holds the extents (min/max) of a given dimension in a MD workspace or MDBox |
| Mantid::MDEvents::MDDimensionStats | A simple class holding some statistics on the distribution of events in a particular dimension |
| Mantid::MDEvents::MDEvent< nd > | Templated class holding data about a neutron detection event in N-dimensions (for example, Qx, Qy, Qz, E) |
| Mantid::MDEvents::MDEventFactory | MDEventFactory : collection of methods to create MDLeanEvent* instances, by specifying the number of dimensions as a parameter |
| Mantid::MDEvents::MDEventWorkspace< MDE, nd > | Templated class for the multi-dimensional event workspace |
| Mantid::MDEvents::MDEventWSWrapper | |
| Mantid::MDEvents::MDGridBox< MDE, nd > | Templated class for a GRIDDED multi-dimensional event "box" |
| Mantid::MDEvents::MDGridBox< MDE, nd >::AddEventsTask | Task for adding events to a MDGridBox |
| Mantid::MDEvents::MDHistoWorkspace | MDHistoWorkspace: |
| Mantid::MDEvents::MDHistoWorkspaceIterator | An implementation of IMDIterator that iterates through a MDHistoWorkspace |
| Mantid::MDEvents::MDLeanEvent< nd > | Templated class holding data about a neutron detection event in N-dimensions (for example, Qx, Qy, Qz, E) |
| Mantid::MDEvents::MDSplitBox< MDE, nd > | Similar to MDGridBox, this class is a split version of a MDBox where a single left/right split occurs along a single dimension, at a variable point |
| Mantid::MDEvents::MDWSDescription | Helper class describes the properties of target MD workspace, which should be obtained as the result of conversion algorithm |
| Mantid::MDEvents::MDWSTransfDescr | |
| Mantid::MDEvents::OneStepMDEW | OneStepMDEW : TODO: DESCRIPTION |
| Mantid::MDEvents::OriginOffsetParam | Unique type declaration for the offset of coordinates |
| Mantid::MDEvents::QueryMDWorkspace | QueryMDWorkspace : Query an MDWorkspace in order to extract overview information as a table workspace |
| Mantid::MDEvents::SaveMD | Save a MDEventWorkspace to a .nxs file |
| Mantid::MDEvents::ScalingParam | Unique type declaration for the step size in transformation |
| Mantid::MDEvents::SkipMaskedBins | Policy that indicates skipping of masked bins |
| Mantid::MDEvents::SkipNothing | Policy that indicates no skipping should be applied |
| Mantid::MDEvents::SkippingPolicy | SkippingPolicy : Policy types for skipping in MDiterators |
| Mantid::MDEvents::SliceMD | Algorithm that can take a slice out of an original MDEventWorkspace while preserving all the events contained wherein |
| Mantid::MDEvents::SlicingAlgorithm | Abstract Algorithm class that will be used by: BinMD and SliceMD and shares code for getting a slice from one workspace to another |
| Mantid::NeXus::NexusFileIO | Utility method for saving NeXus format of Mantid Workspace This class interfaces to the C Nexus API |
| Mantid::NeXus::NXAttributes | Nexus attributes |
| Mantid::NeXus::NXBinary | Implements NXnote Nexus class with binary data |
| Mantid::NeXus::NXClass | The base class for a Nexus class (group) |
| Mantid::NeXus::NXClassInfo | Information about a Nexus class |
| Mantid::NeXus::NXData | Implements NXdata Nexus class |
| Mantid::NeXus::NXDataSet | Abstract base class for a Nexus data set |
| Mantid::NeXus::NXDataSetTyped< T > | Templated class implementation of NXDataSet |
| Mantid::NeXus::NXDetector | Implements NXdetector Nexus class |
| Mantid::NeXus::NXEntry | Implements NXentry Nexus class |
| Mantid::NeXus::NXInfo | C++ implementation of NeXus classes |
| Mantid::NeXus::NXInstrument | Implements NXinstrument Nexus class |
| Mantid::NeXus::NXLog | Implements NXlog Nexus class |
| Mantid::NeXus::NXMainClass | Main class is the one that can contain auxiliary classes |
| Mantid::NeXus::NXNote | Implements NXnote Nexus class |
| Mantid::NeXus::NXObject | The base abstract class for NeXus classes and data sets |
| Mantid::NeXus::NXRoot | Implements NXroot Nexus class |
| Mantid::NoDeleting | An object for constructing a shared_ptr that won't ever delete its pointee |
| Mantid::PhysicalConstants::Atom | Struture to hold the common information for an atom |
| Mantid::PhysicalConstants::MagneticIon | Struture to hold information about magnetic form factor for 3d, 4d, rare earth, and actinide atoms and ions |
| Mantid::PhysicalConstants::NeutronAtom | Structure to store neutronic scattering information for the various elements |
| Mantid::PythonAPI::ConfigServiceWrapper | A wrapper for the ConfigService Singleton |
| Mantid::PythonAPI::DefaultReturn< ResultType > | A structure t handle default returns for template functions |
| Mantid::PythonAPI::DefaultReturn< bool > | |
| Mantid::PythonAPI::DefaultReturn< const bool > | |
| Mantid::PythonAPI::DefaultReturn< const int > | |
| Mantid::PythonAPI::DefaultReturn< const std::string > | |
| Mantid::PythonAPI::DefaultReturn< int > | |
| Mantid::PythonAPI::DefaultReturn< std::string > | |
| Mantid::PythonAPI::FrameworkManagerProxy | FrameworkManager is a wrapper for the API::FrameworkManager class in Mantid |
| Mantid::PythonAPI::FrameworkManagerProxy::PropertyOrdering | Functor for use with std::sort to put the properties that do not have valid values first |
| Mantid::PythonAPI::GlobalInterpreterLock | Defines a structure for acquiring/releasing the Python GIL using the RAII pattern |
| Mantid::PythonAPI::MantidVecHelper | Wrappings for a MantidVec |
| Mantid::PythonAPI::MatrixWorkspaceWrapper | Various structures to aid with Python's interaction with Mantid workspaces |
| Mantid::PythonAPI::OrientedLatticeWrapper | |
| Mantid::PythonAPI::PyAlgorithmBase | A wrapper around API::CloneableAlgorithm that allows inheritance from Python |
| Mantid::PythonAPI::PyAlgorithmWrapper | A callback structure that can route calls into Python |
| Mantid::PythonAPI::PyCall_NoArg< ResultType > | Perform a call to a python function that takes no arguments and returns a value |
| Mantid::PythonAPI::PyCall_NoArg< void > | Specialization for void return type |
| Mantid::PythonAPI::PyCall_OneArg< ResultType, ArgType > | Perform a call to a python function that takes a single argument and returns a value |
| Mantid::PythonAPI::PyCall_OneArg< void, ArgType > | Specialization for void return type |
| Mantid::PythonAPI::PythonObjectInstantiator< Base > | |
| Mantid::PythonAPI::PythonThreadState | Defines a structure for creating and destroying a Python thread state using the RAII pattern |
| Mantid::PythonAPI::UnitCellWrapper | |
| Mantid::PythonAPI::WorkspaceFactoryProxy | A proxy struct for the WorkspaceFactory |
| Mantid::PythonInterface::AlgorithmWrapper | Provides a wrapper class for boost::python to allow virtual functions to be overridden in Python |
| Mantid::PythonInterface::Converters::Clone | Clone is a policy for VectorToNDArray to wrap the vector in a read-write numpy array that looks at the original data |
| Mantid::PythonInterface::Converters::Clone::apply< ContainerType > | |
| Mantid::PythonInterface::Converters::MatrixToNDArray< ElementType, ConversionPolicy > | Converter that takes a Mantid Matrix and converts it into a numpy array |
| Mantid::PythonInterface::Converters::NDArrayToVector< DestElementType > | Converts a Python sequence type to a C++ std::vector, where the vector element type is defined by the template type |
| Mantid::PythonInterface::Converters::NDArrayTypeIndex< T > | Defines a mapping between C++ type given by the template parameter and numpy type enum NPY_TYPES |
| Mantid::PythonInterface::Converters::PyObjectToMatrix | Takes a Python object and if it supports indexing and is two dimensional it attempts to convert it to a Kernel::Matrix object |
| Mantid::PythonInterface::Converters::PyObjectToV3D | Takes a Python object and if it supports indexing and is of length 3 then it will attempt to convert a Kernel::V3D object from it |
| Mantid::PythonInterface::Converters::PySequenceToVector< DestElementType > | Converts a Python sequence type to a C++ std::vector, where the element type is defined by the template type |
| Mantid::PythonInterface::Converters::VectorToNDArray< ElementType, ConversionPolicy > | Converter that takes a std::vector and converts it into a numpy array |
| Mantid::PythonInterface::Converters::WrapReadOnly | WrapReadOnly is a policy for VectorToNDArray to wrap the vector in a read-only numpy array that looks at the original data |
| Mantid::PythonInterface::Converters::WrapReadOnly::apply< ContainerType > | |
| Mantid::PythonInterface::Converters::WrapReadWrite | WrapReadWrite is a policy for VectorToNDArray to wrap the vector in a read-write numpy array that looks at the original data |
| Mantid::PythonInterface::Converters::WrapReadWrite::apply< ContainerType > | |
| Mantid::PythonInterface::Environment::CallMethod_NoArg< ResultType > | Perform a call to a python function that takes no arguments and returns a value |
| Mantid::PythonInterface::Environment::CallMethod_NoArg< void > | Specialization for void return type |
| Mantid::PythonInterface::Environment::GlobalInterpreterLock | Defines a structure for acquiring/releasing the Python GIL using the RAII pattern |
| Mantid::PythonInterface::Environment::PythonThreadState | Defines a structure for creating and destroying a Python thread state using the RAII pattern |
| Mantid::PythonInterface::Environment::UndefinedAttributeError | Defines an exception for an undefined attribute |
| Mantid::PythonInterface::Policies::MatrixToNumpy< ConversionPolicy > | Implements a return value policy that returns a numpy array from a Matrix |
| Mantid::PythonInterface::Policies::MatrixToNumpy< ConversionPolicy >::apply< T > | |
| Mantid::PythonInterface::Policies::upcast_returned_value | Implements the upcast_shared_ptr return_value_policy |
| Mantid::PythonInterface::Policies::upcast_returned_value::apply< T > | |
| Mantid::PythonInterface::Policies::VectorToNumpy< ConversionPolicy > | Implements a return value policy that returns a numpy array from a std::vector |
| Mantid::PythonInterface::Policies::VectorToNumpy< ConversionPolicy >::apply< T > | |
| Mantid::PythonInterface::PropertyWithValueFactory | Defines a static factory class that creates PropertyWithValue instances from python objects |
| Mantid::PythonInterface::PythonAlgorithm | Provides a class that forms an interface between a Python algorithm and a C++ algorithm |
| Mantid::PythonInterface::PythonObjectInstantiator< Base > | |
| Mantid::PythonInterface::Registry::PropertyValueHandler | This class provides a base-class objects that are able to take a python object and set it on an algorithm property |
| Mantid::PythonInterface::Registry::SequenceTypeHandler< ContainerType > | A specialisation of PropertyValueHander to handle coercing a Python value into a C++ sequence/array property |
| Mantid::PythonInterface::Registry::SingleValueTypeHandler< PropertyType > | Templated struct to handle property types whose values are a single item .e.g |
| Mantid::PythonInterface::Registry::TypedPropertyValueHandler< ValueType > | This class provides a templated class object that is able to take a python object and perform operations with a given C type |
| Mantid::PythonInterface::std_set_exporter< ElementType > | Std::set wrapper |
| Mantid::PythonInterface::std_vector_exporter< ElementType > | A struct to help export std::vector types |
| Mantid::PythonInterface::WorkspacePropertyExporter< WorkspaceType > | A helper struct to export WorkspaceProperty<> types to Python |
| Mantid::TestChannel | |
| Mantid::Triple< T > | Triple of three identical types |
| Mantid::VATES::ADSWorkspaceProvider< Workspace_Type > | Type for fetching and disposing of workspaces using the Mantid Analysis Data Service Instance under-the-hood |
| Mantid::VATES::Clipper | Abstract clipper type |
| Mantid::VATES::DimensionPresenter | MVP presenter for a IMDDimension model |
| Mantid::VATES::DimensionView | Class DimensionView Abstract Dimension View |
| Mantid::VATES::DimensionViewFactory | Class Abstract DimensionViewFactory provides Factory Method |
| Mantid::VATES::EscalatingRebinningActionManager | |
| Mantid::VATES::EventNexusLoadingPresenter | Presenter for loading conversion of MDEW workspaces into render-able vtk objects |
| Mantid::VATES::FieldDataToMetadata | Functor Converts fielddata of type vtkFieldData to metadata (std::string) |
| Mantid::VATES::FilterUpdateProgressAction< Filter > | Template argument is the exact filter/source/reader providing the public UpdateAlgorithmProgress method |
| Mantid::VATES::FindId | Comparitor to find DimensionPresenter shared pointers via a dimension id |
| Mantid::VATES::FindIntegrated | Comparitor to find integrated dimensions |
| Mantid::VATES::FindModelId | Comparitor to find IMDDimension shared pointers via a dimension id |
| Mantid::VATES::GeometryPresenter | Abstract type for MVP style presenter for a Multi-dimensional workspace geometry |
| Mantid::VATES::GeometryView | Abstract view for controlling multi-dimensional geometries |
| Mantid::VATES::IgnoreZerosThresholdRange | |
| Mantid::VATES::IMDDimensionComparitor | Dimension comparitor specifically for use with visualisation layer |
| Mantid::VATES::MDEWEventNexusLoadingPresenter | For loading conversion of MDEW workspaces into render-able vtk objects |
| Mantid::VATES::MDEWInMemoryLoadingPresenter | Presenter for loading MDEWs directly from the ADS, does not touch the disk |
| Mantid::VATES::MDEWLoadingPresenter | Abstract presenter encapsulating common operations used by all MDEW type loading |
| Mantid::VATES::MDEWRebinningPresenter | Concrete MDRebinningPresenter using centre piece rebinning directly on MDEWs producing Histogrammed MDWs |
| Mantid::VATES::MDHWInMemoryLoadingPresenter | Presenter for loading MDHWs directly from the ADS, does not touch the disk |
| Mantid::VATES::MDHWLoadingPresenter | Abstract presenter encapsulating common operations used by all MDHW type loading |
| Mantid::VATES::MDLoadingPresenter | Abstract presenters for loading conversion of MDEW workspaces into render-able vtk objects |
| Mantid::VATES::MDLoadingView | Abstract view for MDEW file loading and display |
| Mantid::VATES::MDLoadingViewAdapter< ViewType > | Templated type for wrapping non-MDLoadingView types |
| Mantid::VATES::MDRebinningPresenter | Abstract presenters for multi-dimensional rebinning of various types |
| Mantid::VATES::MDRebinningView | Abstract view for controlling multi-dimensional rebinning |
| Mantid::VATES::MDRebinningViewAdapter< ViewType > | Adapter for non-MDRebinningView types that need to be used as MDRebinningViews |
| Mantid::VATES::MedianAndBelowThresholdRange | |
| Mantid::VATES::MetadataToFieldData | Functor converts metadata (in std::string) to vtkFieldData |
| Mantid::VATES::NoThresholdRange | |
| Mantid::VATES::NullRebinningPresenter | |
| Mantid::VATES::ProgressAction | Abstract update event type |
| Mantid::VATES::RebinningActionManager | |
| Mantid::VATES::RebinningKnowledgeSerializer | This type assists with the generation of well-formed xml meeting the xsd scehema layed-out for Rebinning/cutting type operations |
| Mantid::Vates::SimpleGui::AxisInformation | This class provides a container for a given data axis information |
| Mantid::Vates::SimpleGui::AxisInteractor | This class provides a mechanism for setting slices onto a dataset that are associated with an individual dataset axis |
| Mantid::Vates::SimpleGui::ColorSelectionWidget | This class controls the color scale for the main level program viewed datasets |
| Mantid::Vates::SimpleGui::ColorUpdater | This class handles the application of requests from the ColorSelectionWidget |
| Mantid::Vates::SimpleGui::GeometryParser | This class takes the associated XML information from a given dataset and interrogates it for the current dataset axis information |
| Mantid::Vates::SimpleGui::Indicator | |
| Mantid::Vates::SimpleGui::MdViewerWidget | This class represents the central widget for handling VATES visualization operations for 3D and 4D datasets |
| Mantid::Vates::SimpleGui::ModeControlWidget | This class controls the current view for the main level program |
| Mantid::Vates::SimpleGui::MultiSliceView | This class creates a multislice view which is based on the Matlab(C) SliceOMatic view |
| Mantid::Vates::SimpleGui::RotationPointDialog | This class handles providing the coordinates for a center of rotation |
| Mantid::Vates::SimpleGui::ScalePicker | This class handles finding the axis location when a slice indicator is created |
| Mantid::Vates::SimpleGui::SplatterPlotView | This class creates a scatter plot using the SplatterPlot ParaView plugin |
| Mantid::Vates::SimpleGui::StandardView | This class represents the initial view for the main program |
| Mantid::Vates::SimpleGui::ThreeSliceView | This class creates four views of the given dataset |
| Mantid::Vates::SimpleGui::TimeControlWidget | This class wraps the ParaView time control toolbars into a widget |
| Mantid::Vates::SimpleGui::ViewBase | This class is an abstract base class for all of the Vates simple GUI's views |
| Mantid::VATES::SQWLoadingPresenter | MVP loading presenter for |
| Mantid::VATES::SynchronisingGeometryPresenter | Concrete type for MVP style presenter for a Multi-dimensional workspace geometry |
| Mantid::VATES::ThresholdRange | |
| Mantid::VATES::TimeStepToTimeStep | |
| Mantid::VATES::TimeToTimeStep | |
| Mantid::VATES::UnstructuredPoint | |
| Mantid::VATES::UserDefinedThresholdRange | |
| Mantid::VATES::vtkDataSetFactory | Abstract type to generate a vtk dataset on demand from a MDWorkspace |
| Mantid::VATES::vtkDataSetToGeometry | Handles the extraction of dimensions from a vtkDataSet by getting at the field data and then processing the xml contained within to determine how mappings have been formed |
| Mantid::VATES::vtkDataSetToImplicitFunction | Handles the extraction of existing implcitfunctions from a vtkDataSet by getting at the field data and then processing the xml contained within |
| Mantid::VATES::vtkDataSetToWsLocation | |
| Mantid::VATES::vtkDataSetToWsName | |
| Mantid::VATES::vtkMDHexFactory | Class is used to generate vtkUnstructuredGrids from IMDEventWorkspaces |
| Mantid::VATES::vtkMDHistoHex4DFactory< TimeMapper > | |
| Mantid::VATES::vtkMDHistoHexFactory | |
| Mantid::VATES::vtkMDHistoLineFactory | Line Factory |
| Mantid::VATES::vtkMDHistoQuadFactory | Quad Factory |
| Mantid::VATES::vtkMDLineFactory | Factory for creating a vtkDataSet from an IMDEventWorkspace with a single non-integrated dimensions |
| Mantid::VATES::vtkMDQuadFactory | Factory for creating a vtkDataSet from an IMDEventWorkspace with two non-integrated dimensions |
| Mantid::VATES::vtkPeakMarkerFactory | |
| Mantid::VATES::vtkSplatterPlotFactory | Factory that creates a simple "splatter plot" data set composed of points of a selection of the events in a MDEventWorkspace |
| Mantid::VATES::WorkspaceProvider | Abstract type for fetching and disposing of workspaces |
| Mantid::VATES::XMLDefinitions | This type contains definitions that will be found in the xml schema for the rebinning instructions, but must be used in code as part of the peristance/fetching routines |
| Mantid::WorkflowAlgorithms::ComputeSensitivity | |
| Mantid::WorkflowAlgorithms::EQSANSDarkCurrentSubtraction | Subtract dark current for EQSANS |
| Mantid::WorkflowAlgorithms::EQSANSLoad | Subtract dark current for EQSANS |
| Mantid::WorkflowAlgorithms::EQSANSPatchSensitivity | Apply the sensitivity correction as a function of wavelength for EQSANS |
| Mantid::WorkflowAlgorithms::EQSANSQ2D | Workflow algorithm to process a reduced EQSANS workspace and produce I(Qx,Qy) |
| Mantid::WorkflowAlgorithms::HFIRDarkCurrentSubtraction | Subtract dark current for HFIR SANS |
| Mantid::WorkflowAlgorithms::HFIRLoad | Subtract dark current for HFIR SANS |
| Mantid::WorkflowAlgorithms::RefReduction | Data reduction for reflectometry |
| Mantid::WorkflowAlgorithms::RefRoi | Workflow algorithm for reflectometry to sum up a region of interest on a 2D detector |
| Mantid::WorkflowAlgorithms::SANSBeamFinder | Beam Finder for SANS instruments |
| Mantid::WorkflowAlgorithms::SANSSensitivityCorrection | Sensitivity correction for SANS |
| Mantid::WorkflowAlgorithms::SANSSolidAngleCorrection | Performs a solid angle correction on a 2D SANS data set to correct for the absence of curvature of the detector |
| Mantid::WorkflowAlgorithms::SetupEQSANSReduction | Set up the reduction options for EQSANS reduction |
| Mantid::WorkflowAlgorithms::SetupHFIRReduction | Set up the reduction options for HFIR reduction |
| MantidAbout | This class implements About MantidPlot dialog for mnatid help menu |
| MantidApplication | |
| MantidColorMap | The class inherits from QwtColorMap and implements reading a color color map from a file |
| MantidCurve | Base class for MantidCurve types |
| MantidDockWidget | |
| MantidGLWidget | OpenGL Qt Widget which renders Mantid Geometry ObjComponents |
| MantidLog | |
| MantidMatrix | MantidMatrix is the class that represents a Qtiplot window for displaying workspaces |
| MantidMatrixCurve | This class is for plotting spectra or bins from a Mantid MatrixWorkspace in a QtiPlot's Graph widget |
| MantidMatrixDialog | Matrix properties dialog |
| MantidMatrixFunction | This class helps displaying a MantidMatrix in a 2D graph |
| MantidMatrixModel | MantidMatrixModel is an implementation of QAbstractTableModel which is an interface between the data (workspace) and the widget displaying it (QTableView) |
| MantidMDCurve | This class is for plotting IMDWorkspaces |
| MantidMDCurveDialog | Dialog asking the user for some options on how to plot a MDWorkspace before plotting |
| MantidPreferences | Keeps the preferences for some Mantid-related UI settings |
| MantidQt::API::AbstractAlgorithmInputHistory | This abstract class deals with the loading and saving of previous algorithm property values to/from MantidPlot's QSettings |
| MantidQt::API::AlgorithmDialog | This class should be the basis for all customised algorithm dialogs |
| MantidQt::API::AlgorithmDialogFactoryImpl | The AlgorithmDialogFactory is responsible for creating concrete instances of AlgorithmDialog classes |
| MantidQt::API::AlgorithmInputHistoryImpl | |
| MantidQt::API::AlgorithmPropertiesWidget | Widget that contains dynamically generated PropertyWidget's for each property of an algorithm, contained in a scroll area |
| MantidQt::API::AlgorithmRunner | The AlgorithmRunner is a QObject that encapsulates methods for running an algorithm asynchronously (in the background) and feeds-back to a GUI widget |
| MantidQt::API::BoolPropertyWidget | Set of widgets representing a PropertyWithValue<bool> |
| MantidQt::API::FileDialogHandler | Contains modifications to Qt functions where problems have been found on certain operating systems |
| MantidQt::API::FilePropertyWidget | Widget for FileProperty, which has a "Browse" button |
| MantidQt::API::GenericDialog | This class gives a basic dialog that is not tailored to a particular algorithm |
| MantidQt::API::InterfaceManagerImpl | This class is responsible for creating the correct dialog for an algorithm |
| MantidQt::API::ManageUserDirectories | |
| MantidQt::API::MantidDialog | Dialog derived from this class can capture and handle exceptions raised in its event handlers |
| MantidQt::API::MantidWidget | This is the base class all customised widgets that do not wish to be tied to a specific Mantid algorithm but rather customised for user's requirements |
| MantidQt::API::ObserverCallback | A simple callback class so that we avoid multiple inheritance issues with QObject |
| MantidQt::API::OptionsPropertyWidget | Widget for displaying a Property that has a set of allowed values |
| MantidQt::API::PropertyWidget | Base class for widgets that will set Mantid::Kernel::Property* types |
| MantidQt::API::PropertyWidgetFactory | PropertyWidgetFactory : TODO: DESCRIPTION |
| MantidQt::API::PythonRunner | This is the base class all customised user interfaces that do not wish to be tied to a specific Mantid algorithm but rather customised for user's requirements |
| MantidQt::API::SyncedCheckboxes | QObject that links: |
| MantidQt::API::TextPropertyWidget | The most generic widgets for Property's that are only a simple string |
| MantidQt::API::UserSubWindow | This is the base class all customised user interfaces that do not wish to be tied to a specific Mantid algorithm but rather customised for user's requirements |
| MantidQt::API::UserSubWindowFactoryImpl | The UserSubWindowFactory is responsible for creating concrete instances of user interface classes |
| MantidQt::API::VatesViewerInterface | This class is an interface for the central widget for handling VATES visualization operations |
| MantidQt::API::WorkspaceObserver | Observes AnalysisDataService notifications: add,replace,delete |
| MantidQt::CustomDialogs::BaseInstantiator | Base instantiator to store in a map |
| MantidQt::CustomDialogs::BinaryTreeWidget | A widget to implement a binary tree display |
| MantidQt::CustomDialogs::BinaryTreeWidgetItem | A custom item to use in the BinaryTree widget |
| MantidQt::CustomDialogs::BinMDDialog | |
| MantidQt::CustomDialogs::ComboBoxDelegate | A custom delegate class used for item editing |
| MantidQt::CustomDialogs::ConeDetails | A widget to define a cone |
| MantidQt::CustomDialogs::ConvertTableToMatrixWorkspaceDialog | This class gives specialised dialog for the ConvertTableToMatrixWorkspace algorithm |
| MantidQt::CustomDialogs::CreateSampleShapeDialog | This class gives specialised dialog for the sample shape definition algorithm |
| MantidQt::CustomDialogs::CuboidDetails | A widget to define an infinite plane |
| MantidQt::CustomDialogs::CylinderDetails | A widget to define a cylinder |
| MantidQt::CustomDialogs::DynamicPropertiesWidget | Base class for input workspace's dynamic properties widget |
| MantidQt::CustomDialogs::FitDialog | This class gives specialised dialog for the Load algorithm |
| MantidQt::CustomDialogs::HexahedronDetails | A widget to define a hexahedron |
| MantidQt::CustomDialogs::InfiniteConeDetails | A widget to define an infinite cone |
| MantidQt::CustomDialogs::InfiniteCylinderDetails | A widget to define an infinite cylinder |
| MantidQt::CustomDialogs::InfinitePlaneDetails | A widget to define an infinite plane |
| MantidQt::CustomDialogs::InputWorkspaceWidget | Widget for inputting workspace information |
| MantidQt::CustomDialogs::LoadAsciiDialog | This class gives specialised dialog for the LoadAscii algorithm |
| MantidQt::CustomDialogs::LoadDAEDialog | This class gives specialised dialog for the LoadDAE algorithm |
| MantidQt::CustomDialogs::LoadDialog | This class gives specialised dialog for the Load algorithm |
| MantidQt::CustomDialogs::LoadRawDialog | This class gives specialised dialog for the LoadRaw algorithm |
| MantidQt::CustomDialogs::LOQScriptInputDialog | This class gives specialised dialog for the LOQ input algorithm |
| MantidQt::CustomDialogs::MantidGLWidget | This class provides a widget to display a Mantid Geometry object using OpenGL |
| MantidQt::CustomDialogs::MDPropertiesWidget | Widgets to set properties for a IMDWorkspace: MaxSize |
| MantidQt::CustomDialogs::MWPropertiesWidget | Widgets to set properties for a MatrixWorkspace: WorkspaceIndex, StartX, EndX |
| MantidQt::CustomDialogs::NoDeleting | An object for constructing a shared_ptr that won't ever delete its pointee |
| MantidQt::CustomDialogs::Operation | A struct describing a binary operation Note: The constructor takes an integer where 0 = intersection, 1 = union and 2 = difference |
| MantidQt::CustomDialogs::PlotAsymmetryByLogValueDialog | This class gives specialised dialog for the LoadRaw algorithm |
| MantidQt::CustomDialogs::PointGroupBox | A custom group box for a 3D point |
| MantidQt::CustomDialogs::ShapeDetails | The base class for the details widgets |
| MantidQt::CustomDialogs::ShapeDetailsInstantiator< T > | A structure used for holding the type of a details widget |
| MantidQt::CustomDialogs::SliceMDDialog | |
| MantidQt::CustomDialogs::SliceOfCylinderRingDetails | A widget to define an infinite cylinder |
| MantidQt::CustomDialogs::SlicingAlgorithmDialog | |
| MantidQt::CustomDialogs::SphereDetails | A widget to define a sphere |
| MantidQt::CustomDialogs::StartLiveDataDialog | |
| MantidQt::CustomInterfaces::Background | |
| MantidQt::CustomInterfaces::ConvertToEnergy | This class defines the ConvertToEnergy interface |
| MantidQt::CustomInterfaces::CreateMDWorkspace | |
| MantidQt::CustomInterfaces::deltaECalc | |
| MantidQt::CustomInterfaces::EventNexusFileMemento | A workspace memento refering to a Event nexus File on disk |
| MantidQt::CustomInterfaces::Homer | This class implements the ConvertToEnergy interface for the direct instruments |
| MantidQt::CustomInterfaces::IdComparitor | Helper type to perform comparisons between WorkspaceMementos |
| MantidQt::CustomInterfaces::Indirect | This class defines handles the ConvertToEnergy interface for indirect instruments (IRIS/OSIRIS) |
| MantidQt::CustomInterfaces::IndirectDataAnalysis | |
| MantidQt::CustomInterfaces::IndirectDiffractionReduction | |
| MantidQt::CustomInterfaces::LatticePresenter | Presenter of MVP type for controlling interaction of lattice view with WorkspaceMementos |
| MantidQt::CustomInterfaces::LatticeView | Abstract lattice view |
| MantidQt::CustomInterfaces::Muon::MuonAnalysisFitDataTab | This is a Helper class for MuonAnalysis |
| MantidQt::CustomInterfaces::Muon::MuonAnalysisOptionTab | This is a Helper class for MuonAnalysis |
| MantidQt::CustomInterfaces::Muon::MuonAnalysisResultTableTab | This is a Helper class for MuonAnalysis |
| MantidQt::CustomInterfaces::MuonAnalysis | This is the main class for the MuonAnalysis interface see <http://www.mantidproject.org/MuonAnalysis> |
| MantidQt::CustomInterfaces::QtWorkspaceMementoModel | QtWorkspaceMementoModel is a QAbstractTableModel wrapping a table workspace in order to serve-up display specific workspace memento views |
| MantidQt::CustomInterfaces::RawFileMemento | A workspace memento refering to a Raw File on disk |
| MantidQt::CustomInterfaces::RectDetectorDetails | Stores the rectangualr detector name and minimum and maximum detector id |
| MantidQt::CustomInterfaces::SANSAddFiles | |
| MantidQt::CustomInterfaces::SANSDiagnostics | The SANSDiagnostics is responsible for the diagnostics tab of SANS interface |
| MantidQt::CustomInterfaces::SANSPlotSpecial | |
| MantidQt::CustomInterfaces::SANSPlotSpecial::Transform | Small utility class to hold information about the different functions |
| MantidQt::CustomInterfaces::SANSRunWindow | Implements the SANS, small angle neutron scattering, dialog box |
| MantidQt::CustomInterfaces::ScopedMemento | |
| MantidQt::CustomInterfaces::Updateable | Abstraction of an updateable item, i.e |
| MantidQt::CustomInterfaces::WorkspaceInADS | A workspace memento refering to a workspace in the Analysis Data Service |
| MantidQt::CustomInterfaces::WorkspaceMemento | A memento carrying basic information about an existing workspace |
| MantidQt::CustomInterfaces::WorkspaceMemento::LogEntry | Log entry type |
| MantidQt::CustomInterfaces::WorkspaceMementoLock | Abstract Functor for locking usage |
| MantidQt::Factory::WidgetFactory | Factory class that handles the creation of MantidQt widgets such as the SliceViewer |
| MantidQt::MantidWidgets::AlgorithmSelectorWidget | A widget consisting of a ComboBox and a TreeWidget to allow a user to select an algorithm either by category or by typing |
| MantidQt::MantidWidgets::AlgorithmTreeWidget | Tree widget with the categories and algorithms listed |
| MantidQt::MantidWidgets::Contains | |
| MantidQt::MantidWidgets::CreateAttributeProperty | Attribute visitor to create a QtProperty |
| MantidQt::MantidWidgets::CreateAttributePropertyForFunctionBrowser | Attribute visitor to create a QtProperty |
| MantidQt::MantidWidgets::DiagResults | |
| MantidQt::MantidWidgets::FindAlgComboBox | ComboBox for finding algorithms |
| MantidQt::MantidWidgets::FindFilesThread | A class to allow the asyncronous finding of files |
| MantidQt::MantidWidgets::FitPropertyBrowser | Class FitPropertyBrowser implements QtPropertyBrowser to display and control fitting function parameters and settings |
| MantidQt::MantidWidgets::FormulaDialogEditor | |
| MantidQt::MantidWidgets::FormulaDialogEditorFactory | |
| MantidQt::MantidWidgets::FunctionBrowser | Class FitPropertyBrowser implements QtPropertyBrowser to display and control fitting function parameters and settings |
| MantidQt::MantidWidgets::FunctionBrowser::AConstraint | Constraint structure |
| MantidQt::MantidWidgets::FunctionBrowser::AProperty | To keep QtProperty and its QtBrowserItem in one place |
| MantidQt::MantidWidgets::FunctionBrowser::ATie | Tie structure |
| MantidQt::MantidWidgets::ICatAdvancedSearch | |
| MantidQt::MantidWidgets::ICatInvestigation | |
| MantidQt::MantidWidgets::ICatMyDataSearch | |
| MantidQt::MantidWidgets::ICatSearch | |
| MantidQt::MantidWidgets::ICatUtils | |
| MantidQt::MantidWidgets::InputFunctionNameDialog | A dialog to enter a category and function name for a new function for saving |
| MantidQt::MantidWidgets::InstrumentSelector | This class defines a widget for selecting an instrument known to Mantid |
| MantidQt::MantidWidgets::MultifitSetupDialog | This is a dialog for doing setting up the MultiBG function |
| MantidQt::MantidWidgets::MuonFitPropertyBrowser | |
| MantidQt::MantidWidgets::MWDiag | |
| MantidQt::MantidWidgets::MWRunFiles | This class defines a widget for file searching |
| MantidQt::MantidWidgets::ProcessingAlgoWidget | A widget containing an algorithm selector and algorithm properties list, or a script editor window |
| MantidQt::MantidWidgets::PropertyHandler | Helps display and edit functions in FitPropertyBrowser |
| MantidQt::MantidWidgets::pythonCalc | |
| MantidQt::MantidWidgets::RangeSelector | Allows for simpler (in a way) selection of a range on a QwtPlot in MantidQt |
| MantidQt::MantidWidgets::RenameParDialog | A dialog for renaming parameters for a user function |
| MantidQt::MantidWidgets::SafeQwtPlot | A version of QwtPlot that adds a layer of thread safety |
| MantidQt::MantidWidgets::SaveWorkspaces | Implements a dialog box that allows users to save multiple Mantid workspaces |
| MantidQt::MantidWidgets::SearchCalendar | |
| MantidQt::MantidWidgets::SelectWorkspacesDialog | This is a dialog for selecting workspaces |
| MantidQt::MantidWidgets::SequentialFitDialog | This is a dialog for doing sequential fit |
| MantidQt::MantidWidgets::SetAttribute | Visitor setting new attribute value |
| MantidQt::MantidWidgets::SetAttributeFromProperty | Attribute visitor to set an attribute from a QtProperty |
| MantidQt::MantidWidgets::SetAttributeProperty | Visitor setting new attribute value |
| MantidQt::MantidWidgets::UserFunctionDialog | A dialog for construction a user fitting function from existing components |
| MantidQt::MantidWidgets::WorkspaceSelector | This class defines a widget for selecting a workspace present in the AnalysisDataService |
| MantidQt::SliceViewer::ColorBarWidget | Widget for showing a color bar, modifying its limits, etc |
| MantidQt::SliceViewer::CustomMagnifier | Customized QwtPlotMagnifier for zooming in on the view |
| MantidQt::SliceViewer::CustomPicker | Picker for looking at the data under the mouse |
| MantidQt::SliceViewer::CustomZoomer | Custom zoomer for zooming onto the slice |
| MantidQt::SliceViewer::DimensionSliceWidget | Widget for the 2D slice viewer |
| MantidQt::SliceViewer::LineOverlay | GUI for overlaying a line with a width onto the plot in the SliceViewer |
| MantidQt::SliceViewer::LineViewer | |
| MantidQt::SliceViewer::PickerMachine | |
| MantidQt::SliceViewer::QwtRasterDataMD | Implemenation of QwtRasterData that can display the data from a slice of an IMDWorkspace |
| MantidQt::SliceViewer::QwtScaleWidgetExtended | Extended version of QwtScaleWidget |
| MantidQt::SliceViewer::SliceViewer | GUI for viewing a 2D slice out of a multi-dimensional workspace |
| MantidQt::SliceViewer::SliceViewerWindow | A window that contains a SliceViewer and a LineViewer widget, linked together |
| MantidQwtIMDWorkspaceData | This class is used to plot MDWorkspace line plots |
| MantidQwtMatrixWorkspaceData | This class implements QwtData with direct access to a spectrum in a MatrixWorkspace |
| MantidQwtWorkspaceData | Abstract Qwtdata type |
| MantidSampleLogDialog | This class displays a list of log files for a selected workspace |
| MantidTable | A MantidTable appears to be a MantidPlot "Table" object that shows the data from an ITableWorkspace |
| MantidTreeWidget | |
| MantidTreeWidgetItem | A class derived from QTreeWidgetItem, to accomodate sorting on the items in a MantidTreeWidget |
| MantidUI | MantidUI is the extension of QtiPlot's ApplicationWindow which deals with Mantid framework |
| MantidWSIndexCalculator | Utitlity type to decompose indexes in one dimension to dual indexes used by MatrixWorkspaces |
| MantidWSIndexDialog | |
| MapSupport::mapClone< KeyPart, PtrPart > | Functor for coping map elements with clone functions |
| MapSupport::mapDelete< KeyPart, PtrPart > | Functor for deleting the second component of a map |
| MapSupport::mapSwap< KeyPart, BodyPart > | Functor for reversing a map |
| MapSupport::mapWrite< PartA, PartB > | Functor quick write out of a map |
| MapSupport::PFirst< T, U > | Class to access the first object in index pair |
| MapSupport::PSecond< T, U > | Class to access the second object in index pair |
| MapSupport::sndValue< KeyPart, NumPart > | Functor to get second point in a map |
| MapSupport::valEqual< KeyPart, NumPart > | Functor using second value as equal |
| MDGeometryBuliderXML | Computes Boolean algebra for simplification |
| mexfunc_s_t | A struct holding the name of a mex function and the function pointer to call |
| MockNearestNeighbours | |
| MockNearestNeighboursFactory | |
| MonitorDlg | Dialog that shows a list of algorithms running and cancel buttons for them |
| MuonFitBrowserPlugin | |
| MuonNexusReader | MuunNexusReader opens a Nexus file and reads certain fields expected for a ISIS Muon data file (old format) |
| ObjCompAssemblyActor | This class wraps the ICompAssembly into Actor |
| ObjComponentActor | ObjComponentActor is an actor class for rendering ObjComponents |
| OneCurvePlot | Implements a simple widget for plotting a single curve |
| OpenGLError | Exception for wrapping an OpenGL error |
| PeakHKL | Class for managing overlapping peak labels and drawing them on screen |
| PeakLabel | |
| PeakMarker2D | Shape representing a peak marker on un unwrapped surface |
| PeakMarker2D::Style | |
| PeakOverlay | Class for managing peak markers |
| PeakPickerTool | This class is for selecting peaks on a graph for subsequent fitting |
| PluginCollectionInterface | The PluginCollectionInterface implements the interface for the plugin library and holds a list of plugins defined by the library |
| Poco::FilterChannel | This channel sends a message to multiple channels simultaneously |
| Poco::SignalChannel | Class SignalChannel passes log messages to slots, connected to it |
| PropertyFileConfiguration | |
| SystemConfiguration | |
| ProcessingAlgoWidgetPlugin | |
| ProjectData | |
| Projection3D | TODO: Add description |
| ProjectionSurface | Performs projection of an instrument onto a plane |
| PropertyData | |
| QScienceSpinBox | |
| RectangularDetectorActor | This class wraps a RectangularDetector into Actor |
| RemoveErrorsDialog | |
| RPB_STRUCT | Run parameter block (32*4 bytes) |
| SafeQwtPlotPlugin | |
| SampleActor | SampleActor is an actor class for rendering Samples |
| SANSInstrumentCreationHelper | |
| ScriptEditor | This class provides an area to write scripts |
| ScriptEditorPlugin | |
| SE_STRUCT | Sample environment block (32*4 bytes) |
| SelectFunctionDialog | Select a function type out of a list of available ones |
| SetAllVisibleVisitor | |
| SetUpParaview | SetUpParaview dialog for MantidPlot |
| SetVisibilityVisitor | |
| SetVisibleComponentVisitor | Sets visibility of an actor with a particular ComponentID |
| sgl_limits_struct | Structure holding the limits of s single |
| Shape2D | Base class for an editable 2D shape, which can be drawn on ProjectionSurface |
| Shape2DCollection | Class Shape2DCollection is a collection of 2D shapes |
| Shape2DEllipse | |
| Shape2DRectangle | |
| Shape2DRing | |
| SimpleGuiApp | This is a wrapper to QApplication in order to handle exceptions and present them to the user in dialog boxes for better error reporting |
| SliceViewerPlugin | |
| SnapToGridDialog | Dialog that prompts the user to enter the X and Y snap-to grid values |
| SPB_STRUCT | Sample parameter block (64*4 bytes) |
| SpectrumTester | Helper class that implements ISpectrum |
| Sqrt | To be used in std::transform |
| UnwrappedCylinder | Implementation of UnwrappedSurface as a cylinder |
| UnwrappedDetector | Class helper for drawing detectors on unwraped surfaces |
| UnwrappedSphere | Implementation of UnwrappedSurface as a cylinder |
| UnwrappedSurface | Performs projection of an instrument onto a 2D surface and unwrapping it into a plane |
| USER_STRUCT | User information (8*20 bytes) |
| UserFitFunctionDialog | This is a dialog for constructing fitting functions |
| vax_double | Vax double precision floating point |
| vax_single | Vax single precision floating point |
| VsgMainWindow | This class represents the main level program |
| WorkspaceCreationHelper::FibSeries< T > | Create a fibonacci series |
| WorkspaceCreationHelper::MockAlgorithm | Mock algorithn for doing logging/progress reporting |
| WorkspaceSelectorPlugin | |
| WorkspaceTester | |
| XIntegrationControl | Implements a control for setting the x integration range |
| XIntegrationScrollBar | |
| XYLimitsDialog | Dialog that prompts the user to enter the X and Y limits to the axes |
1.6.1
