refs #4401 Another piece of TM code added back

Code/Mantid/Framework/MDAlgorithms/CMakeLists.txt

@@ -12,8 +12,8 @@ set ( SRC_FILES
 	src/ConvertToDetectorFaceMD.cpp
 #	src/ConvertToMDEvents.cpp
 	src/ConvertToMDEventsParams.cpp
-#	src/ConvertToMDEventsSubalgFactory.cpp
-	src/IConvertToMDEventsMethods.cpp
+	src/ConvertToMDEventsSubalgFactory.cpp
+	src/IConvertToMDEventsWS.cpp
 	src/ConvToMDPreprocDetectors.cpp	
 	src/DivideMD.cpp
 	src/EqualToMD.cpp
@@ -66,14 +66,14 @@ set ( INC_FILES
 #	inc/MantidMDAlgorithms/ConvertToMDEventsEventWS.h
 #	inc/MantidMDAlgorithms/ConvertToMDEventsHistoWS.h
 	inc/MantidMDAlgorithms/ConvertToMDEventsParams.h
-#	inc/MantidMDAlgorithms/ConvertToMDEventsSubalgFactory.h
+	inc/MantidMDAlgorithms/ConvertToMDEventsSubalgFactory.h
 	inc/MantidMDAlgorithms/ConvertToMDEventsTransfInterface.h
 #	inc/MantidMDAlgorithms/ConvertToMDEventsTransfModQ.h
 #	inc/MantidMDAlgorithms/ConvertToMDEventsTransfNoQ.h
 #	inc/MantidMDAlgorithms/ConvertToMDEventsTransfQ3D.h
 	inc/MantidMDAlgorithms/ConvToMDPreprocDetectors.h
 	inc/MantidMDAlgorithms/ConvertToMDEventsUnitsConv.h
-	inc/MantidMDAlgorithms/IConvertToMDEventsMethods.h
+	inc/MantidMDAlgorithms/IConvertToMDEventsWS.h
 	inc/MantidMDAlgorithms/DivideMD.h
 	inc/MantidMDAlgorithms/EqualToMD.h
 	inc/MantidMDAlgorithms/ExponentialMD.h
@@ -121,7 +121,7 @@ set ( TEST_FILES
 #	test/ConvertToMDEventsCoordTransfTest.h
 #	test/ConvertToMDEventsMethodsTest.h
 	test/ConvertToMDEventsParamsTest.h
-#	test/ConvertToMDEventsSubalgFactoryTest.h
+    test/ConvertToMDEventsSubalgFactoryTest.h
 #	test/ConvertToMDEventsTest.h
 	test/ConvertToMDEventsUnitsConvTest.h
 #	test/ConvertToQ3DdETest.h

Code/Mantid/Framework/MDAlgorithms/inc/MantidMDAlgorithms/ConvertToMDEventsEventWS.h

@@ -17,11 +17,12 @@
 #include "MantidMDEvents/MDEventWSWrapper.h"
 #include "MantidMDEvents/MDEvent.h"
 
-#include "MantidMDAlgorithms/IConvertToMDEventsMethods.h"
+#include "MantidMDAlgorithms/IConvertToMDEventsWS.h"
 #include "MantidMDAlgorithms/ConvToMDPreprocDetectors.h"
-#include "MantidMDAlgorithms/ConvertToMDEventsTransfNoQ.h"
-#include "MantidMDAlgorithms/ConvertToMDEventsTransfModQ.h"
-#include "MantidMDAlgorithms/ConvertToMDEventsTransfQ3D.h"
+#include "MantidMDAlgorithms/ConvertToMDEventsTransfInterface.h"
+//#include "MantidMDAlgorithms/ConvertToMDEventsTransfNoQ.h"
+//#include "MantidMDAlgorithms/ConvertToMDEventsTransfModQ.h"
+//#include "MantidMDAlgorithms/ConvertToMDEventsTransfQ3D.h"
 
 
 namespace Mantid
@@ -55,7 +56,7 @@ namespace MDAlgorithms
 
 // Class to process event workspace by direct conversion:
 template<ConvertToMD::QMode Q, ConvertToMD::AnalMode MODE, ConvertToMD::CnvrtUnits CONV,ConvertToMD::SampleType Sample>
-class ConvertToMDEventsWS<ConvertToMD::EventWSType,Q,MODE,CONV,Sample>: public IConvertToMDEventsMethods 
+class ConvertToMDEventsWS<ConvertToMD::EventWSType,Q,MODE,CONV,Sample>: public IConvertToMDEventsWS 
 {
     /// shalow class which is invoked from processQND procedure and describes the transformation from workspace coordinates to target coordinates
     /// presumably will be completely inlined

Code/Mantid/Framework/MDAlgorithms/inc/MantidMDAlgorithms/ConvertToMDEventsHistoWS.h

@@ -16,8 +16,9 @@
 #include "MantidMDEvents/MDEventWSWrapper.h"
 #include "MantidMDEvents/MDEvent.h"
 
-#include "MantidMDAlgorithms/IConvertToMDEventsMethods.h"
+#include "MantidMDAlgorithms/IConvertToMDEventsWS.h"
 #include "MantidMDAlgorithms/ConvToMDPreprocDetectors.h"
+#include "MantidMDAlgorithms/ConvertToMDEventsTransfInterface.h"
 //#include "MantidMDAlgorithms/ConvertToMDEventsTransfNoQ.h"
 //#include "MantidMDAlgorithms/ConvertToMDEventsTransfModQ.h"
 //#include "MantidMDAlgorithms/ConvertToMDEventsTransfQ3D.h"
@@ -52,7 +53,7 @@ namespace MDAlgorithms
 */
 
 // service variable used for efficient filling of the MD event WS  -> should be moved to configuration;
-#define SPLIT_LEVEL  2048
+#define SPLIT_LEVEL  8192
 
 //-----------------------------------------------
 // Method to process rugged Histogram workspace
@@ -61,7 +62,7 @@ class ConvertToMDEventsWS<ConvertToMD::Ws2DHistoType,Q,MODE,CONV,Sample>: public
 {
     /// shalow class which is invoked from processQND procedure and describes the transformation from workspace coordinates to target coordinates
     /// presumably will be completely inlined
-     template<ConvertToMD::QMode XQ,ConvertToMD::AnalMode XMODE,ConvertToMD::CnvrtUnits XCONV,ConvertToMD::XCoordType Type,ConvertToMD::SampleType XSample>
+     template<ConvertToMD::QMode XQ,ConvertToMD::AnalMode XM,ConvertToMD::CnvrtUnits XC,ConvertToMD::XCoordType XT,ConvertToMD::SampleType XS>
      friend struct CoordTransformer;
   // the instanciation of the class which does the transformation itself
      CoordTransformer<Q,MODE,CONV,ConvertToMD::Histogram,Sample> trn; 

Code/Mantid/Framework/MDAlgorithms/inc/MantidMDAlgorithms/ConvertToMDEventsParams.h

@@ -180,6 +180,7 @@ class DLLExport ConvertToMDEventsParams
    static Mantid::Kernel::Logger& convert_log;
 
  };
+
 } // end namespace ConvertToMD
 } // end namespace
 }

Code/Mantid/Framework/MDAlgorithms/inc/MantidMDAlgorithms/ConvertToMDEventsSubalgFactory.h

@@ -3,9 +3,7 @@
 
 
 #include "MantidMDAlgorithms/ConvertToMDEventsParams.h"
-#include "MantidMDAlgorithms/IConvertToMDEventsMethods.h"
-#include "MantidMDAlgorithms/ConvertToMDEventsHistoWS.h"
-#include "MantidMDAlgorithms/ConvertToMDEventsEventWS.h"
+#include "MantidMDAlgorithms/IConvertToMDEventsWS.h"
 
 namespace Mantid
 {
@@ -43,13 +41,13 @@ namespace MDAlgorithms
 class DLLExport ConvertToMDEventsSubalgFactory
 {
   /// map to select an algorithm as function of the key, which describes it
-    std::map<std::string, IConvertToMDEventsMethods *> alg_selector;
+    std::map<std::string, IConvertToMDEventsWS *> alg_selector;
 public:
     /// constructor
     ConvertToMDEventsSubalgFactory();
     ~ConvertToMDEventsSubalgFactory();
     /// access to a subalgorithm 
-    IConvertToMDEventsMethods * getAlg(const std::string &AlgName);
+    IConvertToMDEventsWS * getAlg(const std::string &AlgName);
     /// initiate the subalgorithms and made them availible for getAlg function
     void init(const ConvertToMD::ConvertToMDEventsParams &SubAlgDescriptor);
 private:

Code/Mantid/Framework/MDAlgorithms/inc/MantidMDAlgorithms/IConvertToMDEventsMethods.h → Code/Mantid/Framework/MDAlgorithms/inc/MantidMDAlgorithms/IConvertToMDEventsWS.h

@@ -63,7 +63,7 @@ namespace MDAlgorithms
 */
 
 
- class DLLExport IConvertToMDEventsMethods
+ class DLLExport IConvertToMDEventsWS
  {
  protected:
    /// shalow class which is invoked from processQND procedure and describes the transformation from workspace coordinates to target coordinates
@@ -74,14 +74,14 @@ namespace MDAlgorithms
 
  public:
      // constructor;
-     IConvertToMDEventsMethods();
+     IConvertToMDEventsWS();
 
     ///method which initates all main class variables 
     virtual size_t setUPConversion(Mantid::API::MatrixWorkspace_sptr pWS2D, const ConvToMDPreprocDetectors &detLoc,const MDEvents::MDWSDescription &WSD, boost::shared_ptr<MDEvents::MDEventWSWrapper> inWSWrapper);
     /// method which starts the conversion procedure
     virtual void runConversion(API::Progress *)=0;
     /// virtual destructor
-    virtual ~IConvertToMDEventsMethods(){};
+    virtual ~IConvertToMDEventsWS(){};
 /**> helper functions: To assist with units conversion done by separate class and get access to some important internal states of the subalgorithm */
     Kernel::Unit_sptr              getAxisUnits()const;
     double    getEi()const{return TWS.Ei;}
@@ -127,10 +127,10 @@ namespace MDAlgorithms
 
 /// Templated interface to the workspace conversion algorithm. Every template parameter refers to different conversion possibilities
 template<ConvertToMD::InputWSType WS,ConvertToMD::QMode Q, ConvertToMD::AnalMode MODE, ConvertToMD::CnvrtUnits CONV,ConvertToMD::SampleType Sample>
-class ConvertToMDEventsWS: public IConvertToMDEventsMethods 
+class ConvertToMDEventsWS: public IConvertToMDEventsWS 
 { 
 public:
-    ConvertToMDEventsWS();
+    ConvertToMDEventsWS(){};
     /**templated virtual function to set up conversion*/
     size_t setUPConversion(Mantid::API::MatrixWorkspace_sptr , const ConvToMDPreprocDetectors &,const MDEvents::MDWSDescription &, boost::shared_ptr<MDEvents::MDEventWSWrapper> )
     {return 0;}

Code/Mantid/Framework/MDAlgorithms/src/ConvertToMDEventsSubalgFactory.cpp

@@ -1,9 +1,12 @@
 #include "MantidMDAlgorithms/ConvertToMDEventsSubalgFactory.h"
+//#include "MantidMDAlgorithms/ConvertToMDEventsHistoWS.h"
+//#include "MantidMDAlgorithms/ConvertToMDEventsEventWS.h"
 
 
 
 
-//using namespace Mantid::MDAlgorithms::ConvertToMD;
+
+using namespace Mantid::MDAlgorithms::ConvertToMD;
 
 namespace Mantid
 {
@@ -17,7 +20,7 @@ namespace MDAlgorithms
   *
   * Thows invalid_agrument if subalgorithm, defined by the name is not exist (not initated);
 */
-IConvertToMDEventsMethods * ConvertToMDEventsSubalgFactory::getAlg(const std::string &AlgName)
+IConvertToMDEventsWS* ConvertToMDEventsSubalgFactory::getAlg(const std::string &AlgName)
 {
     auto algoIt  = alg_selector.find(AlgName);
     if (algoIt == alg_selector.end())
@@ -47,7 +50,7 @@ ConvertToMDEventsSubalgFactory::~ConvertToMDEventsSubalgFactory()
 // AUTOINSTANSIATION OF EXISTING CODE:
 /** helper class to orginize metaloop instansiating various subalgorithms dealing with particular 
   * workspaces and implementing particular user requests */
-template<ConvertToMD::QMode Q, size_t AlgoNum>
+template<QMode Q, size_t AlgoNum>
 class LOOP_ALGS{
 private:
     enum{
@@ -60,15 +63,15 @@ class LOOP_ALGS{
   public:
     static inline void EXEC(const ConvertToMD::ConvertToMDEventsParams &AlgoKey,ConvertToMDEventsSubalgFactory *pH){
         // cast loop integers to proper enum type
-        ConvertToMD::CnvrtUnits Conv = static_cast<ConvertToMD::CnvrtUnits>(CONV);
-        ConvertToMD::AnalMode   Mode = static_cast<ConvertToMD::AnalMode>(MODE);
-        ConvertToMD::SampleType Sampl= static_cast<ConvertToMD::SampleType>(SAMPL);
-        ConvertToMD::InputWSType Ws  = static_cast<ConvertToMD::InputWSType>(WS);
+        CnvrtUnits Conv = static_cast<CnvrtUnits>(CONV);
+        AnalMode   Mode = static_cast<AnalMode>(MODE);
+        SampleType Sampl= static_cast<SampleType>(SAMPL);
+        InputWSType Ws  = static_cast<InputWSType>(WS);
 
         std::string  Key = AlgoKey.getAlgoID(Q,Mode,Conv,Ws,Sampl);
-        pH->alg_selector.insert(std::pair<std::string, IConvertToMDEventsMethods *>(Key,
-                (new ConvertToMDEventsWS<ConvertToMD::InputWSType(WS),Q,ConvertToMD::AnalMode(MODE),
-                 ConvertToMD::CnvrtUnits(CONV),ConvertToMD::SampleType(SAMPL)>())));
+        pH->alg_selector.insert(std::pair<std::string, IConvertToMDEventsWS *>(Key,
+                (new ConvertToMDEventsWS<InputWSType(WS),Q,AnalMode(MODE),
+                 CnvrtUnits(CONV),SampleType(SAMPL)>())));
 
 /*#ifdef _DEBUG
             std::cout<<" Instansiating algorithm with ID: "<<Key<<std::endl;
@@ -79,23 +82,23 @@ class LOOP_ALGS{
 
 /** Templated metaloop specialization for noQ case */
 template< size_t AlgoNum>
-class LOOP_ALGS<ConvertToMD::NoQ,AlgoNum>{
+class LOOP_ALGS<NoQ,AlgoNum>{
 private:
     enum{
-        CONV = AlgoNum%ConvertToMD::NConvUintsStates,       // internal Loop over conversion modes, the variable changes first
-        WS   = ((AlgoNum/ConvertToMD::NConvUintsStates))%ConvertToMD::NInWSTypes  //level one loop over ws type;
+        CONV = AlgoNum%NConvUintsStates,       // internal Loop over conversion modes, the variable changes first
+        WS   = ((AlgoNum/NConvUintsStates))%NInWSTypes  //level one loop over ws type;
         //MODE => noQ -- no mode conversion ANY_Mode,     
     };
   public:
-    static inline void EXEC(const ConvertToMD::ConvertToMDEventsParams &AlgoKey,ConvertToMDEventsSubalgFactory *pH){
+    static inline void EXEC(const ConvertToMDEventsParams &AlgoKey,ConvertToMDEventsSubalgFactory *pH){
 
       // cast loop integers to proper enum type
-      ConvertToMD::CnvrtUnits Conv = static_cast<ConvertToMD::CnvrtUnits>(CONV);
-      ConvertToMD::InputWSType Ws  = static_cast<ConvertToMD::InputWSType>(WS);
+      CnvrtUnits Conv = static_cast<CnvrtUnits>(CONV);
+      InputWSType Ws  = static_cast<InputWSType>(WS);
 
-      std::string  Key   = AlgoKey.getAlgoID(ConvertToMD::NoQ,ConvertToMD::ANY_Mode,Conv,Ws,ConvertToMD::NSampleTypes);
-      pH->alg_selector.insert(std::pair<std::string,IConvertToMDEventsMethods *>(Key,
-         (new ConvertToMDEventsWS<ConvertToMD::InputWSType(WS),ConvertToMD::NoQ,ConvertToMD::ANY_Mode,ConvertToMD::CnvrtUnits(CONV),ConvertToMD::NSampleTypes>())));
+      std::string  Key   = AlgoKey.getAlgoID(NoQ,ANY_Mode,Conv,Ws,NSampleTypes);
+      pH->alg_selector.insert(std::pair<std::string,IConvertToMDEventsWS *>(Key,
+         (new ConvertToMDEventsWS<InputWSType(WS),ConvertToMD::NoQ,ANY_Mode,CnvrtUnits(CONV),NSampleTypes>())));
 
 //#ifdef _DEBUG
 //            std::cout<<" Instantiating algorithm with ID: "<<Key<<std::endl;
@@ -112,29 +115,29 @@ class LOOP_ALGS<Q,0>{
   public:
       static inline void EXEC(const ConvertToMD::ConvertToMDEventsParams &AlgoKey,ConvertToMDEventsSubalgFactory *pH)
       {
-          ConvertToMD::CnvrtUnits Conv = static_cast<ConvertToMD::CnvrtUnits>(0);
-          ConvertToMD::AnalMode   Mode = static_cast<ConvertToMD::AnalMode>(0);
-          ConvertToMD::SampleType Sampl= static_cast<ConvertToMD::SampleType>(0);
-          ConvertToMD::InputWSType Ws  = static_cast<ConvertToMD::InputWSType>(0);
+          CnvrtUnits Conv = static_cast<CnvrtUnits>(0);
+          AnalMode   Mode = static_cast<AnalMode>(0);
+          SampleType Sampl= static_cast<SampleType>(0);
+          InputWSType Ws  = static_cast<InputWSType>(0);
 
           std::string  Key   = AlgoKey.getAlgoID(Q,Mode,Conv,Ws,Sampl);
-          pH->alg_selector.insert(std::pair<std::string,IConvertToMDEventsMethods *>(Key,
-            (new ConvertToMDEventsWS<ConvertToMD::InputWSType(0),Q,ConvertToMD::AnalMode(0),ConvertToMD::CnvrtUnits(0),ConvertToMD::SampleType(0)>())));     
+          pH->alg_selector.insert(std::pair<std::string,IConvertToMDEventsWS *>(Key,
+            (new ConvertToMDEventsWS<InputWSType(0),Q,AnalMode(0),CnvrtUnits(0),SampleType(0)>())));     
       } 
 };
 
 /** ANY_Mode (NoQ) metaloop terminator */
 template<>
 class LOOP_ALGS<ConvertToMD::NoQ,0>{
   public:
-      static inline void EXEC(const ConvertToMD::ConvertToMDEventsParams &AlgoKey,ConvertToMDEventsSubalgFactory *pH)
+      static inline void EXEC(const ConvertToMDEventsParams &AlgoKey,ConvertToMDEventsSubalgFactory *pH)
       {     
-          ConvertToMD::CnvrtUnits Conv = static_cast<ConvertToMD::CnvrtUnits>(0);
-          ConvertToMD::InputWSType Ws  = static_cast<ConvertToMD::InputWSType>(0);
+          CnvrtUnits Conv = static_cast<CnvrtUnits>(0);
+          InputWSType Ws  = static_cast<InputWSType>(0);
 
-          std::string  Key   = AlgoKey.getAlgoID(ConvertToMD::NoQ,ConvertToMD::ANY_Mode,Conv,Ws,ConvertToMD::NSampleTypes);
-          pH->alg_selector.insert(std::pair<std::string,IConvertToMDEventsMethods *>(Key,
-          (new ConvertToMDEventsWS<ConvertToMD::InputWSType(0),ConvertToMD::NoQ,ConvertToMD::ANY_Mode,ConvertToMD::CnvrtUnits(0),ConvertToMD::NSampleTypes>())));
+          std::string  Key   = AlgoKey.getAlgoID(NoQ,ANY_Mode,Conv,Ws,NSampleTypes);
+          pH->alg_selector.insert(std::pair<std::string,IConvertToMDEventsWS *>(Key,
+          (new ConvertToMDEventsWS<InputWSType(0),NoQ,ANY_Mode,CnvrtUnits(0),NSampleTypes>())));
 
       } 
 };
@@ -147,11 +150,11 @@ void ConvertToMDEventsSubalgFactory::init(const ConvertToMD::ConvertToMDEventsPa
     if (alg_selector.empty()) // Instansiate the subalgorithms for different cases
     {    
     // NoQ --> any Analysis mode will do as it does not depend on it; we may want to convert unuts
-    //    LOOP_ALGS<ConvertToMD::NoQ,ConvertToMD::NInWSTypes*ConvertToMD::NConvUintsStates>::EXEC(SubAlgDescriptor,this); 
+        LOOP_ALGS<NoQ,NInWSTypes*NConvUintsStates>::EXEC(SubAlgDescriptor,this); 
     // MOD Q
-    //   LOOP_ALGS<ConvertToMD::ModQ,ConvertToMD::NInWSTypes*ConvertToMD::NConvUintsStates*ConvertToMD::ANY_Mode*ConvertToMD::NSampleTypes>::EXEC(SubAlgDescriptor,this);
+       LOOP_ALGS<ModQ,NInWSTypes*NConvUintsStates*ANY_Mode*NSampleTypes>::EXEC(SubAlgDescriptor,this);
     // Q3D
-//        LOOP_ALGS<ConvertToMD::Q3D,ConvertToMD::NInWSTypes*ConvertToMD::NConvUintsStates*ConvertToMD::ANY_Mode*ConvertToMD::NSampleTypes>::EXEC(SubAlgDescriptor,this);
+        LOOP_ALGS<Q3D,NInWSTypes*NConvUintsStates*ANY_Mode*NSampleTypes>::EXEC(SubAlgDescriptor,this);
     }
 
 }

Code/Mantid/Framework/MDAlgorithms/src/IConvertToMDEventsMethods.cpp → Code/Mantid/Framework/MDAlgorithms/src/IConvertToMDEventsWS.cpp

@@ -1,11 +1,11 @@
-#include "MantidMDAlgorithms/IConvertToMDEventsMethods.h"
+#include "MantidMDAlgorithms/IConvertToMDEventsWS.h"
 namespace Mantid
 {
 namespace MDAlgorithms
 {
 
 // logger for loading workspaces  
-   Kernel::Logger& IConvertToMDEventsMethods::convert_log =Kernel::Logger::get("MD-Algorithms");
+   Kernel::Logger& IConvertToMDEventsWS::convert_log =Kernel::Logger::get("MD-Algorithms");
 
 /** Helper function to obtain the units set along X-axis of the input workspace. 
   *
@@ -14,7 +14,7 @@ namespace MDAlgorithms
   *@returns the name(ID) of the unit, specified along X-axis of current workspace
 */
 Kernel::Unit_sptr    
-IConvertToMDEventsMethods::getAxisUnits()const{
+IConvertToMDEventsWS::getAxisUnits()const{
     if(!this->inWS2D.get()){
         convert_log.error()<<"getAxisUnits: invoked when input workspace is undefined\n";
         throw(std::logic_error(" should not be able to call this function when workpsace is undefined"));
@@ -40,7 +40,7 @@ IConvertToMDEventsMethods::getAxisUnits()const{
 
  */
 
-bool IConvertToMDEventsMethods::fillAddProperties(std::vector<coord_t> &Coord,size_t nd,size_t n_ws_properties)
+bool IConvertToMDEventsWS::fillAddProperties(std::vector<coord_t> &Coord,size_t nd,size_t n_ws_properties)
 {
      for(size_t i=n_ws_properties;i<nd;i++){
          //HACK: A METHOD, Which converts TSP into value, correspondent to time scale of matrix workspace has to be developed and deployed!
@@ -68,7 +68,7 @@ bool IConvertToMDEventsMethods::fillAddProperties(std::vector<coord_t> &Coord,si
   * @param WSD        -- class describing the target workspace. Only target workspace limints are used by the algorithm at the moment
   * @param pWSWrapper -- shared pointer to target MD Event workspace to add converted events to.
 */
-size_t  IConvertToMDEventsMethods::setUPConversion(Mantid::API::MatrixWorkspace_sptr pWS2D, const ConvToMDPreprocDetectors &detLoc,const MDEvents::MDWSDescription &WSD, boost::shared_ptr<MDEvents::MDEventWSWrapper> inWSWrapper)
+size_t  IConvertToMDEventsWS::setUPConversion(Mantid::API::MatrixWorkspace_sptr pWS2D, const ConvToMDPreprocDetectors &detLoc,const MDEvents::MDWSDescription &WSD, boost::shared_ptr<MDEvents::MDEventWSWrapper> inWSWrapper)
 {
         TWS   = WSD;
         inWS2D= pWS2D;
@@ -84,7 +84,7 @@ size_t  IConvertToMDEventsMethods::setUPConversion(Mantid::API::MatrixWorkspace_
         return n_spectra;
 };  
 
-IConvertToMDEventsMethods::IConvertToMDEventsMethods()
+IConvertToMDEventsWS::IConvertToMDEventsWS()
 {}