LoadEventPreNexusTest.h

/*
 * LoadEventPreNexusTest.h
 *
 *  Created on: Jun 23, 2010
 *      Author: janik zikovsky
 */

#ifndef LOADEVENTPRENEXUSTEST_H_
#define LOADEVENTPRENEXUSTEST_H_

#include <cxxtest/TestSuite.h>

#include "MantidDataObjects/EventList.h"
#include "MantidDataObjects/EventWorkspace.h"
#include "MantidDataObjects/Workspace2D.h"
#include "MantidKernel/DateAndTime.h"
#include "MantidKernel/TimeSeriesProperty.h"
#include "MantidDataHandling/LoadEventPreNexus.h"
#include <sys/stat.h>

using namespace Mantid;
using namespace Mantid::DataHandling;
using namespace Mantid::DataObjects;
using namespace Mantid::Kernel;
using namespace Mantid::Kernel::Exception;
using namespace Mantid::API;
using namespace Mantid::Geometry;

using std::runtime_error;
using std::size_t;
using std::vector;
using std::cout;
using std::endl;

//==========================================================================================
class LoadEventPreNexusTest : public CxxTest::TestSuite {
public:
  LoadEventPreNexus *eventLoader;

  static LoadEventPreNexusTest *createSuite() {
    return new LoadEventPreNexusTest();
  }
  static void destroySuite(LoadEventPreNexusTest *suite) { delete suite; }

  LoadEventPreNexusTest() {}

  void setUp() {
    eventLoader = new LoadEventPreNexus();
    eventLoader->initialize();
  }

  void test_file_not_found() {
    TS_ASSERT_THROWS(eventLoader->setPropertyValue(
                         "EventFilename", "this_file_doesnt_exist.blabla.data"),
                     std::invalid_argument);
    // Execute fails since the properties aren't set correctly.
    TS_ASSERT_THROWS(eventLoader->execute(), std::runtime_error);
  }

  void test_data_sizes() {
    // Make sure the structs are the right size
    TS_ASSERT_EQUALS(sizeof(Pulse), 24);
    TS_ASSERT_EQUALS(sizeof(DasEvent), 8);
  }

  void checkWorkspace(std::string eventfile, std::string WSName,
                      int numpixels_with_events) {
    // Get the event file size
    struct stat filestatus;
    stat(eventfile.c_str(), &filestatus);

    EventWorkspace_sptr ew =
        AnalysisDataService::Instance().retrieveWS<EventWorkspace>(WSName);

    // The # of events = size of the file / 8 bytes (per event)
    TS_ASSERT_EQUALS(ew->getNumberEvents(), filestatus.st_size / 8);

    // Only some of the pixels were loaded, because of lot of them are empty
    TS_ASSERT_EQUALS(ew->getNumberHistograms(), numpixels_with_events);

    // Mapping between workspace index and spectrum number
    // Is the length good?
    TS_ASSERT_EQUALS(ew->getAxis(1)->length(), numpixels_with_events);
  }

  void test_LoadPreNeXus_REFL() {
    std::string eventfile("REF_L_32035_neutron_event.dat");
    std::string pulsefile("REF_L_32035_pulseid.dat");
    eventLoader->setPropertyValue("EventFilename", eventfile);
    eventLoader->setPropertyValue("PulseidFilename", pulsefile);
    eventLoader->setPropertyValue("MappingFilename", "REF_L_TS_2010_02_19.dat");
    eventLoader->setPropertyValue("OutputWorkspace", "refl");

    // Get the event file size
    struct stat filestatus;
    eventfile = eventLoader->getPropertyValue("EventFilename");
    stat(eventfile.c_str(), &filestatus);

    // no instrument definition - should fail
    TS_ASSERT((eventLoader->execute()));
  }

  void test_LoadPreNeXus_CNCS_7860() {
    std::string eventfile("CNCS_7860_neutron_event.dat");
    eventLoader->setPropertyValue("EventFilename", eventfile);
    eventLoader->setPropertyValue("MappingFilename", "CNCS_TS_2008_08_18.dat");
    eventLoader->setPropertyValue("OutputWorkspace", "cncs");

    // Get the event file size
    struct stat filestatus;
    stat(eventfile.c_str(), &filestatus);

    // std::cout << "***** executing *****" << std::endl;
    TS_ASSERT(eventLoader->execute());

    EventWorkspace_sptr ew = boost::dynamic_pointer_cast<EventWorkspace>(
        AnalysisDataService::Instance().retrieve("cncs"));

    // Get the start time of all pulses
    Kernel::TimeSeriesProperty<double> *log =
        dynamic_cast<Kernel::TimeSeriesProperty<double> *>(
            ew->mutableRun().getProperty("proton_charge"));
    std::map<DateAndTime, double> logMap = log->valueAsMap();
    std::map<DateAndTime, double>::iterator it, it2;
    it = logMap.begin();
    Kernel::DateAndTime start = it->first;

    std::vector<TofEvent> events1 = ew->getEventListPtr(1000)->getEvents();
    for (size_t i = 0; i < events1.size(); i++) {
      std::cout << (events1[i].pulseTime() - start) << " sec \n";
    }
  }

