Reorganised using namespace declarations that were polluting the test helper...

Reorganised using namespace declarations that were polluting the test helper headers. All are now in the cpp files. Ported over the SANSInstrumentCreationHelper and added it to the ComponentCreationHelper file. All the helper classes are ported but Scons knows nothing so the originals are left in their place. Re #2196

Code/Mantid/Framework/TestHelpers/CMakeLists.txt

@@ -7,6 +7,8 @@ set ( INC_FILES inc/MantidTestHelpers/DLLExport.h
 		inc/MantidTestHelpers/ComponentCreationHelper.h 
 		inc/MantidTestHelpers/TestChannel.h )
 
+# Requires DataHandling for a load call
+include_directories (../DataHandling/inc)
 include_directories ( inc )
 
 # For Windows:

Code/Mantid/Framework/TestHelpers/inc/MantidTestHelpers/ComponentCreationHelper.h

@@ -2,21 +2,25 @@
 #define COMPONENTCREATIONHELPER_H_
 
 #include "MantidTestHelpers/DLLExport.h"
-
-#include "MantidGeometry/Instrument/CompAssembly.h"
-#include "MantidGeometry/Instrument/ObjComponent.h"
-#include "MantidGeometry/Instrument/DetectorGroup.h"
-#include "MantidGeometry/Instrument/Detector.h"
-#include "MantidGeometry/Instrument/Instrument.h"
-#include "MantidGeometry/Instrument/RectangularDetector.h"
 #include "MantidGeometry/Objects/Object.h"
-#include "MantidGeometry/Objects/ShapeFactory.h"
+#include "MantidGeometry/V3D.h"
+#include "MantidGeometry/Instrument/Instrument.h"
 
-namespace ComponentCreationHelper
+#include "MantidDataObjects/Workspace2D.h"
+
+// Forward declarations
+namespace Mantid
 {
+  namespace Geometry
+  {
+    class CompAssembly;
+    class ObjComponent;
+    class DetectorGroup;
+  }
+}
 
-using namespace Mantid;
-using namespace Mantid::Geometry;
+namespace ComponentCreationHelper
+{
 
   /** 
   A set of helper functions for creating various component structures for the unit tests.
@@ -47,52 +51,97 @@ using namespace Mantid::Geometry;
   /**
    * Create a capped cylinder object
    */
-  DLL_TESTHELPERS Object_sptr createCappedCylinder(double radius, double height, const V3D & baseCentre, const V3D & axis, const std::string & id);
+  DLL_TESTHELPERS Mantid::Geometry::Object_sptr 
+  createCappedCylinder(double radius, double height, const Mantid::Geometry::V3D & baseCentre, 
+		       const Mantid::Geometry::V3D & axis, const std::string & id);
   /**
    * Return the XML for a sphere.
    */
-  DLL_TESTHELPERS std::string sphereXML(double radius, const V3D & centre, const std::string & id);
+  DLL_TESTHELPERS std::string sphereXML(double radius, const Mantid::Geometry::V3D & centre, const std::string & id);
   /**
    * Create a sphere object
    */
-  DLL_TESTHELPERS Object_sptr createSphere(double radius, const V3D & centre, const std::string & id);
+  DLL_TESTHELPERS Mantid::Geometry::Object_sptr createSphere(double radius, const Mantid::Geometry::V3D & centre, const std::string & id);
   /** Create a cuboid shape for your pixels */
-  DLL_TESTHELPERS Object_sptr createCuboid(double x_side_length, double y_side_length = -1.0, double z_side_length = -1.0);
+  DLL_TESTHELPERS Mantid::Geometry::Object_sptr createCuboid(double x_side_length, double y_side_length = -1.0, 
+							     double z_side_length = -1.0);
   /**
   * Create a component assembly at the origin made up of 4 cylindrical detectors
   */
-  DLL_TESTHELPERS boost::shared_ptr<CompAssembly> createTestAssemblyOfFourCylinders();
+  DLL_TESTHELPERS boost::shared_ptr<Mantid::Geometry::CompAssembly> createTestAssemblyOfFourCylinders();
   /**
    * Create an object component that has a defined shape
    */
-  DLL_TESTHELPERS ObjComponent * createSingleObjectComponent();
+  DLL_TESTHELPERS Mantid::Geometry::ObjComponent * createSingleObjectComponent();
   /**
    * Create a hollow shell, i.e. the intersection of two spheres or radius r1 and r2
    */
-  DLL_TESTHELPERS Object_sptr createHollowShell(double innerRadius, double outerRadius, const V3D & centre = V3D());
+  DLL_TESTHELPERS Mantid::Geometry::Object_sptr createHollowShell(double innerRadius, double outerRadius, 
+						const Mantid::Geometry::V3D & centre = Mantid::Geometry::V3D());
   /**
    * Create a detector group containing 5 detectors
    */
-  DLL_TESTHELPERS boost::shared_ptr<DetectorGroup> createDetectorGroupWith5CylindricalDetectors();
+  DLL_TESTHELPERS boost::shared_ptr<Mantid::Geometry::DetectorGroup> createDetectorGroupWith5CylindricalDetectors();
   /**
    * Create a group of two monitors
    */
-  DLL_TESTHELPERS boost::shared_ptr<DetectorGroup> createGroupOfTwoMonitors();
+  DLL_TESTHELPERS boost::shared_ptr<Mantid::Geometry::DetectorGroup> createGroupOfTwoMonitors();
   /**
    * Create an test instrument with n panels of 9 cylindrical detectors, a source and spherical sample shape.
    *
    * @param num_banks: number of 9-cylinder banks to create
    * @param verbose: prints out the instrument after creation.
    */
-  DLL_TESTHELPERS IInstrument_sptr createTestInstrumentCylindrical(int num_banks, bool verbose = false);
+  DLL_TESTHELPERS Mantid::Geometry::IInstrument_sptr 
+  createTestInstrumentCylindrical(int num_banks, bool verbose = false);
   /**
    * Create an test instrument with n panels of rectangular detectors, pixels*pixels in size, a source and spherical sample shape.
    *
    * @param num_banks: number of 9-cylinder banks to create
    * @param verbose: prints out the instrument after creation.
    */
-  DLL_TESTHELPERS IInstrument_sptr createTestInstrumentRectangular(int num_banks, int pixels);
+  DLL_TESTHELPERS Mantid::Geometry::IInstrument_sptr createTestInstrumentRectangular(int num_banks, int pixels);
 
 }
 
