Refs #3724: Pulled wiki description text from the wiki site and added in...

Refs #3724: Pulled wiki description text from the wiki site and added in algorithms' header file with special tags. The auto_wiki.py script can retrieve the text to generate the wiki page fully.

Code/Mantid/Build/class_maker.py

@@ -122,7 +122,6 @@ def write_source(subproject, classname, filename, args):
   {
     this->setWikiSummary("TODO: Enter a quick description of your algorithm.");
     this->setOptionalMessage("TODO: Enter a quick description of your algorithm.");
-    this->setWikiDescription("TODO: Enter the text to be placed in the Description section of the wiki page.");
   }
 
   //----------------------------------------------------------------------------------------------

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/AbsorptionCorrection.h

 #ifndef MANTID_ALGORITHMS_ABSORPTIONCORRECTION_H_
 #define MANTID_ALGORITHMS_ABSORPTIONCORRECTION_H_
+/*WIKI* 
+
+This algorithm uses a numerical integration method to calculate attenuation factors resulting from absorption and single scattering in a sample with the material properties given. Factors are calculated for each spectrum (i.e. detector position) and wavelength point, as defined by the input workspace. 
+The sample is first bounded by a cuboid, which is divided up into small cubes. The cubes whose centres lie within the sample make up the set of integration elements (so you have a kind of 'Lego' model of the sample) and path lengths through the sample are calculated for the centre-point of each element, and a numerical integration is carried out using these path lengths over the volume elements.
+
+Note that the duration of this algorithm is strongly dependent on the element size chosen, and that too small an element size can cause the algorithm to fail because of insufficient memory.
+
+==== Assumptions ====
+This algorithm assumes that the (parallel) beam illuminates the entire sample '''unless''' a 'gauge volume' has been defined using the [[DefineGaugeVolume]] algorithm (or by otherwise adding a valid XML string [[HowToDefineGeometricShape | defining a shape]] to a [[Run]] property called "GaugeVolume"). In this latter case only scattering within this volume (and the sample) is integrated, because this is all the detector can 'see'. The full sample is still used for the neutron paths. ('''N.B.''' If your gauge volume is of axis-aligned cuboid shape and fully enclosed by the sample then you will get a more accurate result from the [[CuboidGaugeVolumeAbsorption]] algorithm.)
+
+==== Restrictions on the input workspace ====
+The input workspace must have units of wavelength. The [[instrument]] associated with the workspace must be fully defined because detector, source & sample position are needed.
+
+
+
+*WIKI*/
 
 //----------------------------------------------------------------------
 // Includes

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/AddLogDerivative.h

 #ifndef MANTID_ALGORITHMS_ADDLOGDERIVATIVE_H_
 #define MANTID_ALGORITHMS_ADDLOGDERIVATIVE_H_
+/*WIKI* 
+
+This algorithm performs a simple numerical derivative of the values in a sample log.
+
+The 1st order derivative is simply: dy = (y1-y0) / (t1-t0), which is placed in the log at t=(t0+t1)/2
+
+Higher order derivatives are obtained by performing the equation above N times. Since this is a simple numerical derivative, you can expect the result to quickly get noisy at higher derivatives.
+*WIKI*/
     
 #include "MantidKernel/System.h"
 #include "MantidAPI/Algorithm.h" 

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/AddSampleLog.h

 #ifndef MANTID_ALGORITHMS_ADDSAMPLELOG_H_
 #define MANTID_ALGORITHMS_ADDSAMPLELOG_H_
+/*WIKI* 
+
+Workspaces contain information in logs. Often these detail what happened to the sample during the experiment. This algorithm allows one named log to be entered. 
+
+The log can be either a String, a Number, or a Number Series. If you select Number Series, the current time will be used as the time of the log entry, and the number in the text used as the (only) value.
+*WIKI*/
 
 //----------------------------------------------------------------------
 // Includes

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/AlignDetectors.h

 #ifndef MANTID_ALGORITHMS_ALIGNDETECTORS_H_
 #define MANTID_ALGORITHMS_ALIGNDETECTORS_H_