  void test_LoadPreNeXus_CNCS() { do_test_LoadPreNeXus_CNCS("Serial"); }

  void test_LoadPreNeXus_CNCS_parallel() {
    do_test_LoadPreNeXus_CNCS("Parallel");
  }

  void do_test_LoadPreNeXus_CNCS(std::string parallel) {
    std::string eventfile("CNCS_7860_neutron_event.dat");
    eventLoader->setPropertyValue("EventFilename", eventfile);
    eventLoader->setPropertyValue("MappingFilename", "CNCS_TS_2008_08_18.dat");
    eventLoader->setPropertyValue("OutputWorkspace", "cncs");
    eventLoader->setPropertyValue("UseParallelProcessing", parallel);

    // Get the event file size
    struct stat filestatus;
    stat(eventfile.c_str(), &filestatus);

    // std::cout << "***** executing *****" << std::endl;
    TS_ASSERT(eventLoader->execute());

    EventWorkspace_sptr ew = boost::dynamic_pointer_cast<EventWorkspace>(
        AnalysisDataService::Instance().retrieve("cncs"));

    // The # of events = size of the file / 8 bytes (per event)
    // This fails cause of errors in events
    TS_ASSERT_EQUALS(ew->getNumberEvents(), 112266);

    // We pad all pixels by default
    int numpixels_with_events = 51200;
    TS_ASSERT_EQUALS(ew->getNumberHistograms(), numpixels_with_events);

    // Check if the instrument was loaded correctly
    boost::shared_ptr<const Instrument> inst = ew->getInstrument();
    TS_ASSERT_EQUALS(inst->getName(), "CNCS");

    // Mapping between workspace index and spectrum number
    // Is the length good?
    TS_ASSERT_EQUALS(ew->getAxis(1)->length(), numpixels_with_events);

    //--------------------------------------------------------
    // Now let's test if a copy works too
    EventWorkspace_sptr inputWS = ew;
    TS_ASSERT_EQUALS(inputWS->getInstrument()->getName(), "CNCS");

    // Create a new one
    EventWorkspace_sptr outputWS = boost::dynamic_pointer_cast<EventWorkspace>(
        API::WorkspaceFactory::Instance().create(
            "EventWorkspace", inputWS->getNumberHistograms(), 2, 1));
    TS_ASSERT(outputWS); // non-null pointer

    // Copy geometry over.
    API::WorkspaceFactory::Instance().initializeFromParent(inputWS, outputWS,
                                                           false);

    // You need to copy over the data as well.
    outputWS->copyDataFrom(*inputWS);

    // Bunch of checks
    TS_ASSERT_EQUALS(outputWS->getNumberEvents(), inputWS->getNumberEvents());
    TS_ASSERT_EQUALS(outputWS->getNumberHistograms(),
                     inputWS->getNumberHistograms());
    TS_ASSERT_EQUALS(outputWS->getInstrument()->getName(), "CNCS");

    std::size_t wkspIndex = 4348; // a good workspace index (with events)
    TS_ASSERT_EQUALS(outputWS->getEventList(wkspIndex).getNumberEvents(), 11);
    if (outputWS->getEventList(wkspIndex).getNumberEvents() != 11)
      return;

    TS_ASSERT_EQUALS(outputWS->getEventList(wkspIndex).getEvents()[0].tof(),
                     inputWS->getEventList(wkspIndex).getEvents()[0].tof());
    // It should be possible to change an event list and not affect the other
    // one
    outputWS->getEventList(wkspIndex).convertTof(1.5, 0.2);
    TS_ASSERT_DIFFERS(outputWS->getEventList(wkspIndex).getEvents()[0].tof(),
                      inputWS->getEventList(wkspIndex).getEvents()[0].tof());

    // Setting X should still be possible
    Kernel::cow_ptr<MantidVec> x;
    TS_ASSERT_THROWS_NOTHING(outputWS->setX(0, x));
    // Accessing Y is still possible
    const MantidVec Y =
        boost::dynamic_pointer_cast<const EventWorkspace>(outputWS)->dataY(0);

    // Check the run_start property exists and is right.
    Property *p = NULL;
    TS_ASSERT(outputWS->mutableRun().hasProperty("run_start"));
    TS_ASSERT_THROWS_NOTHING(
        p = outputWS->mutableRun().getProperty("run_start");)
    if (p) {
      TS_ASSERT_EQUALS(p->value(), "2010-03-25T16:08:37.457381666");
    }
  }