+// SANS helpers
+
+class DLL_TESTHELPERS SANSInstrumentCreationHelper
+{
+public:
+
+  // Number of detector pixels in each dimension
+  static const int nBins;
+  // The test instrument has 2 monitors
+  static const int nMonitors;
+
+  /*
+   * Generate a SANS test workspace, with instrument geometry.
+   * The geometry is the SANSTEST geometry, with a 30x30 pixel 2D detector.
+   *
+   * @param workspace: name of the workspace to be created.
+   */
+  static Mantid::DataObjects::Workspace2D_sptr createSANSInstrumentWorkspace(std::string workspace);
+  /** Run the sub-algorithm LoadInstrument (as for LoadRaw)
+   * @param inst_name The name written in the Nexus file
+   * @param workspace The workspace to insert the instrument into
+   */
+  static void runLoadInstrument(const std::string & inst_name,
+				Mantid::DataObjects::Workspace2D_sptr workspace);
+
+  /**
+   * Populate spectra mapping to detector IDs
+   *
+   * @param workspace: Workspace2D object
+   * @param nxbins: number of bins in X
+   * @param nybins: number of bins in Y
+   */
+  static void runLoadMappingTable(Mantid::DataObjects::Workspace2D_sptr workspace, 
+				  int nxbins, int nybins);
+
+};
+
+
+
+
 #endif //COMPONENTCREATIONHELPERS_H_

Code/Mantid/Framework/TestHelpers/inc/MantidTestHelpers/WorkspaceCreationHelper.h

@@ -5,25 +5,10 @@
 //------------------------------------------------------------------------------
 #include "MantidTestHelpers/DLLExport.h"
 
-#include <cmath>
-
-#include "MantidAPI/AnalysisDataService.h"
-#include "MantidAPI/WorkspaceFactory.h"
-#include "MantidGeometry/Instrument/Detector.h"
-#include "MantidGeometry/Instrument/ParameterMap.h"
-#include "MantidGeometry/Objects/ShapeFactory.h"
 #include "MantidDataObjects/EventWorkspace.h"
 #include "MantidDataObjects/Workspace2D.h"
 #include "MantidDataObjects/Workspace1D.h"
 #include "MantidDataObjects/WorkspaceSingleValue.h"