+/*WIKI* 
+
+The offsets are a correction to the dSpacing values and are applied during the conversion from time-of-flight to dSpacing as follows:
+
+:<math> d = \frac{h}{2m_N} \frac{t.o.f.}{L_{tot} sin \theta} (1+ \rm{offset})</math>
+
+The detector offsets can be obtained from either: an [[OffsetsWorkspace]] where each pixel has one value, the offset; or a .cal file (in the form created by the ARIEL software). 
+
+'''Note:''' the workspace that this algorithms outputs is a [[ragged workspace]].
+
+==== Restrictions on the input workspace ====
+The input workspace must contain histogram or event data where the X unit is time-of-flight and the Y data is raw counts. The [[instrument]] associated with the workspace must be fully defined because detector, source & sample position are needed.
+*WIKI*/
 
 #include "MantidAPI/Algorithm.h"
 #include "MantidDataObjects/EventWorkspace.h"

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/AlphaCalc.h

 #ifndef MANTID_ALGORITHM_MUONALPHACALC_H_
 #define MANTID_ALGORITHM_MUONALPHACALC_H_
+/*WIKI* 
+
+
+Returns the relative efficiency of the forward detector group compared to the backward detector group. If Alpha is larger than 1 more counts has been collected in the forward group.
+
+This algorithm leave the input workspace unchanged. To group detectors in a workspace use [[GroupDetectors]].
+
+
+*WIKI*/
 
 //----------------------------------------------------------------------
 // Includes

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/ApplyDetailedBalance.h

 #ifndef MANTID_ALGORITHMS_APPLYDETAILEDBALANCE_H_
 #define MANTID_ALGORITHMS_APPLYDETAILEDBALANCE_H_
+/*WIKI* 
+
+TODO: Enter the text to be placed in the Description section of the wiki page.
+*WIKI*/
     
 #include "MantidKernel/System.h"
 #include "MantidAPI/Algorithm.h" 

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/ApplyTransmissionCorrection.h

 #ifndef MANTID_ALGORITHMS_APPLYTRANSMISSIONCORRECTION_H_
 #define MANTID_ALGORITHMS_APPLYTRANSMISSIONCORRECTION_H_
+/*WIKI* 
+
+The transmission can be given as a MatrixWorkspace or given directly as numbers. One or the other method must be used.
+
+See [http://www.mantidproject.org/Reduction_for_HFIR_SANS SANS Reduction] documentation for details.
+
+
+
+*WIKI*/
 
 //----------------------------------------------------------------------
 // Includes

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/BlendSq.h

 #ifndef MANTID_ALGORITHMS_BLENDSQ_H_
 #define MANTID_ALGORITHMS_BLENDSQ_H_
+/*WIKI* 
+
+
+*WIKI*/
     
 #include "MantidKernel/System.h"
 #include "MantidAPI/Algorithm.h" 

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/CalculateEfficiency.h

 #ifndef MANTID_ALGORITHMS_CALCULATEEFFICIENCY_H_
 #define MANTID_ALGORITHMS_CALCULATEEFFICIENCY_H_
+/*WIKI* 
+
+See [http://www.mantidproject.org/Reduction_for_HFIR_SANS SANS Reduction] documentation for calculation details.
+
+
+*WIKI*/
 
 //----------------------------------------------------------------------
 // Includes

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/CalculateTransmission.h

 #ifndef MANTID_ALGORITHMS_CALCULATETRANSMISSION_H_
 #define MANTID_ALGORITHMS_CALCULATETRANSMISSION_H_
