Algorithm to calibrate detector phases

Code/Mantid/Framework/Algorithms/CMakeLists.txt

@@ -22,6 +22,7 @@ set ( SRC_FILES
 	src/BinaryOperateMasks.cpp
 	src/BinaryOperation.cpp
 	src/CalMuonDeadTime.cpp
+	src/CalMuonDetectorPhases.cpp
 	src/CalculateDIFC.cpp
 	src/CalculateEfficiency.cpp
 	src/CalculateFlatBackground.cpp
@@ -155,7 +156,7 @@ set ( SRC_FILES
 	src/Minus.cpp
 	src/ModeratorTzero.cpp
 	src/ModeratorTzeroLinear.cpp
-        src/MonitorEfficiencyCorUser.cpp
+	src/MonitorEfficiencyCorUser.cpp
 	src/MonteCarloAbsorption.cpp
 	src/MultipleScatteringCylinderAbsorption.cpp
 	src/Multiply.cpp
@@ -294,6 +295,7 @@ set ( INC_FILES
 	inc/MantidAlgorithms/BinaryOperateMasks.h
 	inc/MantidAlgorithms/BinaryOperation.h
 	inc/MantidAlgorithms/CalMuonDeadTime.h
+	inc/MantidAlgorithms/CalMuonDetectorPhases.h
 	inc/MantidAlgorithms/CalculateDIFC.h
 	inc/MantidAlgorithms/CalculateEfficiency.h
 	inc/MantidAlgorithms/CalculateFlatBackground.h
@@ -428,7 +430,7 @@ set ( INC_FILES
 	inc/MantidAlgorithms/Minus.h
 	inc/MantidAlgorithms/ModeratorTzero.h
 	inc/MantidAlgorithms/ModeratorTzeroLinear.h
-        inc/MantidAlgorithms/MonitorEfficiencyCorUser.h
+	inc/MantidAlgorithms/MonitorEfficiencyCorUser.h
 	inc/MantidAlgorithms/MonteCarloAbsorption.h
 	inc/MantidAlgorithms/MultipleScatteringCylinderAbsorption.h
 	inc/MantidAlgorithms/Multiply.h
@@ -578,6 +580,7 @@ set ( TEST_FILES
 	BinaryOperateMasksTest.h
 	BinaryOperationTest.h
 	CalMuonDeadTimeTest.h
+	CalMuonDetectorPhasesTest.h
 	CalculateDIFCTest.h
 	CalculateEfficiencyTest.h
 	CalculateFlatBackgroundTest.h
@@ -701,7 +704,7 @@ set ( TEST_FILES
 	MinusTest.h
 	ModeratorTzeroLinearTest.h
 	ModeratorTzeroTest.h
-        MonitorEfficiencyCorUserTest.h
+	MonitorEfficiencyCorUserTest.h
 	MonteCarloAbsorptionTest.h
 	MultipleScatteringCylinderAbsorptionTest.h
 	MultiplyRangeTest.h

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

@@ -0,0 +1,74 @@
+#ifndef MANTID_ALGORITHMS_CALMUONDETECTORPHASES_H_
+#define MANTID_ALGORITHMS_CALMUONDETECTORPHASES_H_
+
+#include "MantidAlgorithms/DllConfig.h"
+#include "MantidAPI/Algorithm.h"
+namespace Mantid {
+namespace Algorithms {
+
+/** CalMuonDetectorPhases : Calculates asymmetry and phase for each spectra in a workspace
+
+  Copyright © 2015 ISIS Rutherford Appleton Laboratory, NScD Oak Ridge
+  National Laboratory & European Spallation Source
+
+  This file is part of Mantid.
+
+  Mantid is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 3 of the License, or
+  (at your option) any later version.
+
+  Mantid is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+  File change history is stored at: <https://github.com/mantidproject/mantid>
+  Code Documentation is available at: <http://doxygen.mantidproject.org>
+*/
+class DLLExport CalMuonDetectorPhases : public API::Algorithm {
+public:
+  /// Default constructor
+  CalMuonDetectorPhases() : API::Algorithm(){};
+  /// Destructor
+  virtual ~CalMuonDetectorPhases(){};
+  /// Algorithm's name for identification overriding a virtual method
+  virtual const std::string name() const { return "CalMuonDetectorPhases"; }
+  /// Summary of algorithms purpose
+  virtual const std::string summary() const {
+    return "Calculates the asymmetry and phase for each detector in a workspace.";
+  }
+
+  /// Algorithm's version for identification overriding a virtual method
+  virtual int version() const { return 1; }
+  /// Algorithm's category for identification overriding a virtual method
+  virtual const std::string category() const { return "Muon"; }
+
+private:
+  /// Initialise the algorithm
+  void init();
+  /// Execute the algorithm
+  void exec();
+  /// Validate the inputs
+  std::map<std::string, std::string> validateInputs();
+  /// Prepare workspace for fit
+  API::MatrixWorkspace_sptr
+  prepareWorkspace(const API::MatrixWorkspace_sptr &ws, double startTime,
+                   double endTime);
+  /// Fit the workspace
+  void fitWorkspace(const API::MatrixWorkspace_sptr &ws, double freq,
+                    std::string groupName, API::ITableWorkspace_sptr &resTab,
+                    API::WorkspaceGroup_sptr &resGroup);
+  /// Create the fitting function as string
+  std::string createFittingFunction(int nspec, double freq);
+  /// Extract asymmetry and phase from fitting results
+  API::ITableWorkspace_sptr
+  extractDetectorInfo(const API::ITableWorkspace_sptr &paramTab, size_t nspec);
+};
+} // namespace Algorithms
+} // namespace Mantid
+
+#endif /* MANTID_ALGORITHMS_CALMUONDETECTORPHASES_H_ */

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

@@ -37,18 +37,14 @@ Code Documentation is available at: <http://doxygen.mantidproject.org>
 class DLLExport PhaseQuadMuon : public API::Algorithm {
 public:
   /// Default constructor
-  PhaseQuadMuon()
-      : API::Algorithm(), m_muLife(2.19703), m_bigNumber(1e10), m_tPulseOver(0),
-        m_pulseTail(182), m_poissonLim(30), m_pulseTwo(0.325), m_nHist(0),
-        m_nData(0), m_res(0.0), m_meanLag(0.0), m_tValid(0), m_isDouble(false),
-        m_tMin(0.0){};
+  PhaseQuadMuon() {};
   /// Destructor
   virtual ~PhaseQuadMuon(){};
   /// Algorithm's name for identification overriding a virtual method
   virtual const std::string name() const { return "PhaseQuad"; }
   /// Summary of algorithm's purpose
   virtual const std::string summary() const {
-    return "Calculate Muon squashograms from InputWorkspace and PhaseTable/PhaseList.";
+    return "Generates a quadrature phase signal.";
   }
 
   /// Algorithm's version for identification overriding a virtual method
@@ -57,71 +53,18 @@ class DLLExport PhaseQuadMuon : public API::Algorithm {
   virtual const std::string category() const { return "Muon"; }
 
 private:
-  class HistData {
-  public:
-    bool detOK;   // Detector is OK
-    double n0;    // Detector n0
-    double alpha; // Detector efficiency
-    double phi;   // Detector phase
-  };
-
   /// Initialise the properties
   void init();
   /// Run the algorithm
   void exec();
-  /// Convert X units from micro-secs to nano-secs and shift to start at t=0
-  void convertToNanoSecs(API::MatrixWorkspace_sptr inputWs);
-  /// Convert X units from nano-secs to micro-secs and shift back
-  void convertToMicroSecs(API::MatrixWorkspace_sptr inputWs);
-  /// Load the Phase Table
-  void loadPhaseTable(API::ITableWorkspace_sptr phaseTable,
-                      API::ITableWorkspace_sptr deadTimeTable);
-  /// Load the Phase List
-  void loadPhaseList(const std::string &filename,
-                     API::ITableWorkspace_sptr deadTimeTable);
-  /// Apply dead time correction
-  void deadTimeCorrection(API::MatrixWorkspace_sptr inputWs,
-                          API::ITableWorkspace_sptr deadTimeTable,
-                          API::MatrixWorkspace_sptr &tempWs);
-  /// Rescale detector efficiency to maximum value
-  void normaliseAlphas(std::vector<HistData> &m_histData);
-  /// Remove exponential decay from input histograms
-  void loseExponentialDecay(API::MatrixWorkspace_sptr tempWs);
+  /// Validate inputs
+  std::map<std::string, std::string> validateInputs();
+  /// Calculate the normalization constants
+  std::vector<double> getExponentialDecay(const API::MatrixWorkspace_sptr &ws);
   /// Create squashograms
-  void squash(const API::MatrixWorkspace_sptr tempWs,
-              API::MatrixWorkspace_sptr outputWs);
-  /// Put back in exponential decay
-  void regainExponential(API::MatrixWorkspace_sptr outputWs);
-  /// Muon lifetime
-  double m_muLife;
-  /// Maximum counts expected
-  double m_bigNumber;
-  /// Pulse definitely finished by here (bin no)
-  int m_tPulseOver;
-  /// Number of bins to exclude after lag-time (ie pulse arrival time)
-  double m_pulseTail;
-  /// Poisson limit
-  double m_poissonLim;
-  /// Time (microsec) by which a well-def'd point in the first proton/pion pulse
-  /// leads its counterpart in the second
-  double m_pulseTwo;
-  /// Number of input histograms
-  int m_nHist;
-  /// Number of datapoints per histogram
-  int m_nData;
-  /// Time resolution
-  double m_res;
-  /// Mean of time-shifts
-  double m_meanLag;
-  /// Good muons from here on (bin no). Unused now but can be needed in the
-  /// future
-  int m_tValid;
-  /// Double-pulse flag
-  bool m_isDouble;
-  /// Minimum value of t
-  double m_tMin;
-  /// Vector of detector data
-  std::vector<HistData> m_histData;
+  API::MatrixWorkspace_sptr squash(const API::MatrixWorkspace_sptr &ws,
+                                   const API::ITableWorkspace_sptr &phase,
+                                   const std::vector<double> &n0);
 };
 
 } // namespace Algorithms