ConvertToDetectorFaceMDTest.h

#ifndef MANTID_MDALGORITHMS_CONVERTTODETECTORFACEMDTEST_H_
#define MANTID_MDALGORITHMS_CONVERTTODETECTORFACEMDTEST_H_

#include "MantidAPI/MatrixWorkspace.h"
#include "MantidDataObjects/Events.h"
#include "MantidDataObjects/EventWorkspace.h"
#include "MantidGeometry/MDGeometry/IMDDimension.h"
#include "MantidMDAlgorithms/ConvertToDetectorFaceMD.h"
#include "MantidDataObjects/MDEventFactory.h"
#include "MantidTestHelpers/MDEventsTestHelper.h"
#include "MantidTestHelpers/WorkspaceCreationHelper.h"

#include <cxxtest/TestSuite.h>

using namespace Mantid;
using namespace Mantid::MDAlgorithms;
using namespace Mantid::API;
using namespace Mantid::DataObjects;
using Mantid::Geometry::IMDDimension_const_sptr;

class ConvertToDetectorFaceMDTest : public CxxTest::TestSuite
{
public:
  // This pair of boilerplate methods prevent the suite being created statically
  // This means the constructor isn't called when running other tests
  static ConvertToDetectorFaceMDTest *createSuite() { return new ConvertToDetectorFaceMDTest(); }
  static void destroySuite( ConvertToDetectorFaceMDTest *suite ) { delete suite; }


  void test_Init()
  {
    ConvertToDetectorFaceMD alg;
    TS_ASSERT_THROWS_NOTHING( alg.initialize() )
    TS_ASSERT( alg.isInitialized() )
  }

  //----------------------------------------------------------------------------
  EventWorkspace_sptr makeTestWS(EventType type)
  {
    EventWorkspace_sptr in_ws = WorkspaceCreationHelper::createEventWorkspaceWithFullInstrument(5, 10, false);
    if ((type == WEIGHTED) || (type == WEIGHTED_NOTIME))
    {
      for (size_t i =0; i<in_ws->getNumberHistograms(); i++)
      {
        EventList & el = in_ws->getEventList(i);
        if (type == WEIGHTED)
          el.multiply(2.0);
        else
          el.compressEvents(0.0, &el);
      }
    }
    return in_ws;
  }


  //----------------------------------------------------------------------------
  template <class WSTYPE>
  boost::shared_ptr<WSTYPE> doTest(EventType type, const std::string & BankNumbers)
  {
    EventWorkspace_sptr in_ws = makeTestWS(type);
    ConvertToDetectorFaceMD alg;
    TS_ASSERT_THROWS_NOTHING( alg.initialize() )
    TS_ASSERT( alg.isInitialized() )
    alg.setProperty("InputWorkspace", boost::dynamic_pointer_cast<MatrixWorkspace>(in_ws) );
    alg.setPropertyValue("BankNumbers", BankNumbers);
    alg.setPropertyValue("OutputWorkspace", "output_md");
    TS_ASSERT_THROWS_NOTHING( alg.execute(); )
    TS_ASSERT( alg.isExecuted() )

    boost::shared_ptr<WSTYPE> ws;
    TS_ASSERT_THROWS_NOTHING(
        ws = AnalysisDataService::Instance().retrieveWS<WSTYPE>("output_md") );
    TS_ASSERT(ws);
    if (!ws) return ws;

    TS_ASSERT_EQUALS(ws->getNumExperimentInfo(), 1);

    for (size_t d=0; d<2; d++)
    {
      IMDDimension_const_sptr dim = ws->getDimension(d);
      TS_ASSERT_EQUALS( dim->getName(), (d == 0 ? "x" : "y") );
      TS_ASSERT_EQUALS( dim->getNBins(), 10);
      TS_ASSERT_DELTA(  dim->getMinimum(), 0, 1e-5);
      TS_ASSERT_DELTA(  dim->getMaximum(),10, 1e-5);
      TS_ASSERT_EQUALS( dim->getUnits(), "pixel");
    }
    IMDDimension_const_sptr dim = ws->getDimension(2);
    TS_ASSERT_EQUALS( dim->getName(), "dSpacing" );
    TS_ASSERT_EQUALS( dim->getNBins(), 101);
    TS_ASSERT_DELTA(  dim->getMinimum(),   0, 1e-5);
    TS_ASSERT_DELTA(  dim->getMaximum(), 100, 1e-5);
    TS_ASSERT_EQUALS( dim->getUnits(), "Angstrom");

    return ws;
  }