+/*WIKI* 
+
+
+Calculates the probability of a neutron being transmitted through the sample using detected counts from two monitors, one in front and one behind the sample. A data workspace can be corrected for transmission by [[Divide|dividing]] by the output of this algorithm.
+
+Because the detection efficiency of the monitors can be different the transmission calculation is done using two runs, one run with the sample (represented by <math>S</math> below) and a direct run without it(<math>D</math>). The fraction transmitted through the sample <math>f</math> is calculated from this formula:
+<br>
+<br>
+<math> p = \frac{S_T}{D_T}\frac{D_I}{S_I} </math>
+<br>
+<br>
+where <math>S_I</math> is the number of counts from the monitor in front of the sample (the incident beam monitor), <math>S_T</math> is the transmission monitor after the sample, etc.
+
+The resulting fraction as a function of wavelength is created as the OutputUnfittedData workspace. However, because of statistical variations it is recommended to use the OutputWorkspace, which is the evaluation of a fit to those transmission fractions. The unfitted data is not affected by the RebinParams or Fitmethod properties but these can be used to refine the fitted data. The RebinParams method is useful when the range of wavelengths passed to CalculateTransmission is different from that of the data to be corrected.
+
+=== Subalgorithms used ===
+
+Uses the algorithm [[linear]] to fit to the calculated transmission fraction.
+
+
+*WIKI*/
 
 //----------------------------------------------------------------------
 // Includes

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/CalculateTransmissionBeamSpreader.h

 #ifndef MANTID_ALGORITHMS_CALCTRANSBEAMSPREADER_H_
 #define MANTID_ALGORITHMS_CALCTRANSBEAMSPREADER_H_
+/*WIKI* 
+
+See [http://www.mantidproject.org/Reduction_for_HFIR_SANS SANS Reduction] documentation for details.
+
+
+*WIKI*/
 
 //----------------------------------------------------------------------
 // Includes

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/CaltoDspacemap.h

 #ifndef MANTID_ALGORITHMS_CALTODSPACEMAP_H_
 #define MANTID_ALGORITHMS_CALTODSPACEMAP_H_
+/*WIKI* 
+
+This is the inverse of the DspacemaptoCal algorithm.  The detector offset file created by this algorithm are in the form created by the ARIEL software. The offsets are a correction to the dSpacing values and are applied during the conversion from time-of-flight to dSpacing as follows:
+
+:<math> d = \frac{h}{m_N} \frac{t.o.f.}{L_{tot} sin \theta} (1+ \rm{offset})</math>
+
+
+==Usage==
+'''Python'''
+    LoadEmptyInstrument("POWGEN_Definition.xml","POWGEN")
+    CaltoDspacemap("POWGEN","PG3.cal", "PG3.dat")
+
+'''C++'''
+    IAlgorithm* alg1 = FrameworkManager::Instance().createAlgorithm("LoadEmptyInstrument");
+    alg1->setPropertyValue("Filename", "POWGEN_Definition.xml");
+    alg1->setProperty<MatrixWorkspace_sptr>("OutputWorkspace", "POWGEN");
+    alg1->execute();
+    IAlgorithm* alg2 = FrameworkManager::Instance().createAlgorithm("DspacemaptoCal");
+    alg2->setProperty<MatrixWorkspace_sptr>("InputWorkspace", "POWGEN");
+    alg2->setPropertyValue("CalibrationFile", "PG3.cal");
+    alg2->setPropertyValue("DspacemapFile", "PG3.dat");
+    alg2->execute();
+
+
+
+
+
+*WIKI*/
 
 #include "MantidAPI/Algorithm.h"
 #include "MantidAPI/DeprecatedAlgorithm.h"

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/ChangeBinOffset.h

 #ifndef MANTID_ALGORITHM_CHANGEBINOFFSET_H_
 #define MANTID_ALGORITHM_CHANGEBINOFFSET_H_
+/*WIKI* 
+
+
+This algorithm can be used to change the time-of-flight bins of a workspace by a specified amount (defined above as the Offset). A possible use of this algorithm is to correct time bins that have been recorded incorrectly.
+
+Optionally, the range of spectra can be selected to apply this offset selectively using the IndexMin and IndexMax properties.
+
+The output workspace will be an exact copy of the input workspace except for the changed time bins.
+
+
+
+*WIKI*/
 
 //----------------------------------------------------------------------
 // Includes

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/ChangeLogTime.h

 #ifndef CHANGELOGTIME_H
 #define CHANGELOGTIME_H
+/*WIKI* 
+
+
+*WIKI*/
 
 #include "MantidAPI/Algorithm.h"
 

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/ChangePulsetime.h

 #ifndef MANTID_ALGORITHMS_CHANGEPULSETIME_H_
 #define MANTID_ALGORITHMS_CHANGEPULSETIME_H_