-// Other Helper
-#include "ComponentCreationHelper.h"
-
-using namespace Mantid;
-using namespace Mantid::DataObjects;
-using namespace Mantid::Kernel;
-using namespace Mantid::API;
-using namespace Mantid::Geometry;
 
 namespace WorkspaceCreationHelper
 {
@@ -39,67 +24,67 @@ namespace WorkspaceCreationHelper
     inline T operator()() { const T out(x1+x2); x1=x2; x2=out;  return out; }
   };
 
-  DLL_TESTHELPERS Workspace1D_sptr Create1DWorkspaceRand(int size);
-  DLL_TESTHELPERS Workspace1D_sptr Create1DWorkspaceConstant(int size, double value, double error);
-  DLL_TESTHELPERS Workspace1D_sptr Create1DWorkspaceFib(int size);
-  DLL_TESTHELPERS Workspace2D_sptr Create2DWorkspace(int xlen, int ylen);
-  DLL_TESTHELPERS Workspace2D_sptr Create2DWorkspace123(int xlen, int ylen,bool isHist=0, const std::set<int> & 
+  DLL_TESTHELPERS Mantid::DataObjects::Workspace1D_sptr Create1DWorkspaceRand(int size);
+  DLL_TESTHELPERS Mantid::DataObjects::Workspace1D_sptr Create1DWorkspaceConstant(int size, double value, double error);
+  DLL_TESTHELPERS Mantid::DataObjects::Workspace1D_sptr Create1DWorkspaceFib(int size);
+  DLL_TESTHELPERS Mantid::DataObjects::Workspace2D_sptr Create2DWorkspace(int xlen, int ylen);
+  DLL_TESTHELPERS Mantid::DataObjects::Workspace2D_sptr Create2DWorkspace123(int xlen, int ylen,bool isHist=0, const std::set<int> & 
 					       maskedWorkspaceIndices = std::set<int>());
-  DLL_TESTHELPERS Workspace2D_sptr Create2DWorkspace154(int xlen, int ylen,bool isHist=0, 
+  DLL_TESTHELPERS Mantid::DataObjects::Workspace2D_sptr Create2DWorkspace154(int xlen, int ylen,bool isHist=0, 
 					       const std::set<int> & maskedWorkspaceIndices = std::set<int>());
-  DLL_TESTHELPERS Workspace2D_sptr maskSpectra(DLL_TESTHELPERS Workspace2D_sptr workspace, 
-				      const std::set<int> & maskedWorkspaceIndices);
+  DLL_TESTHELPERS Mantid::DataObjects::Workspace2D_sptr maskSpectra(Mantid::DataObjects::Workspace2D_sptr workspace, 
+								    const std::set<int> & maskedWorkspaceIndices);
   /** Create a 2D workspace with this many histograms and bins.
    * Filled with Y = 2.0 and E = sqrt(2.0)w
    */
-  DLL_TESTHELPERS Workspace2D_sptr Create2DWorkspaceBinned(int nhist, int nbins, double x0=0.0, double deltax = 1.0);
+  DLL_TESTHELPERS Mantid::DataObjects::Workspace2D_sptr Create2DWorkspaceBinned(int nhist, int nbins, double x0=0.0, double deltax = 1.0);
 
   /** Create a 2D workspace with this many histograms and bins. The bins are assumed to be non-uniform and given by the input array
    * Filled with Y = 2.0 and E = sqrt(2.0)w
    */
-  DLL_TESTHELPERS Workspace2D_sptr Create2DWorkspaceBinned(int nhist, const int numBoundaries, 
-						  const double xBoundaries[]);
+  DLL_TESTHELPERS Mantid::DataObjects::Workspace2D_sptr Create2DWorkspaceBinned(int nhist, const int numBoundaries, 
+							   const double xBoundaries[]);
   /**
    * Create a test workspace with a fully defined instrument
    * Each spectra will have a cylindrical detector defined 2*cylinder_radius away from the centre of the
    * pervious. 
    * Data filled with: Y: 2.0, E: sqrt(2.0), X: nbins of width 1 starting at 0 
    */
-  DLL_TESTHELPERS Workspace2D_sptr create2DWorkspaceWithFullInstrument(int nhist, int nbins, 
+  DLL_TESTHELPERS Mantid::DataObjects::Workspace2D_sptr create2DWorkspaceWithFullInstrument(int nhist, int nbins, 
 							      bool includeMonitors = false);
-  DLL_TESTHELPERS WorkspaceSingleValue_sptr CreateWorkspaceSingleValue(double value);
-  DLL_TESTHELPERS WorkspaceSingleValue_sptr CreateWorkspaceSingleValueWithError(double value, double error);
+  DLL_TESTHELPERS Mantid::DataObjects::WorkspaceSingleValue_sptr CreateWorkspaceSingleValue(double value);
+  DLL_TESTHELPERS Mantid::DataObjects::WorkspaceSingleValue_sptr CreateWorkspaceSingleValueWithError(double value, double error);
   /** Perform some finalization on event workspace stuff */
-  DLL_TESTHELPERS void EventWorkspace_Finalize(EventWorkspace_sptr ew);
+  DLL_TESTHELPERS void EventWorkspace_Finalize(Mantid::DataObjects::EventWorkspace_sptr ew);
   /** Create event workspace with:
    * 500 pixels
    * 1000 histogrammed bins.
    */
-  DLL_TESTHELPERS EventWorkspace_sptr CreateEventWorkspace();
+  DLL_TESTHELPERS Mantid::DataObjects::EventWorkspace_sptr CreateEventWorkspace();
   /** Create event workspace with:
    * 50 pixels
    * 100 histogrammed bins from 0.0 in steps of 1.0
    * 200 events; two in each bin, at time 0.5, 1.5, etc.
    * PulseTime = 1 second, 2 seconds, etc.
    */
-  DLL_TESTHELPERS EventWorkspace_sptr CreateEventWorkspace2();
+  DLL_TESTHELPERS Mantid::DataObjects::EventWorkspace_sptr CreateEventWorkspace2();
   /** Create event workspace
    */
-  DLL_TESTHELPERS EventWorkspace_sptr 
+  DLL_TESTHELPERS Mantid::DataObjects::EventWorkspace_sptr 
   CreateEventWorkspace(int numPixels, int numBins, int numEvents = 100, double x0=0.0, double binDelta=1.0,
 		       int eventPattern = 1, int start_at_pixelID = 0);
   /** Create event workspace
    */
-  DLL_TESTHELPERS EventWorkspace_sptr CreateGroupedEventWorkspace(std::vector< std::vector<int> > groups,
+  DLL_TESTHELPERS Mantid::DataObjects::EventWorkspace_sptr CreateGroupedEventWorkspace(std::vector< std::vector<int> > groups,
 							 int numBins, double binDelta=1.0);
   //not strictly creating a workspace, but really helpfull to see what one contains
-  DLL_TESTHELPERS void DisplayDataY(const MatrixWorkspace_sptr ws);
+  DLL_TESTHELPERS void DisplayDataY(const Mantid::API::MatrixWorkspace_sptr ws);
   //not strictly creating a workspace, but really helpfull to see what one contains
-  DLL_TESTHELPERS void DisplayData(const MatrixWorkspace_sptr ws);
+  DLL_TESTHELPERS void DisplayData(const Mantid::API::MatrixWorkspace_sptr ws);
   //not strictly creating a workspace, but really helpfull to see what one contains
-  DLL_TESTHELPERS void DisplayDataX(const MatrixWorkspace_sptr ws);
+  DLL_TESTHELPERS void DisplayDataX(const Mantid::API::MatrixWorkspace_sptr ws);
   //not strictly creating a workspace, but really helpfull to see what one contains
-  DLL_TESTHELPERS void DisplayDataE(const MatrixWorkspace_sptr ws);
+  DLL_TESTHELPERS void DisplayDataE(const Mantid::API::MatrixWorkspace_sptr ws);
 
 };
 

Code/Mantid/Framework/TestHelpers/src/ComponentCreationHelper.cpp

@@ -2,6 +2,24 @@
 // Includes
 //------------------------------------------------------------------------------
 #include "MantidTestHelpers/ComponentCreationHelper.h"
+#include "MantidTestHelpers/WorkspaceCreationHelper.h"
+#include "MantidAPI/AnalysisDataService.h"
+#include "MantidKernel/UnitFactory.h"
+#include "MantidKernel/ConfigService.h"
+#include "MantidGeometry/Objects/ShapeFactory.h"
+#include "MantidGeometry/Instrument/CompAssembly.h"
+#include "MantidGeometry/Instrument/ObjComponent.h"
+#include "MantidGeometry/Instrument/DetectorGroup.h"
+#include "MantidGeometry/Instrument/Detector.h"
+#include "MantidGeometry/Instrument/RectangularDetector.h"
+
+#include "MantidDataHandling/LoadInstrument.h"
+#include <Poco/Path.h>
+#include <boost/shared_array.hpp>
+
+using namespace Mantid::Geometry;
+using namespace Mantid::API;
+using namespace Mantid::DataObjects;
 
 namespace ComponentCreationHelper
 {
@@ -280,7 +298,7 @@ namespace ComponentCreationHelper
       // Mark them all as detectors
       for (int i=0; i < bank->nelements(); i++)
       {
-        boost::shared_ptr<Geometry::Detector> detector = boost::dynamic_pointer_cast<Geometry::Detector>((*bank)[i]);
+        boost::shared_ptr<Detector> detector = boost::dynamic_pointer_cast<Detector>((*bank)[i]);
         if (detector)
         {
           //Mark it as a detector (add to the instrument cache)
@@ -309,3 +327,125 @@ namespace ComponentCreationHelper
   }
 }
 
+/*****************************************************
+ * SANS instrument helper class
+ *****************************************************/
+
+// Number of detector pixels in each dimension
+const int SANSInstrumentCreationHelper::nBins = 30;
+// The test instrument has 2 monitors
+const int SANSInstrumentCreationHelper::nMonitors = 2;
+
+  /*
+   * Generate a SANS test workspace, with instrument geometry.
+   * The geometry is the SANSTEST geometry, with a 30x30 pixel 2D detector.
+   *
+   * @param workspace: name of the workspace to be created.
+   */
+Workspace2D_sptr SANSInstrumentCreationHelper::createSANSInstrumentWorkspace(std::string workspace)
+{
+  // Create a test workspace with test data with a well defined peak
+  // The test instrument has two monitor channels
+  Workspace2D_sptr ws = WorkspaceCreationHelper::Create2DWorkspace123(1,nBins*nBins+nMonitors,1);
+  AnalysisDataService::Instance().addOrReplace(workspace, ws);
+  ws->getAxis(0)->unit() = Mantid::Kernel::UnitFactory::Instance().create("Wavelength");
+  ws->setYUnit("");
+  for (int i = 0; i < ws->getNumberHistograms(); ++i)
+  {
+    ws->getAxis(1)->spectraNo(i) = i;
+  }
+  
+  // Load instrument geometry
+  runLoadInstrument("SANSTEST", ws);
+  runLoadMappingTable(ws, nBins, nBins);
+  
+  return ws;
+}
+
+  /** Run the sub-algorithm LoadInstrument (as for LoadRaw)
+   * @param inst_name The name written in the Nexus file
+   * @param workspace The workspace to insert the instrument into
+   */
+  void SANSInstrumentCreationHelper::runLoadInstrument(const std::string & inst_name,
+      Workspace2D_sptr workspace)
+  {
+    // Determine the search directory for XML instrument definition files (IDFs)
+    std::string directoryName = Mantid::Kernel::ConfigService::Instance().getString(
+        "instrumentDefinition.directory");
+    if (directoryName.empty())
+    {
+      // This is the assumed deployment directory for IDFs, where we need to be relative to the
+      // directory of the executable, not the current working directory.
+      directoryName = Poco::Path(Mantid::Kernel::ConfigService::Instance().getBaseDir()).resolve(
+          "../Instrument").toString();
+    }
+
+    // For Nexus Mantid processed, Instrument XML file name is read from nexus
+    std::string instrumentID = inst_name;
+    // force ID to upper case
+    std::transform(instrumentID.begin(), instrumentID.end(), instrumentID.begin(), toupper);
+    std::string fullPathIDF = directoryName + "/" + instrumentID + "_Definition.xml";
+
+    Mantid::DataHandling::LoadInstrument loadInst;
+    loadInst.initialize();
+    // Now execute the sub-algorithm. Catch and log any error, but don't stop.
+    loadInst.setPropertyValue("Filename", fullPathIDF);
+    loadInst.setProperty<MatrixWorkspace_sptr> ("Workspace", workspace);
+    loadInst.execute();
+
+  }
+
+  /**
+   * Populate spectra mapping to detector IDs
+   *
+   * @param workspace: Workspace2D object
+   * @param nxbins: number of bins in X
+   * @param nybins: number of bins in Y
+   */
+  void SANSInstrumentCreationHelper::runLoadMappingTable(Workspace2D_sptr workspace, int nxbins, int nybins)
+  {
+    // Get the number of monitor channels
+    int nMonitors = 0;
+    boost::shared_ptr<Instrument> instrument = workspace->getBaseInstrument();
+    std::vector<int> monitors = instrument->getMonitors();
+    nMonitors = monitors.size();
+
+    // Number of monitors should be consistent with data file format
+    if( nMonitors != 2 ) {
+      std::stringstream error;
+      error << "Geometry error for " << instrument->getName() <<
+          ": Spice data format defines 2 monitors, " << nMonitors << " were/was found";
+      throw std::runtime_error(error.str());
+    }
+
+    int ndet = nxbins*nybins + nMonitors;
+    boost::shared_array<int> udet(new int[ndet]);
+    boost::shared_array<int> spec(new int[ndet]);
+
+    // Generate mapping of detector/channel IDs to spectrum ID
+
+    // Detector/channel counter
+    int icount = 0;
+
+    // Monitor: IDs start at 1 and increment by 1
+    for(int i=0; i<nMonitors; i++)
+    {
+      spec[icount] = icount;
+      udet[icount] = icount+1;
+      icount++;
+    }
+
+    // Detector pixels
+    for(int ix=0; ix<nxbins; ix++)
+    {
+      for(int iy=0; iy<nybins; iy++)
+      {
+        spec[icount] = icount;
+        udet[icount] = 1000000 + iy*1000 + ix;
+        icount++;
+      }
+    }
+
+    // Populate the Spectra Map with parameters
+    workspace->mutableSpectraMap().populate(spec.get(), udet.get(), ndet);
+  }

Code/Mantid/Framework/TestHelpers/src/WorkspaceCreationHelper.cpp

@@ -2,10 +2,23 @@
 // Includes
 //------------------------------------------------------------------------------
 #include "MantidTestHelpers/WorkspaceCreationHelper.h"
+// Other Helper
+#include "MantidTestHelpers/ComponentCreationHelper.h"
+#include <cmath>
+#include "MantidGeometry/Instrument/Detector.h"
+#include "MantidGeometry/Instrument/ParameterMap.h"
+#include "MantidGeometry/Objects/ShapeFactory.h"
 
 namespace WorkspaceCreationHelper
 {
 
+  using namespace Mantid::DataObjects;
+  using namespace Mantid::Kernel;
+  using namespace Mantid::API;
+  using namespace Mantid::Geometry;
+  using Mantid::MantidVec;
+  using Mantid::MantidVecPtr;
+
   Workspace1D_sptr Create1DWorkspaceRand(int size)
   {
     MantidVecPtr x1,y1,e1;
@@ -314,15 +327,15 @@ namespace WorkspaceCreationHelper
 	for (int i=0; i<numEvents; i++)
 	{
 	  if (eventPattern == 1) // 0, 1 diagonal pattern
-	    retVal->getEventListAtPixelID(pix) += TofEvent((pix+i+0.5)*binDelta, Kernel::DateAndTime(i,0));
+	    retVal->getEventListAtPixelID(pix) += TofEvent((pix+i+0.5)*binDelta, DateAndTime(i,0));
 	  else if (eventPattern == 2) // solid 2
 	  {
-	    retVal->getEventListAtPixelID(pix) += TofEvent((i+0.5)*binDelta, Kernel::DateAndTime(i,0));
-	    retVal->getEventListAtPixelID(pix) += TofEvent((i+0.5)*binDelta, Kernel::DateAndTime(i,0));
+	    retVal->getEventListAtPixelID(pix) += TofEvent((i+0.5)*binDelta, DateAndTime(i,0));
+	    retVal->getEventListAtPixelID(pix) += TofEvent((i+0.5)*binDelta, DateAndTime(i,0));
 	  }
 	  else if (eventPattern == 3) // solid 1
 	  {
-	    retVal->getEventListAtPixelID(pix) += TofEvent((i+0.5)*binDelta, Kernel::DateAndTime(i,0));
+	    retVal->getEventListAtPixelID(pix) += TofEvent((i+0.5)*binDelta, DateAndTime(i,0));
 	  }
 	}
       }