| ►Nboost | |
| ►Nalgorithm | |
| ►Ndetail | |
| Ceq | |
| ►Npython | |
| ►Nconverter | |
| Cobject_manager_traits< Mantid::PythonInterface::NDArray > | Register ndarray as a type that manages a PyObject* internally |
| Chas_back_reference< ConfigObserverWrapper > | |
| Chas_back_reference< ConfigPropertyObserverWrapper > | |
| ►NFacilityHelper | |
| CScopedFacilities | Simple RAII struct to switch the facilities files to the when constructed and switch back to the previous settings on destruction |
| ►NICat4 | |
| C__ns1__create | |
| C__ns1__createMany | |
| C__ns1__delete | |
| C__ns1__deleteMany | |
| C__ns1__deleteManyResponse | |
| C__ns1__deleteResponse | |
| C__ns1__dummy | |
| C__ns1__dummyResponse | |
| C__ns1__get | |
| C__ns1__getApiVersion | |
| C__ns1__getEntityInfo | |
| C__ns1__getEntityNames | |
| C__ns1__getProperties | |
| C__ns1__getRemainingMinutes | |
| C__ns1__getUserName | |
| C__ns1__isAccessAllowed | |
| C__ns1__login | |
| C__ns1__logout | |
| C__ns1__logoutResponse | |
| C__ns1__luceneClear | |
| C__ns1__luceneClearResponse | |
| C__ns1__luceneCommit | |
| C__ns1__luceneCommitResponse | |
| C__ns1__luceneGetPopulating | |
| C__ns1__lucenePopulate | |
| C__ns1__lucenePopulateResponse | |
| C__ns1__luceneSearch | |
| C__ns1__refresh | |
| C__ns1__refreshResponse | |
| C__ns1__search | |
| C__ns1__searchText | |
| C__ns1__update | |
| C__ns1__updateResponse | |
| C_ns1__login_credentials | |
| C_ns1__login_credentials_entry | |
| CICATPortBindingProxy | |
| Cns1__accessType_ | |
| Cns1__application | |
| Cns1__constraint | |
| Cns1__create | |
| Cns1__createMany | |
| Cns1__createManyResponse | |
| Cns1__createResponse | |
| Cns1__dataCollection | |
| Cns1__dataCollectionDatafile | |
| Cns1__dataCollectionDataset | |
| Cns1__dataCollectionParameter | |
| Cns1__datafile | |
| Cns1__datafileFormat | |
| Cns1__datafileParameter | |
| Cns1__dataset | |
| Cns1__datasetParameter | |
| Cns1__datasetType | |
| Cns1__delete | |
| Cns1__deleteMany | |
| Cns1__deleteManyResponse | |
| Cns1__deleteResponse | |
| Cns1__dummy | |
| Cns1__dummyResponse | |
| Cns1__entityBaseBean | |
| Cns1__entityField | |
| Cns1__entityInfo | |
| Cns1__facility | |
| Cns1__facilityCycle | |
| Cns1__get | |
| Cns1__getApiVersion | |
| Cns1__getApiVersionResponse | |
| Cns1__getEntityInfo | |
| Cns1__getEntityInfoResponse | |
| Cns1__getEntityNames | |
| Cns1__getEntityNamesResponse | |
| Cns1__getProperties | |
| Cns1__getPropertiesResponse | |
| Cns1__getRemainingMinutes | |
| Cns1__getRemainingMinutesResponse | |
| Cns1__getResponse | |
| Cns1__getUserName | |
| Cns1__getUserNameResponse | |
| Cns1__grouping | |
| Cns1__IcatException | |
| Cns1__icatExceptionType_ | |
| Cns1__instrument | |
| Cns1__instrumentScientist | |
| Cns1__investigation | |
| Cns1__investigationInstrument | |
| Cns1__investigationParameter | |
| Cns1__investigationType | |
| Cns1__investigationUser | |
| Cns1__isAccessAllowed | |
| Cns1__isAccessAllowedResponse | |
| Cns1__job | |
| Cns1__keyword | |
| Cns1__log | |
| Cns1__login | |
| Cns1__loginResponse | |
| Cns1__logout | |
| Cns1__logoutResponse | |
| Cns1__luceneClear | |
| Cns1__luceneClearResponse | |
| Cns1__luceneCommit | |
| Cns1__luceneCommitResponse | |
| Cns1__luceneGetPopulating | |
| Cns1__luceneGetPopulatingResponse | |
| Cns1__lucenePopulate | |
| Cns1__lucenePopulateResponse | |
| Cns1__luceneSearch | |
| Cns1__luceneSearchResponse | |
| Cns1__parameter | |
| Cns1__parameterType | |
| Cns1__parameterValueType_ | |
| Cns1__permissibleStringValue | |
| Cns1__publication | |
| Cns1__publicStep | |
| Cns1__refresh | |
| Cns1__refreshResponse | |
| Cns1__relatedDatafile | |
| Cns1__relType_ | |
| Cns1__rule | |
| Cns1__sample | |
| Cns1__sampleParameter | |
| Cns1__sampleType | |
| Cns1__search | |
| Cns1__searchResponse | |
| Cns1__searchText | |
| Cns1__searchTextResponse | |
| Cns1__shift | |
| Cns1__study | |
| Cns1__studyInvestigation | |
| Cns1__studyStatus_ | |
| Cns1__update | |
| Cns1__updateResponse | |
| Cns1__user | |
| Cns1__userGroup | |
| Cxsd__anyType | |
| Cxsd__boolean | |
| Cxsd__dateTime | |
| Cxsd__double | |
| Cxsd__int | |
| Cxsd__long | |
| Cxsd__string | |
| ►NMantid | Helper class which provides the Collimation Length for SANS instruments |
| ►NAlgorithms | |
| ►NCorelliCalibration | |
| CCalibrationTableHandler | Class containing static and member methods to work with calibration table workspaces |
| CComponentPosition | Structure to handle all the calibration component positions |
| ►NFitPeaksAlgorithm | |
| CFitFunction | |
| CPeakFitResult | |
| ►NSolidAngleHelpers | |
| CAlphaAngleCalculator | Returns the angle between the sample-to-pixel vector and its projection on the X-Z (vertical tube) or Y-Z (horizontal tube) plane |
| CAlphaAngleHorizontal | |
| CAlphaAngleVertical | |
| CGenericShape | |
| CRectangle | |
| CSolidAngleCalculator | Creates the solid angle calculator based on the selected method |
| CTube | |
| CWing | |
| CAbsorptionCorrection | A base class for absorption correction algorithms |
| CAddAbsorptionWeightedPathLengths | Calculates the absorption weighted path length for each peak in a peaks workspace and saves it to the tbar column in the workspace |
| CAddLogDerivative | Takes an existing sample log, and calculates its first or second derivative, and adds it as a new log |
| CAddNote | An Algorithm that adds a timestamped note to a workspace |
| CAddPeak | Add a peak to a PeaksWorkspace |
| CAddSampleLog | Used to insert a single string into the sample in a workspace |
| CAddTimeSeriesLog | |
| CAlignDetectors | Performs a unit change from TOF to dSpacing, correcting the X values to account for small errors in the detector positions |
| CAnnularRingAbsorption | Constructs a hollow sample shape, defines material for the sample and runs the MonteCarloAbsorption algorithm |
| CAnyShapeAbsorption | Calculates an approximation of the attenuation due to absorption and scattering in a generic sample shape |
| CAppendSpectra | Joins two partial, non-overlapping workspaces into one |
| CApplyCalibration | Update detector positions from input table workspace |
| CApplyDetailedBalance | ApplyDetailedBalance : The algorithm calculates the imaginary part of the dynamic susceptibility chi''=Pi*(1-exp(-E/T))*S |
| CApplyFloodWorkspace | Algorithm to apply a flood correction workspace to a reflectometry data workspace |
| CApplyInstrumentToPeaks | ApplyInstrumentToPeaks : TODO: DESCRIPTION |
| CApplyTransmissionCorrection | Apply angle-dependent transmission correction from zero-angle transmission measurement |
| CAverageLogData | AverageLogData : TODO: DESCRIPTION |
| CBackgroundHelper | Performs removal of constant (and possibly non-constant after simple modification) background calculated in TOF units from a matrix workspace, expressed in units, different from TOF |
| CBeamProfileFactory | |
| CBin2DPowderDiffraction | Bin2DPowderDiffraction : |
| CBinaryOperateMasks | BinaryOperateMasks : TODO: DESCRIPTION |
| CBinaryOperation | BinaryOperation supports the implementation of a binary operation on two input workspaces |
| CCalculateCarpenterSampleCorrection | Multiple scattering absorption correction, originally used to correct vanadium spectrum at IPNS |
| CCalculateCountRate | In normal circumstances an instrument in event mode counts neutrons with constant steady rate which depends on beam intensity, instrument settings and sample |
| CCalculateDIFC | CalculateDIFC : Calculate the DIFC for every pixel |
| CCalculateDynamicRange | CalculateDynamicRange Calculates the Qmin and Qmax of SANS workspace, sets to sample logs |
| CCalculateEfficiency | Compute relative detector pixel efficiency from flood data as part of SANS reduction |
| CCalculateEfficiency2 | Compute relative detector pixel efficiency from flood data as part of SANS reduction |
| CCalculateFlatBackground | Finds a constant background value of each desired spectrum and optionally subtracts that value from the entire spectrum |
| CCalculateIqt | |
| CCalculatePlaczek | CalculatePlaczek : Placzek 1st&2nd order correction for inelastic scattering |
| CCalculatePlaczekSelfScattering | CalculatePlaczekSelfScattering : This algorithm calculates a correction for an incident spectrum defracted by a sample |
| CCalculatePlaczekSelfScattering2 | CalculatePlaczekSelfScattering2 : TODO: DESCRIPTION |
| CCalculatePolynomialBackground | CalculatePolynomialBackground : This algorithm fits a polynomial background to an input workspace and returns the evaluated background as the output workspace |
| CCalculateTransmission | Calculates the transmission correction, as a function of wavelength, for a SANS instrument |
| CCalculateTransmissionBeamSpreader | Calculates the transmission correction, as a function of wavelength, for a SANS instrument |
| CCalculateZscore | CalculateZscore : Calculate Zscore for a Matrix Workspace |
| CCarpenterSampleCorrection | Multiple scattering absorption correction, originally used to correct vanadium spectrum at IPNS |
| CChangeBinOffset | Takes a workspace and adjusts all the time bin values by the same amount |
| CChangeLogTime | |
| CChangePulsetime | ChangePulsetime : TODO: DESCRIPTION |
| CChangePulsetime2 | ChangePulsetime : TODO: DESCRIPTION |
| CChangeTimeZero | |
| CCheckWorkspacesMatch | Compares two workspaces for equality |
| CChopData | For use in TOSCA reduction |
| CCircularBeamProfile | Defines a flat, circular beam profile that has a radius and center point |
| CClearCache | ClearCache : TODO: DESCRIPTION |
| CClearInstrumentParameters | ClearInstrumentParameters : Clear out an instrument's parameters |
| CClearMaskFlag | ClearMaskFlag : Delete the mask flag/bit on all spectra in a workspace |
| CCloneWorkspace | Creates a copy of the input workspace |
| CCombineDiffCal | CombineDiffCal : Calibrate groups of pixels after cross correlation so that diffraction peaks can be adjusted to the correct positions |
| CComment | Comment : Adds a note into the history record of a workspace |
| CCommutativeBinaryOperation | CommutativeBinaryOperation supports commutative binary operations on two input workspaces |
| CCompareWorkspaces | Compares two workspaces for equality |
| CComponentScatterPoint | |
| CComponentWorkspaceMapping | |
| CConjoinWorkspaces | Joins two partial, non-overlapping workspaces into one |
| CConjoinXRuns | ConjoinXRuns : This algorithms joins the input workspaces horizontally, i.e |
| ►CConvertAxesToRealSpace | ConvertAxesToRealSpace : Converts the spectrum and TOF axes to real space values, integrating the data in the process |
| CAxisData | Summary data about an Axis |
| CSpectraData | Local cache data about a spectra |
| ►CConvertAxisByFormula | ConvertAxisByFormula : Performs a unit conversion based on a supplied formula |
| CVariable | A simple internal structure to hold information on variables |
| CConvertDiffCal | ConvertDiffCal : TODO: DESCRIPTION |
| CConvertEmptyToTof | ConvertEmptyToTof : |
| CConvertFromDistribution | Converts a histogram workspace from a distribution |
| CConvertSpectrumAxis | 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 |
| CConvertSpectrumAxis2 | 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 - theta, elastic Q and elastic Q^2 |
| CConvertTableToMatrixWorkspace | Creates a single spectrum matrix workspace from some columns of a table workspace |
| CConvertToConstantL2 | Convert workspace to have a constant L2 |
| CConvertToDistribution | Makes a histogram workspace a distribution |
| CConvertToEventWorkspace | Perform a conversion for a Workspace2D to an equivalent EventWorkspace |
| CConvertToHistogram | Converts a histogram workspace to point data by simply taking the centre point of the bin as the new point on the X axis |
| CConvertToMatrixWorkspace | Creates a copy of the matrix workspace representation of the input workspace |
| CConvertToPointData | Converts a histogram workspace to point data by simply taking the centre point of the bin as the new point on the X axis |
| CConvertToRelativeTime | Helper method to transform a MantidVector containing absolute times in nanoseconds to relative times in seconds given an offset |
| CConvertUnits | Converts the units in which a workspace is represented |
| CConvertUnitsUsingDetectorTable | ConvertUnitsUsingDetectorTable : Converts the units in which a workspace is represented, this variant of ConvertUnits uses a supplied table of geometry values rather than those given by the instrument geometry |
| CCopyDataRange | CopyDataRange : This algorithm takes a continuous block of data from an input workspace specified by spectra indices and x indices and replaces a block of data within a destination workspace |
| CCopyDetectorMapping | Algorithm to copy spectra-detector mapping from one matrix workspace to another |
| CCopyInstrumentParameters | Transfers an instrument from one workspace to another workspace with the same base instrument |
| CCopyLogs | CopyLogs |
| CCopySample | CopySample : The algorithm copies some/all the sample information from one workspace to another |
| CCorelliCalibrationApply | Apply calibration table for Corelli Powder Diffraction |
| CCorelliCalibrationDatabase | CorelliCalibrationDatabase: blablabla TODO |
| CCorelliCrossCorrelate | CorelliCrossCorrelate : TODO: DESCRIPTION |
| CCorrection | The Correction struct to be applied as factor * TOF + offset offset:: TOF offset in unit of TOF factor: TOF correction factor to multiply with |
| CCorrectKiKf | Multiplies the workspace with k_i/k_f The initial workspace must have energy transfer units |
| CCorrectTOFAxis | CorrectTOFAxis : Corrects the time-of-flight axis with regards to the incident energy and the L1+L2 distance or a reference workspace |
| CCorrectToFile | Required properties: |
| CCreateCalFileByNames | Create a calibration file for diffraction focussing (*.cal old Ariel format) based on list of names of the instrument tree |
| CCreateDetectorTable | |
| CCreateDummyCalFile | Create a calibration file for diffraction focussing (*.cal old Ariel format) based on list of names of the instrument tree |
| CCreateEPP | CreateEPP : Calculates the nominal elastic time-of flights for each spectrum and creates an elastic peak position table (EPP) like the one returned by the FindEPP algorithm |
| CCreateFlatEventWorkspace | CreateFlatEventWorkspace : Creates a flat event workspace that can be used for background removal |
| CCreateFloodWorkspace | Algorithm to create a flood correction workspace for reflectometry data reduction |
| CCreateGroupingWorkspace | Creates a new GroupingWorkspace using an instrument from one of: an input workspace, an instrument name, or an instrument IDF file |
| CCreateLogPropertyTable | |
| CCreateLogTimeCorrection | CreateLogTimeCorrection : Create correction file and workspace to correct event time against recorded log time for each pixel |
| CCreatePeaksWorkspace | Create an empty PeaksWorkspace |
| CCreatePSDBleedMask | This algorithm implements a "bleed" diagnostic for PSD detectors (i.e |
| CCreateSampleWorkspace | CreateSampleWorkspace : This algorithm is intended for the creation of sample workspaces for usage examples and other situations |
| CCreateSingleValuedWorkspace | Required properties: |
| CCreateUserDefinedBackground | CreateUserDefinedBackground : Given an input workspace containing data with a background and a table of user-selected points defining the background, creates a new workspace containing background data that can be subtracted from the original data |
| CCreateWorkspace | CreateWorkspace Algorithm |
| CCropToComponent | CropToComponent : Crops a workspace to a set of components |
| CCropWorkspace | Extracts a 'block' from a workspace and places it in a new workspace |
| CCropWorkspaceRagged | Extracts a 'block' from a workspace and places it in a new workspace |
| CCrossCorrelate | Compute the cross correlation function for a range of spectra with respect to a reference spectrum |
| CCuboidGaugeVolumeAbsorption | Calculates attenuation due to absorption and scattering in a generic sample, considering only the scattering within a cuboid shaped 'gauge volume' |
| CCylinderAbsorption | Calculates attenuation due to absorption and scattering in a cylindrical sample |
| CDeadTimeCorrection | DeadTimeCorrection : Performs dead time correction |
| CDeleteLog | |
| CDeleteWorkspace | A simple algorithm to remove a workspace from the ADS |
| CDeleteWorkspaces | A simple algorithm to remove multiple workspaces from the ADS |
| CDetectorDiagnostic | A base class for a detector diagnostic algorithm |
| CDetectorEfficiencyCor | Returns efficiency of cylindrical helium gas tube |
| CDetectorEfficiencyCorUser | DetectorEfficiencyCorUser : |
| CDetectorEfficiencyVariation | Required Properties: |
| CDetectorGridDefinition | DetectorGridDefinition is a helper class for building the sparse instrument in MonteCarloAbsorption |
| CDiffractionEventCalibrateDetectors | Find the offsets for each detector |
| CDiffractionFocussing | This is a parent algorithm that uses several different child algorithms to perform it's task |
| CDiffractionFocussing2 | Algorithm to focus powder diffraction data into a number of histograms according to a grouping scheme defined in a file |
| CDirectILLTubeBackground | DirectILLTubeBackground : Fits polynomial backgrounds over the pixels of position sensitive tubes |
| CDiscusData1D | |
| CDiscusData2D | |
| CDiscusMultipleScatteringCorrection | Calculates a multiple scattering correction Based on Muscat Fortran code provided by Spencer Howells |
| CDivide | Divide performs the division of two input workspaces |
| CEditInstrumentGeometry | EditInstrumentGeometry : TODO: DESCRIPTION |
| CElasticWindow | |
| CEQSANSCorrectFrame | Apply correction to EQSANS data to account for its TOF structure |
| CEQSANSResolution | Computes the resolution on EQSANS data Required Properties: |
| CEQSANSTofStructure | |
| CEstimateDivergence | EstimateDivergence : Calculate the instrument divergence according to Windsor |
| CEstimateResolutionDiffraction | EstimateResolutionDiffraction : TODO: DESCRIPTION |
| CEventWorkspaceAccess | |
| CExponential | Exponential performs the exponential function on an input workspace |
| CExponentialCorrection | 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) |
| CExportTimeSeriesLog | ExportTimeSeriesLog : Read a TimeSeries log and return some information required by users |
| CExtractFFTSpectrum | This algorithm performs a Fast Fourier Transform on each spectra of the input workspace |
| CExtractMask | Extract the masking from a given workspace |
| CExtractMaskToTable | ExtractMaskToTable : Extract the mask in a workspace to a table workspace |
| CExtractQENSMembers | ExtractQENSMembers : Extracts the fit members from a QENS fit |
| CExtractSingleSpectrum | Copies a single spectrum from a 2D Workspace into a new workspace |
| CExtractSpectra | Extracts specified spectra from a workspace and places them in a new workspace |
| CExtractSpectra2 | Extracts specified spectra from a workspace and places them in a new workspace |
| CExtractUnmaskedSpectra | ExtractUnmaskedSpectra : TODO: DESCRIPTION |
| CFFT | Performs a Fast Fourier Transform of data |
| CFFTDerivative | Calculates derivatives of the spectra in a MatrixWorkspace using a Fast Fourier Transform |
| CFFTSmooth | Data smoothing using the FFT algorithm and various filters |
| CFFTSmooth2 | Data smoothing using the FFT algorithm and various filters |
| CFilterBadPulses | Filters out events associated with pulses that happen when proton charge is lower than a given percentage of the average |
| CFilterByLogValue | Filters events in an EventWorkspace using values in a SampleLog |
| CFilterByTime | Filters an EventWorkspace by wall-clock time, and outputs to a new event workspace or replaces the existing one |
| CFilterByTime2 | FilterByTime2 : TODO: DESCRIPTION |
| CFilterByXValue | Filters the events in an event workspace according to a minimum and/or maximum value of X |
| CFilterEvents | FilterEvents : Filter Events in EventWorkspace to multiple EventsWorkspace by Splitters |
| CFindCenterOfMassPosition | Part of data reduction for SANS |
| CFindCenterOfMassPosition2 | Part of data reduction for SANS |
| CFindDeadDetectors | 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 |
| CFindDetectorsOutsideLimits | Takes a workspace as input and identifies all spectra where the sum of the counts in all bins is outside a range |
| CFindEPP | Performs Gaussian fits over each spectrum to find the Elastic Peak Position (EPP) |
| ►CFindPeakBackground | FindPeakBackground : Calculate Zscore for a Matrix Workspace |
| Cby_len | |
| Ccont_peak | |
| CFindPeaks | This algorithm searches for peaks in a dataset |
| CFitOneSinglePeak | FitOneSinglePeak: a class to perform peak fitting on a single peak |
| CFitPeak | FitPeak : Fit a single peak |
| CFitPeaks | |
| CFixGSASInstrumentFile | FixGSASInstrumentFile : TODO: DESCRIPTION |
| CFlatPlateAbsorption | Calculates attenuation due to absorption and scattering in a flat plate/slab sample |
| CFlatWeighting | |
| CGaussianWeightingnD | |
| CGeneralisedSecondDifference | Compute the generalised second difference of a spectrum or several spectra based on the method described by M.A |
| CGenerateEventsFilter | GenerateEventsFilter : Generate an events-filter, i.e., a SplittersWorkspace according to user's request |
| CGenerateIPythonNotebook | GenerateIPythonNotebook |
| CGeneratePeaks | GeneratePeaks : Generate peaks from a table workspace containing peak parameters |
| CGeneratePythonFitScript | |
| CGeneratePythonScript | GeneratePythonScript : TODO: DESCRIPTION |
| CGetAllEi | Estimate all incident energies, used by chopper instrument |
| CGetDetectorOffsets | Find the offsets for each detector |
| CGetEi | Requires an estimate for the initial neutron energy which it uses to search for monitor peaks and from these calculate an accurate energy |
| CGetEi2 | Requires an estimate for the initial neutron energy which it uses to search for monitor peaks and from these calculate an accurate energy |
| CGetEiMonDet3 | Estimates the incident neutron energy from the time of flight between a monitor and a set of detectors |
| CGetQsInQENSData | Extracts Q-values from a workspace containing QENS data |
| CGetTimeSeriesLogInformation | GetTimeSeriesLogInformation : Read a TimeSeries log and return some information required by users |
| CGravitySANSHelper | A helper class for calculating neutron's gravitional drop |
| CGroupToXResolution | GroupToXResolution : Groups points within intervals defined by Dx into a single point |
| CGroupWorkspaces | Takes workspaces as input and groups the workspaces |
| CHe3TubeEfficiency | Corrects the input workspace for helium3 tube efficiency based on an exponential parameterization |
| CHRPDSlabCanAbsorption | Calculates attenuation due to absorption and scattering in an HRPD 'slab' can |
| CHyspecScharpfCorrection | HyspecScharpfCorrection : Divide by cos(2alpha) where alpha is the angle between incident beam and the polarization direction |
| ►CIBeamProfile | Base class for all classes defining a beam profile |
| CRay | |
| CIdentifyNoisyDetectors | Identifies "bad" detectors based on their standard deviation, and how this differs from the standard deviation of other detectors |
| CIMCAbsorptionStrategy | Defines a base class for objects that calculate correction factors for self-attenuation |
| CIMCInteractionVolume | Defines a base class for objects describing a volume where interactions of Tracks and Objects can take place |
| CIntegrateByComponent | IntegrateByComponent : The algorithm integrates up the instrument hierarchy, and each pixel will contain the average value for the component |
| CIntegrateEPP | IntegrateEPP : Integrate a workspace around the elastic peak positions given by a EPP table |
| CIntegration | 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 |
| CInterpolatingRebin | 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 |
| CInterpolationOption | Class to provide a consistent interface to an interpolation option on algorithms |
| CInvertMask | InvertMask : TODO: DESCRIPTION |
| CIQTransform | This algorithm permits the linearisation of reduced SANS data by applying a chosen transformation to the input data |
| CLinearWeighting | |
| CLineProfile | LineProfile : Calculates a horizontal or vertical line profile over a MatrixWorkspace |
| CLogarithm | Takes a workspace as input and calculates the natural logarithm of number of counts for each 1D spectrum |
| CLorentzCorrection | LorentzCorrection : Algorithm Performs a lorentz correction (sin(theta)^2)/(wavelength^4) on a MatrixWorkspace in units of wavelength |
| CMagFormFactorCorrection | MagneticFormFactors scales the input workspace by the 1/F(Q) where F(Q) is the magnetic form factor for the given magnetic ion |
| CMaskBins | Masks bins in a workspace |
| CMaskBinsFromTable | MaskBinsFromTable : TODO: DESCRIPTION |
| CMaskBinsFromWorkspace | |
| CMaskBinsIf | MaskBinsIf : Masks bins based on muparser expression |
| CMaskDetectorsIf | This algorithm is used to select/deselect detectors in a *.cal file |
| CMaskInstrument | Mask specified detectors in an instrument |
| CMaskNonOverlappingBins | MaskNonOverlappingBins : Compares the X ranges of two workspace and masks the non-overlapping bins in the first workspace |
| CMatrixWorkspaceAccess | |
| CMax | Takes a 2D workspace as input and find the maximum in each 1D spectrum |
| CMaxEnt | MaxEnt : Entropy maximization algorithm following the approach described in the article by J |
| CMaxentCalculator | MaxentCalculator : This class performs one maxent iteration and calculates chi-sq, angle between gradient of S and gradient of chi-sq, search directions and quadratic coefficients |
| CMaxentEntropy | MaxentEntropy : Abstract base class defining the necessary methods to calculate any type of entropy to be used by MaxEnt |
| CMaxentEntropyNegativeValues | MaxentEntropyNegativeValues : Class defining the entropy of a 'PosNeg' image (i.e |
| CMaxentEntropyPositiveValues | MaxentEntropyPositiveValues : Class defining the entropy of a positive image (i.e |
| CMaxentSpace | MaxentSpace : Abstract base class defining a MaxentSpace |
| CMaxentSpaceComplex | MaxentSpaceComplex : Defines a space of complex numbers |
| CMaxentSpaceReal | MaxentSpaceReal : Defines the space of real numbers |
| CMaxentTransform | MaxentTransform : Abstract base class defining MaxEnt transformations from image space to data space and vice-versa |
| CMaxentTransformFourier | MaxentTransformFourier : Defines a transformation from data space to image space (and vice-versa) where spaces are related by a 1D Fourier Transform |
| CMaxentTransformMultiFourier | MaxentTransformMultiFourier : Defines a transformation from data space to image space (and vice-versa) where spaces are related by a 1D Fourier Transform, in which which the data has multiple spectra concatenatenated |
| CMaxMin | Takes a 2D workspace as input and find the maximum(minimum) in each 1D spectrum |
| CMayersSampleCorrection | Corrects for the effects of absorption and multiple scattering using the algorithm of Jerry Mayers |
| ►CMayersSampleCorrectionStrategy | Applies the procedure found in section 4 of https://inis.iaea.org/search/search.aspx?orig_q=RN:20000574 for an array of tof, signal & error values |
| CParameters | Stores parameters for a single calculation for a given angle and sample details |
| CMCAbsorptionStrategy | Implements the algorithm for calculating the correction factor for self-attenuation and single wavelength using a Monte Carlo |
| CMCInteractionStatistics | Stores statistics relating to the tracks generated in MCInteractionVolume for a specific detector |
| CMCInteractionVolume | Defines a volume where interactions of Tracks and Objects can take place |
| CMedianDetectorTest | 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 |
| CMergeLogs | |
| CMergeRuns | |
| CMin | Takes a 2D workspace as input and find the minimum in each 1D spectrum |
| CMinus | Minus performs the difference of two input workspaces |
| CModeratorTzero | |
| CModeratorTzeroLinear | |
| CMonIDPropChanger | |
| CMonitorEfficiencyCorUser | |
| CMonteCarloAbsorption | Calculates attenuation due to absorption and scattering in a sample + its environment using a Monte Carlo algorithm |
| CMostLikelyMean | MostLikelyMean : Computes the most likely mean of the array by minimizing the taxicab distance of the elements from the rest |
| CMultipleScatteringCorrection | MultipleScatteringCorrection : TODO: DESCRIPTION |
| CMultipleScatteringCorrectionDistGraber | MultipleScatteringCorrectionDistGraber : This is a helper class to calculate the distance from source to sample voxel |
| CMultipleScatteringCylinderAbsorption | Multiple scattering absorption correction, originally used to correct vanadium spectrum at IPNS |
| CMultiply | Multiply performs the product of two input workspaces |
| CMultiplyRange | An algorithm to multiply a range of bins in a workspace by the factor given |
| CNormaliseByCurrent | Normalises a workspace according to the good proton charge figure taken from the raw file (and stored in the Sample object) |
| CNormaliseByDetector | NormaliseByDetector : Normalises a workspace with respect to the detector efficiency function stored against components in the instrument parameters |
| CNormaliseToMonitor | Normalizes a 2D workspace by a specified monitor spectrum |
| CNormaliseToUnity | Takes a workspace as input and normalises it to 1 |
| CNullWeighting | |
| COneMinusExponentialCor | 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)) |
| CPaalmanPingsAbsorptionCorrection | PaalmanPingsAbsorptionCorrection : calculate paalman-pings absorption terms |
| CPaddingAndApodization | Takes a workspace as input and applies a apodization function and/or padding |
| CParabolicWeighting | |
| CParallaxCorrection | ParallaxCorrection : Performs geometrical correction for parallax effect in tube based SANS instruments |
| CPause | Pause a script for a given duration |
| ►CPDCalibration | PDCalibration : TODO: DESCRIPTION |
| CFittedPeaks | Private inner class |
| CPDDetermineCharacterizations | PDDetermineCharacterizations |
| CPDFFourierTransform | PDFFourierTransform : TODO: DESCRIPTION |
| CPDFFourierTransform2 | PDFFourierTransform : TODO: DESCRIPTION |
| CPerformIndexOperations | PerformIndexOperations : Crop and sum a workspace according to the parsed workspace index operations provided |
| CPlus | Plus performs the addition of two input workspaces |
| CPointByPointVCorrection | First attempt at spectrum by spectrum division for vanadium normalisation correction |
| CPoissonErrors | 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 |
| CPolarizationCorrectionFredrikze | PolarizationCorrectionFredrikze : Algorithm to perform polarisation corrections on multi-period group workspaces that implements the Fredrikze (Dutch) method |
| ►CPolarizationCorrectionWildes | PolarizationCorrectionWildes : This algorithm corrects for non-ideal component efficiencies in polarized neutron analysis |
| CEfficiencyMap | A convenience set of efficiency factors |
| CWorkspaceMap | A convenience set of workspaces corresponding flipper configurations |
| CPolarizationEfficiencyCor | PolarizationEfficiencyCor: a generalised polarization correction algorithm |
| CPolynomialCorrection | 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 |
| CPower | Provides the ability to raise the values in the workspace to a specified power |
| CPowerLawCorrection | 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 |
| CProcessIndirectFitParameters | ProcessIndirectFitParameters : Convert a parameter table output by PlotPeakByLogValue to a MatrixWorkspace |
| CQ1D2 | Takes account of the effects of gravity for instruments where the y-axis points upwards, for example SANS instruments |
| ►CQ1DWeighted | Part of data reduction for SANS |
| CWedge | |
| CQhelper | Helper class for the Q1D and Qxy algorithms |
| CQxy | This algorithm rebins a 2D workspace in units of wavelength into 2D Q |
| CRadiusFilter | |
| CRadiusSum | RadiusSum : |
| CRayTracerTester | Algorithm to test ray tracer by spraying evenly spaced rays around |
| CReadGroupsFromFile | 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 |
| CRealFFT | Performs a Fast Fourier Transform of real data |
| CRebin | Takes a workspace as input and rebins the data according to the input rebin parameters |
| CRebin2D | Rebins both axes of a two-dimensional workspace to the given parameters |
| CRebinByPulseTimes | RebinByPulseTimes : Rebin an input EventWorkspace according to the pulse times of the events |
| CRebinByTimeAtSample | RebinByTimeAtSample : Rebins an event workspace to a histogram workspace with time at sample along the x-axis |
| CRebinByTimeBase | RebinByTimeBase : Algorithm base class for algorithms performing rebinning by an absolute time axis |
| CRebinToWorkspace | Rebins a workspace so that the binning, for all its spectra, match that of the first spectrum of a second workspace |
| CRebunch | Takes a workspace as input and rebunches the data according to the input rebunch parameters |
| CRecordPythonScript | RecordPythonScript : |
| CRectangularBeamProfile | Defines a flat, rectangular beam profile that has a width, height and center point |
| CRegroup | Takes a 2D workspace as input and regroups the data according to the input regroup parameters |
| CRemoveBackground | |
| CRemoveBins | Removes bins from a workspace |
| CRemoveInstrumentGeometry | RemoveInstrumentGeometry : |
| CRemoveLowResTOF | |
| CRemoveMaskedSpectra | RemoveMaskedSpectra removes all masked spectra |
| CRemovePromptPulse | RemovePromptPulse : TODO: DESCRIPTION |
| CRemoveSpectra | |
| CRemoveWorkspaceHistory | RemoveWorkspaceHistory |
| CRenameWorkspace | Renames a workspace to a different name in the data service |
| CRenameWorkspaces | Renames a workspace to a different name in the data service |
| CReplaceSpecialValues | Replaces instances of NaN and infinity in the workspace with user defined numbers |
| CResampleX | ResampleX : TODO: DESCRIPTION |
| CResetNegatives | ResetNegatives : Reset negative values to something else |
| CResizeRectangularDetector | ResizeRectangularDetector : TODO: DESCRIPTION |
| CRingProfile | Calculates the sum of the counts against a circular ring |
| CRunCombinationHelper | |
| ►CSampleLogsBehaviour | SampleLogsBehaviour : This class holds information relating to the behaviour of the sample log merging |
| CParameterName | |
| CSampleLogBehaviour | |
| CSampleLogNames | |
| CSANSCollimationLengthEstimator | |
| CSassenaFFT | Perform Fourier Transform of the Sassena Intermediate Scattering Function |
| CScale | Scales an input workspace by the given factor, which can be either multiplicative or additive |
| CScaleX | Takes a workspace and adjusts all the time bin values by the same multiplicative factor |
| CScatterPointStat | |
| CSegfault | Segfault : TODO: DESCRIPTION |
| CSetInstrumentParameter | SetInstrumentParameter : A simple algorithm to add or set the value of an instrument parameter |
| CSetUncertainties | Set the uncertainties of the data to zero |
| CShiftLogTime | ShiftLogTime : TODO: DESCRIPTION |
| CSignalOverError | Calculate Y/E for a Workspace2D |
| CSmoothData | 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 |
| CSmoothNeighbours | Smooth neighboring pixels |
| CSofQCommon | |
| CSofQW | |
| CSofQWCentre | 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 |
| CSofQWNormalisedPolygon | 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 |
| CSofQWPolygon | 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 |
| CSolidAngle | Calculates and outputs the solid angles for each detector in the instrument |
| CSortEvents | Takes an EventWorkspace and sorts by TOF or frame_index |
| CSortXAxis | SortXAxis will take Histogram or Point data and reorder it based on the X Axis' values, whilst maintaining it's Dx, Y and E axis relative values |
| CSparseWorkspace | Defines functions and utilities to create and deal with sparse instruments |
| CSpatialGrouping | This algorithm creates an XML Grouping File for use in the GroupDetectors (v2) or ReadGroupsFromFile algorithms |
| ►CSpectrumAlgorithm | SpectrumAlgorithm is a base class for algorithms that work with MatrixWorkspace |
| Ccontains | Helpers for for_each(), struct contains and 2 specializations |
| Ccontains< Tp > | |
| Ccontains< Tp, Head, Rest... > | |
| Cgens | |
| ►CIndices | Dummy struct holding compile-time flags to for_each() |
| CFromProperty | Flag: Include only indices specified via properties in for_each |
| Cseq | Helpers for for_each(), struct seq and gens with a specialization |
| CSphericalAbsorption | A spherical absorption correction algorithm |
| CStitch | Stitches overlapping spectra from multiple 2D workspaces |
| CStitch1D | Stitch1D : Stitches two Matrix Workspaces together into a single output |
| CStitch1DMany | Stitch1DMany : Stitches multiple Matrix Workspaces together into a single output |
| CStripPeaks | This algorithm calls FindPeaks as a ChildAlgorithm and then subtracts all the peaks found from the data, leaving just the 'background' |
| CStripVanadiumPeaks | StripVanadiumPeaks algorithm |
| CStripVanadiumPeaks2 | StripVanadiumPeaks2 |
| CSumEventsByLogValue | Produces a table or single spectrum workspace containing the total summed events in the workspace as a function of a specified log |
| CSumNeighbours | Sums neighboring pixels on rectangular detectors |
| CSumOverlappingTubes | SumOverlappingTubes : Converts workspaces containing an instrument with PSD tubes into a workspace with counts as a function of height and scattering angle |
| CSumRowColumn | This algorithm is the equivalent of the COLETTE "DISPLAY H/V" command |
| CSumSpectra | Takes a workspace as input and sums all of the spectra within it maintaining the existing bin structure and units |
| CTimeAtSampleStrategy | TimeAtSampleStrategy : Strategy (technique dependent) for determining Time At Sample |
| CTimeAtSampleStrategyDirect | TimeAtSampleStrategyDirect : Determine the Time at Sample corrections for a Direct Geometry instrument |
| CTimeAtSampleStrategyElastic | TimeAtSampleStrategyElastic : Time at sample stragegy for elastic scattering |
| CTimeAtSampleStrategyIndirect | TimeAtSampleStrategyIndirect : Determine Time At Sample for an indirect instrument setup |
| CTOFSANSResolution | Computes the resolution on TOF SANS data Required Properties: |
| CTOFSANSResolutionByPixel | Calculates the TOF-SANS Q-resolution for each wavelenght and pixel using formula by Mildner and Carpenter |
| CTOFSANSResolutionByPixelCalculator | Helper class which provides the uncertainty calculations for the TOFSANSResolutionByPixel class |
| Ctolerant_less | Std-style comparision function object (satisfies the requirements of Compare) |
| CTranspose | This algorithm "transposes" the bins of the input workspace into a single spectra |
| CUnaryOperation | UnaryOperation supports the implementation of a Unary operation on an input workspace |
| CUnGroupWorkspace | Takes the name of a group workspace as input and ungroups the workspaces |
| CUnwrapMonitor | Takes an input Workspace2D that contains 'raw' data, unwraps the data according to the reference flightpath provided and converts the units to wavelength |
| CUnwrapMonitorsInTOF | UnwrapMonitorsInTOF : Handles workspaces which contain monitors that recorded data which spills over from the previous frame |
| CUnwrapSNS | Takes an input Workspace2D that contains 'raw' data, unwraps the data according to the reference flightpath provided and converts the units to wavelength |
| CUpdateScriptRepository | UpdateScriptRepository : Check the MantidWeb, for updates of the ScriptRepository |
| CVesuvioL1ThetaResolution | VesuvioL1ThetaResolution |
| CWeightedMean | An algorithm to calculate the weighted mean of two workspaces |
| CWeightedMeanOfWorkspace | WeightedMeanOfWorkspace This algorithm calculates the weighted mean for a single workspace from all the detector (non-monitor, not masked) spectra in that workspace |
| CWeightingStrategy | WeightingStrategy : |
| CWienerSmooth | WienerSmooth algorithm performes smoothing data in a spectrum of a matrix workspace using the Wiener filter smoothing |
| CWorkflowAlgorithmRunner | Controls the data flow and the order of algorithm execution |
| CWorkspaceBoundingBox | |
| CWorkspaceJoiners | A base class to hold code common to two algorithms that bolt two workspaces together spectra-wise - ConjoinWorkspaces & AppendSpectra |
| CXDataConverter | This is an abstract base class for sharing methods between algorithms that operate only on X data |
| CXrayAbsorptionCorrection | Calculates attenuation of xrays due to absorption in a sample |
| ►NAPI | |
| CADSValidator | ADSValidator : a validator that requires the value of a property to be present in the ADS |
| ►CAlgorithm | Base class from which all concrete algorithm classes should be derived |
| CAlgorithmNotification | Base class for algorithm notifications |
| CCancelException | CancelException is thrown to cancel execution of the algorithm |
| CErrorNotification | ErrorNotification is sent when an exception is caught during execution of the algorithm |
| CFinishedNotification | FinishedNotification is sent after the algorithm finishes its execution |
| CProgressNotification | An algorithm can report its progress by sending ProgressNotification |
| CStartedNotification | StartedNotification is sent when the algorithm begins execution |
| CAlgorithmDescriptor | Structure uniquely describing an algorithm with its name, category and version |
| CAlgorithmFactoryImpl | The AlgorithmFactory class is in charge of the creation of concrete instances of Algorithms |
| CAlgorithmFactoryObserver | |
| CAlgorithmHasProperty | A validator to check whether a given algorithm has a named property |
| CAlgorithmHistory | This class stores information about the Command History used by algorithms on a workspace |
| CAlgorithmManagerImpl | Responsible for controlling algorithm instances |
| CAlgorithmObserver | Observes Algorithm notifications: start,progress,finish,error |
| CAlgorithmProperty | Define an algorithm property that can be used to supply an algorithm object to a subsequent algorithm |
| CAlgorithmStartingNotification | Class for when an algorithm is starting asynchronously |
| ►CAnalysisDataServiceImpl | The Analysis data service stores instances of the Workspace objects and anything that derives from template class DynamicFactory<Mantid::Kernel::IAlgorithm> |
| CGroupUpdatedNotification | GroupWorkspaces notification is send when a group is updated by adding or removing members |
| CGroupWorkspacesNotification | GroupWorkspaces notification is send from GroupWorkspaces algorithm |
| CUnGroupingWorkspaceNotification | UnGroupingWorkspace notification is sent from UnGroupWorkspace algorithm before the WorkspaceGroup is removed from the DataService |
| CAnalysisDataServiceObserver | |
| CArchiveSearchFactoryImpl | Creates instances of IArchiveSearch |
| CAttributeLambdaVisitor | Attribute visitor structure supporting lambda expressions Example usage: AttributeLambdaVisitor{[](const int val) {...}, [] (const double val) {}} would create a visitor capable of "visiting" an integer and double attribute* It functions by inheriting the () operator defined in each lambda |
| CAxis | Class to represent the axis of a workspace |
| CBinEdgeAxis | Stores numeric values that are assumed to be bin edge values |
| CBoolean | As TableColumn stores its data in a std::vector bool type cannot be used in the same way as the other types |
| CBoxController | This class is used by MDBox and MDGridBox in order to intelligently determine optimal behavior |
| CBoxControllerSettingsAlgorithm | An abstract algorithm sub-class for algorithms that define properties for BoxController settings |
| CCatalogFactoryImpl | The factory is a singleton that hands out shared pointers to the base Catalog class |
| CCatalogManagerImpl | This class is a singleton and is responsible for creating, destroying, and managing catalogs |
| CCatalogSession | This class is a responsible for storing session information for a specific catalog |
| CCitation | |
| CColumn | Column is the base class for columns of TableWorkspace |
| CColumnFactoryImpl | The ColumnFactory class is in charge of the creation of concrete instances of columns |
| CColumnVector | ColumnVector gives access to the column elements without alowing its resizing |
| CCommonBinsValidator | A validator which provides a TENTATIVE check that a workspace contains common bins in each spectrum |
| CCompositeCatalog | CompositeCatalog is responsible for storing and performing options on multiple catalogues |
| CCompositeDomain | Base class for a composite domain |
| CCompositeDomainMD | A composite domain for MD functions |
| CCompositeFunction | A composite function is a function containing other functions |
| CConstColumnVector | ConstColumnVector gives const access to the column elements without alowing its resizing |
| CConstraintFactoryImpl | The ConstraintFactory class is in charge of the creation of concrete instances of Constraints |
| CCoordTransform | Unique SingleValueParameter Declaration for InputNDimensions |
| CCostFunctionFactoryImpl | The CostFunctionFactory class is in charge of the creation of concrete instances of minimizers |
| CDeleterPolicy | |
| CDeprecatedAlgorithm | Class for marking algorithms as deprecated |
| CDeprecatedAlias | DeprecatedAlias : Class for making algorithm with deprecated names (aliases) |
| CDetectorSearcher | |
| CDistributedAlgorithm | Base class for algorithms that treat all spectra independently, i.e., we can trivially parallelize over the spectra without changes |
| CDomainCreatorFactoryImpl | Constructs a DomainCreator object from a string |
| CElementTraits | Default ElementTraits SFINAE Typetraits are used to provide the correct formatting based on the element type chosen |
| CElementTraits< bool > | ElementTraits for boolean element types |
| CElementTraits< double > | ElementTraits for double element types |
| CElementTraits< float > | ElementTraits for float element types |
| CElementTraits< size_t > | ElementTraits for boolean element types |
| CEnabledWhenWorkspaceIsType | Show a property as enabled when the workspace pointed to by another is of a given type |
| CEqualBinSizesValidator | EqualBinSizesValidator : Checks that all bins in a workspace are equally sized to within a given tolerance |
| CExperimentInfo | This class is shared by a few Workspace types and holds information related to a particular experiment/run: |
| ►CExpression | This class represents an expression made up of names, binary operators and brackets |
| COperators | Keeps operator that can be used in an expression |
| CParsingError | Specialised exception for parsing errors |
| CToken | This is a struct to mark a token in a string expression |
| CFileBackedExperimentInfo | Implements a lazy-loading mechanism for the experimental information stored in a NeXus file |
| CFileFinderImpl | This class finds data files given an instrument name (optionally) and a run number |
| ►CFileLoaderRegistryImpl | Keeps a registry of algorithm's that are file loading algorithms to allow them to be searched to find the correct one to load a particular file |
| CSubscriptionValidator | Helper for subscribe to check base class |
| CFileProperty | A specialized class for dealing with file properties |
| CFrameworkManagerImpl | The main public API via which users interact with the Mantid framework |
| CFuncMinimizerFactoryImpl | The FuncMinimizerFactory class is in charge of the creation of concrete instances of minimizers |
| CFunctionDomain | Base class that represents the domain of a function |
| CFunctionDomain1D | Represent a domain for functions of one real argument |
| CFunctionDomain1DHistogram | Implements FunctionDomain1D as a set of bins for a histogram |
| CFunctionDomain1DSpectrum | Specialization of FunctionDomain1DVector for spectra of MatrixWorkspaces |
| CFunctionDomain1DVector | Implements FunctionDomain1D with its own storage in form of a std::vector |
| CFunctionDomain1DView | 1D domain - a wrapper around an array of doubles |
| CFunctionDomainGeneral | Represent a domain of a very general type |
| CFunctionDomainMD | Implements a domain for MD functions (IFunctionMD) |
| CFunctionFactoryImpl | The FunctionFactory class is in charge of the creation of concrete instances of fitting functions |
| CFunctionGenerator | FunctionGenerator is a partial implementation of IFunction that defines a function consisting of two parts: the source and the target |
| CFunctionHandler | Classes inherited from FunctionHandler will handle the function |
| CFunctionParameterDecorator | FunctionParameterDecorator |
| CFunctionProperty | A property class for functions |
| CFunctionValues | A class to store values calculated by a function |
| CGenericDataProcessorAlgorithm | Data processor algorithm to be used as a parent to workflow algorithms |
| CGridDomain | |
| CGridDomain1D | |
| CGrouping | Structure to represent grouping information |
| CGroupingLoader | GroupingLoader : Loads instrument grouping from IDF file |
| CHistogramValidator | A validator which checks that a workspace contains histogram data (the default) or point data as required |
| CHistoryItem | |
| CHistoryView | This class wraps an algorithm history pointer to add additional functionality when creating a HistoryView |
| CHistoWorkspace | HistoWorkspace is an abstract base class for MatrixWorkspace types that are NOT event workspaces |
| CIAlgorithm | IAlgorithm is the interface implemented by the Algorithm base class |
| CIArchiveSearch | This class is an archive searching interface |
| CIBackgroundFunction | An interface to a background function |
| CIBoxControllerIO | The header describes interface to IO Operations perfomed by the box controller May be replaced by a boost filestream in a future |
| CICatalog | This class creates an interface for information catalogs to support multiple facilities |
| CICatalogInfoService | This class is responsible for interfacing with the Information Data Service (IDS) to upload and download files to and from the archives |
| CIConstraint | An interface to a constraint |
| CICostFunction | An interface for specifying the cost function to be used with Fit algorithm or minimizers, for example, the default being least squares fitting |
| CIDomainCreator | An base class for domain creators for use in Fit |
| CIEventList | IEventList : Interface to Mantid::DataObjects::EventList class, used to expose to PythonAPI |
| CIEventWorkspace | This class provides an interface to an EventWorkspace |
| CIFileLoader | Defines an interface to an algorithm that loads a file so that it can take part in the automatic selection procedure provided by the FileLoaderRegistry |
| CIFuncMinimizer | An interface for function minimizers |
| ►CIFunction | This is an interface to a fitting function - a semi-abstarct class |
| CAttribute | Attribute is a non-fitting parameter |
| CAttributeValidatorVisitor | Atribute validator visitor class |
| CAttributeVisitor | Atribute visitor class |
| CConstAttributeVisitor | Const version of AttributeVisitor |
| CValidationException | Simple Exception Struct to differentiate validation error from other exceptions |
| CValidatorEvaluator | Simple struct to constain function to evaluate attribute validators that is required in both attributes and visitors |
| CIFunction1D | This is a specialization of IFunction for functions of one real argument |
| CIFunction1DSpectrum | IFunction1DSpectrum : |
| CIFunctionGeneral | IFunctionGeneral: a very general function definition |
| CIFunctionMD | This is a specialization of IFunction for functions defined on an IMDWorkspace |
| CIFunctionMW | This is a specialization of IFunction for functions defined on a MatrixWorkspace |
| CIFunctionWithLocation | An interface to a function with location, which here means a function for which the user may ask what is its centre and height |
| CIJournal | IJournal: Interface for classes that fetch information from journal files |
| CILatticeFunction | ILatticeFunction |
| CILiveListener | ILiveListener is the interface implemented by classes which connect directly to instrument data acquisition systems (DAS) for retrieval of 'live' data into Mantid |
| CIMaskWorkspace | This class provides an interface to a MaskWorkspace |
| CIMDEventWorkspace | Abstract base class for multi-dimension event workspaces (MDEventWorkspace) |
| CIMDHistoWorkspace | Abstract interface to MDHistoWorkspace, for use in exposing to Python |
| CIMDIterator | This is an interface to an iterator of an IMDWorkspace |
| CIMDNode | |
| ►CIMDWorkspace | Basic MD Workspace Abstract Class |
| CLinePlot | Holds X, Y, E for a line plot |
| CImmutableCompositeFunction | Immutable composite function is a composite function which members cannot be added or removed after creation |
| CImplicitFunctionBuilder | This class is the abstract type for building IImplicitFunctions |
| CImplicitFunctionFactoryImpl | |
| CImplicitFunctionParameter | Abstract parameter type for use with IImplicitFunctions |
| CImplicitFunctionParameterParser | |
| CImplicitFunctionParameterParserFactoryImpl | |
| CImplicitFunctionParser | XML Parser for function types |
| CImplicitFunctionParserFactoryImpl | |
| CIncreasingAxisValidator | A validator which checks that the X axis of a workspace is increasing from left to right |
| CIndexProperty | IndexProperty : Implementation of a property type which returns a SpectrumIndexSet provided an input vector of integers or a string |
| CIndexTypeProperty | IndexTypeProperty : Implementation of a property which stores the type of input indices users require for accessing workspace data |
| CInstrumentDataServiceImpl | InstrumentDataService Class |
| CInstrumentFileFinder | |
| CInstrumentValidator | A validator which checks that a workspace has a valid instrument |
| CIntegrationResult | PeakFunctionIntegrator : |
| CIPawleyFunction | IPawleyFunction |
| CIPeakFunction | An interface to a peak function, which extend the interface of IFunctionWithLocation by adding methods to set and get peak width |
| CIPeaksWorkspace | Interface to the class Mantid::DataObjects::PeaksWorkspace |
| CIPowderDiffPeakFunction | An interface to a peak function, which extend the interface of IFunctionWithLocation by adding methods to set and get peak width |
| CIPreview | IPreview : This is the abstract base class of the raw data previews |
| CISpectrum | A "spectrum" is an object that holds the data for a particular spectrum, in particular: |
| CISplittersWorkspace | ISplittersWorkspace : Workspace to contain splitters for event filtering |
| CITableWorkspace | ITableWorkspace is an implementation of Workspace in which the data are organised in columns of same size |
| CITransformScale | |
| CIWorkspaceProperty | An interface that is implemented by WorkspaceProperty |
| CJacobian | Represents the Jacobian in IFitFunction::functionDeriv |
| CJointDomain | An implementation of CompositeDomain |
| CLatticeDomain | LatticeDomain |
| CLinearScale | |
| CLiveListener | Base implementation for common behaviour of all live listener classes |
| CLiveListenerFactoryImpl | The factory for creating instances of ILiveListener implementations |
| CLockMode | Enumeration for locking behaviour |
| CLogarithmScale | |
| CLogFilterGenerator | LogFilterGenerator : utility to generate a LogFilter, to filter by running status or period |
| CLogManager | This class contains the information about the log entries |
| CMatrixWorkspace | Base MatrixWorkspace Abstract Class |
| CMatrixWorkspaceMDIterator | IMDIterator-compatible implementation of an iterator through a MatrixWorkspace |
| CMatrixWorkspaceValidator | An interface for those validators that require the MatrixWorkspace interface |
| CMDFrameValidator | |
| CMDGeometry | Describes the geometry (i.e |
| CMDGeometryNotificationHelper | |
| CMultiDomainFunction | A composite function defined on a CompositeDomain |
| CMultiPeriodGroupAlgorithm | MutliPeriodGroupAlgorithm : Abstract algorithm |
| CMultiPeriodGroupWorker | MultiPeriodGroupWorker : Multiperiod group logic relating to determining a valid multiperiod group, and processing a multiperiod group, as well as combining and returning the output |
| CMultipleExperimentInfos | Small class that allows a MDEventWorkspace or a MDHistoWorkspace to hold several ExperimentInfo classes |
| CMultipleFileProperty | A property to allow a user to specify multiple files to load |
| CMWDimension | |
| CMWXDimension | An implementation of IMDDimension for MatrixWorkspace that points to the X vector of the first spectrum |
| CNexusFileLoader | |
| CNotebookBuilder | |
| CNotebookWriter | |
| CNullCoordTransform | NullCoordTransform : A transform that sets the outVector to have the same values as the inputVector |
| CNumericAxis | Class to represent a numeric axis of a workspace |
| CNumericAxisValidator | A validator which checks whether the input workspace has the Numeric data in the axis |
| COrientedLatticeValidator | |
| CParallelAlgorithm | Base class for algorithms that can run in parallel on all MPI ranks but not in a distributed fashion |
| CParameterReference | A reference to a parameter in a function |
| CParameterTie | Ties fitting parameters |
| CParamFunction | Implements the part of IFunction interface dealing with parameters |
| CPartialJacobian | A Jacobian for individual functions |
| CPeakFunctionIntegrator | |
| CPreviewManagerImpl | PreviewManager : Manages the raw data previews |
| CProgress | Helper class for reporting progress from algorithms |
| CProjection | |
| CPropertyMode | Enumeration for a mandatory/optional property |
| CRawCountValidator | A validator which checks that a workspace contains raw counts in its bins |
| CRefAxis | 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 |
| CReferenceEqual | Used to find ParameterTie for a parameter i |
| CRegionSelectorObserver | |
| CRun | This class stores information regarding an experimental run as a series of log entries |
| CSample | This class stores information about the sample used in particular run |
| CSampleShapeValidator | Verify that a workspace has valid sample shape |
| CSampleValidator | A validator which checks that sample has the required properties |
| CScopedWorkspace | ScopedWorkspace : scoped workspace ADS entry |
| CScriptBuilder | This class build a sttring which cana be executed as a python script |
| CScriptInfo | Information about the files inside the repository |
| CScriptRepoException | The ScriptRepository class is intended to be used mainly by the users, who will be willing to share and download scripts for their analysis |
| CScriptRepository | |
| CScriptRepositoryFactoryImpl | In charge of the creation of concrete instance of ScriptRepository interface |
| CSerialAlgorithm | Base class for algorithms that can only run serially (Parallel::ExecutionMode::MasterOnly) in an MPI run |
| CSingleCountValidator | SingleCountValidator : This validator checks that there is only a single entry per spectrum, the counts, so no Time-of-Flight data |
| CSingleValueParameter | SingleValueParameter is a templated base class implementing CRTP |
| CSingleValueParameterParser | XML Parser for single value parameter types |
| CSpectraAxis | Class to represent the spectra axis of a workspace |
| CSpectraAxisValidator | A validator which checks whether the input workspace has the Spectra number in the axis |
| CSpectrumDetectorMapping | A minimal class to hold the mapping between the spectrum number and its related detector ID numbers for a dataset |
| CSpectrumInfo | API::SpectrumInfo is an intermediate step towards a SpectrumInfo that is part of Instrument-2.0 |
| CSpectrumInfoItem | SpectrumInfoItem |
| CSpectrumInfoIterator | SpectrumInfoIterator |
| CTableColumnHelper | Helper class used to create ColumnVector |
| CTableConstColumnHelper | Helper class used to create ConstColumnVector |
| CTableRow | TableRow represents a row in a TableWorkspace |
| CTableRowHelper | Helper class used to create TableRow |
| CTempJacobian | |
| CTextAxis | Class to represent a text axis of a workspace |
| CTopology | Abstract type represents topology for visualisation |
| CTransformScaleFactoryImpl | Constructs a scaling transform object from a string |
| CVectorParameter | VectorParameter is abstract type implementing curiously recurring template pattern to implement common code associated with vector storage |
| CVectorParameterParser | XML parser for vector value (n elements) parameter types |
| CWorkspace | Base Workspace Abstract Class |
| CWorkspaceFactoryImpl | The WorkspaceFactory class is in charge of the creation of all types of workspaces |
| CWorkspaceGroup | Class to hold a set of workspaces |
| CWorkspaceHasDxValidator | WorkspaceHasDxValidator : A validator which checks that all histograms in a workspace have Dx values |
| CWorkspaceHelpers | A collection of static functions for use with workspaces |
| CWorkspaceHistory | This class stores information about the Workspace History used by algorithms on a workspace and the environment history |
| CWorkspaceNearestNeighbourInfo | WorkspaceNearestNeighbourInfo provides easy access to nearest-neighbour information for a workspace |
| CWorkspaceNearestNeighbours | This class is not intended for direct use |
| CWorkspaceProperty | A property class for workspaces |
| CWorkspaceUnitValidator | A validator which checks that the unit of the workspace referred to by a WorkspaceProperty is the expected one |
| ►NCrystal | |
| ►NFindSXPeaksHelper | |
| CAbsoluteBackgroundStrategy | |
| CAbsoluteCompareStrategy | |
| CAllPeaksStrategy | |
| CBackgroundStrategy | |
| CCompareStrategy | |
| CFindMaxReduceStrategy | |
| CPeakContainer | |
| CPeakFindingStrategy | |
| CPerSpectrumBackgroundStrategy | |
| CReducePeakListStrategy | |
| CRelativeCompareStrategy | |
| CSimpleReduceStrategy | |
| CStrongestPeaksStrategy | |
| CSXPeak | |
| ►NPeakStatisticsTools | |
| CPeaksStatistics | Small helper class that is used in SortHKL |
| CUniqueReflection | This class is a small helper for SortHKL to hold Peak-objects that belong to the same family of reflections |
| CUniqueReflectionCollection | This class computes all possible unique reflections within the specified d-limits, given a certain unit cell, lattice centering and point group |
| CAddPeakHKL | AddPeakHKL : Algorithm to add a peaks to a PeaksWorkspace in the HKL frame |
| CAnvredCorrection | Calculates anvred correction factors for attenuation due to absorption and scattering in a spherical sample |
| CBackgroundStrategy | BackgroundStrategy : Abstract class used for identifying elements of a IMDWorkspace that are not considered background |
| CCalculatePeaksHKL | CalculatePeaksHKL : Calculate the HKL value for each peak without any rounding or optimization of the UB Matrix |
| CCalculateUMatrix | CalculateUMatrix : Algorithm to calculate the U matrix, given lattice parameters and a list of peaks |
| CCentroidPeaks | Find the centroid of single-crystal peaks in a 2D Workspace, in order to refine their positions |
| CClearUB | ClearUB : Clear the UB matrix from a workspace by removing the oriented lattice |
| CCluster | Cluster : Image cluster used by connected component labeling |
| CClusterRegister | ClusterRegister : A fly-weight ICluster regeister |
| CCombinePeaksWorkspaces | An algorithm that combines the sets of peaks in two peaks workspaces |
| CCompositeCluster | CompositeCluster : Cluster made by by merging other IClusters |
| CConnectedComponentLabeling | ConnectedComponentLabelling : Implements connected component labeling on MDHistoWorkspaces |
| CConvertPeaksWorkspace | ConvertPeaksWorkspace : Bi-directional conversion between a regular PeaksWorkspace (with instrument) and a LeanElasticPeaksWorkspace (no instrument) |
| CCountReflections | CountReflections |
| CDataModeHandler | Integrates each time slice using the BivariateNormal formula, adding the results to the peak object |
| CDiffPeaksWorkspaces | An algorithm that subtracts from a workspace (the LHSWorkspace) any peaks that match entries in a second workspace (the RHSWorkspace) |
| CDisjointElement | DisjointElement : Cluster item used in a disjoint-set data structure |
| CFilterPeaks | FilterPeaks : Filter a peaks workspace based on a set number of queries to provide a new, filtered peaks workspace |
| CFindClusterFaces | FindClusterFaces : Algorithm to find faces of clusters in an MDHistoWorkspace (image) |
| CFindSXPeaks | Search detector space for single crystal peaks |
| CFindUBUsingFFT | FindUBUsingFFT : Algorithm to calculate a UB matrix using fast Fourier transforms given a list of peaks and bounds on the lattice parameters |
| CFindUBUsingIndexedPeaks | FindUBUsingIndexedPeaks : Algorithm to calculate a UB matrix, given a list of peaks that have already been indexed by some means |
| CFindUBUsingLatticeParameters | FindUBUsingLatticeParameters : Algorithm to calculate a UB matrix, given lattice parameters and a list of peaks |
| CFindUBUsingMinMaxD | FindUBUsingMinMaxD : Algorithm to calculate a UB matrix, given bounds on the lattice parameters and a list of peaks |
| CGoniometerAnglesFromPhiRotation | |
| CHardThresholdBackground | HardThresholdBackground : Implementation of BackgroundStrategy using a fixed background signal value as the threshold |
| CHasUB | HasUB : Determine if a workspace has a UB matrix on any of it's samples |
| CICluster | ICluster : Abstract cluster |
| CImplClusterRegister | |
| Cindex | Peak indexing algorithm, which works by assigning multiple possible HKL values to each peak and then culling these options by comparison with neighbouring peaks |
| CIndexPeaks | Implements an algorithm for indexing main and satellites peaks in single crystal peaks |
| CIndexSXPeaks | |
| CIntegratePeaksHybrid | IntegratePeaksHybrid : Integrate single crystal peaks algorithm |
| CIntegratePeaksUsingClusters | IntegratePeaksUsingClusters : Uses clustering to integrate peaks |
| CIntegratePeakTimeSlices | |
| CLoadHKL | LoadHKL : Load an ISAW-style .hkl file into a PeaksWorkspace |
| CLoadIsawPeaks | Load an ISAW-style .peaks or .integrate file into a PeaksWorkspace |
| CLoadIsawSpectrum | Load incident spectrum and detector efficiency correction file |
| CLoadIsawUB | Algorithm to load an ISAW-style ASCII UB matrix and lattice parameters file, and place its information into a workspace |
| CMaskPeaksWorkspace | Find the offsets for each detector |
| CModulationProperties | Tie together the names of the properties for the modulation vectors |
| CNormaliseVanadium | Calculates anvred correction factors for attenuation due to absorption and scattering in a spherical sample |
| COptimizeCrystalPlacement | OptimizeCrystalPlacement |
| COptimizeLatticeForCellType | Find the offsets for each detector |
| COrEnabledWhenProperties | |
| CPeakBackground | PeakBackground : Extension of HardThresholdBackground to consider regions of the image as background if they are outside the peaks radius limits (no mater what their theshold is) |
| CPeakCandidate | |
| CPeakClusterProjection | PeakClusterProjection : Maps peaks onto IMDHistoWorkspaces and returns the signal value at the peak center |
| CPeakHKLErrors | |
| CPeakIntegration | Find the offsets for each detector |
| CPeakIntensityVsRadius | Calculate the integrated intensity of peaks vs integration radius |
| CPeaksInRegion | PeaksInRegion : Find peaks that are either inside a box region, or that have a radius of sufficent size, that they intersect the box |
| CPeaksIntersection | PeaksIntersection : Abstract base algorithm class for algorithms that identify peaks interacting with one or more surfaces i.e |
| CPeaksOnSurface | PeaksOnSurface : Check peak workspace interaction with a single surface |
| CPredictFractionalPeaks | Using a set of offset vectors, either provided as separate lists or as a set of vectors, predict whether |
| CPredictPeaks | Using a known crystal lattice and UB matrix, predict where single crystal peaks should be found in detector/TOF space |
| CPredictSatellitePeaks | PredictSatellitePeaks : Algorithm to create a PeaksWorkspace with peaks corresponding to fractional h,k,and l values |
| CSaveHKL | Save a PeaksWorkspace to a Gsas-style ASCII .hkl file |
| CSaveIsawPeaks | Save a PeaksWorkspace to a ISAW-style ASCII .peaks file |
| CSaveIsawUB | Algorithm to save a UB matrix and lattice parameters to an ISAW-style ASCII file |
| CSaveLauenorm | Save a PeaksWorkspace to a lauenorm format http://www.ccp4.ac.uk/cvs/viewvc.cgi/laue/doc/lauenorm.ptx?diff_format=s&revision=1.1.1.1&view=markup |
| CSCDCalibratePanels | SCDCalibratePanels calibrates instrument parameters for Rectangular Detectors |
| CSCDCalibratePanels2 | SCDCalibratePanels2 : Using input peakworkspace with indexation results to calibrate each individual panels |
| CSCDCalibratePanels2ObjFunc | SCDCalibratePanels2ObjFunc : TODO: DESCRIPTION |
| CSCDPanelErrors | |
| CSelectCellOfType | 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 |
| CSelectCellWithForm | 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 |
| CSetCrystalLocation | SetCrystalLocation |
| CSetGoniometer | Define the goniometer used in an experiment by giving the axes and directions of rotations |
| CSetSpecialCoordinates | SetSpecialCoordinates : |
| CSetUB | 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 |
| CShowPeakHKLOffsets | |
| CShowPossibleCells | 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 |
| CSortHKL | Save a PeaksWorkspace to a Gsas-style ASCII .hkl file |
| CSortPeaksWorkspace | SortPeaksWorkspace : Sort a PeaksWorkspace by a range of properties |
| CStatisticsOfPeaksWorkspace | Statistics of a PeaksWorkspace |
| CTransformHKL | TransformHKL : Algorithm to adjust the UB saved in the sample associated with the specified PeaksWorkspace, so the HKL values are reordered or otherwise transformed |
| ►NCurveFitting | |
| ►NAlgorithms | |
| CCalculateChiSquared | Calculate chi squared for a function and a data set in a workspace |
| CCalculateCostFunction | Calculate cost function for a function and a data set in a workspace |
| CChiSlice | Helper class to calculate the chi squared along a direction in the parameter space |
| CConvertToYSpace | Takes a workspace with X axis in TOF and converts it to Y-space where the transformation is defined by equation (7) in http://link.aip.org/link/doi/10.1063/1.3561493?ver=pdfcov |
| CConvolutionFit | ConvolutionFit : Performs a QENS convolution fit |
| CConvolveWorkspaces | Convolution of two workspaces |
| CDetectorParams | Simple data structure to store nominal detector values It avoids some functions taking a huge number of arguments |
| CDoublePulseFit | A function to fit muon data from a double pulse source |
| CEstimateFitParameters | Estimate parameters of a fitting function using a Monte Carlo algorithm |
| CEstimatePeakErrors | |
| CEvaluateFunction | Evaluate a function (1D or MD) on a domain of an input workspace and save the result in the output workspace |
| CFit | A generic fitting algorithm |
| CFit1D | Deprecation notice: instead of using this algorithm please use the Fit algorithm instead |
| CFitData | Structure to contain least squares data and used by GSL |
| CFitPowderDiffPeaks | FitPowderDiffPeaks : Fit peaks in powder diffraction pattern |
| CInputSpectraToFit | |
| CIqtFit | |
| CJacobianImpl | The implementation of Jacobian |
| CLeBailFit | |
| CLeBailFunction | LeBailFunction : LeBailFunction is to calculate peak intensities in a composite function including neutron peak and background functions |
| CNormaliseByPeakArea | |
| CParameter | LeBailFit : Algorithm to do Le Bail Fit |
| CPawleyFit | This algorithm uses the Pawley-method to refine lattice parameters using a powder diffractogram and a list of unique Miller indices |
| CPlotPeakByLogValue | Takes a workspace group and fits the same spectrum in all workspaces with the same function |
| CProfileChiSquared1D | Profiles chi2 about its minimum to find parameter errors |
| CQENSFitSequential | QENSFitSequential - Performs a sequential QENS fit |
| CQENSFitSimultaneous | QENSFitSimultaneous - Algorithm for performing a simultaneous QENS fit |
| CRefinePowderInstrumentParameters | RefinePowderInstrumentParameters : Algorithm to refine instrument geometry parameters only |
| CRefinePowderInstrumentParameters3 | RefinePowderInstrumentParameters3 : |
| ►CSplineBackground | SplineBackground |
| CbSplinePointers | Struct holding various pointers required by GSL |
| CSplineInterpolation | Takes two workspaces as input |
| CSplineSmoothing | Takes a 2D workspace and produces an output workspace containing a smoothed version of the data by selecting a number of points to define a spline for each histogram in the workspace |
| CV3DFromHKLColumnExtractor | Small helper class to extract HKLs as V3D from table columns |
| ►CVesuvioCalculateGammaBackground | |
| CFoilInfo | Hold information about a single foil |
| ►CVesuvioCalculateMS | Calculates the multiple scattering & total scattering contributions for a flat-plate or cylindrical sample |
| CComptonNeutronAtom | |
| CSampleComptonProperties | |
| ►NConstraints | |
| CBoundaryConstraint | A boundary constraint is designed to be used to set either upper or lower (or both) boundaries on a single parameter |
| ►NCostFunctions | |
| CCostFuncFitting | A semi-abstract class for a cost function for fitting functions |
| CCostFuncLeastSquares | Cost function for least squares |
| CCostFuncPoisson | CostFuncPoisson : Implements a cost function for fitting applications using a Poisson measure |
| CCostFuncRwp | Cost function for Rwp = (sum_i (( obs_i - cal_i )/sigma_i)**2 ) / (sum_i (obs_i/sigma_i)**2) |
| CCostFuncUnweightedLeastSquares | In contrast to CostFuncLeastSquares, this variant of the cost function assumes that there are no weights attached to the values, so all observations will have unit weights |
| ►NFuncMinimisers | |
| CBFGS_Minimizer | Implementing Broyden-Fletcher-Goldfarb-Shanno (BFGS) algorithm by wrapping the IFuncMinimizer interface around the GSL implementation of this algorithm |
| CDampedGaussNewtonMinimizer | Implements a Gauss-Newton minimization algorithm with damping for use with least squares cost function |
| CDerivMinimizer | A wrapper around the GSL functions implementing a minimizer using derivatives |
| CFABADAMinimizer | FABADA : Implements the FABADA Algorithm, based on a Adaptive Metropolis Algorithm extended with Gibbs Sampling |
| CFRConjugateGradientMinimizer | Implementing Fletcher-Reeves flavour of the conjugate gradient algorithm by wrapping the IFuncMinimizer interface around the GSL implementation of this algorithm |
| CLevenbergMarquardtMDMinimizer | Implementing Levenberg-Marquardt algorithm |
| CLevenbergMarquardtMinimizer | Implementing Levenberg-Marquardt by wrapping the IFuncMinimizer interface around the GSL implementation of this algorithm |
| CMaleableCostFunction | Used to access the setDirty() protected member |
| CPRConjugateGradientMinimizer | Implementing Polak-Ribiere flavour of the conjugate gradient algorithm by wrapping the IFuncMinimizer interface around the GSL implementation of this algorithm |
| CSimplexMinimizer | Implementing Simplex by wrapping the IFuncMinimizer interface around the GSL implementation of this algorithm |
| CSteepestDescentMinimizer | Implementing the steepest descent algorithm by wrapping the IFuncMinimizer interface around the GSL implementation of this algorithm |
| CTrustRegionMinimizer | Trust Region minimizer class using the DTRS method of GALAHAD |
| ►NFunctions | |
| CAbragam | Provide Abragam fitting function for muon scientists |
| CActivationK | Provide Activation fit function for data in Kelvin interface to IFunction |
| CActivationmeV | Provide Activation fit function for data in meV interface to IFunction |
| CAsymmetricPearsonVII | Provides an implementation of the asymmetric PearsonVII function (sometimes it is also referred to as the split-PearsonVII function) |
| CBackgroundFunction | A background function |
| CBackToBackExponential | Provide BackToBackExponential peak shape function interface to IPeakFunction |
| CBivariateNormal | Provide peak shape function interface a Peak shape on one time slice of a RectangularDetector |
| CBk2BkExpConvPV | Bk2BkExpConvPV : Peak profile as tback-to-back exponential convoluted with pseudo-Voigt |
| CBSpline | A wrapper around Eigen functions implementing a B-spline |
| CChebfunBase | Base for function approximation with Chebyshev polynomials |
| CChebyshev | Implements Chebyshev polynomial expansion |
| CChudleyElliotSQE | Chudley-Elliots jump diffusion model |
| CComptonPeakProfile | This implements a resolution function for fitting a single mass in a compton scattering spectrum |
| CComptonProfile | This class serves as a base-class for ComptonProfile type functions |
| CComptonScatteringCountRate | Implements a specialized function that encapsulates the combination of ComptonProfile functions that give the Neutron count rate |
| ►CConvolution | Performes convolution of two functions |
| CHalfComplex | Class for helping to read the transformed data |
| CConvTempCorrection | Temperature correction used in the convolution fitting tab within the IDA GUI |
| CCriticalPeakRelaxationRate | Provide Critical peak of relaxation rate for fitting interface to IFunction |
| CCrystalFieldControl | A function that controls creation of the source of CrystalFieldFunction |
| CCrystalFieldFunction | Calculates crystal field spectra |
| CCrystalFieldHeatCapacity | |
| CCrystalFieldHeatCapacityBase | CrystalFieldHeatCapacity is a function that calculates the molar magnetic heat capacity (in J/K/mol) due to the splitting of electronic energy levels due to the crystal field |
| CCrystalFieldHeatCapacityCalculation | |
| CCrystalFieldMagnetisation | |
| CCrystalFieldMagnetisationBase | CrystalFieldMagnetisation is a function that calculates the induced magnetic moment (in bohr magnetons per ion, Am^2 or erg/Gauss) as a function of applied external magnetic field (in Tesla or Gauss), for a particular crystal field splitting |
| CCrystalFieldMagnetisationCalculation | |
| CCrystalFieldMoment | |
| CCrystalFieldMomentBase | CrystalFieldMoment is a function that calculates the induced magnetic moment (in bohr magnetons per ion, Am^2 or erg/Gauss) at some applied external magnetic field (in Tesla or Gauss) as a function of temperature (in Kelvin) for a particular crystal field splitting |
| CCrystalFieldMomentCalculation | |
| CCrystalFieldMultiSpectrum | Calculates crystal field spectra |
| CCrystalFieldPeaks | CrystalFieldPeaks is a function that calculates crystal field peak positions and intensities |
| CCrystalFieldPeaksBase | CrystalFieldPeaks is a function that calculates crystal field peak positions and intensities |
| CCrystalFieldPeaksBaseImpl | |
| CCrystalFieldPhysPropControl | |
| CCrystalFieldSpectrum | Calculates crystal field spectrum |
| CCrystalFieldSpectrumControl | |
| CCrystalFieldSusceptibility | |
| CCrystalFieldSusceptibilityBase | CrystalFieldSusceptibility is a function that calculates the molar magnetic susceptibility (in cm^3/mol or m^3/mol) due to the crystalline electric field |
| CCrystalFieldSusceptibilityCalculation | |
| ►CCubicSpline | A wrapper around GSL functions implementing cubic spline interpolation |
| CGSLFree | Functor to free a GSL objects in a shared pointer |
| CDecoupAsymPowderMagLong | Provide Decoupling of asymmetry in the ordered state of a powdered magnet for fitting function interface to IFunction |
| CDecoupAsymPowderMagRot | Provide Decoupling of asymmetry in the ordered state of a powdered magnet for fitting function interface to IFunction |
| CDeltaFunction | Delta function |
| CDiffRotDiscreteCircle | |
| CDiffSphere | |
| CDynamicKuboToyabe | Provide Dynamic Kubo Toyabe function interface to IFunction1D for muon scientists |
| CElasticDiffRotDiscreteCircle | |
| CElasticDiffSphere | Elastic part of the DiffSphere function |
| CElasticIsoRotDiff | Elastic part of the DiffSphere function |
| CEndErfc | Provide Errore function erfc()for calibrating the end of a tube |
| CExpDecay | Provide exponential decay function: h*exp(-(x-c)/t) |
| CExpDecayMuon | Provide exponential decay function: h*exp(-lambda.x) |
| CExpDecayOsc | Provide oscillating exponential decay function: h*exp(-lambda.x)*(cos(2pi*f*x+phi)) |
| CFickDiffusionSQE | Fick's law for diffusion |
| CFlatBackground | FlatBackground : TODO: DESCRIPTION |
| CFullprofPolynomial | FullprofPolynomial : Polynomial background defined in Fullprof |
| CFunctionQDepends | This is a specialization of IFunction1D for functions having the magnitude of the momentum transfer (Q) as attribute |
| CGausDecay | Provide gaussian decay function: A*exp(-(sigma.x)^2)) |
| CGausOsc | Provide gaussian decay function: A*exp(-(sigma.x)^2)) |
| CGaussian | Provide gaussian peak shape function interface to IPeakFunction |
| CGaussianComptonProfile | Implements a function to calculate the Compton profile of a nucleus using a Gaussian approximation convoluted with an instrument resolution function that is approximated by a Voigt function |
| CGramCharlier | Implements a Gram-Charlier A series expansion |
| CGramCharlierComptonProfile | Implements a function to calculate the Compton profile of a nucleus using a Gram-Charlier approximation convoluted with an instrument resolution function that is approximated by a Voigt function |
| CHallRossSQE | Hall-Ross jump diffusion model |
| CIkedaCarpenterPV | Provide Ikeda-Carpenter-pseudo-Voigt peak shape function interface to IPeakFunction |
| CInelasticDiffRotDiscreteCircle | |
| CInelasticDiffSphere | Inelastic part of the DiffSphere function |
| CInelasticIsoRotDiff | Inelastic part of the IsoRotDiff function |
| CIsoRotDiff | |
| CKeren | Keren : Keren fitting function for muon scientists |
| CLinearBackground | Provide linear function interface to IFunction |
| ClinearJ | Simple structure to hold a linear interpolation of factor J around its numerical divergence point |
| CLogNormal | Provide Log Normal function: h*exp(-(log(x)-t)^2 / (2*b^2) )/x |
| CLorentzian | Provide lorentzian peak shape function interface to IPeakFunction |
| CMagneticOrderParameter | Provide Magnetic Order Paramtere fit function interface to IFunction |
| CMultivariateGaussianComptonProfile | |
| CMuonFInteraction | Provide Muon F Interaction fitting function |
| CMuoniumDecouplingCurve | Provide Muonium-style decoupling curve function interface to IFunction |
| CNeutronBk2BkExpConvPVoigt | NeutronBk2BkExpConvPVoigt : Back-to-back exponential function convoluted with pseudo-voigt for epithermal neutron TOF |
| CPawleyFunction | The Pawley approach to obtain lattice parameters from a powder diffractogram works by placing peak profiles at d-values (which result from the lattice parameters and the Miller indices of each peak) and fitting the total profile to the recorded diffractogram |
| CPawleyParameterFunction | This function is used internally by PawleyFunction to hold the unit cell parameters as well as the ZeroShift parameter |
| CPeakParameterFunction | PeakParameterFunction : |
| CPolynomial | Polynomial : N-th polynomial background function |
| CPowerLaw | Provide Power Law function interface to IFunction |
| CProcessBackground | ProcessBackground : Process background obtained from LeBailFit |
| CProductFunction | Allow user to create a fit function which is the product of two or more other fit functions |
| CProductLinearExp | ProductLinearExp : Function that evauates the product of an exponential and linear function |
| CProductQuadraticExp | ProductQuadraticExp : Function that evauates the product of an exponential and quadratic function |
| CPseudoVoigt | PseudoVoigt |
| CQuadratic | Provide quadratic function interface to IFunction |
| CReflectivityMulf | ReflectivityMulf : Calculate the ReflectivityMulf from a simple layer model |
| CRemovePeaks | |
| CResolution | Resolution function |
| CResolutionParams | Simple data structure to store resolution parameter values It avoids some functions taking a huge number of arguments |
| CSimpleChebfun | SimpleChebfun : approximates smooth 1d functions and provides methods to manipulate them |
| CSmoothTransition | Provide Smooth Transition function interface to IFunction |
| CStaticKuboToyabe | Provide static Kubo Toyabe fitting function |
| CStaticKuboToyabeTimesExpDecay | StaticKuboToyabeTimesExpDecay fitting function |
| CStaticKuboToyabeTimesGausDecay | StaticKuboToyabeTimesGausDecay fitting function |
| CStaticKuboToyabeTimesStretchExp | StaticKuboToyabeTimesStretchExp fitting function |
| CStretchExp | Provide Streteched Exponential fitting function: h*exp(-(x/t)^b ) |
| CStretchExpMuon | Provide stetch exponential function for Muon scientists |
| CTabulatedFunction | A function which takes its values from a file or a workspace |
| CTeixeiraWaterSQE | Teixeira's model to describe the translational diffusion of water |
| CThermalNeutronBk2BkExpAlpha | ThermalNeutronBk2BkExpAlpha : Function to calculate Alpha of Bk2Bk Exponential function from Thermal Neutron Function's Alph0, Alph1, Alph0t, Alph1t, Dtt1, and etc |
| CThermalNeutronBk2BkExpBeta | ThermalNeutronBk2BkExpBETA : Function to calculate Beta of Bk2Bk Exponential function from Thermal Neutron Function's beta0, Alph1, Alph0t, Alph1t, Dtt1, and etc |
| CThermalNeutronBk2BkExpConvPVoigt | ThermalNeutronBk2BkExpConvPVoigt : Back-to-back exponential convoluted with pseudo Voigt for thermal neutron and epithermal neutron TOF |
| CThermalNeutronBk2BkExpSigma | ThermalNeutronBk2BkExpSIGMA : Function to calculate Sigma of Bk2Bk Exponential function from Thermal Neutron Function's Sig0, Sig1, Sig2, Width and etc |
| CThermalNeutronDtoTOFFunction | ThermalNeutronDtoTOFFunction : TODO: DESCRIPTION |
| CUserFunction | A user defined function |
| CUserFunction1D | 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 |
| CVesuvioResolution | Calculate the resolution from a workspace of Vesuvio data using the mass & instrument definition |
| CVoigt | Implements an analytical approximation to the Voigt function |
| Cxnlc | Structure to hold info on Volino's coefficients |
| ►NMSVesuvioHelper | |
| CRandomVariateGenerator | |
| CSimulation | |
| CSimulationAggregator | |
| CSimulationWithErrors | |
| ►NNLLS | |
| Call_eig_symm_work | Workspace for subroutine allEigSymm |
| Cevaluate_model_work | Workspace for subroutine evaluateModel |
| Cget_svd_J_work | Workspace for subroutine getSvdJ |
| Cmax_eig_work | Workspace for subroutine max_eig |
| Cmin_eig_symm_work | Workspace for subroutine min_eig_work |
| Cnlls_inform | Inform derived type with component defaults |
| Cnlls_options | |
| CNLLS_workspace | All workspaces called from the top level |
| Csolve_general_work | Workspace for subroutine solve_general |
| Csolve_LLS_work | Workspace for subroutine solve_LLS |
| ►NParameterEstimator | |
| CLinearFunction | A linear function |
| CAugmentedLagrangianOptimizer | Implements the Augmented Lagrangian optimization method of Birgin & Martinez |
| CComplexMatrix | A complex-valued matrix for linear algebra computations |
| CComplexVector | A complex-valued vector for linear algebra computations |
| CCrystalFieldEnergies | CrystalFieldEnergies : Calculates crystal field energies and wave functions for rare earth ions given the field parameters |
| CEigenJacobian | Two implementations of Jacobian |
| CEigenMatrix | A wrapper around Eigen::Matrix |
| CEigenMatrix_View | |
| CEigenVector | A wrapper around Eigen::Vector |
| CEigenVector_View | |
| CExcludeRangeFinder | ExcludeRangeFinder : Helper clss that finds if a point should be excluded from fit |
| CFitMW | Creates FunctionDomain1D form a spectrum in a MatrixWorkspace |
| CFortranMatrix | FortranMatrix is a wrapper template for EigenMatrix and EigenComplexMatrix to simplify porting fortran programs to C++ |
| CFortranVector | FortranVector is a wrapper template for EigenVactor and EigenComplexVector to simplify porting fortran programs to C++ |
| CFunctionDomain1DSpectrumCreator | FunctionDomain1DSpectrumCreator : |
| CGeneralDomainCreator | GeneralDomainCreator: |
| CGSL_FitData | Various GSL specific functions used GSL specific minimizers |
| CHalfComplex | Class for helping to read the transformed data |
| CHistogramDomainCreator | HistogramDomainCreator: |
| CIFittingAlgorithm | A base class for fitting algorithms |
| CIMWDomainCreator | A base class for domain creators taking 1D data from a spectrum of a matrix workspace |
| CJacobian | An implementation of Jacobian using std::vector |
| CJacobianImpl1 | The implementation of Jacobian |
| CLatticeDomainCreator | LatticeDomainCreator |
| CLatticeFunction | LatticeFunction |
| CMultiDomainCreator | Creates a composite domain |
| CParDomain | An implementation of SeqDomain for parallel cost function and derivatives computation |
| CSeqDomain | An implementation of CompositeDomain |
| CSeqDomainSpectrumCreator | SeqDomainSpectrumCreator : |
| CTableWorkspaceDomainCreator | |
| ►NDataHandling | |
| ►NANSTO | |
| ►NTar | |
| CEntryHeader | |
| ►CFile | |
| CFileInfo | |
| CEventAssigner | |
| CEventAssignerFixedWavelength | |
| CEventCounter | |
| CEventFileHeader_Base | |
| CEventFileHeader_Packed | |
| CEventProcessor | |
| CFastReadOnlyFile | |
| CProgressTracker | Helper class to keep track of progress |
| ►NAxisHelper | |
| CAxisProxy | |
| CBinEdgeAxisProxy | |
| ►NEMU | |
| CEventAssigner | |
| CEventCounter | |
| CEventProcessor | |
| ►NLoadNexusMonitorsAlg | Load Monitors from NeXus files |
| CMonitorInfo | |
| ►NMuonNexus | |
| CSampleInformation | |
| ►NPLN | |
| CEventAssigner | |
| CEventCounter | |
| CEventProcessor | |
| CSimpleHist | |
| CApplyDiffCal | ApplyDiffCal : |
| CAvrgDetector | Helper class-collection to keep together the parameters, which characterize average composite detector and help to calculate these parameters |
| CCheckMantidVersion | CheckMantidVersion : Checks if the current version of Mantid is the most recent |
| CChopperConfiguration | |
| CCoincidenceEvent | A detected neutron |
| CCompressEvents | Compress an EventWorkspace by lumping together events with very close TOF value, while ignoring the event's pulse time |
| CCreateChunkingFromInstrument | CreateChunkingFromInstrument : TODO: DESCRIPTION |
| CCreatePolarizationEfficiencies | CreatePolarizationEfficiencies |
| CCreatePolarizationEfficienciesBase | CreatePolarizationEfficienciesBase - the base class for algorithms that create polarization efficiency workspaces: |
| CCreateSampleShape | This class allows the shape of the sample to be defined by using the allowed XML expressions |
| CCreateSimulationWorkspace | |
| CDasEvent | Structure that matches the form in the binary event list |
| CDataBlock | DataBlock: The DataBlock class holds information about a contiguous block of spectrum numbers |
| CDataBlockComposite | DataBlockComposite: The DataBlockComposite handles a collection of DataBlocks |
| CDataBlockGenerator | DataBlockGenerator: The DataBlockGenerator class provides increasing int64_t numbers from a collection of intervals which are being input into the generator at construction |
| CDefaultEventLoader | Helper class for LoadEventNexus that is specific to the current default loading code for NXevent_data entries in Nexus files, in particular LoadBankFromDiskTask and ProcessBankData |
| CDefineGaugeVolume | This class allows the shape of the sample to be defined by using the allowed XML expressions |
| CDeleteTableRows | Deletes a row from a TableWorkspace |
| CDetectorWord | Holds the 128 bit words from the detector |
| CDetermineChunking | |
| CDetParameters | Small helper class-holder used to precalculate the detectors parameters in spherical coordinate system |
| CDownloadFile | DownloadFile : Downloads a file from a url to the file system |
| CDownloadInstrument | DownloadInstrument : Downloads one or more instrument files to the local instrument cache from the instrument repository |
| CEventUnion | Is able to hold all versions of the data words in the same memory location |
| CEventWorkspaceCollection | EventWorkspaceCollection : Collection of EventWorspaces to give backward-forward compatibility around performing operations on groups |
| CExtractMonitorWorkspace | Looks for an internally-stored monitor workspace on the input workspace and sets it as the output workspace if found |
| CExtractPolarizationEfficiencies | Looks for a parameter in the parameter file that stores polarization efficiencies to be used with the polarization correction algorithm (PolarizationEfficienciesCor) |
| CFileTypeDescriptor | Description of the ASCII data header, common for all ASCII PAR and PHX files |
| CFilterEventsByLogValuePreNexus | A data loading and splitting routine for SNS pre-nexus event files |
| CFindDetectorsInShape | An algorithm for finding which detectors are contained within a user defined shape within the instrument |
| CFindDetectorsPar | |
| CFITSInfo | |
| CGenerateGroupingPowder | GenerateGroupingPowder : Generate grouping file and par file, for powder scattering |
| CGenericEvent | Generic event to separate bits |
| CgetWithoutMonitors | To be used with std::generate to copy only those values from a dataset that don't relate to monitors |
| CGroupDetectors | An algorithm for grouping detectors and the spectra associated with them into a single DetectorGroup and spectrum |
| ►CGroupDetectors2 | An algorithm for grouping detectors and their associated spectra into single spectra and DetectorGroups |
| CRangeHelper | Function that expands pairs of integers separated with a hyphen into a list of all the integers between those values |
| CHashV3DPair | |
| CheaderData | |
| CIntermediateEvent | Structure used as an intermediate for parallel processing of events |
| CInvalidLogPeriods | Custom exception extending std::invalid_argument Thrown when nperiods does not match period_log Custom exception so we can re-propagate this error and handle all other errors |
| CISampleEnvironmentSpecFinder | Interface for a class responsible for finding a specification based on a name |
| CISISDataArchive | This class is for searching the ISIS data archive |
| CISISJournal | ISISJournal: Helper class to aid in fetching ISIS specific run information from journal files |
| CISISJournalGetExperimentRuns | ISISJournalGetExperimentRuns obtains a list of runs and related information for an investigation and cycle |
| CISISRunLogs | Defines a class to aid in creating ISIS specific run logs for periods, status etc |
| CJoinISISPolarizationEfficiencies | JoinISISPolarizationEfficiencies : Joins reflectometry polarization efficiency correction factors to form a single matrix workspace |
| CLoad | Loads a workspace from a data file |
| CLoadAscii | Loads a workspace from an ascii file |
| CLoadAscii2 | Loads a workspace from an ascii file |
| CLoadAsciiStl | |
| CLoadBankFromDiskTask | This task does the disk IO from loading the NXS file, and so will be on a disk IO mutex |
| ►CLoadBBY | |
| CInstrumentInfo | |
| CLoadBinaryStl | |
| CLoadCalFile | Algorithm to load a 5-column ascii .cal file into up to 3 workspaces: a GroupingWorkspace, OffsetsWorkspace and/or MaskWorkspace |
| CLoadCanSAS1D | This algorithm loads 1 CanSAS1d xml file into a workspace |
| CLoadCanSAS1D2 | This algorithm loads 1 CanSAS1d xml file into a workspace |
| CLoadCSNSNexus | LoadCSNSNexus : TODO: DESCRIPTION |
| CLoadDaveGrp | Reads the DAVE grouped ASCII format into a workspace |
| ►CLoadDetectorInfo | |
| CDetectorInfo | Simple data holder for passing the detector info around when dealing with the NeXus data |
| CLoadDetectorsGroupingFile | LoadDetectorsGroupingFile |
| CLoadDiffCal | LoadDiffCal : TODO: DESCRIPTION |
| ►CLoadDNSEvent | LoadDNSEvent |
| CBufferHeader | |
| CCompactEvent | |
| CEventAccumulator | |
| CNeutronEvent | |
| CTriggerEvent | |
| CLoadDspacemap | Loads a Dspacemap file (POWGEN binary, VULCAN binary or ascii format) into an OffsetsWorkspace |
| CLoadEmptyInstrument | 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 |
| CLoadEMU | |
| CLoadEMUHdf | LoadEMUHdf : Loads an ANSTO EMU Hdf and linked event file into a workspace |
| CLoadEMUTar | LoadEMUTar : Loads a merged ANSTO EMU Hdf and event file into a workspace |
| CLoadEventNexus | Load Event Nexus files |
| CLoadEventNexusIndexSetup | Helper for LoadEventNexus dealing with setting up indices (spectrum numbers an detector ID mapping) for workspaces |
| CLoadEventPreNexus2 | A data loading routine for SNS pre-nexus event files |
| CLoadFITS | LoadFITS: Load one or more of FITS files into a Workspace2D |
| CLoadFullprofResolution | LoadFullprofResolution : Load Fullprof resolution (.irf) file to TableWorkspace(s) |
| CLoadGroupMapFile | Class used to load a grouping information from .map file |
| CLoadGroupXMLFile | |
| CLoadGSASInstrumentFile | LoadGSASInstrumentFile : Load GSAS instrument file to TableWorkspace(s) |
| CLoadGSS | Loads a file as saved by SaveGSS |
| CLoadHFIRSANS | This algorithm loads a SPICE2D file for HFIR SANS into a workspace |
| CLoadIDFFromNexus | DataHandling/LoadIDFFromNexus.h |
| ►CLoadILLDiffraction | LoadILLDiffraction : Loads ILL diffraction nexus files |
| CScannedVariables | |
| CLoadILLIndirect2 | Loads an ILL IN16B nexus file into a Mantid workspace |
| CLoadILLPolarizationFactors | LoadILLPolarizationFactors : Load reflectometry polarization efficiency correction factors from disk |
| CLoadILLPolarizedDiffraction | LoadILLPolarizedDiffraction : Loads ILL polarized diffraction nexus files from instrument D7 |
| CLoadILLReflectometry | LoadILLReflectometry : Loads an ILL reflectometry Nexus data file |
| CLoadILLSALSA | Loads an ILL SALSA NeXus file into a Mantid workspace |
| ►CLoadILLSANS | LoadILLSANS; supports D11, D22 and D33 (TOF/monochromatic) |
| CDetectorPosition | |
| CLoadILLTOF2 | Loads an ILL IN4/5/6/Panther NeXus file into a Mantid workspace |
| CLoadInstrument | Loads instrument data from an XML or Nexus instrument description file and adds it to a workspace |
| CLoadInstrumentFromNexus | DataHandling/LoadInstrumentFromNexus.h |
| CLoadInstrumentFromRaw | DataHandling/LoadInstrumentFromRaw.h |
| ►CLoadIsawDetCal | Find the offsets for each detector |
| CComponentScaling | |
| ►CLoadISISNexus2 | Loads a file in a NeXus format and stores it in a 2D workspace |
| CSpectraBlock | Spectra block descriptor |
| CLoadISISPolarizationEfficiencies | LoadISISPolarizationEfficiencies : Load reflectometry polarization efficiency correction factors from disk |
| CLoadLLB | LoadLLB : Loads an LLB MIBEMOL TOF NeXus file into a Workspace2D with the given name |
| CLoadLog | Load ISIS log file(s) |
| CLoadMappingTable | Loads the mapping table between spectra and IDetector from a raw file |
| CLoadMask | LoadMask : Load masking file to generate a SpecialWorkspace2D object (masking workspace) |
| CLoadMcStas | LoadMcStas : TODO: DESCRIPTION |
| CLoadMcStasNexus | LoadMcStasNexus : TODO: DESCRIPTION |
| CLoadMLZ | LoadMLZ : Loads MLZ nexus or hdf file into a Mantid workspace |
| CLoadMuonLog | Load ISIS Muon log data from a NeXus file |
| CLoadMuonNexus | It is a base class for loaders for versions 1 and 2 of the muon nexus file format |
| CLoadMuonNexus1 | |
| CLoadMuonNexus2 | Loads an file in NeXus Muon format version 1 and 2 and stores it in a 2D workspace (Workspace2D class) |
| CLoadMuonNexusV2 | Loads a file in the Nexus Muon format V2 and stores it in a 2D workspace (Workspace2D class) |
| CLoadMuonNexusV2NexusHelper | |
| CLoadMuonStrategy | |
| CLoadNexus | Loads a file in NeXus format and stores it in a 2D workspace (Workspace2D class) |
| CLoadNexusLogs | Loads the run logs from a NeXus file |
| CLoadNexusMonitors | DataHandling/LoadNexusMonitors.h |
| CLoadNexusMonitors2 | |
| CLoadNexusProcessed | Loads a workspace from a NeXus Processed entry in a NeXus file |
| CLoadNexusProcessed2 | LoadNexusProcessed2 : Second variation of LoadNexusProcess, built to handle ESS file specifics in addition to existing behaviour for standard Mantid Processed files |
| CLoadNGEM | |
| CLoadNXcanSAS | LoadNXcanSAS : Tries to load an NXcanSAS file type into a Workspace2D |
| CLoadNXSPE | LoadNXSPE : Algorithm to load an NXSPE file into a workspace2D |
| CLoadOff | |
| CLoadParameterFile | DataHandling/LoadParameterFile.h |
| CLoadPDFgetNFile | LoadPDFgetNFile : TODO: DESCRIPTION |
| CLoadPLN | LoadPLN : Loads an ANSTO PLN Hdf and linked event file into a workspace |
| CLoadPreNexus | LoadPreNexus : Workflow algorithm to load a collection of preNeXus files |
| CLoadPreNexusMonitors | |
| CLoadPSIMuonBin | |
| CLoadQKK | Loads a Quokka data file |
| CLoadRaw3 | Loads an file in ISIS RAW format and stores it in a 2D workspace (Workspace2D class) |
| CLoadRawBin0 | Loads bin zero for all spectra from ISIS RAW file and stores it in a 2D workspace (Workspace2D class) |
| CLoadRawHelper | Helper class for LoadRaw algorithms |
| CLoadRawSpectrum0 | Loads zeroth spectrum from ISIS RAW format file and stores it in a 2D workspace (Workspace2D class) |
| CLoadRKH | Loads an RKH file into a Mantid 1D workspace |
| CLoadSampleDetailsFromRaw | An algorithm to extract the sample details from the SPB structure within a RAW file |
| CLoadSampleEnvironment | Load Environment into the sample of a workspace, either replacing the current environment, or replacing it, you may also set the material |
| CLoadSampleShape | Load Shape into an instrument of a workspace |
| CLoadSassena | Load Sassena Output files |
| CLoadSESANS | LoadSESANS : Load a workspace in the SESANS file format |
| CLoadSingleMesh | |
| CLoadSINQFocus | Loads an PSI nexus file into a Mantid workspace |
| CLoadSNSspec | Loads a workspace from an SNS spec file |
| CLoadSPE | Loads an SPE format file into a Mantid workspace |
| CLoadSpec | Loads a workspace from an ascii file |
| CLoadSpice2D | This algorithm loads a SPICE2D file for HFIR SANS into a workspace |
| CLoadSpiceAscii | LoadSpiceAscii : TODO: DESCRIPTION |
| CLoadSpiceXML2DDet | LoadSpiceXML2DDet : Load 2D detector data in XML format form SPICE |
| CLoadStl | |
| CLoadStlFactory | |
| CLoadSwans | LoadSwans : Test Loader to read data from the LDRD new SWANS detector |
| CLoadTBL | Loads a table workspace from an ascii file in reflectometry tbl format |
| CLoadTOFRawNexus | Loads a NeXus file that conforms to the TOFRaw instrument definition format and stores it in a 2D workspace |
| CMantid3MFFileIO | Class to load and save .3mf files .3mf format is a 3D manufacturing format for storing mesh descriptions of multi-component objects + metadata about the overall model (eg scale) and the individual components |
| CMaskDetectors | An algorithm to mask a detector, or set of detectors |
| CMaskDetectorsInShape | An algorithm for finding masking detectors that are contained within a user defined shape within the instrument |
| CMaskSpectra | Mask specified spectra and the underlying detectors in a workspace |
| CMeshFileIO | |
| CModifyDetectorDotDatFile | Modifies an ISIS detector dot data file, so that the detector positions are as in the given workspace |
| CMoveInstrumentComponent | DataHandling/MoveInstrumentComponent.h |
| CMultiPeriodLoadMuonStrategy | |
| CNexusTester | NexusTester : debugging/performance testing algorithm for nexus file loading and saving |
| CORNLDataArchive | Please see the .cpp file for more information |
| CParallelEventLoader | Loader for event data from Nexus files with parallelism based on multiple processes (MPI or MultiProcessing) for performance |
| CPatchBBY | |
| CPDLoadCharacterizations | LoadPDCharacterizations : Load a characterization file used in Powder Diffraction Reduction |
| CProcessBankData | This task does the disk IO from loading the NXS file, and so will be on a disk IO mutex |
| CPropertyInfo | |
| CPulse | Structure that matches the form in the new pulseid files |
| CRawFileInfo | An algorithm to extract pertinent information about a RAW file without loading the data |
| ►CReadMaterial | This class contains code for interpreting a material input for SetSampleMaterial, validating the parameters before sending them on to MaterialBuilder |
| CMaterialParameters | This struct contains the parameters for constructing a material, and gives them a default value for ease of testing |
| CRemoveLogs | Load ISIS log file(s) |
| CRenameLog | RenameLog : TODO: DESCRIPTION |
| CRotateInstrumentComponent | DataHandling/RotateInstrumentComponent.h |
| CRotateSource | RotateSource : Moves the source by a given angle taking into account the handedness |
| CSampleEnvironmentFactory | Create a single instance of a SampleEnvironment |
| CSampleEnvironmentSpec | Defines the properties of a named SampleEnvironment setup |
| CSampleEnvironmentSpecFileFinder | Class responsible for finding a specifications on disk |
| CSampleEnvironmentSpecParser | Read an XML definition of a SampleEnvironmentSpec and produce a new SampleEnvironmentSpec object |
| CSaveAscii | Saves a workspace or selected spectra in a coma-separated ascii file |
| CSaveAscii2 | Saves a workspace or selected spectra in a coma-separated ascii file |
| CSaveBankScatteringAngles | |
| CSaveCalFile | Algorithm to save a 5-column ascii .cal file from to 3 workspaces: a GroupingWorkspace, OffsetsWorkspace and/or MaskWorkspace |
| CSaveCanSAS1D | |
| CSaveCanSAS1D2 | This algorithm saves workspace into CanSAS1d format |
| CSaveCSV | Saves a 1D or 2D workspace to a CSV file |
| CSaveDaveGrp | |
| CSaveDetectorsGrouping | SaveDetectorsGrouping : TODO: DESCRIPTION |
| CSaveDiffCal | SaveDiffCal : TODO: DESCRIPTION |
| CSaveDiffFittingAscii | |
| CSaveDspacemap | Saves an OffsetsWorkspace into a POWGEN-format binary dspace map file |
| CSaveFITS | SaveFITS : Save images in FITS formats |
| CSaveFocusedXYE | 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 |
| CSaveFullprofResolution | SaveFullprofResolution : TODO: DESCRIPTION |
| ►CSaveGDA | |
| CCalibrationParams | |
| CSaveGSASInstrumentFile | SaveGSASInstrumentFile : Convert Fullprof"s instrument resolution file
(.irf) to GSAS"s instrument file (.iparm/.prm) |
| CSaveGSS | Saves a focused data set into a three column GSAS format containing X_i, Y_i*step, and E_i*step |
| CSaveIsawDetCal | Saves an instrument with RectangularDetectors to an ISAW .DetCal file |
| CSaveISISNexus | The SaveISISNexus algorithm will convert a RAW file to a NeXus file |
| CSaveMask | SaveMaskingToFile : TODO: DESCRIPTION |
| CSaveNexus | Saves a file in NeXus format and from a 2D workspace (Workspace2D class) |
| CSaveNexusESS | SaveNexusESS : Save algorithm to save a NeXus organised hdf5 file containing data and geometry from reduced experiment for use at European Spallation Source |
| CSaveNexusGeometry | |
| CSaveNexusProcessed | DataHandling/SaveNexusProcessed.h |
| CSaveNISTDAT | Writer for compatibility with SansView and NIST reduced data file format |
| CSaveNXcanSAS | SaveNXcanSAS : Saves a reduced workspace in the NXcanSAS format |
| CSaveNXSPE | Saves a workspace into a NeXus/HDF5 NXSPE file |
| CSaveNXTomo | Saves a workspace into a NeXus/HDF5 NXTomo file |
| CSaveOpenGenieAscii | |
| CSavePAR | Saves a workspace into an ASCII PAR file |
| CSaveParameterFile | SaveParameterFile : Save a workspace's parameters to an instrument parameter file |
| CSavePDFGui | SavePDFGui : Saves a workspace containing a pair distrebution function in a format readable by the PDFgui package |
| CSavePHX | Saves a workspace into an ASCII PHX file |
| CSaveReflectometryAscii | Saves a file of desired (mft, txt, dat or custom) Ascii format from a 2D workspace |
| CSaveRKH | Saves a workspace in the RKH file format |
| CSaveRMCProfile | SaveRMCProfile : Saves a workspace containing a spectral density in a format readable by the RMCProfile package |
| CSaveSampleEnvironmentAndShape | Save the Shape of the sample and environment into a single binary .stl file |
| CSaveSESANS | SaveSESANS : Save a workspace in the SESANS file format |
| CSaveSPE | Saves a workspace into an ASCII SPE file |
| CSaveStl | Class to contain functionality for writing out STL files for SaveShapeAndEnvironment |
| CSaveTBL | Saves a table workspace to a reflectometry tbl format ascii file |
| ►CSaveToSNSHistogramNexus | Save a Workspace2D or an EventWorkspace into a NeXus file whose format corresponds to that expected at the SNS |
| Clink_to_make | |
| CSaveVTK | Saves a 1D or 2D workspace using the vtk file format described in the "file
formats" document at http://www.vtk.org/documents.php |
| CSetBeam | Set properties of the beam |
| CSetSample | High-level interface for setting sample metadata on a workspace |
| CSetSampleMaterial | This class allows the shape of the sample to be defined by using the allowed XML expressions |
| CSetScalingPSD | Read the scaling information from a file (e.g |
| CSinglePeriodLoadMuonStrategy | |
| CSNSAppendGeometryToNexus | SNSAppendGeometryToNexus : Appends geometry information to a NeXus file |
| CSortTableWorkspace | SortTableWorkspace : TODO: DESCRIPTION |
| CSpiceXMLNode | |
| CT0FrameEvent | Indicate time 0, the start of a new frame |
| CtemperatureHeaderData | |
| ►CUpdateInstrumentFromFile | Update detector positions initially loaded in from Instrument Defintion File (IDF) from information in the provided files |
| CAsciiFileHeader | Simple structure to store information about the ASCII file header |
| CV3DTrueComparator | |
| CVulcanCorrectionFactor | Structure of the vulcan binary file |
| CXmlHandler | |
| ►NDataObjects | |
| ►Ndetail | Factory methods for creating MatrixWorkspaces |
| CIsIndexInfo | |
| CIsIndexInfo< Indexing::IndexInfo > | |
| CAffineMatrixParameter | Type to wrap an affine matrix and allow serialization via xml |
| CAffineMatrixParameterParser | Parser for a parameter of type affinematrixparameter |
| CBasePeak | Structure describing a single-crystal peak |
| CBinaryOperator | An SpecialWorkspace2D is a specialized Workspace2D where the Y value at each pixel will be used for a special meaning |
| CBoxControllerNeXusIO | The class responsible for saving events into nexus file using generic box controller interface Expected to provide thread-safe file access |
| CCalculateReflectometry | Provides a common interface to Reflectometry Transform calculators |
| CCalculateReflectometryKiKf | Class CalculateReflectometryKiKf: Calculation type for converting to ki or kf given a theta value (in degrees) and a wavelength |
| CCalculateReflectometryP | Class CalculateReflectometryP: p-type transformation calculator |
| CCalculateReflectometryQxQz | Converts from inputs of wavelength, incident theta and final theta to Qx and Qz for reflectometry experiments |
| CcomparePulseTimeTOFDelta | |
| CCoordTransformAffine | Generic class to transform from M input dimensions to N output dimensions |
| CCoordTransformAffineParser | A parser for processing coordinate transform xml |
| CCoordTransformAligned | Unique type declaration for which dimensions are used in the input workspace |
| CCoordTransformDistance | Unique CoordCenterVectorParam type declaration for ndimensional coordinate centers |
| CCoordTransformDistanceParser | A parser for processing coordinate transform xml |
| CDetectorAngularCache | Simple container for porting detector angular information |
| CEventAccessor | Structure to mark the classes, which can switch the "physical" meaning of the union used in MDLeanEvent to store coordinates or index |
| CEventList | A class for holding : |
| CEventSortingTask | Task for sorting an event list |
| CEventWorkspace | This class is intended to fulfill the design specified in <https://github.com/mantidproject/documents/tree/master/Design/Event WorkspaceDetailed Design Document.doc> |
| CEventWorkspaceHelpers | A collection of functions that help for EventWorkspaces |
| CEventWorkspaceMRU | This is a container for the MRU (most-recently-used) list of generated histograms |
| CFakeMD | Provides a helper class to add fake data to an MD workspace |
| CGroupingWorkspace | 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 |
| CHistogram1D | 1D histogram implementation |
| CIF | |
| CIF< MDLeanEvent< nd >, nd > | |
| CLeanElasticPeak | Structure describing a single-crystal peak |
| CLeanElasticPeaksWorkspace | The class LeanElasticPeaksWorkspace stores information about a set of SCD lean peaks |
| CLOOP | MDEventFactory : collection of methods to create MDLeanEvent* instances, by specifying the number of dimensions as a parameter |
| CLOOP< 0 > | |
| CMaskWorkspace | |
| CMDBin | MDBin : Class describing a single bin in a dense, Multidimensional histogram |
| CMDBox | Templated class for a multi-dimensional event "box" |
| CMDBoxBase | Templated super-class of a multi-dimensional event "box" |
| CMDBoxFlatTree | The class responsible for saving/loading MD boxes structure to/from HDD and for flattening/restoring the interconnected box structure (customized linked list) of MD workspace |
| CMDBoxIterator | MDBoxIterator: iterate through MDBoxBase hierarchy down to a given maximum depth |
| CMDBoxSaveable | Two classes responsible for implementing methods which automatically save/load MDBox in conjuction with DiskBuffer One class responsible for saving events into nexus and another one – for identifying the data positions in a file in conjuction with DB |
| CMDDimensionStats | A simple class holding some statistics on the distribution of events in a particular dimension |
| CMDEvent | Templated class holding data about a neutron detection event in N-dimensions (for example, Qx, Qy, Qz, E) |
| CMDEventFactory | |
| ►CMDEventInserter | MDEventInserter : Helper class that provides a generic interface for adding events to an MDWorkspace without knowing whether the workspace is storing MDLeanEvents or full MDEvents |
| CIntToType | Loki IntToType, used for template overload deduction |
| CMDEventWorkspace | Templated class for the multi-dimensional event workspace |
| CMDFramesToSpecialCoordinateSystem | MDFrameFromMDWorkspace: Each dimension of the MDWorkspace contains an MDFrame |
| CMDGridBox | Templated class for a GRIDDED multi-dimensional event "box" |
| CMDHistoWorkspace | MDHistoWorkspace: |
| CMDHistoWorkspaceIterator | An implementation of IMDIterator that iterates through a MDHistoWorkspace |
| ►CMDLeanEvent | Templated class holding data about a neutron detection event in N-dimensions (for example, Qx, Qy, Qz, E) |
| CAccessFor | Internal structure to avoid the direct exposing of API functions, which change the state of event (switch between union fields) |
| CMementoTableWorkspace | Variation on the TableWorkspace with a set of pre-defined columns used to store diffs on Workspaces |
| CNoShape | PeakShapeNone : No peak shape |
| CNullDeleter | |
| COffsetsWorkspace | An OffsetsWorkspace is a specialized Workspace2D where the Y value at each pixel is the offset to be used for correcting calculations (specifically AlignDetectors) |
| CPeak | Structure describing a single-crystal peak |
| CPeakColumn | PeakColumn : a Column sub-class used to display peak information as a TableWorkspace |
| CPeakComparator | Comparator class for sorting peaks by one or more criteria |
| CPeakNoShapeFactory | PeakNoShapeFactory : Factory method for types of NoShape |
| CPeakShapeBase | PeakShapeBase : Base class for concrete PeakShapes containing common code |
| CPeakShapeEllipsoid | PeakShapeEllipsoid : PeakShape representing a 3D ellipsoid |
| CPeakShapeEllipsoidFactory | PeakShapeEllipsoidFactory : Create ellipsoid peak shapes |
| CPeakShapeFactory | PeakShapeFactory : Factory for creating peak shapes |
| CPeakShapeSpherical | PeakShapeSpherical : PeakShape for a spherical peak |
| CPeakShapeSphericalFactory | PeakShapeSphericalFactory : Factory for spherical peak shapes for de-serializing from JSON |
| CPeaksWorkspace | The class PeaksWorkspace stores information about a set of SCD peaks |
| CRebinnedOutput | RebinnedOutput |
| CReflectometryTransform | ReflectometryMDTransform : Base type for reflectometry transforms to MDWorkspaces |
| CScanningWorkspaceBuilder | ScanningWorkspaceBuilder : This is a helper class to make it easy to build a scanning workspace (a workspace with moving detectors), where all the information about the scan is known in advance |
| CSkipMaskedBins | Policy that indicates skipping of masked bins |
| CSkipNothing | Policy that indicates no skipping should be applied |
| CSkippingPolicy | SkippingPolicy : Policy types for skipping in MDiterators |
| CSpecialWorkspace2D | |
| CSplittersWorkspace | SplittersWorkspace : A TableWorkspace to contain TimeSplitters |
| ►CTableColumn | Class TableColumn implements abstract class Column for any copyable data type |
| CInconvertibleToDoubleType | Helper struct helping to write a generic casting to double |
| CTableColumn_ptr | Shared pointer to a column with automatic type cast and data type check |
| CTableColumn_ptr< bool > | Special case of bool |
| ►CTableWorkspace | TableWorkspace is an implementation of Workspace in which the data are organised in columns of same size |
| CFindName | Used in std::find_if algorithm to find a Column with name name |
| CTypeWithMarker | This little class holds data and an index marker that is used for uniqueness |
| CVectorColumn | VectorColumn : table column type capable of storing vectors of primitive types |
| CWeightedEvent | Info about a single neutron detection event, including a weight and error value: |
| CWeightedEventNoTime | Info about a single neutron detection event, including a weight and error value, but excluding the pulsetime to save memory: |
| CWorkspace2D | Concrete workspace implementation |
| CWorkspaceSingleValue | Concrete workspace implementation |
| ►NFrameworkTestHelpers | |
| CFunctionChangesNParams | |
| CMockONCatAPI | |
| CMockTokenStore | |
| CMultiDomainFunctionTest_Function | |
| ►NGeometry | |
| ►Ndetail | ShapeInfo : Stores shape types and information relevant to drawing the shape |
| CGeometryTriangulator | GeometryTriangulator : Triangulates object surfaces |
| ►CShapeInfo | |
| CConeGeometry | |
| CCuboidGeometry | |
| CCylinderGeometry | |
| CHexahedronGeometry | |
| CHollowCylinderGeometry | |
| CSphereGeometry | |
| ►NMDAlgorithms | |
| CMDBoxMaskFunction | |
| CAbstractIDFObject | IDFObject : File object wrapper over an IDF file |
| CAbstractSpaceGroupGenerator | AbstractSpaceGroupGenerator is used by SpaceGroupFactory to delay (possibly costly) construction of space group prototype objects until they are actually requested |
| CAbstractSymmetryElementGenerator | SymmetryElementFactoryImpl does not generate SymmetryElement objects directly |
| CAcomp | Holds a state point in the decision tree |
| CAlgebra | Computes Boolean algebra for simplification |
| CAlgorithmicSpaceGroupGenerator | Concrete space group generator that uses space group generators as given in ITA |
| CAtomPositionsEqual | Equality-functor for comparison of atom positions with specifiable precision |
| CAtomPositionsLessThan | Less-than-functor for comparison of atom positions with specifiable precision |
| CBaseVisit | Adds the main |
| CBnId | Tri-state variable |
| CBoolValue | Rule Status class |
| CBoundingBox | A simple structure that defines an axis-aligned cuboid shaped bounding box for a geometrical object |
| CBraggScatterer | BraggScatterer is a general interface for representing scatterers in the unit cell of a periodic structure |
| CBraggScattererFactoryImpl | |
| CBraggScattererInCrystalStructure | This class provides an extension of BraggScatterer, suitable for scatterers that are part of a crystal structure |
| CCenteringGroup | This class is mostly a convenience class |
| CCenteringGroupCreatorImpl | Helper class to keep this out of the interface of CenteringGroup |
| CCompAssembly | Class for Assembly of geometric components |
| CCompGrp | Compemented Grup |
| CCompObj | Compemented Object |
| CComponent | Component is a wrapper for a Component which can modify some of its parameters, e.g |
| ►CComponentInfo | ComponentInfo : Provides a component centric view on to the instrument |
| CQuadrilateralComponent | |
| CComponentInfoItem | ComponentInfoItem Return type for ComponentInfoIterators |
| CComponentInfoIterator | ComponentInfoIterator for random access iteration over ComponentInfo |
| CComponentParser | This class implements the Poco SAX ContentHandler class for reading component XML |
| CComponentPool | |
| CComponentVisitor | ComponentVisitor : Visitor for IComponents |
| CCompositeBraggScatterer | CompositeBraggScatterer accumulates scatterers, for easier calculation of structure factors |
| CCompositeImplicitFunction | This class represents a composite implicit function used for communicating and implementing an operation against an MDWorkspace |
| CConcretePeakTransformFactory | Concrete PeakTransformFactory producing PeakTransforms of type provided by type argument |
| CCone | Holds a cone in vector form |
| CContainer | Models a Container is used to hold a sample in the beam |
| CConventionalCell | Instances of this class represent information about a selected conventional cell based on a specified UB for a Niggli reduced cell |
| ►CConvexPolygon | An implementation of a convex polygon |
| CIterator | |
| CCrystalStructure | Three components are required to describe a crystal structure: |
| CCrystalSystemComparator | This is necessary to make the map work with older compilers |
| CCSGObject | Constructive Solid Geometry object |
| CCuboidCorners | |
| CCyclicGroup | A cyclic group G has the property that it can be represented by powers of one symmetry operation S of order n: |
| CCylinder | Holds a cylinder as a vector form |
| CDetector | This class represents a detector - i.e |
| CDetectorGroup | Holds a collection of detectors |
| CDetectorInfo | Geometry::DetectorInfo is an intermediate step towards a DetectorInfo that is part of Instrument-2.0 |
| CDetectorInfoItem | DetectorInfoItem |
| CDetectorInfoIterator | DetectorInfoIterator for random access iteration over DetectorInfo |
| CfindID | Helper unary comparison type for finding IMDDimensions by a specified id |
| CfindIntegrated | Helper unary comparison type for finding non-integrated dimensions |
| CFitParameter | Store information about a fitting parameter such as its value if it is constrained or tied |
| CGeneral | Holds a general quadratic surface |
| CGeneralFrame | GeneralFrame : Any MDFrame that isn't related to momemtum transfer |
| CGeneralFrameFactory | GeneralFrameFactory derived MDFrameFactory type |
| CGeometryHandler | Handles rendering of all object Geometry |
| CGoniometer | Class to represent a particular goniometer setting, which is described by the rotation matrix |
| CGoniometerAxis | Counter clockwise rotation |
| CGridDetector | GridDetector is a type of CompAssembly, an assembly of components |
| CGridDetectorPixel | GridrDetectorPixel: a sub-class of Detector that is one pixel inside a GridDetector |
| CGroup | The class Group represents a set of symmetry operations (or symmetry group) |
| CGroupTransformation | GroupTransformation |
| CHexahedron | |
| CHKL | HKL : HKL MDFrame |
| CHKLFilter | HKLFilter |
| CHKLFilterAnd | Logical "And"-operation for HKLFilter |
| CHKLFilterBinaryLogicOperation | Base class for binary logic operations for HKLFilter |
| CHKLFilterCentering | A class to filter HKLs according to a lattice centering |
| CHKLFilterDRange | A class to filter HKLs by their d-values |
| CHKLFilterNone | BasicHKLFilters |
| CHKLFilterNot | Logical "Not"-operation for HKLFilter |
| CHKLFilterOr | Logical "Or"-operation for HKLFilter |
| CHKLFilterSpaceGroup | A class to filter HKLs according to a space group |
| CHKLFilterStructureFactor | A class to filter HKLs according to structure factor magnitudes |
| CHKLFilterUnaryLogicOperation | Base class for unary logic operations for HKLFilter |
| CHKLFilterWavelength | HKLFilterWavelength |
| CHKLFrameFactory | HKLFrame derived MDFrameFactory type |
| ►CHKLGenerator | HKLGenerator |
| Cconst_iterator | The const_iterator class |
| CICompAssembly | Class for Assembly of geometric components |
| CIComponent | Base class for Geometric IComponent |
| CIDetector | Interface class for detector objects |
| CIDFObject | Concrete IDF Object |
| CIMDDimension | The class describes one dimension of multidimensional dataset representing an orthogonal dimension and linear axis |
| CIndexingUtils | This class contains static utility methods for indexing peaks and finding the UB matrix |
| CInfoIteratorBase | InfoIterator |
| CInstrument | Base Instrument Class |
| ►CInstrumentDefinitionParser | Creates an instrument data from a XML instrument description file |
| CIdList | Structure for holding detector IDs |
| CSphVec | Stripped down vector that holds position in terms of spherical coordinates, Needed when processing instrument definition files that use the 'Ariel format' |
| CInstrumentRayTracer | This class is responsible for tracking rays and accumulating a list of objects that are intersected along the way |
| CInstrumentVisitor | InstrumentVisitor : Visitor for components with access to Info wrapping features |
| CIntersection | Combines two Rule objects in an intersection |
| CIntersectionPoint | Stores a point of intersection along a track |
| CIObjComponent | Object Component class, this class brings together the physical attributes of the component to the positioning and geometry tree |
| CIObject | IObject : Interface for geometry objects |
| CIPeak | Structure describing a single-crystal peak |
| CIsotropicAtomBraggScatterer | IsotropicAtomBraggScatterer calculates the structure factor for a given HKL using the following equation, which gives the structure factor for the j-th atom in the unit cell: |
| CIsotropicAtomBraggScattererParser | |
| CLatticeSpacingCalculator | Small helper functor to calculate d-Values from a unit cell |
| CLine | Impliments a line |
| CLineIntersectVisit | Interset of Line with a surface |
| CLink | For a leg of a track |
| CMatrixVectorPair | MatrixVectorPair |
| CMatrixVectorPairBuilder | |
| CMatrixVectorPairParser | MatrixVectorPairParser |
| CMDBoxImplicitFunction | General N-dimensional box implicit function: Defines a cuboid in N dimensions that is aligned with the axes of a MDEventWorkspace |
| CMDDimensionExtents | Simple class that holds the extents (min/max) of a given dimension in a MD workspace or MDBox |
| CMDFrame | MDFrame : The coordinate frame for a dimension, or set of dimensions in a multidimensional workspace |
| CMDFrameArgument | Input argument type for MDFrameFactory chainable factory |
| CMDFrameFactory | MDFrameFactory.h : Chain of repsonsibility factory for the MDFrameFactory |
| CMDGeometryBuilderXML | |
| CMDGeometryXMLDefinitions | 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 |
| CMDGeometryXMLParser | Handles the extraction of dimensions from a xml xml string to determine how mappings have been formed |
| CMDHistoDimension | MDHistoDimension : |
| CMDHistoDimensionBuilder | MDHistoDimensionBuilder : |
| CMDImplicitFunction | An "ImplicitFunction" defining a hyper-cuboid-shaped region in N dimensions |
| CMDPlane | A generalized description of a N-dimensional hyperplane |
| CMDPlaneImplicitFunction | A general N-dimensional plane implicit function |
| CMeshObject | Triangular Mesh Object |
| ►CMeshObject2D | MeshObject2D : |
| CPlaneParameters | |
| CNiggliCell | Class to implement UB matrix |
| CNoDeleting | Void deleter for shared pointers |
| CNoDimensionPolicy | |
| CNullIDFObject | |
| CNullImplicitFunction | This class represents a Null Implicit function |
| CObjCompAssembly | Class for Assembly of geometric components |
| CObjComponent | Object Component class, this class brings together the physical attributes of the component to the positioning and geometry tree |
| COrientedLattice | Class to implement UB matrix |
| CParameter | Base class for parameters of an instrument |
| CParameterFactory | Creates parameters for the instrument ParameterMap |
| CParameterMap | ParameterMap class |
| CParameterType | Templated class for parameters of type Type |
| CParComponentFactory | A Factory for creating Parameterized component from their respective non-parameterized objects |
| CPeakShape | PeakShape : Abstract type to describes the shape of a peak |
| CPeakTransform | Used to remap coordinates into a form consistent with an axis reordering |
| CPeakTransformException | Exceptions occuring when PeakTransformations cannot be formed |
| CPeakTransformFactory | Abstract type defining Factory Method interface for generating PeakTransforms |
| CPeakTransformHKL | Used to remap coordinates into a form consistent with an axis reordering |
| CPeakTransformQLab | Used to remap coordinates into a form consistent with an axis reordering |
| CPeakTransformQSample | Used to remap coordinates into a form consistent with an axis reordering |
| CPeakTransformSelector | Used to choose an appropriate PeakTransformFactory |
| CPlane | Holds a simple Plane |
| CPointGroup | A class containing the Point Groups for a crystal |
| CPointGroupFactoryImpl | |
| CPointGroupGenerator | |
| CPolygonEdge | PolygonEdge Defines a directed edge between two points on a polygon |
| CProductOfCyclicGroups | ProductOfCyclicGroups expands a bit on the explanations given in CyclicGroup |
| CQLab | QLab : Q in the lab frame MDFrame |
| CQLabFrameFactory | QLabFrameFactory derived MDFrameFactory type |
| CQSample | QSample : Q in the sample frame |
| CQSampleFrameFactory | QSampleFrameFactory derived MDFrameFactory type |
| CQuadratic | Holds a basic quadratic surface |
| CQuadrilateral | A ConvexPolygon with only 4 vertices |
| CRaster | Holds the information used for doing numerical integrations of object in the beam |
| CRectangularDetector | RectangularDetector is a type of CompAssembly, an assembly of components |
| CReducedCell | Instances of this class represent information about reduced cell types including the transformation required to transform the reduced cell to a conventional cell |
| CReferenceFrame | ReferenceFrame : Holds reference frame information from the geometry description file |
| CReflectionCondition | A class containing the Reflection Condition for a crystal |
| CReflectionConditionAFaceCentred | A-face centred ReflectionCondition |
| CReflectionConditionAllFaceCentred | All-face centred ReflectionCondition |
| CReflectionConditionBFaceCentred | B-face centred ReflectionCondition |
| CReflectionConditionBodyCentred | Body centred ReflectionCondition |
| CReflectionConditionCFaceCentred | C-face centred ReflectionCondition |
| CReflectionConditionHexagonallyReverse | Hexagonally centred, reverse ReflectionCondition |
| CReflectionConditionPrimitive | Primitive ReflectionCondition |
| CReflectionConditionRhombohedrallyObverse | Rhombohedrally centred, obverse ReflectionCondition |
| CReflectionConditionRhombohedrallyReverse | Rhombohedrally centred, reverse ReflectionCondition |
| CReflectionGenerator | ReflectionGenerator |
| CRegisterConditions | |
| CRegisterConditions< R, Args... > | |
| CRegisterConditions<> | |
| CRenderingMesh | RenderingMesh : Mesh abstraction required for rendering |
| CRotaryCounter | Simple multilevel-cyclic counter |
| CRule | Object generation rule tree |
| CSampleEnvironment | Defines a single instance of a SampleEnvironment |
| CScalarUtils | 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 |
| CShapeFactory | Class originally intended to be used with the DataHandling 'LoadInstrument' algorithm |
| CSpaceGroup | A class for representing space groups, inheriting from Group |
| CSpaceGroupFactoryImpl | |
| CSphere | Holds a Sphere as vector form |
| CStrictDimensionPolicy | |
| CStructuredDetector | StructuredDetector is a type of CompAssembly, an assembly of components |
| CStructureFactorCalculator | StructureFactorCalculator |
| CStructureFactorCalculatorSummation | StructureFactorCalculatorSummation |
| CSurface | Holds a basic quadratic surface |
| CSurfaceFactory | Creates instances of Surfaces |
| CSurfPoint | Surface leaf node |
| CSymmetryElement | SymmetryElement is an interface for representing symmetry elements that occur for example in space and point groups |
| CSymmetryElementFactoryImpl | This factory takes a SymmetryOperation and generates the corresponding SymmetryElement |
| CSymmetryElementIdentity | SymmetryElementIdentity represents the identity |
| CSymmetryElementIdentityGenerator | This implementation of AbstractSymmetryElementGenerator produces only identity elements |
| CSymmetryElementInversion | SymmetryElementInversion represents the inversion |
| CSymmetryElementInversionGenerator | This implementation of AbstractSymmetryElementGenerator produces only inversion elements |
| CSymmetryElementMirror | SymmetryElementMirror represents mirror and glide-planes |
| CSymmetryElementMirrorGenerator | SymmetryElementMirrorGenerator also inherits from SymmetryElementWithAxisGenerator |
| CSymmetryElementRotation | SymmetryElementRotation represents rotation-, rotoinversion- and screw-axes |
| CSymmetryElementRotationGenerator | SymmetryElementRotationGenerator inherits from SymmetryElementWithAxisGenerator, using its methods for determination of rotation axis and translations in case of screw axes |
| CSymmetryElementTranslation | SymmetryElementTranslation represents translations |
| CSymmetryElementTranslationGenerator | This implementation of AbstractSymmetryElementGenerator produces only translation elements |
| CSymmetryElementWithAxis | SymmetryElementWithAxis does not represent any symmetry element directly |
| CSymmetryElementWithAxisGenerator | SymmetryElementWithAxisGenerator does not create any elements directly, it serves as a base for SymmetryElementRotationGenerator and SymmetryAxisMirrorGenerator, which have in common that the axis of the symmetry element as well as any potential translations must be determined |
| CSymmetryOperation | Crystallographic symmetry operations are composed of a rotational component, which is represented by a matrix and a translational part, which is described by a vector |
| CSymmetryOperationFactoryImpl | A factory for symmetry operations |
| CSymmetryOperationSymbolParser | This is a parser for symmetry operation symbols in the Jones faithful representation |
| CTabulatedSpaceGroupGenerator | Concrete space group generator that constructs space groups from a list of symmetry operations with no further computations |
| CTorus | Holds a torus in vector form |
| CTrack | Defines a track as a start point and a direction |
| CTransformationSpaceGroupGenerator | Concrete generator that generates a space group from another space group using a transformation |
| CUnion | Combines two Rule objects in an union |
| CUnitCell | Class to implement unit cell of crystals |
| CUnitCellStringValidator | Helper class for validating unit cell strings |
| CUnknownFrame | UnknownFrame : Unknown MDFrame |
| CUnknownFrameFactory | Unknown Frame derived MDFrameFactory type |
| CV3R | |
| CvtkGeometryCacheReader | Reads the Geometry Cache from the file to the Object |
| CvtkGeometryCacheWriter | Writes the Geometry from Object to Cache |
| CXMLInstrumentParameter | This class is used to store information about parameters in XML instrument definition files and instrument parameter files, so that such parameters can be added to a workspace when appropriate |
| ►NICat | |
| CCatalogAlgorithmHelper | |
| CCatalogDownloadDataFiles | CatalogDownloadDataFiles is responsible for downloading datafiles from a catalog |
| CCatalogGetDataFiles | CatalogGetDataFiles obtains a list of datafiles and related information for an investigation |
| CCatalogGetDataSets | This algorithm obtains the datasets for a given investigation record using the related ID |
| CCatalogKeepAlive | CatalogKeepAlive is responsible for keeping a catalog alive based on the session information |
| CCatalogListInstruments | This algorithm obtains a list of instruments types from the catalog |
| CCatalogListInvestigationTypes | This algorithm obtains a list of investigation types from the catalog |
| CCatalogLogin | This class is responsible for authentication of credentials against the catalog |
| CCatalogLogout | CatalogLogout is responsible for logging out of a catalog based on session information provided by the user |
| CCatalogMyDataSearch | This algorithm obtains all of the information for the investigations the logged in user is an investigator of |
| CCatalogPublish | CatalogPublish is responsible for publishing user data to the data archive |
| CCatalogSearch | This class is responsible for searching the catalog using the properties specified |
| CCatalogSearchParam | This class is used in Catalog Search service to set/get all the inputs to search for |
| CICat4Catalog | This class is responsible for the implementation of ICat4 version based information catalogs |
| ►NIndirectFitDataCreationHelper | |
| CAreSpectraEqual | This is used to compare Spectra which is implemented as a boost::variant |
| CSetUpADSWithWorkspace | Simple struct used to access features of the ADS No destructor so ensure you tearDown the ADS |
| ►NInstrumentation | |
| ►CAlgoTimeRegister | AlgoTimeRegister : simple class to dump information about executed algorithms |
| CDump | |
| CInfo | |
| ►NKernel | |
| ►NDetail | |
| CIsEmpty | Defines the concept of emptiness |
| ►NException | The exception classes used by Mantid |
| CAbsObjMethod | Exception for a call to an abstract class function |
| CExistsError | Exception for when an item is already in a collection |
| CFileError | Records the filename and the description of failure |
| CFitSizeWarning | Exception thrown when a fitting function changes number of parameters during fit |
| CIndexError | Exception for index errors |
| CInstrumentDefinitionError | Exception for errors associated with the instrument definition |
| CInternetError | Exception thrown when error occurs accessing an internet resource |
| CMisMatch | Error when two numbers should be identical (or close) |
| CNotFoundError | Exception for when an item is not found in a collection |
| CNotImplementedError | Marks code as not implemented yet |
| CNullPointerException | Exception thrown when an attempt is made to dereference a null pointer |
| COpenGLError | OpenGL Exception |
| CParseError | Records the filename, the description of failure and the line on which it happened |
| ►NMath | |
| ►CSLSQPMinimizer | Minimize an objective function using the SLSQP optimization subroutine originally implemented by Dieter Kraft and ported to Python by scipy |
| ►CFunctionWrapper | Non-templated wrapper for objective function object to allow it to be stored without templating the class |
| CBaseHolder | |
| CTypeHolder | |
| ►NMultiFileNameParsing | |
| CGenerateFileName | A functor that generates a vector of file names from the given vector of runs, and other state passed to it when constructed |
| CParser | This class takes a string representing multiple files and parses it into a vector of vectors of file names |
| CReverseCaselessCompare | Comparator for set that holds instrument names in Parser |
| CRunRangeList | A class that holds a list of ranges of runs |
| ►Npwvjdetail | |
| CJsonType | |
| CJsonType< int > | |
| CJsonType< long > | |
| CJsonType< long long > | |
| CJsonType< unsigned int > | |
| CJsonType< unsigned long > | |
| CJsonType< unsigned long long > | |
| CToCpp | General type to convert a Json::Value to a set C++ type |
| CToCpp< bool > | Specialization of ToCpp for bool |
| CToCpp< double > | Specialization of ToCpp for double |
| CToCpp< float > | Specialization of ToCpp for float |
| CToCpp< int > | Specialization of ToCpp for int |
| CToCpp< long > | Specialization of ToCpp for long |
| CToCpp< long long > | Specialization of ToCpp for long long |
| CToCpp< OptionalBool > | |
| CToCpp< std::string > | Specialization of ToCpp for std::string |
| CToCpp< std::vector< T > > | Specialization of ToCpp for std::vector |
| CToCpp< unsigned int > | Specialization of ToCpp for unsigned int |
| CToCpp< unsigned long long int > | Specialization of ToCpp for unsigned long long int |
| ►NUnits | The namespace for concrete units classes |
| CAtomicDistance | Atomic Distance in Angstroms |
| CDegrees | Degrees that has degrees as unit and "Scattering angle" as title |
| CDeltaE | Energy transfer in milli-electronvolts |
| CDeltaE_inFrequency | Energy transfer in units of frequency (MHz) |
| CDeltaE_inWavenumber | Energy transfer in units of wavenumber (cm^-1) |
| CdSpacing | D-Spacing in Angstrom |
| CdSpacingPerpendicular | D-SpacingPerpendicular in Angstrom |
| CEmpty | Empty unit |
| CEnergy | Energy in milli-electronvolts |
| CEnergy_inWavenumber | Absolute energy in units of wavenumber (cm^-1) |
| CLabel | Label unit |
| CMomentum | Momentum in Angstrom^-1 |
| CMomentumTransfer | Momentum Transfer in Angstrom^-1 |
| CPhi | Phi that has degrees as unit and "Phi" as title |
| CQSquared | Momentum transfer squared in Angstrom^-2 |
| CSpinEchoLength | SpinEchoLength in nm |
| CSpinEchoTime | SpinEchoTime in ns |
| CSymbol | A simple class containing common symbol types |
| CTemperature | Temperature in kelvin |
| CTime | Time In Second |
| CTOF | Time of flight in microseconds |
| CWavelength | Wavelength in Angstrom |
| ►NVectorHelper | |
| CAddVariance | Functor to deal with the increase in the error when adding (or subtracting) a number of counts |
| CDividesNonNull | Divide functor with result reset to 0 if the denominator is null |
| CLog | Log functor |
| CLogNoThrow | |
| CSimpleAverage | A binary functor to compute the simple average of 2 numbers |
| CSquares | Square functor |
| CSumGaussError | Functor used for computing the sum of the square values of a vector, using the accumulate algorithm |
| CSumSquares | Functor to accumulate a sum of squares |
| CTimesSquares | Functor giving the product of the squares of the arguments |
| C__save_flags | |
| CAbstractInstantiator | The base class for instantiators |
| CArrayBoundedValidator | Kernel/ArrayBoundedValidator.h |
| CArrayLengthValidator | ArrayLenghtValidator : Validate length of an array property |
| CArrayOrderedPairsValidator | Kernel/ArrayOrderedPairsValidator.h |
| CArrayProperty | Support for a property that holds an array of values |
| CAttenuationProfile | |
| CBinaryFile | The BinaryFile template is a helper function for loading simple binary files |
| CBinaryStreamReader | Assists with reading a binary file by providing standard overloads for the istream operators (>>) to given types (and vectors of those types) |
| CBinaryStreamWriter | Assists with writing a binary file by providing standard overloads for the ostream operators (<<) to given types (and vectors of those types) |
| CBinFinder | Helper class that allows one to quickly find a bin index for many events |
| CBoundedValidator | BoundedValidator is a validator that requires the values to be between upper or lower bounds, or both |
| CCache | Cache is a generic caching storage class |
| CCaseInsensitiveCmp | |
| CCaseInsensitiveStringComparator | Functor to provide a case insensitive string comparator |
| CCatalogConfigService | |
| CCatalogInfo | A class that holds information about catalogs |
| CChainable | Chainable |
| CChainableFactory | ChainableFactory : Chain of Responsiblity generic factory |
| CChebyshevPolyFit | Compute a weighted least-squares polynomial approximations to an arbitrary set of data points |
| CChebyshevPolynomial | Evaluates a single Chebyshev polynomial (first kind) for x in range [-1,1] |
| CChebyshevSeries | Evaluate an approximation to a nth order polynomial using a Chebyshev series through Crenshaw's algorithm to evaluate \(p_n(x) = \Sigma_{i=1}^{n}c_iT_i\) The evaluation is implemented using the reccurrence relations http://mathworld.wolfram.com/ClenshawRecurrenceFormula.html |
| CCompositeValidator | |
| CConfigObserver | The ConfigObserver is used to observe changes in the configuration based on notifications sent from the ConfigService |
| CConfigPropertyObserver | The ConfigObserver is used to observe changes to the value of a single configuration property based on notifications sent from the ConfigService |
| ►CConfigServiceImpl | The ConfigService class provides a simple facade to access the Configuration functionality of the Mantid Framework |
| CConfigServiceNotification | This is the base class for POCO Notifications sent out from the Config Service |
| CValueChanged | This is the class for the notification that is to be sent when a value has been changed in config service |
| Ccow_ptr | Implements a copy on write data template |
| CCPUTimer | CPUTimer : Timer that uses the CPU time, rather than wall-clock time to measure execution time |
| CCreateUsingNew | Policy class controlling creation of the singleton Implementation classes should mark their default constructors private and insert a friend declaration for this class, e.g.: |
| CDataItem | This class forms the base class of any item that wishes to be stored in the analysis data service |
| ►CDataService | DataService stores instances of a given type |
| CAddNotification | AddNotification is sent after an new object is added to the data service |
| CAfterReplaceNotification | AfterReplaceNotification is sent after an object is replaced in the addOrReplace() function |
| CBeforeReplaceNotification | BeforeReplaceNotification is sent before an object is replaced in the addOrReplace() function |
| CClearNotification | Clear notification is sent when the service is cleared |
| CDataServiceNotification | Base class for DataService notifications that also stores a pointer to the object |
| CNamedObjectNotification | Class for named object notifications |
| CPostDeleteNotification | PostDeleteNotification is sent after an object is deleted from the data service |
| CPreDeleteNotification | PreDeleteNotification is sent before an object is deleted from the data service |
| CRenameNotification | Rename notification is sent when the rename method is called |
| CDateTimeValidator | Checks that a string contains a timestamp in ISO 8601 format (YYYY-MM-DDTHH:MM:SS.mmmmmm) |
| CDateValidator | 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 |
| CDeltaEMode | Defines the possible energy transfer modes: |
| CDirection | Describes the direction (within an algorithm) of a Property |
| CDirectoryValidator | DirectoryValidator is a validator that checks that a directory path is valid |
| CDiskBuffer | Buffer objects that need to be written out to disk so as to optimize writing operations |
| CDllOpen | Simple class for opening shared libraries at run-time |
| ►CDynamicFactory | The dynamic factory is a base dynamic factory for serving up objects in response to requests from other classes |
| CDynamicFactoryNotification | Base class for dynamic factory notifications |
| CUpdateNotification | A notification that the factory has been updated |
| ►CEnabledWhenProperty | |
| CComparisonDetails | Struct which holds details for comparison between two EnabledWhenPropertyObjects |
| CPropertyDetails | Struct which holds associated property details for comparison |
| CEnvironmentHistory | This class stores information about the Environment of the computer used by the framework |
| CEqualBinsChecker | EqualBinsChecker : Checks for evenly spaced bins |
| CErrorReporter | ErrorReporter : The error reporter is responsible for sending error reports |
| CFacilityInfo | A class that holds information about a facility |
| CFeatureUsage | UsageReporter : The Usage reporter is responsible for collating, and sending all usage data |
| CFileDescriptor | Defines a wrapper around an open file |
| CFileValidator | FileValidator is a validator that checks that a filepath is valid |
| CFilteredTimeSeriesProperty | Templated class that defines a filtered time series but still gives access to the original data |
| CFreeBlock | FreeBlock: a simple class that holds the position and size of block of free space in a file |
| CFunctionTask | A FunctionTask can easily create a Task from a method pointer |
| CGitHubApiHelper | GitHubApiHelper : A helper class for supporting access to the github api through HTTP and HTTPS, inherits from the InternetHelper |
| CGlob | This Glob class overrides the glob() method of Poco::Glob class to make it more reliable |
| CICatalogInfo | ICatalogInfo : An abstract class that holds information about catalogs |
| CIndexSet | IndexSet is a container that can be used to define and access a subset of elements in a larger container such as std::vector |
| CINode | Helper class providing interface to ISAveable |
| CInstantiator | The instantiator is a generic class for creating objects of the template type |
| CInstrumentInfo | A class that holds information about an instrument |
| CInternetHelper | InternetHelper : A helper class for supporting access to resources through HTTP and HTTPS |
| CInterpolation | Provide interpolation over a series of points |
| CInverseAngstromsUnit | Inverse Angstroms unit |
| CInverseAngstromsUnitFactory | |
| CInvisibleProperty | This property setting object makes a property invisible in the GUI |
| ►CIPropertyManager | Interface to PropertyManager |
| CTypedValue | Utility class that enables the getProperty() method to effectively be templated on the return type |
| CIPropertySettings | Interface for modifiers to Property's that specify if they should be enabled or visible in a GUI |
| CISaveable | An interface for objects that can be cached or saved to disk |
| CITimeSeriesProperty | A non-templated interface to a TimeSeriesProperty |
| CIValidator | IValidator is the basic interface for all validators for properties |
| CLabelUnit | |
| CLabelUnitFactory | |
| CLessOrEqualFunctor | |
| CLibraryManagerImpl | Class for opening shared libraries |
| CLibraryWrapper | Class for wrapping a shared library |
| CListValidator | ListValidator is a validator that requires the value of a property to be one of a defined list of possibilities |
| CLiveListenerInfo | A class that holds information about a LiveListener connection |
| CLogFilter | This class is for filtering TimeSeriesProperty data |
| CLogger | In charge of the publishing messages from the framework through various channels |
| CLogParser | LogParser parses the instrument log files to select records corresponding to 'RUNNING' instrument status |
| CMandatoryValidator | Validator to check that a property is not left empty |
| ►CMantidVersion | Class containing static methods to return the Mantid version number and date |
| CVersionInfo | |
| CMaskedProperty | A property class for masking the properties |
| ►CMaterial | A material is defined as being composed of a given element, defined as a PhysicalConstants::NeutronAtom, with the following properties: |
| CFormulaUnit | Structure to hold the information for a parsed chemical formula |
| ►CMaterialBuilder | Create a material from a set of user defined options |
| Cdensity_packing | |
| CMaterialXMLParser | Read an XML definition of a Material and produce a new Material object |
| CMatrix | Numerical Matrix class |
| CMatrixProperty | |
| CMDAxisValidator | MDAxisValidator is a class that checks the number of MD axes match the number of workspace dimensions, refactoring out the common validation code from several MD algorithms into a common class |
| CMDUnit | MDUnit : Unit type for multidimensional data types |
| CMDUnitFactory | MDUnitFactory : Abstract type |
| CMemoryStats | This class is responsible for memory statistics |
| CMersenneTwister | This implements the the Mersenne Twister 19937 pseudo-random number generator algorithm as a specialzation of the PseudoRandomNumberGenerator interface |
| CMRUList | An MRU (most recently used) list keeps record of the last n inserted items, listing first the newer ones |
| CMultiFileValidator | The MultiFileValidator validates a MultiFileProperty, which contains a vector of vectors* of filenames - the meaning of which is discussed in MultiFileProperty.h |
| CNDPseudoRandomNumberGenerator | Defines an ND pseudo-random number generator |
| CNDRandomNumberGenerator | This class defines an interface for N dimensional random number generators |
| CNearestNeighbours | |
| CNetworkProxy | NetworkProxy : Network proxy utility for getting network proxy information |
| CNexusDescriptor | Defines a wrapper around a file whose internal structure can be accessed using the NeXus API |
| CNexusHDF5Descriptor | |
| CNNDataPoints | NNDataPoints is a thin RAII wrapper class around the ANNpointArray type |
| ►Cnormal_distribution | |
| Cparam_type | |
| CNullValidator | NullValidator is a validator that doesn't |
| COptionalBool | OptionalBool : Tri-state bool |
| CProgressBase | ProgressBase |
| CProperty | Base class for properties |
| CPropertyHistory | This class stores information about the parameters used by an algorithm |
| CPropertyManager | Property manager helper class |
| CPropertyManagerDataServiceImpl | PropertyManagerDataService Class |
| CPropertyManagerOwner | Kernel/PropertyManagerOwner.h |
| CPropertyManagerProperty | |
| CPropertyWithValue | The concrete, templated class for properties |
| CProxyInfo | ProxyInfo : Container for carrying around network proxy information |
| CPseudoRandomNumberGenerator | Defines a 1D pseudo-random number generator, i.e |
| CQuasiRandomNumberSequence | Defines an interface to a quasi-random number sequence |
| CQuat | Class for quaternions |
| CQUnit | QUnit base |
| CReadLock | Scoped, read-only lock for thread-safe access to DataItems |
| CRebinParamsValidator | Validator to check the format of a vector providing the rebin parameters to an algorithm |
| CReciprocalLatticeUnit | Dimensionless RLU |
| CReciprocalLatticeUnitFactory | |
| CRegistrationHelper | This class is simply used in the subscription of classes into the various factories in Mantid |
| CRfactor | R factor for powder data analysis |
| CSetValueWhenProperty | |
| CSingletonHolder | Manage the lifetime of a class intended to be a singleton |
| CSobolSequence | Defines a generator that produces quasi-random numbers according to a Sobol sequence http://en.wikipedia.org/wiki/Sobol_sequence |
| CSplittingInterval | Class holding a start/end time and a destination for splitting event lists and logs |
| CStartsWithValidator | StartsWithValidator is a validator that requires the value of a property to start with one of the strings in a defined list of possibilities |
| CStatistics | Simple struct to store statistics |
| CStatOptions | Controls the computation of statisical data |
| CStringContainsValidator | StringContainsValidator : A validator designed to ensure that a string input contain a given sub string or a set of sub strings |
| CStringTokenizer | |
| CTask | A Task is a unit of work to be scheduled and run by a ThreadPool |
| CThreadPool | 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 |
| CThreadPoolRunnable | ThreadPoolRunnable : Class used by thread pool (and POCO) to run inside a thread |
| CThreadSafeLogIOS | The base class for ThreadSafeLogStream |
| CThreadSafeLogStream | The main log stream class implementing an ostream interface to a Logger |
| CThreadSafeLogStreamBuf | This class implements a threadsafe version of the POCO buffer interface to a Logger's stream object |
| CThreadScheduler | The ThreadScheduler object defines how tasks are allocated to threads and in what order |
| CThreadSchedulerFIFO | A First-In-First-Out Thread Scheduler |
| CThreadSchedulerLargestCost | A Largest Cost Thread Scheduler |
| CThreadSchedulerLIFO | A Last-In-First-Out Thread Scheduler |
| CThreadSchedulerMutexes | ThreadSchedulerMutexes : Version of a ThreadSchedulerLargestCost that also makes sure to not try to schedule two tasks with the same mutex at the same time |
| CTimeInterval | Represents a time interval |
| CTimer | A simple class that provides a wall-clock (not processor time) timer |
| CTimeSeriesProperty | A specialised Property class for holding a series of time-value pairs |
| CTimeSeriesPropertyStatistics | Struct holding some useful statistics for a TimeSeriesProperty |
| CTimeValueUnit | Class to hold unit value (DateAndTime, T) |
| CTopicInfo | TopicInfo : Class that holds information on a kafka topic |
| ►Cuniform_int_distribution | |
| Cparam_type | |
| CUnit | The base units (abstract) class |
| CUnitConversion | A set of static helper methods to perform conversions between units |
| CUnitFactoryImpl | Creates instances of concrete units |
| CUnitLabel | A base-class for the a class that is able to return unit labels in different representations |
| CUsageServiceImpl | |
| CUserCatalogInfo | UserCatalogInfo : Takes catalog info from the facility (via CatalogInfo), but provides the ability to override the facility defaults based on user preferences |
| CUserStringParser | This class parses a given string into vector of vectors of numbers |
| CV2D | Implements a 2-dimensional vector embedded in a 3D space, i.e |
| CV3D | Class for 3D vectors |
| CVisibleWhenProperty | Same as EnabledWhenProperty, but returns the value for the isVisible() property instead of the isEnabled() property |
| CVMDBase | Simple vector class for multiple dimensions (i.e |
| CWriteLock | Scoped write-lock for thread-safe access to DataItems |
| ►NmathLevel | |
| CPolyBase | Holds a polynominal as a primary type |
| ►NMDAlgorithms | |
| ►NLoadSQWHelper | LoadSQW : Load an SQW file and read observations in as events to generate a IMDEventWorkspace, with events in reciprocal space (Qx, Qy, Qz) |
| CdataPositions | |
| CAccumulateMD | AccumulateMD : Algorithm for appending new data to a MDHistoWorkspace |
| CAndMD | AndMD : Perform the And boolean operation on two MDHistoWorkspaces |
| CApplyDetailedBalanceMD | ApplyDetailedBalance : Perform the And boolean operation on two MDHistoWorkspaces |
| CBaseConvertToDiffractionMDWorkspace | BaseConvertToDiffractionMDWorkspace |
| CBinaryOperationMD | Abstract base class for binary operations on IMDWorkspaces, e.g |
| CBinMD | Take a MDEventWorkspace and bin it to a dense histogram in a MDHistoWorkspace |
| CBooleanBinaryOperationMD | BooleanBinaryOperationMD : base class for boolean-type operations on MDHistoWorkspaces |
| CCalculateCoverageDGS | CalculateCoverageDGS : Calculate coverage for single crystal direct geometry scattering |
| CCellCoords | Partition QLab space into a cubic lattice |
| CCentroidPeaksMD | Find the centroid of single-crystal peaks in a MDEventWorkspace, in order to refine their positions |
| CCentroidPeaksMD2 | Find the centroid of single-crystal peaks in a MDEventWorkspace, in order to refine their positions |
| CChangeQConvention | Save a MDEventWorkspace to a .nxs file |
| CCloneMDWorkspace | Algorithm to clone a MDEventWorkspace to a new one |
| CCompactMD | |
| CCompareMDWorkspaces | Compare two MDWorkspaces for equality |
| CConvertCWPDMDToSpectra | ConvertCWPDMDToSpectra : Convert one MDWorkspaces containing reactor-source powder diffractometer's data to single spectrum matrix workspace by merging and binning the detectors' counts by their 2theta value |
| CConvertCWSDExpToMomentum | ConvertCWSDExpToMomentum : TODO: DESCRIPTION |
| CConvertCWSDMDtoHKL | ConvertCWSDMDtoHKL : TODO: DESCRIPTION |
| CConvertHFIRSCDtoMDE | ConvertHFIRSCDtoMDE : TODO: DESCRIPTION |
| CConvertMDHistoToMatrixWorkspace | Creates a single spectrum Workspace2D with X,Y, and E copied from an first non-integrated dimension of a IMDHistoWorkspace |
| CConvertSpiceDataToRealSpace | ConvertSpiceDataToRealSpace : Convert data from SPICE file to singals in real space contained in MDEventWrokspaces |
| CConvertToDetectorFaceMD | Convert a MatrixWorkspace containing to a MD workspace for viewing the detector face |
| CConvertToDiffractionMDWorkspace | ConvertToDiffractionMDWorkspace : Create a MDEventWorkspace with events in reciprocal space (Qx, Qy, Qz) from an input EventWorkspace |
| CConvertToDiffractionMDWorkspace2 | ConvertToDiffractionMDWorkspace2 : Create a MDEventWorkspace with events in reciprocal space (Qx, Qy, Qz) from an input EventWorkspace |
| CConvertToDiffractionMDWorkspace3 | ConvertToDiffractionMDWorkspace3 : Create a MDEventWorkspace with events in reciprocal space (Qx, Qy, Qz) from an input EventWorkspace |
| CConvertToMD | ConvertToMD : Transform a workspace into MD workspace with components defined by user |
| CConvertToMDMinMaxGlobal | ConvertToMDMinMaxGlobal : Algorithm to calculate limits for ConvertToMD transformation which can be observed using an instrument which covers whole MD-space The current version knows |
| CConvertToMDMinMaxLocal | ConvertToMDMinMaxLocal : Algorithm to calculate limits for ConvertToMD |
| CConvertToMDParent | ConvertToMDParent : Main part of two algorithms which use ConvertToMD factory to transform points from instrument space to physical MD space |
| CConvToMDBase | Class describes the interface to the methods, which perform conversion from usual workspaces to MDEventWorkspace |
| CConvToMDEventsWS | The class specializes ConvToDataObjectsBase for the case when the conversion occurs from Events WS to the MD events WS |
| ►CConvToMDEventsWSIndexing | This class creates the MDWorkspace from the collection of ToF events: converts to the MD events with proper Nd coordinate and than assigns the groups of them to the spatial tree-like box structure |
| CMDEventMaker | |
| CMDEventMaker< ND, Mantid::DataObjects::MDLeanEvent > | |
| CConvToMDHistoWS | The class to transform matrix workspace into MDEvent workspace when matrix workspace is ragged 2D workspace |
| CConvToMDSelector | Small class to select proper solver as function of the workspace kind and (possibly, in a future) other workspace parameters |
| CCreateMD | CreateMD : This workflow algorithm creates MDWorkspaces in the Q3D, HKL frame using ConvertToMD |
| CCreateMDHistoWorkspace | CreateMDHistoWorkspace |
| CCreateMDWorkspace | CreateMDWorkspace : |
| CCutMD | CutMD : Slices multidimensional workspaces |
| CDgsScatteredTransmissionCorrectionMD | |
| CDisabledProperty | Small class to diable propery on interface |
| CDisplayNormalizationSetter | DisplayNormalizationSetter: Sets the displaynormalization on a workspace based on several parameters such as workspace-type, energy-transfer-mode and if we are dealing with Q3D |
| CDivideMD | DivideMD : divide operation for MDWorkspaces |
| CEqualToMD | EqualToMD : boolean operation on MDHistoWorkspaces |
| CEvaluateMDFunction | EvaluateMDFunction : TODO: DESCRIPTION |
| CExponentialMD | ExponentialMD : exponential function on MDHistoWorkspace |
| CFakeMDEventData | FakeMDEventData : Algorithm to create fake multi-dimensional event data that gets added to MDEventWorkspace, for use in testing |
| CFindPeaksMD | FindPeaksMD : TODO: DESCRIPTION |
| CFitMD | Creates FunctionDomainMD from an IMDWorkspace |
| CFlippingRatioCorrectionMD | FlippingRatioCorrectionMD : Algorithm to correct MDEvents for flipping ratio |
| CGetSpiceDataRawCountsFromMD | GetSpiceDataRawCountsFromMD : Export raw detectors' counts or sample log values from IMDEventWorkspaces from the output of algorithm ConvertSpiceDataToRealSpace |
| CGreaterThanMD | GreaterThanMD : boolean operation on MDHistoWorkspaces |
| CIDynamicRebinning | Class provides commont interface for various classes performing rebinning operations; |
| CImportMDEventWorkspace | ImportMDEventWorkspace : Loads a file containing dimensionality and data for an MDEventWorkspace |
| CImportMDHistoWorkspace | ImportMDHistoWorkspace : Takes a text file containing structured signal and error information and imports it as a new MDHistoWorkspace |
| CImportMDHistoWorkspaceBase | ImportMDHistoWorkspaceBase : Base class for algorithms Importing data as MDHistoWorkspaces |
| CInputArgument | Local type to group min, max extents with a dimension index |
| CIntegrate3DEvents | This is a low-level class to construct a map with lists of events near each peak Q-vector, shifted to be centered at (0,0,0) |
| CIntegrateEllipsoids | |
| CIntegrateEllipsoidsTwoStep | IntegrateEllipsoidsTwoStep provides a two pass peak integration algorithm |
| CIntegrateEllipsoidsV1 | |
| CIntegrateEllipsoidsV2 | |
| CIntegrateFlux | Algorithm IntegrateFlux |
| CIntegrateMDHistoWorkspace | IntegrateMDHistoWorkspace : Algorithm to perform axis aligned integration of an MDHistoWorkspace |
| CIntegratePeaksCWSD | Integrate single-crystal peaks in reciprocal-space |
| CIntegratePeaksMD | Integrate single-crystal peaks in reciprocal-space |
| CIntegratePeaksMD2 | Integrate single-crystal peaks in reciprocal-space |
| CIntegratePeaksMDHKL | Integrate single-crystal peaks in reciprocal-space |
| CIntegrateQLabEvents | This is a low-level class to construct a map with lists of events near each peak Q-vector in the lab frame |
| CIntegrationParameters | |
| CInvalidParameter | Invalid parameter type |
| CInvalidParameterParser | XML Parser for invalid parameter types |
| CLessThanIndex | Comparator to allow sorting by dimension index |
| CLessThanMD | LessThanMD : boolean operation on MDHistoWorkspaces |
| ►CLoadDNSSCD | LoadDNSSCD : Load a list of DNS .d_dat files into a MDEventWorkspace |
| CExpData | Structure for experimental data |
| CLoadMD | Load a .nxs file into a MDEventWorkspace |
| CLoadSQW | |
| CLoadSQW2 | |
| CLogarithmMD | LogarithmMD : natural logarithm of a MDHistoWorkspace |
| CLOOP | |
| CLOOP< 0 > | |
| CMaskMD | MaskMD : Mask an MDWorkspace |
| ►CMDEventTreeBuilder | Class to create the box structure of MDWorkspace |
| CTask | Structure to store the subtask of creating subtree from the range of events |
| CTreeWithIndexError | |
| CMDEventWSWrapper | |
| CMDNorm | MDNormalization : Bin single crystal diffraction or direct geometry inelastic data and calculate the corresponding statistical weight |
| CMDNormDirectSC | MDNormSCD : Generate MD normalization for single crystal diffraction |
| CMDNormSCD | MDNormSCD : Generate MD normalization for single crystal diffraction |
| CMDTransfAxisNames | |
| CMDTransfFactoryImpl | Creates instances of concrete transformations into multidimensional (MD) coordinates |
| CMDTransfInterface | Interface to set of sub-classes used by ConvertToMD algorithm and responsible for conversion of input workspace data into MD events |
| CMDTransfModQ | Class responsible for conversion of input workspace data into proper number of output dimensions for ModQ case |
| CMDTransfNoQ | Class responsible for conversion of input workspace data into proper number of output dimensions in NoQ case, when the data from a ws are just copied to MD WS |
| CMDTransfQ3D | Class responsible for conversion of input workspace data into proper number of output dimensions for Q3D case |
| CMDWSDescription | Helper class describes the properties of target MD workspace, which should be obtained as the result of conversion algorithm |
| CMDWSTransform | |
| CMergeMD | Merge several MDWorkspaces into one |
| CMergeMDFiles | Algorithm to merge multiple MDEventWorkspaces from files that obey a common box format |
| CMinusMD | MinusMD : minus operation for MDWorkspaces |
| CMultiplyMD | MultiplyMD : multiplication operation for MDWorkspaces |
| CNotMD | NotMD : boolean negation of a MDHistoWorkspace |
| COccupiedCell | |
| COrMD | OrMD : boolean operation on MDHistoWorkspaces |
| CPlusMD | Sum two MDWorkspaces together |
| CPolarizationAngleCorrectionMD | PolarizationAngleCorrection : Perform polarization angle correction to an MDEventWorkspace |
| CPowerMD | PowerMD : raise a MDHistoWorkspace to a power |
| CPreprocessDetectorsToMD | This is helper algorithm used to preprocess detector's positions namely to perform generic part of the transformation from a matrix workspace of a real instrument to physical MD workspace of an experimental results (e.g Q-space) |
| CProduct | Functor to compute the product of the set |
| CQueryMDWorkspace | QueryMDWorkspace : Query an MDWorkspace in order to extract overview information as a table workspace |
| CRecalculateTrajectoriesExtents | RecalculateTrajectoriesExtents : |
| CReplicateMD | ReplicateMD : Algorithm header for ReplicateMD |
| CSaveIsawQvector | SaveIsawQvector |
| CSaveMD | Save a MDEventWorkspace to a .nxs file |
| CSaveMD2 | Save a MDEventWorkspace to a .nxs file |
| CSaveZODS | Save a MDHistoWorkspace to a HDF5 format for use with the ZODS analysis software |
| CSetMDFrame | SetMDFrame : This algorithm changes the MDFrame stored alongside the dimension of MDWorkspaes.The algorithm should primarily be used to introduce the correct MDFrame type to workspaces based on legacy files |
| CSetMDUsingMask | Algorithm to set a MDHistoWorkspace in points determined by a mask boolean MDHistoWorkspace |
| CSimpleMDEvent | |
| CSliceMD | Algorithm that can take a slice out of an original MDEventWorkspace while preserving all the events contained wherein |
| CSlicingAlgorithm | Abstract Algorithm class that will be used by: BinMD and SliceMD and shares code for getting a slice from one workspace to another |
| CSmoothMD | SmoothMD : Algorithm for smoothing MDHistoWorkspaces |
| CSquare | Helper type to compute the square in-place |
| CThresholdMD | ThresholdMD : TODO: DESCRIPTION |
| CTransformMD | Scale and/or offset the coordinates of a MDWorkspace |
| CTransposeMD | TransposeMD : Transpose an MDWorkspace |
| CUnaryOperationMD | Abstract base class for unary operations (e.g |
| CUnitsConversionHelper | |
| CUserFunctionMD | A user defined function |
| CVector3DParameter | Vector3DParameter is abstract type implementing curiously recurring template pattern to implement common code associated with vector storage |
| CVector3DParameterParser | XML parser for vector value (3 elements) parameter types |
| CWeightedMeanMD | WeightedMeanMD : Find the weighted mean of two MDWorkspaces |
| CXorMD | XorMD : boolean operation on MDHistoWorkspaces |
| ►NNeXus | |
| ►NNeXusIOHelper | |
| CAllowNarrowing | |
| CPreventNarrowing | |
| CNexusFileIO | Utility method for saving NeXus format of Mantid Workspace This class interfaces to the C Nexus API |
| CNXAttributes | Nexus attributes |
| CNXBinary | Implements NXnote Nexus class with binary data |
| CNXClass | The base class for a Nexus class (group) |
| CNXClassInfo | Information about a Nexus class |
| CNXData | Implements NXdata Nexus class |
| CNXDataSet | Abstract base class for a Nexus data set |
| CNXDataSetTyped | Templated class implementation of NXDataSet |
| CNXDetector | Implements NXdetector Nexus class |
| CNXDiskChopper | Implements NXdisk_chopper Nexus class |
| CNXEntry | Implements NXentry Nexus class |
| CNXInfo | C++ implementation of NeXus classes |
| CNXInstrument | Implements NXinstrument Nexus class |
| CNXLog | Implements NXlog Nexus class |
| CNXMainClass | Main class is the one that can contain auxiliary classes |
| CNXNote | Implements NXnote Nexus class |
| CNXObject | The base abstract class for NeXus classes and data sets |
| CNXRoot | Implements NXroot Nexus class |
| ►NNexusGeometry | |
| CNexusFileReader | |
| ►NPhysicalConstants | A namespace containing physical constants that are required by algorithms and unit routines |
| CAtom | Struture to hold the common information for an atom |
| CMagneticIon | Struture to hold information about magnetic form factor for 3d, 4d, rare earth, and actinide atoms and ions |
| CNeutronAtom | Structure to store neutronic scattering information for the various elements |
| ►NPythonInterface | |
| ►NConverters | |
| CCArrayToNDArray | Converter that takes a c array and its size then converts/wraps it into a numpy array |
| ►CClone | Clone is a policy (in the C++ sense)for converting to an ND Array |
| Capply | |
| CMapToPyDictionary | |
| CMatrixToNDArray | Converter that takes a Mantid Matrix and converts it into a numpy array |
| CNDArrayToVector | Converter taking an input numpy array and converting it to a std::vector |
| CNDArrayTypeIndex | Defines a mapping between C++ type given by the template parameter and numpy type enum NPY_TYPES |
| CPyObjectToMatrix | Takes a Python object and if it supports indexing and is two dimensional it attempts to convert it to a Kernel::Matrix object |
| CPyObjectToV3D | 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 |
| CPyObjectToVMD | Takes a Python object and if it supports indexing and is of length 3 then it will attempt to convert a Kernel::VMD object from it |
| CPySequenceToVector | Converts a Python sequence type to a C++ std::vector, where the element type is defined by the template type |
| CToPyList | Converter that takes a std::vector and converts it into a python list |
| CVectorToNDArray | Converter that takes a std::vector and converts it into a flat numpy array |
| ►CWrapReadOnly | WrapReadOnly is a policy for VectorToNDArray to wrap the vector in a read-only numpy array that looks at the original data |
| Capply | |
| ►CWrapReadWrite | WrapReadWrite is a policy for VectorToNDArray to wrap the vector in a read-write numpy array that looks at the original data |
| Capply | |
| ►NPolicies | |
| ►CAsType | Implements the AsType policy |
| Capply | |
| ►CMatrixRefToNumpy | Implements a return value policy that returns a numpy array from a Matrix |
| Capply | |
| ►CMatrixToNumpy | Implements a return value policy that returns a numpy array from a function returning a std::vector by value |
| Capply | |
| ►CRemoveConst | Implements the RemoveConst policy |
| Capply | |
| ►CRemoveConstSharedPtr | Implements the RemoveConstSharedPtr policy |
| Capply | |
| ►CVectorRefToNumpy | Implements a return value policy that returns a numpy array from a rerence to a std::vector |
| Capply | |
| ►CVectorToNumpy | Implements a return value policy that returns a numpy array from a function returning a std::vector by ref or value |
| Capply | |
| ►NRegistry | |
| CMappingTypeHandler | Defines a handler class for converting a Python mapping type object to a C++ PropertyManager type |
| CPropertyValueHandler | This class provides a base-class objects that are able to take a python object and set it on an algorithm property |
| CPropertyWithValueFactory | Defines a static factory class that creates PropertyWithValue instances from python objects |
| CRegisterWorkspacePtrToPython | Encapsulates the registration required for an interface type T that sits on top of a Kernel::DataItem object |
| CSequenceTypeHandler | A specialisation of PropertyValueHander to handle coercing a Python value into a C++ sequence/array property |
| CTypedPropertyValueHandler | This class provides a templated class object that is able to take a python object and perform operations with a given C type |
| CTypedPropertyValueHandler< std::shared_ptr< T >, std::enable_if< std::is_base_of< API::Workspace, T >::value >::type > | |
| CTypeRegistry | The values that are held within a given C++ property type all have a fixed type, required by static typing |
| CAlgorithmAdapter | Provides a layer class for boost::python to allow C++ virtual functions to be overridden in a Python object that is derived an Algorithm |
| CAlgorithmFactoryObserverAdapter | A wrapper class helping to export AnalysisDataServiceObserver to python |
| CAlgorithmIDProxy | Provides a concrete type to wrap & return AlgorithmIDs that are actually just typedefs for void* |
| CAlgorithmObserverAdapter | A wrapper class helping to export AlgorithmObserver to python |
| CAnalysisDataServiceObserverAdapter | A wrapper class helping to export AnalysisDataServiceObserver to python |
| CDataProcessorAdapter | Provides a layer class for boost::python to allow C++ virtual functions to be overridden in a Python object that is derived an DataProcessorAlgorithm |
| CDataServiceExporter | A helper struct to export templated DataService<> types to Python |
| CExtractSharedPtr | |
| CGILSharedPtrDeleter | Special shared_ptr::deleter object that locks the GIL while deleting the underlying Python object |
| CGILState | |
| CGlobalInterpreterLock | Defines a structure for acquiring/releasing the Python GIL using the RAII pattern |
| CIFunction1DAdapter | Provides a layer class for boost::python to allow C++ virtual functions to be overridden in a Python object that is derived from IFunction1D |
| CIFunctionAdapter | Provides a layer to hook into the protected functions of IFunction |
| CIPeakFunctionAdapter | Provides a layer class for boost::python to allow C++ virtual functions to be overridden in a Python object that is derived from IPeakFunction |
| CIPyTypeVisitor | |
| CNDArray | Thin object wrapper around a numpy array |
| CPropertyWithValueExporter | A helper struct to export PropertyWithValue<> types to Python |
| CPyNativeTypeExtractor | |
| CPythonException | Exception type that captures the current Python error state as a generic C++ exception for any general Python exception |
| CPythonObjectInstantiator | |
| CReleaseGlobalInterpreterLock | Defines a structure for releasing the Python GIL using the RAII pattern |
| CRunPythonScript | |
| CSpectrumInfoPythonIterator | SpectrumInfoPythonIterator |
| Cstd_set_exporter | Std::set wrapper |
| Cstd_vector_exporter | A struct to help export std::vector types |
| CTypedValidatorExporter | Declares a simple static struct to export a TypedValidator to Python |
| CUndefinedAttributeError | Defines an exception for an undefined attribute |
| CUninstallTrace | RAII handler to temporarily remove and reinstall a Python trace function |
| CWorkspacePropertyExporter | A helper struct to export WorkspaceProperty<> types to Python |
| ►NSingleCrystalDiffractionTestHelper | |
| CWorkspaceBuilder | |
| ►NWorkflowAlgorithms | |
| CAlignAndFocusPowder | This is a parent algorithm that uses several different child algorithms to perform it's task |
| CComputeSensitivity | Workflow algorithm to compute a patched sensitivity correction for EQSANS |
| CDgsAbsoluteUnitsReduction | DgsAbsoluteUnitsReduction : This is the algorithm responsible for processing and creating the absolute units normalisation data |
| CDgsConvertToEnergyTransfer | DgsConvertToEnergyTransfer : This is the algorithm responsible for the conversion from TOF to energy transfer |
| CDgsDiagnose | DgsDiagnose : This algorithm constructs all of the necessary workspaces for performing detector diagnostics and then runs the diagnostic algorithm |
| CDgsPreprocessData | DgsPreprocessData : This algorithm is responsible for normalising the data to current (proton charge) or monitor |
| CDgsProcessDetectorVanadium | DgsProcessDetectorVanadium : This is the algorithm responsible for processing the detector vanadium into the form needed for the normalisation of sample data in the convert to energy transfer process |
| CDgsReduction | DgsReduction : This is the top-level workflow algorithm for controlling direct geometry spectrometer reduction |
| CDgsRemap | DgsRemap : This algorithm takes a workspace and masks and groups that workspace if appropriate information is passed |
| CEQSANSDarkCurrentSubtraction | Subtract dark current for EQSANS |
| CEQSANSDarkCurrentSubtraction2 | Subtract dark current for EQSANS |
| CEQSANSLoad | Subtract dark current for EQSANS |
| CEQSANSMonitorTOF | |
| CEQSANSPatchSensitivity | Calculate the detector sensitivity and patch the pixels that are masked in a second workspace |
| CEQSANSQ2D | Workflow algorithm to process a reduced EQSANS workspace and produce I(Qx,Qy) |
| CHFIRDarkCurrentSubtraction | Subtract dark current for HFIR SANS |
| CHFIRLoad | Subtract dark current for HFIR SANS |
| CHFIRSANSNormalise | |
| CIMuonAsymmetryCalculator | IMuonAsymmetryCalculator : Abstract base class for muon asymmetry calculations |
| CLoadEventAndCompress | LoadEventAndCompress : TODO: DESCRIPTION |
| CMuonGroupAsymmetryCalculator | MuonGroupAsymmetryCalculator : Calculates asymmetry between given group (specified via GroupIndex) and Muon exponential decay |
| CMuonGroupCalculator | MuonGroupCalculator : Base class for Muon group counts/asymmetry calculators |
| CMuonGroupCountsCalculator | MuonGroupCountsCalculator : Calculates pure counts of the group specified via group index |
| CMuonPairAsymmetryCalculator | MuonPairAsymmetryCalculator : Calculates asymmetry for a given pair of groups, given the alpha value |
| CMuonProcess | MuonProcess : Processes and analyses Muon workspace |
| CRegLowVectorPair | |
| CSANSBeamFinder | Beam Finder for SANS instruments |
| CSANSBeamFluxCorrection | Performs beam flux correction on TOF SANS data |
| CSANSSensitivityCorrection | Sensitivity correction for SANS |
| CSANSSolidAngleCorrection | Performs a solid angle correction on a 2D SANS data set to correct for the absence of curvature of the detector |
| CSetupEQSANSReduction | Set up the reduction options for EQSANS reduction |
| CSetupHFIRReduction | Set up the reduction options for HFIR reduction |
| CSofTwoThetaTOF | SofTwoThetaTOF : Convert a S(spectrum number, TOF) workspace to S(twoTheta, TOF) workspace |
| CStepScan | This workflow algorithm is for generation of a rocking curve from an alignment scan performed on an ADARA-enabled instrument at the SNS |
| CDTriple | Triple of three different things |
| CNoDeleting | An object for constructing a shared_ptr that won't ever delete its pointee |
| CTestChannel | |
| CTriple | Triple of three identical types |
| ►NMantidQt | The AlgorithmProgressDialogPresenter keeps track of the running algorithms and displays a progress bar for them, and a property list |
| ►NAPI | |
| CAbstractAlgorithmInputHistory | This abstract class deals with the loading and saving of previous algorithm property values to/from MantidPlot's QSettings |
| CAlgorithmCompleteNotification | |
| CAlgorithmDialog | This class should be the basis for all customised algorithm dialogs |
| CAlgorithmDialogFactoryImpl | The AlgorithmDialogFactory is responsible for creating concrete instances of AlgorithmDialog classes |
| CAlgorithmErrorNotification | |
| CAlgorithmInputHistoryImpl | |
| CAlgorithmPropertiesWidget | Widget that contains dynamically generated PropertyWidget's for each property of an algorithm, contained in a scroll area |
| CAlgorithmRunner | The AlgorithmRunner is a QObject that encapsulates methods for running an algorithm asynchronously (in the background) and feeds-back to a GUI widget |
| CAlgorithmRuntimeProps | |
| CAlgorithmStartedNotification | |
| CBaseDecoder | |
| CBaseEncoder | |
| CBatchAlgorithmRunner | Algorithm runner for execution of a queue of algorithms |
| CBatchCancelledNotification | |
| CBatchCompleteNotification | |
| CBoolPropertyWidget | Set of widgets representing a PropertyWithValue<bool> |
| CClickableLabel | A small extension to QLabel, so that it emits a signal when clicked |
| CConfiguredAlgorithm | |
| CFakeFileFinderWidget | FakeFileFinderWidget |
| CFakeFindFilesThread | FakeFindFilesThread |
| CFileFinderWidget | This class defines a widget for file searching |
| CFilePropertyWidget | Widget for FileProperty, which has a "Browse" button |
| CFindFilesSearchParameters | POD struct to hold details about the parameters of a file search |
| CFindFilesSearchResults | POD struct to hold details about the results of a file search |
| CFindFilesThreadPoolManager | A small helper class to hold a handle to a static thread pool |
| CFindFilesWorker | A class to allow the asynchronous finding of files |
| CFlowLayout | |
| CGenericDialog | This class gives a basic dialog that is not tailored to a particular algorithm |
| CHelpWindow | |
| CIAlgorithmRuntimeProps | |
| CIConfiguredAlgorithm | |
| CInterfaceManager | This class is responsible for creating the correct dialog for an algorithm |
| CIProjectSerialisable | Defines an interface to a MantidPlot class that can be saved into or loaded from a project |
| CListPropertyWidget | Widget for displaying a Property that has a set of allowed values |
| CManageUserDirectories | Access and update the user directory settings within the Mantid config service |
| CMantidDesktopServices | This class provides a wrapper around QDesktopServices to fix a bug in opening URLs in firefox when tcmalloc is in the LD_PRELOAD environment variable on Linux |
| CMantidDialog | |
| CMantidHelpInterface | |
| CMantidWidget | 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 |
| CObserverCallback | A simple callback class so that we avoid multiple inheritance issues with QObject |
| COptionsPropertyWidget | Widget for displaying a Property that has a set of allowed values |
| CPlotAxis | Deals with formatting a label for a plot axis for a given type of workspace |
| CPropertyWidget | Base class for widgets that will set Mantid::Kernel::Property* types |
| CPropertyWidgetFactory | PropertyWidgetFactory : TODO: DESCRIPTION |
| CPythonRunner | 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 |
| CQScienceSpinBox | |
| ►CRepoModel | RepoModel : Wrapper for ScriptRepository to fit the Model View Qt Framework |
| CDeleteQueryBox | Auxiliary Dialog to get the option from the user about removing the entries from the local folder or the central repository |
| CRepoItem | A nested class to help RepoModel to implement the QAbstractItemModel |
| CUploadForm | |
| CRepoTreeView | RepoTreeView : A specialization of QTreeView class that emits signal every time the selection change |
| ►CScriptRepositoryView | ScriptRepositoryView : Provide the User Interface to the ScriptRepository |
| CCheckBoxDelegate | Delegate to show the checkbox for configuring the auto update |
| CRemoveEntryDelegate | Delegate to show the icon to remove the entry from the local and central repository |
| CRepoDelegate | Delegate to show the icons Download and Upload |
| CSelectionNotificationServiceImpl | Provides a simple loosely coupled mechanism for passing information about a selected point from several possible sources to several possible destinations |
| CSyncedCheckboxes | QObject that links: |
| CTextPropertyWidget | The most generic widgets for Property's that are only a simple string |
| CTSVSerialiser | |
| CUserSubWindow | 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 |
| CUserSubWindowFactoryImpl | The UserSubWindowFactory is responsible for creating concrete instances of user interface classes |
| CWidgetScrollbarDecorator | WidgetScrollbarDecorator : Adds scrollbar functionality to a QWidget |
| CWindowIcons | Defines a mapping between a workspace ID and a pixmap to use for an icon |
| CWorkspaceIcons | Defines a mapping between a workspace ID and a pixmap to use for an icon |
| CWorkspaceObserver | Observes AnalysisDataService notifications: add,replace,delete |
| ►NCustomDialogs | |
| CBaseInstantiator | Base instantiator to store in a map |
| CCatalogPublishDialog | This class gives specialised dialog for the CatalogPublish algorithm |
| CConeDetails | A widget to define a cone |
| CConvertTableToMatrixWorkspaceDialog | This class gives specialised dialog for the ConvertTableToMatrixWorkspace algorithm |
| CCuboidDetails | A widget to define an infinite plane |
| CCylinderDetails | A widget to define a cylinder |
| CDynamicPropertiesWidget | Base class for input workspace's dynamic properties widget |
| CFitDialog | This class gives specialised dialog for the Load algorithm |
| CHexahedronDetails | A widget to define a hexahedron |
| CInfiniteConeDetails | A widget to define an infinite cone |
| CInfiniteCylinderDetails | A widget to define an infinite cylinder |
| CInfinitePlaneDetails | A widget to define an infinite plane |
| CInputWorkspaceWidget | Widget for inputting workspace information |
| CLoadDAEDialog | This class gives specialised dialog for the LoadDAE algorithm |
| CLoadDialog | |
| CLoadRawDialog | This class gives specialised dialog for the LoadRaw algorithm |
| CLOQScriptInputDialog | This class gives specialised dialog for the LOQ input algorithm |
| CMantidGLWidget | This class provides a widget to display a Mantid Geometry object using OpenGL |
| CMDPropertiesWidget | Widgets to set properties for a IMDWorkspace: MaxSize |
| CMWPropertiesWidget | Widgets to set properties for a MatrixWorkspace: WorkspaceIndex, StartX, EndX |
| CNoDeleting | An object for constructing a shared_ptr that won't ever delete its pointee |
| COperation | A struct describing a binary operation Note: The constructor takes an integer where 0 = intersection, 1 = union and 2 = difference |
| CPlotAsymmetryByLogValueDialog | This class gives specialised dialog for the LoadRaw algorithm |
| CPointGroupBox | A custom group box for a 3D point |
| CPreventLoadRequests | |
| CShapeDetails | The base class for the details widgets |
| CShapeDetailsInstantiator | A structure used for holding the type of a details widget |
| CSliceOfCylinderRingDetails | A widget to define an infinite cylinder |
| CSortTableWorkspaceDialog | This class gives specialised dialog for the SortTableWorkspace algorithm |
| CSphereDetails | A widget to define a sphere |
| CStartLiveDataDialog | |
| ►NCustomInterfaces | |
| CUserInputValidator | A class to try and get rid of some of the boiler-plate code surrounding input validation, and hopefully as a result make it more readable |
| ►NMantidWidgets | |
| ►NBatch | |
| CBuildSubtreeItems | |
| CCell | |
| CCellDelegate | |
| CExtractSubtrees | |
| CFilteredTreeModel | |
| CFindSubtreeRoots | |
| CIJobTreeView | |
| CJobTreeView | |
| CJobTreeViewSignalAdapter | |
| CJobTreeViewSubscriber | |
| CLambdaRowPredicate | |
| CMockJobTreeView | |
| CQModelIndexForFilteredModel | |
| CQModelIndexForMainModel | |
| CQtStandardItemTreeModelAdapter | |
| CQtTreeCursorNavigation | |
| CRow | |
| CRowLocation | |
| CRowLocationAdapter | |
| CRowPredicate | |
| CStrictQModelIndex | |
| CAddWorkspaceDialog | A dialog for selecting a workspace from the ADS |
| CADSAdapter | |
| CAlgorithmHintStrategy | AlgorithmHintStrategy : Produces hints using a given algorithm's properties |
| CAlgorithmProgressDialogPresenter | |
| CAlgorithmProgressDialogWidget | |
| CAlgorithmProgressDialogWidgetCancelButton | |
| CAlgorithmProgressModel | |
| CAlgorithmProgressPresenter | |
| CAlgorithmProgressPresenterBase | |
| CAlgorithmProgressWidget | |
| CAlgorithmSelectorWidget | A widget consisting of a ComboBox and a TreeWidget to allow a user to select an algorithm either by category or by typing |
| CAlgorithmTreeWidget | Tree widget with the categories and algorithms listed |
| CApplyEnumeratedSpectra | |
| CApplySpectra | |
| CBinMDDialog | |
| CCatalogHelper | |
| CCatalogSearch | This class defines the interface and functionality for the cataloging system within Mantid |
| CCatalogSelector | |
| CCheckboxHeader | This class subclasses and overwrites QHeaderView methods to enable checkboxes to exist in the table header |
| CConfigurable | Defines an interface for an object to load and store any configuration settings that should persist between objects |
| CConvolutionFunctionModel | |
| CCreateAttributeProperty | Attribute visitor to create a QtProperty |
| CCreateAttributePropertyForFunctionTreeView | Attribute visitor to create a QtProperty |
| CCustomItemDelegate | This class is used for formating the type of data allowed in each of the tables columns |
| CDataSelector | This class defines a widget for selecting a workspace of file path by using a combination of two child MantidWidgets: FileFinderWidget and WorkspaceSelector |
| CDiagResults | |
| CEditLocalParameterDialog | A dialog for displaying and editing values of local parameters |
| CFilenameDialogEditor | A stringDialogEditor for editing file names |
| CFilenameDialogEditorFactory | The factory for the FilenameDialogEditor |
| CFindAlgComboBox | ComboBox for finding algorithms |
| CFitDomain | This class is used to store all data relating to a single domain to be fitted |
| CFitOptionsBrowser | Class FitOptionsBrowser implements QtPropertyBrowser to display and set properties of Fit algorithm (excluding Function and Workspace) |
| CFitPropertyBrowser | Class FitPropertyBrowser implements QtPropertyBrowser to display and control fitting function parameters and settings |
| CFitScriptGeneratorDataTable | This class represents the table widget which holds domain data for the FitScriptGenerator interface |
| CFitScriptGeneratorModel | This class stores the domain and fit data to be fitted to |
| CFitScriptGeneratorPresenter | |
| CFitScriptGeneratorView | |
| CFitScriptOptionsBrowser | The BasicFitOptionsBrowser class implements a QtPropertyBrowser to display fitting properties found in the Fit algorithm |
| CFunctionBrowser | Class FitPropertyBrowser implements QtPropertyBrowser to display and control fitting function parameters and settings |
| CFunctionModel | |
| CFunctionModelDataset | |
| CFunctionModelSpectra | |
| CFunctionMultiDomainPresenter | |
| ►CFunctionTreeView | Class FitPropertyBrowser implements QtPropertyBrowser to display and control fitting function parameters and settings |
| CAConstraint | Constraint structure |
| CAProperty | To keep QtProperty and its QtBrowserItem in one place |
| CATie | Tie structure |
| CGlobalParameter | This struct stores the name of a global parameter which is shared across ALL domains in a multi dataset fit |
| CGlobalTie | This struct stores the data associated with a global tie |
| CHint | |
| CHintingLineEdit | HintingLineEdit : A QLineEdit widget providing autocompletion |
| CHintingLineEditFactory | HintingLineEditFactory : A QStyledItemDelegate that produces HintingLineEdits using the given hint strategy |
| CHintStrategy | HintStrategy : Provides an interface for generating hints to be used by a HintingLineEdit |
| CIAlgorithmProgressDialogWidget | |
| CIAlgorithmProgressWidget | |
| CIFitScriptGeneratorModel | |
| CIFitScriptGeneratorPresenter | |
| CIFitScriptGeneratorView | |
| CIFunctionBrowser | IFunctionBrowser: interface for FunctionBrowser |
| CIFunctionModel | |
| CIFunctionView | The interface to a function view |
| CIImageInfoWidget | |
| ►CImageInfoModel | |
| CImageInfo | |
| CImageInfoModelMatrixWS | Model to support looking up information about a given point with a MatrixWorkspace |
| CImageInfoModelMD | |
| CImageInfoPresenter | A table widget containing information about the pixel the mouse is over in an image |
| CImageInfoWidget | A table widget containing information about the pixel the mouse is over in an image |
| CIMessageHandler | |
| CIMuonFitDataModel | IMuonFitDataModel: set data to fit for a muon fit property browser |
| CIMuonFitDataSelector | Interface for MuonFitDataSelector |
| CIMuonFitFunctionModel | IMuonFitFunctionModel: set function to fit for a muon fit property browser |
| CIndexCollectionType | A class which wraps a vector so that you supply not only the value type but also the expected index type |
| CIndexType | A struct to impliment strongly typed integers, without implicit conversion |
| CInputController | The base class for the mouse and keyboard controllers to work with ProjectionSurfaces |
| CInputController3DMove | Controller for moving the instrument on Projection3D surface: translation, rotation and zooming |
| CInputControllerDraw | Controller for free drawing on an unwrapped surface |
| CInputControllerDrawAndErase | Controller for drawing and erasing arbitrary shapes on an unwrapped surface |
| CInputControllerDrawShape | Controller for drawing mask shapes |
| CInputControllerMoveUnwrapped | Controller for moving the instrument on an unwrapped surface |
| CInputControllerPick | Controller for picking detectors |
| CInputControllerSelection | Controller for erasing peaks on an unwrapped surface |
| CInputFunctionNameDialog | A dialog to enter a category and function name for a new function for saving |
| CInstrumentSelector | This class defines a widget for selecting an instrument known to Mantid |
| CInterval | |
| CIntervalList | |
| CIntervalListValidator | |
| CIProjectSaveView | IProjectSaveView is the interface for defining the functions that the project save view needs to implement |
| CISlitCalculator | |
| CIWorkspaceDockView | |
| CIWorkspaceFitControl | IWorkspaceFitControl: set data to fit for a fit property browser |
| CLineEditWithClear | |
| CLocalParameterEditor | An editor widget for editing a local parameter value |
| CLocalParameterItemDelegate | A custom item delegate - an object controlling display and editing of a cell in a table widget |
| CLogValueFinder | MDFLogValueFinder : Holds a collection of workspace names, and finds log values from them |
| CLogValueSelector | LogValueSelector : Select a log name and mean/min/max/first/last |
| CMantidDisplayBase | |
| CMantidHelpWindow | |
| CMantidTreeModel | |
| CMantidTreeWidget | |
| CMantidTreeWidgetItem | A class derived from QTreeWidgetItem, to accomodate sorting on the items in a MantidTreeWidget |
| CMantidWSIndexDialog | |
| ►CMantidWSIndexWidget | |
| CQLineEditWithErrorMark | Auxiliary class to wrap the QLineEdit allowing warning to the user for invalid inputs |
| CUserInput | |
| CUserInputAdvanced | Plain old data structures to hold all user-selected input |
| CMessage | Provides a simple binding of a text message with a priority |
| CMessageDisplay | Provides a widget for display messages in a text box It deals with Message objects which in turn hide whether a message is a framework Poco message or a simple string |
| CMessageHandler | |
| CMultifitSetupDialog | This is a dialog for doing setting up the MultiBG function |
| CMuonFitDataSelector | MuonFitDataSelector : Selects runs, groups, periods for fit |
| CMuonFitPropertyBrowser | |
| CMuonFunctionBrowser | MuonFunctionBrowser : Subclasses FunctionBrowser for muon-specific use |
| CMuonPeriodInfo | A widget used in the Muon GUI's to display period information in a readable format |
| CNotificationService | This is a singleton providing a notification service for the Mantid Qt based applications |
| CProcessingAlgoWidget | A widget containing an algorithm selector and algorithm properties list, or a script editor window |
| CProgressableView | ProgressableView : Abstract view useful for indicating progress |
| CProjectSaveModel | |
| CProjectSavePresenter | Implements a presenter for the project saving dialog |
| CPropertyHandler | Helps display and edit functions in FitPropertyBrowser |
| CQtSignalChannel | Provides a translation layer that takes a Poco::Message and converts it to a Qt signal |
| CRenameParDialog | A dialog for renaming parameters for a user function |
| CSaveWorkspaces | Implements a dialog box that allows users to save multiple Mantid workspaces |
| CScopedFalse | |
| CSelectedAlgorithm | Represents the algorithm selected by the user Contains name and version |
| CSelectFunctionDialog | Select a function type out of a list of available ones |
| CSelectWorkspacesDialog | This is a dialog for selecting workspaces |
| CSequentialFitDialog | This is a dialog for doing sequential fit |
| CSetAttribute | Visitor setting new attribute value |
| CSetAttributeFromProperty | Attribute visitor to set an attribute from a QtProperty |
| CSetAttributeProperty | Visitor setting new attribute value |
| CSliceMDDialog | |
| CSlicingAlgorithmDialog | |
| CSlitCalculator | SlitCalculator : A calculator for Reflectometry instrument slits |
| CTrackedAction | TrackedAction : This is a version of QAction that tracks usage through the Mantid usage service |
| CUserFunctionDialog | A dialog for construction a user fitting function from existing components |
| CViewNotifiable | |
| CWindowInfo | |
| CWorkspaceInfo | |
| CWorkspaceIsNotOfType | Helper comparitor class used to determine if a workspace is not of a given type |
| CWorkspacePresenter | Presenter class for Workspace dock in MantidPlot UI |
| CWorkspaceProvider | |
| CWorkspaceProviderNotifiable | |
| CWorkspaceSelector | This class defines a widget for selecting a workspace present in the AnalysisDataService |
| CWorkspaceTreeWidget | |
| CWorkspaceTreeWidgetSimple | WorkspaceTreeWidget implementation for the Workbench - required for some function overides |
| ►NWidgets | |
| ►NCommon | |
| ►NPython | |
| CCodeExecution | Support execution of arbitrary Python code with the option to install a trace handler to track lines executed and tell an editor to mark them appropriately |
| CInstanceHolder | Holds a Python instance of an object with a method to access it |
| ►NMantidTestHelpers | |
| CBoxControllerDummyIO | The class responsible for dummy IO operations, which mimic saving events into a direct access file using generic box controller interface |
| ►NMapSupport | Holds stuff for manipulating maps |
| CmapClone | Functor for coping map elements with clone functions |
| CmapDelete | Functor for deleting the second component of a map |
| CmapSwap | Functor for reversing a map |
| CmapWrite | Functor quick write out of a map |
| CPFirst | Class to access the first object in index pair |
| CPSecond | Class to access the second object in index pair |
| CsndValue | Functor to get second point in a map |
| CvalEqual | Functor using second value as equal |
| ►Nmorton_index | |
| CIndexTypes | This structure determines Morton index type and underlying unsigned integer type for the floating point coordinate type and number of dimensions |
| CInterleaver | |
| CInterleaver< ND, IntT, Morton96 > | |
| CMortonIndex | This structure binds the size of accesible memory to store the Morton index to the Morton index type |
| CMortonIndex< 1 > | |
| CMortonIndex< 12 > | |
| CMortonIndex< 16 > | |
| CMortonIndex< 2 > | |
| CMortonIndex< 4 > | |
| CMortonIndex< 8 > | |
| CUnderlyingInt | This structure binds floating point types to the unsigned integer types of the same width |
| CUnderlyingInt< double > | |
| CUnderlyingInt< float > | |
| ►NMuonWorkspaceCreationHelper | |
| CeData | |
| CyDataAsymmetry | |
| CyDataCounts | |
| ►NParallelTestHelpers | |
| CParallelRunner | Runs a callable in parallel |
| ►NPoco | |
| CActiveMethod | |
| CActiveResult | |
| CActiveStarter | |
| CNObserver | |
| CPythonLoggingChannel | |
| CPythonStdoutChannel | |
| CStdoutChannel | |
| ►NScopedFileHelper | |
| CScopedFile | File object type |
| ►Nstd | STL namespace |
| Cfrom_chars_result | |
| Cto_chars_result | |
| Cwide_integer | |
| ►NWorkspaceCreationHelper | |
| CEPPTableRow | A struct containing the cells of an EPP table row |
| CFibSeries | Create a Fibonacci series |
| CReturnOne | |
| CStubAlgorithm | Stub algorithm for doing logging/progress reporting |
| CADD_STRUCT | Address offsets to various sections (9*4 bytes) |
| CAlgEnvHistoryGrpBox | |
| CAlgExecSummaryGrpBox | |
| CAlgHistoryItem | |
| CAlgHistoryProperties | |
| CAlgHistoryTreeWidget | |
| CAlgorithmHistoryWindow | |
| CAlternateCSPythonLexer | Defines a Python lexer with a alternative colour scheme to the standard one provided by QsciLexerPython |
| CAxeslessWorkspaceTester | |
| CBankPulseTimes | This class defines the pulse times for a specific bank |
| CBraggScattererFactory | This class implements a factory for concrete BraggScatterer classes |
| CClearADS | Defines a CxxTest::GlobalFixture that clears the AnalysisDataService when its tearDownWorld() method is called |
| CClearAlgorithmManager | Defines a CxxTest::GlobalFixture that clears the AlgorithmManager when its tearDownWorld() method is called |
| CClearPropertyManagerDataService | Defines a CxxTest::GlobalFixture that clears the PropertyManagerDataService when its tearDownWorld() method is called |
| CColumnTester | |
| CCompareFailsException | Custom exception class to signal a failure in the comparison |
| CConfigObserverWrapper | |
| CConfigPropertyObserverWrapper | |
| CDAEP_STRUCT | DAE parameters block (64*4 bytes) |
| CDDES_STRUCT | 2*4 bytes |
| CDelegatingWebPage | Mimic the WebKit class to emit linkClicked signal from the page |
| CDHDR_STRUCT | Data section header (32*4 bytes) |
| CDoubleSpinBox | A QDoubleSpinBox allowing to customize numbers display with respect to |
| CFakeWorkspace | |
| CFileByteStream | |
| CFileResource | RAII: Gives a clean file destination and removes the file when handle is out of scope |
| CFindDialog | Specialisation of FindReplaceDialog that only does finding |
| CFindReplaceDialog | Raises a dialog allowing the user to find/replace text in the editor |
| CHDR_STRUCT | Run header (80 bytes) |
| Cieee_double | What IEEE double precision floating point looks like |
| Cieee_single | What IEEE single precision floating point looks like on local machine |
| CImplicitFunctionFactory | Kernel/ImplicitFunctionFactory.h |
| CImplicitFunctionParserFactory | Kernel/ImplicitFunctionParserFactory.h |
| CISISRAW | Isis raw file |
| CISISRAW2 | Isis raw file |
| CITableWorkspacePickleSuite | |
| ►Citem_struct | Structure to hold a dae item |
| Citem_t | Structure to hold a dae item |
| CIVPB_STRUCT | Instrument parameter block (64*4 bytes) |
| CLOG_LINE | Log line entry |
| CLOG_STRUCT | Log line entry |
| CLoggingCleaner | |
| CLoadPreNeXusMonitors | A data loading routine for SNS PreNeXus beam monitor (histogram) files |
| CMantidBase | Contains display methods which will be used by QWorkspaceDockView |
| CMDGeometryBuliderXML | Computes Boolean algebra for simplification |
| CMDHistoWorkspaceTester | |
| CMockAlgorithmRunner | |
| CMockFitScriptGeneratorModel | |
| CMockFitScriptGeneratorPresenter | |
| CMockFitScriptGeneratorView | |
| CMockProgressableView | |
| CMockSlitCalculator | |
| CMockWorkspaceDockView | |
| CMockWorkspaceProviderNotifiable | |
| CMuonNexusReader | MuunNexusReader opens a Nexus file and reads certain fields expected for a ISIS Muon data file (old format) |
| CNexusTestHelper | A Helper class for easily writing nexus saving/loading tests |
| CNotebookBuilder | This class builds an ipython notebook of an algorithm's history, using NotebookWriter |
| CNotebookWriter | This class assists with writing ipython notebooks |
| CObservable | Simple observable class |
| CObserver | |
| CPeriodicTableWidget | PeriodicTableWidget: A Widget representing a colour coded Periodic Table of Elements, with corresponding buttons as the elements |
| CPointGroupFactory | A factory for point groups |
| CpqHelpWindow | PqHelpWindow provides an assistant-like window for showing help provided by a QHelpEngine |
| CProgressPresenter | |
| CPropertyFactory | |
| CPythonInterpreterGlobalFixture | PythonInterpreter |
| CQApplicationGlobalFixture | QApplication |
| CQHash | |
| CQList | |
| CQMultiMap | |
| CQtHelpSchemeRegistration | Register on the scheme on library load as it must be done before QApplication is created |
| CQtHelpUrlHandler | Adds support for qthelp scheme links that load content from them QHelpEngine |
| CQuadraticCoefficients | |
| CRangeLimitBox | A checkable DoubleSpinBox that can be used to select the limits of a double |
| CRPB_STRUCT | Run parameter block (32*4 bytes) |
| CSANSInstrumentCreationHelper | |
| ►CScriptEditor | This class provides an area to write scripts |
| CSaveCancelledException | Exception type to indicate that saving was cancelled |
| CSE_STRUCT | Sample environment block (32*4 bytes) |
| Csgl_limits_struct | Structure holding the limits of s single |
| CSmoothNeighboursDialog | |
| CSpaceGroupFactory | This factory is used to create space group objects |
| CSPB_STRUCT | Sample parameter block (64*4 bytes) |
| CSpectrumTester | Helper class that implements ISpectrum |
| CTableWorkspaceTester | |
| CUSER_STRUCT | User information (8*20 bytes) |
| CV3DPickleSuite | |
| CVariableBinThrowingTester | |
| Cvax_double | Vax double precision floating point |
| Cvax_single | Vax single precision floating point |
| CVectorByteStream | |
| CViewNotifiable | Mixin class allows view notifications |
| CVoidObserver | Simple observer class (for void functions/slots) |
| CWorkspaceProviderNotifiable | Mixin class allows ADS notifications |
| CWorkspaceTester | |