  void test_LoadPreNeXus_CNCS_SkipPixels() {
    std::string eventfile("CNCS_7860_neutron_event.dat");
    eventLoader->setPropertyValue("EventFilename", eventfile);
    eventLoader->setPropertyValue("MappingFilename", "CNCS_TS_2008_08_18.dat");
    eventLoader->setPropertyValue("OutputWorkspace", "cncs_skipped");
    // Load just 2 pixels
    eventLoader->setProperty("SpectrumList", "45, 110");

    TS_ASSERT(eventLoader->execute());

    EventWorkspace_sptr ew = boost::dynamic_pointer_cast<EventWorkspace>(
        AnalysisDataService::Instance().retrieve("cncs_skipped"));

    // Only some of the pixels weretof loaded, because of lot of them are empty
    int numpixels = 2;
    TS_ASSERT_EQUALS(ew->getNumberHistograms(), numpixels);

    // Mapping between workspace index and spectrum number; simple
    TS_ASSERT_EQUALS(ew->getAxis(1)->spectraNo(0), 46);
    TS_ASSERT_EQUALS(ew->getAxis(1)->spectraNo(1), 111);
    TS_ASSERT_EQUALS(ew->getAxis(1)->length(), 2);

    // Are the pixel IDs ok?
    TS_ASSERT_EQUALS(ew->getSpectrum(0)->getSpectrumNo(), 46);
    std::set<detid_t> dets = ew->getSpectrum(0)->getDetectorIDs();
    TS_ASSERT_EQUALS(dets.size(), 1);
    TS_ASSERT_EQUALS(*dets.begin(), 45);

    TS_ASSERT_EQUALS(ew->getSpectrum(1)->getSpectrumNo(), 111);
    dets = ew->getSpectrum(1)->getDetectorIDs();
    TS_ASSERT_EQUALS(dets.size(), 1);
    TS_ASSERT_EQUALS(*dets.begin(), 110);
  }

  void test_invalid_chunk_number() {
    eventLoader->setPropertyValue("EventFilename",
                                  "CNCS_7860_neutron_event.dat");
    eventLoader->setPropertyValue("ChunkNumber", "3");
    eventLoader->setPropertyValue("TotalChunks", "2");
    TS_ASSERT_THROWS(eventLoader->execute(), std::runtime_error);
  }

  void test_loading_chunks() {
    // Load chunk 1 of 2
    eventLoader->setPropertyValue("EventFilename",
                                  "CNCS_7860_neutron_event.dat");
    eventLoader->setPropertyValue("ChunkNumber", "1");
    eventLoader->setPropertyValue("TotalChunks", "2");
    eventLoader->setPropertyValue("OutputWorkspace", "chunk1");
    TS_ASSERT(eventLoader->execute());
    EventWorkspace_sptr chunk1 = boost::dynamic_pointer_cast<EventWorkspace>(
        AnalysisDataService::Instance().retrieve("chunk1"));

    // Load chunk 2 of 2
    eventLoader->setPropertyValue("EventFilename",
                                  "CNCS_7860_neutron_event.dat");
    eventLoader->setPropertyValue("ChunkNumber", "2");
    eventLoader->setPropertyValue("TotalChunks", "2");
    eventLoader->setPropertyValue("OutputWorkspace", "chunk2");
    TS_ASSERT(eventLoader->execute());
    EventWorkspace_sptr chunk2 = boost::dynamic_pointer_cast<EventWorkspace>(
        AnalysisDataService::Instance().retrieve("chunk2"));

    // The number of events should be roughly equal and the sum should be 112266
    TS_ASSERT_EQUALS(chunk1->getNumberEvents(), 56139)
    TS_ASSERT_EQUALS(chunk2->getNumberEvents(), 56127)
  }
};

//------------------------------------------------------------------------------
// Performance test
//------------------------------------------------------------------------------

class LoadEventPreNexusTestPerformance : public CxxTest::TestSuite {
public:
  void testDefaultLoad() {
    LoadEventPreNexus loader;
    loader.initialize();
    loader.setPropertyValue("EventFilename", "CNCS_7860_neutron_event.dat");
    loader.setPropertyValue("OutputWorkspace", "ws");
    TS_ASSERT(loader.execute());
  }
};

#endif /* LOADEVENTPRENEXUSTEST_H_ */