  //----------------------------------------------------------------------------
  /** Run algorithm and check that it fails */
  void doTestFails(const std::string & BankNumbers)
  {
    EventWorkspace_sptr in_ws = makeTestWS(TOF);
    ConvertToDetectorFaceMD alg;
    TS_ASSERT_THROWS_NOTHING( alg.initialize() )
    TS_ASSERT( alg.isInitialized() )
    alg.setProperty("InputWorkspace", boost::dynamic_pointer_cast<MatrixWorkspace>(in_ws) );
    alg.setPropertyValue("BankNumbers", BankNumbers);
    alg.setPropertyValue("OutputWorkspace", "output_md");
    TS_ASSERT_THROWS_NOTHING( alg.execute(); )
    TS_ASSERT( !alg.isExecuted() )
  }

  void test_name()
  {
    ConvertToDetectorFaceMD alg;
    TS_ASSERT_EQUALS("ConvertToDetectorFaceMD", alg.name())
  }

  void test_categories()
  {
    ConvertToDetectorFaceMD alg;
    TS_ASSERT_EQUALS("MDAlgorithms", alg.category());
  }

  //----------------------------------------------------------------------------
  void test_oneBank()
  {
    MDEventWorkspace3::sptr ws = doTest<MDEventWorkspace3>(TOF, "1");
    TS_ASSERT_EQUALS( ws->getNPoints(), 20000);
  }

  void test_WeightedEvent()
  {
    MDEventWorkspace3::sptr ws3 = doTest<MDEventWorkspace3>(WEIGHTED, "1");
    TS_ASSERT_EQUALS( ws3->getNPoints(), 20000);
    MDEventWorkspace4::sptr ws4 = doTest<MDEventWorkspace4>(WEIGHTED, "1,2");
    TS_ASSERT_EQUALS( ws4->getNPoints(), 20000*2);
  }
  void test_WeightedEventNoTime()
  {
    MDEventWorkspace3::sptr ws3 = doTest<MDEventWorkspace3>(WEIGHTED_NOTIME, "1");
    TS_ASSERT_EQUALS( ws3->getNPoints(), 10000);
    MDEventWorkspace4::sptr ws4 = doTest<MDEventWorkspace4>(WEIGHTED_NOTIME, "1,2");
    TS_ASSERT_EQUALS( ws4->getNPoints(), 10000*2);
  }

  void test_nonexistentBank_fails()
  {
    doTestFails("7");
    doTestFails("0");
  }
  
  //----------------------------------------------------------------------------
  void test_severalBanks()
  {
    MDEventWorkspace4::sptr ws = doTest<MDEventWorkspace4>(TOF, "1, 3");
    TS_ASSERT_EQUALS( ws->getNPoints(), 2*20000);
    IMDDimension_const_sptr dim = ws->getDimension(3);
    TS_ASSERT_EQUALS( dim->getName(), "bank" );
    TS_ASSERT_EQUALS( dim->getNBins(), 3);
    TS_ASSERT_DELTA(  dim->getMinimum(), 1, 1e-5);
    TS_ASSERT_DELTA(  dim->getMaximum(), 4, 1e-5);
    TS_ASSERT_EQUALS( dim->getUnits(), "number");
  }

  /** If you do not specify a list of banks, all are used */
  void test_allBanks()
  {
    MDEventWorkspace4::sptr ws = doTest<MDEventWorkspace4>(TOF, "");
    TS_ASSERT_EQUALS( ws->getNPoints(), 5*20000);
    IMDDimension_const_sptr dim = ws->getDimension(3);
    TS_ASSERT_EQUALS( dim->getName(), "bank" );
    TS_ASSERT_EQUALS( dim->getNBins(), 5);
    TS_ASSERT_DELTA(  dim->getMinimum(), 1, 1e-5);
    TS_ASSERT_DELTA(  dim->getMaximum(), 6, 1e-5);
    TS_ASSERT_EQUALS( dim->getUnits(), "number");
  }


};


#endif /* MANTID_MDALGORITHMS_CONVERTTODETECTORFACEMDTEST_H_ */