+/*WIKI* 
+
+
+Modifies the pulse time (wall-clock time) of all the events in the specified spectra of an EventWorkspace, by adding the given number of seconds.
+
+
+*WIKI*/
     
 #include "MantidKernel/System.h"
 #include "MantidAPI/Algorithm.h" 

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/CheckWorkspacesMatch.h

 #ifndef MANTID_ALGORITHMS_CHECKWORKSPACESMATCH_H_
 #define MANTID_ALGORITHMS_CHECKWORKSPACESMATCH_H_
+/*WIKI* 
+
+
+Compares two workspaces for equality. This algorithm is mainly intended for use by Mantid developers as part of the testing process.
+    
+The data values (X,Y and error) are always checked. The algorithm can also optionally check the axes (this includes the units), the spectra-detector map, the instrument (the name and parameter map) and any bin masking.
+
+In the case of [[EventWorkspace]]s, they are checked to hold identical event lists. Comparisons between an EventList and a Workspace2D always fail.
+
+
+*WIKI*/
 
 //----------------------------------------------------------------------
 // Includes

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/ChopData.h

 #ifndef MANTID_ALGORITHMS_CHOPDATA
 #define MANTID_ALGORITHMS_CHOPDATA
+/*WIKI* 
+
+This algorithm will chop the input workspace into equally sized workspaces, and adjust the X-values given so that they all begin from the same point. This is useful if your raw files contain multiple frames.
+
+=== Identifying Extended Frames ===
+[[File:ChopDataIntegrationExplanation.png|frame|Figure 1: Example Monitor Spectrum with Extended Frames]]
+
+If the parameters ''IntegrationRangeLower'', ''IntegrationRangeUpper'' and ''MonitorWorkspaceIndex'' are provided to the algorithm, then it will attempt to identify where in the workspace the frames have been extended.
+
+For example: looking at Figure 1 which shows an input workspace covering 100000 microseconds, we can see that the first frame covers forty thousand, and the other three cover twenty thousand each.
+
+In order for Mantid to determine this programatically, it integrates over a range (defined by IntegrationRangeLower and IntegrationRangeUpper) for each "chop" of the data. If the relative values for this integration fall within certain bounds, then the chop is deemed to be a continuation of the previous one rather than a separate frame. If this happens, then they will be placed in the same workspace within the result group.
+
+The algorithm will only look at the workspace given in ''MonitorWorkspaceIndex'' property to determine this. Though it is expected and recommended that you use a monitor spectrum for this purpose, it is not enforced so you may use a regular detector if you have cause to do so.
+
+
+*WIKI*/
 
 #include "MantidAPI/Algorithm.h"
 

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/CloneWorkspace.h

 #ifndef MANTID_ALGORITHMS_CLONEWORKSPACE_H_
 #define MANTID_ALGORITHMS_CLONEWORKSPACE_H_
+/*WIKI* 
+
+This algorithm performs a deep copy of all of the information in the workspace. It maintains events if the input is an [[EventWorkspace]].
+
+
+*WIKI*/
 
 //----------------------------------------------------------------------
 // Includes

Code/Mantid/Framework/Algorithms/inc/MantidAlgorithms/ConjoinWorkspaces.h

 #ifndef MANTID_ALGORITHMS_CONJOINWORKSPACES_H_
 #define MANTID_ALGORITHMS_CONJOINWORKSPACES_H_
+/*WIKI* 
+
+
+This algorithm can be useful when working with large datasets. It enables the raw file to be loaded in two parts (not necessarily of equal size), the data processed in turn and the results joined back together into a single dataset. This can help avoid memory problems either because intermediate workspaces will be smaller and/or because the data will be much reduced after processing.
+
+The output of the algorithm, in which the data from the second input workspace will be appended to the first, will be stored under the name of the first input workspace. Workspace data members other than the data (e.g. instrument etc.) will be copied from the first input workspace (but if they're not identical anyway, then you probably shouldn't be using this algorithm!). Both input workspaces will be deleted.
+
+==== Restrictions on the input workspace ====
+
+The input workspaces must come from the same instrument, have common units and bins and no detectors that contribute to spectra should overlap.
+
+
+*WIKI*/
 
 //----------------------------------------------------------------------
 // Includes