testMDetector.cc

Go to the documentation of this file.

#include <fwk/RunController.h>
#include <fwk/CentralConfig.h>
#include <fwk/CoordinateSystemRegistry.h>

#include <det/Detector.h>
#include <sdet/SDetector.h>
#include <sdet/Station.h>

#include <utl/TimeStamp.h>
#include <utl/UTCDateTime.h>
#include <utl/Point.h>
#include <utl/ReferenceEllipsoid.h>
#include <utl/CoordinateSystem.h>

#include <mdet/MDetector.h>
#include <mdet/Module.h>
#include <mdet/Counter.h>
#include <mdet/Scintillator.h>
#include <mdet/Channel.h>
#include <mdet/PMT.h>
#include <mdet/Fiber.h>

#include <tst/Verify.h>
 
#include <cppunit/extensions/HelperMacros.h>
# include <bitset> 

using namespace det;
using namespace std;
using namespace utl;
using namespace fwk;
using namespace tst;
using namespace mdet;

#define ASSERT_CLOSE(x, y, eps) CPPUNIT_ASSERT(Verify<CloseTo>(x, y, eps))
#define ASSERT_EQUAL(x, y) CPPUNIT_ASSERT(Verify<Equal>(x, y))

class MDetectorTest : public CppUnit::TestFixture  {

  CPPUNIT_TEST_SUITE(MDetectorTest);
  CPPUNIT_TEST(testBasic);
  CPPUNIT_TEST(testComponentAssignment);
  CPPUNIT_TEST(testBrokenChannelsAssignment);
  CPPUNIT_TEST_SUITE_END();

public:
  void
  setUp()
  {
    ErrorLogger::GetInstance().SetVerbosity(Verbosity::eVerbose);

    // CentralConfig must be created first. 
    //
    /*CentralConfig* fCentralConfig =*/
    fwk::CentralConfig::GetInstance(BOOTSTRAPFILE);

    // Create a detector
    //
    /*Detector& theDetector =*/
    Detector::GetInstance(); 
  }

  void tearDown() { }

  void 
  testBasic()
  {
    Detector& detector = Detector::GetInstance();
    const TimeStamp t = UTCDateTime(2013,1,1).GetTimeStamp();
    detector.Update(t);

    const CoordinateSystemPtr cs = detector.GetSiteCoordinateSystem(); // Malargue CS
    const MDetector& mDetector = detector.GetMDetector();    
    const Counter& dCounter = mDetector.GetCounter(2); // get counter 2 (associated to SD tank 639)
    
    // test if position is correct
    ASSERT_CLOSE(dCounter.GetPosition().GetX(cs), 9487.37, 1e-3*m);
    ASSERT_CLOSE(dCounter.GetPosition().GetY(cs), 52594.7, 1e-3*m);
    ASSERT_CLOSE(dCounter.GetPosition().GetZ(cs), 1337.47, 1e-3*m);
        
    const sdet::Station& asscociatedStation = dCounter.GetAssociatedTank();
    ASSERT_EQUAL(asscociatedStation.GetId(), 639);
    
    // segmentation should be 192
    ASSERT_EQUAL(dCounter.GetSegmentation(), static_cast<unsigned int>(192));
 
    // check that counter has 3 modules with IDs from 1 to 3
    int moduleCounter = 1;
    for (Counter::ModuleConstIterator cIt = dCounter.ModulesBegin();
          cIt !=dCounter.ModulesEnd(); ++cIt) {
       ASSERT_EQUAL(cIt->GetId(), moduleCounter);
       ++moduleCounter;
    }
    ASSERT_EQUAL(moduleCounter, 4);
    
    // now test module substructure of module 3 (fibers and scintillators)
    const Module& dModule = dCounter.GetModule(3);
    
    int fiberCounter = 1;
    for (Module::FiberConstIterator fIt = dModule.FibersBegin();
          fIt !=dModule.FibersEnd(); ++fIt) {
       ASSERT_EQUAL(fIt->GetId(), fiberCounter);
       ++fiberCounter;
    }
    ASSERT_EQUAL(fiberCounter, 65);
    
    int scintillatorCounter = 1;
    for (Module::ScintillatorConstIterator sIt = dModule.ScintillatorsBegin();
          sIt !=dModule.ScintillatorsEnd(); ++sIt) {
       ASSERT_EQUAL(sIt->GetId(), scintillatorCounter);
       ++scintillatorCounter;
    }
    ASSERT_EQUAL(scintillatorCounter, 65);
    
  }  

  void 
  testBrokenChannelsAssignment( int CtrId, int ModId, TimeStamp t )
  {
    Detector& detector = Detector::GetInstance();
    detector.Update(t);

    const MDetector& mDetector = detector.GetMDetector();
    const Counter& dCounter = mDetector.GetCounter(CtrId); 
    const Module& dModule = dCounter.GetModule(ModId);
    const FrontEnd& frontend = dModule.GetFrontEnd();
    const ULong64_t mask = dModule.GetFrontEnd().GetMask();    
    const bitset<64> bit_mask = mask;

    std::cout << "mask for counter " << CtrId << " module " << ModId << "\nin decimal: " << std::endl;
    std::cout << "Sampling rate:" <<  frontend.GetMeanSampleRatePeriod() << endl;
    std::cout << "Buffer length:" <<  frontend.GetPreT1BufferLength() + frontend.GetPostT1BufferLength() << endl;
    std::cout << mask <<  std::endl;
    std::cout << "in bits: " << std::endl;
    std::cout << bit_mask << " ==> (" << bit_mask.count() << ")\n";

  }  

  void 
  testBrokenChannelsAssignment()
  {
    testBrokenChannelsAssignment(1764, 1, UTCDateTime(2015,7,22).GetTimeStamp());
    testBrokenChannelsAssignment(1764, 2, UTCDateTime(2015,7,23).GetTimeStamp());
    testBrokenChannelsAssignment(93  , 2, UTCDateTime(2015,7,24).GetTimeStamp());
    testBrokenChannelsAssignment(1622, 7, UTCDateTime(2015,7,25).GetTimeStamp()); 
  }
  
  void 
  testComponentAssignment()
  {
    Detector& detector = Detector::GetInstance();
    const TimeStamp t = UTCDateTime(2013,1,1).GetTimeStamp();
    detector.Update(t);

    const MDetector& mDetector = detector.GetMDetector();

    const Counter& dCounter = mDetector.GetCounter(1); // get counter 1 (associated to SD tank 608)
    const Module& dModule = dCounter.GetModule(1);
    
    const PMT& pmt = dModule.GetPMT();

    int pixelCounter = 1;
    for (PMT::PixelConstIterator pIt = pmt.PixelsBegin();
          pIt !=pmt.PixelsEnd(); ++pIt) {
       ASSERT_EQUAL(pIt->GetId(), pixelCounter);
       ++pixelCounter;
    }
    ASSERT_EQUAL(pixelCounter, 65);
    
    const FrontEnd& frontend = dModule.GetFrontEnd();

    int channelCounter = 1;
    for (FrontEnd::ChannelConstIterator cIt = frontend.ChannelsBegin();
          cIt !=frontend.ChannelsEnd(); ++cIt) {
       ASSERT_EQUAL(cIt->GetId(), channelCounter-1); // channel IDs start at 0
       ++channelCounter;
    }
    ASSERT_EQUAL(channelCounter, 65);

    // test association of differerent commponents in two ways
    ASSERT_EQUAL(dModule.ScintillatorToChannelId(10), 10); 
    ASSERT_EQUAL(dModule.ScintillatorToPixelId(10), 22); 
    ASSERT_EQUAL(dModule.ScintillatorToFiberId(10), 10); 
    ASSERT_EQUAL(dModule.GetChannelFor(dModule.GetScintillator(10)).GetId(), 10); 
    ASSERT_EQUAL(dModule.GetPixelFor(dModule.GetScintillator(10)).GetId(), 22); 
    ASSERT_EQUAL(dModule.GetFiberFor(dModule.GetScintillator(10)).GetId(), 10); 
    
    ASSERT_EQUAL(dModule.ChannelToScintillatorId(10), 10); 
    ASSERT_EQUAL(dModule.ChannelToPixelId(10), 22); 
    ASSERT_EQUAL(dModule.ChannelToFiberId(10), 10); 
    ASSERT_EQUAL(dModule.GetScintillatorFor(dModule.GetChannel(10)).GetId(), 10); 
    ASSERT_EQUAL(dModule.GetPixelFor(dModule.GetChannel(10)).GetId(), 22); 
    ASSERT_EQUAL(dModule.GetFiberFor(dModule.GetChannel(10)).GetId(), 10); 
    
    ASSERT_EQUAL(dModule.FiberToChannelId(10), 10); 
    ASSERT_EQUAL(dModule.FiberToScintillatorId(10), 10); 
    ASSERT_EQUAL(dModule.FiberToPixelId(26), 10); 
    ASSERT_EQUAL(dModule.GetChannelFor(dModule.GetFiber(10)).GetId(), 10); 
    ASSERT_EQUAL(dModule.GetScintillatorFor(dModule.GetFiber(10)).GetId(), 10); 
    ASSERT_EQUAL(dModule.GetPixelFor(dModule.GetFiber(26)).GetId(), 10); 
    
    ASSERT_EQUAL(dModule.PixelToScintillatorId(22), 10); 
    ASSERT_EQUAL(dModule.PixelToFiberId(10), 26); 
    ASSERT_EQUAL(dModule.PixelToChannelId(22), 10); 
    ASSERT_EQUAL(dModule.GetScintillatorFor(dModule.GetPixel(22)).GetId(), 10);     
    ASSERT_EQUAL(dModule.GetFiberFor(dModule.GetPixel(10)).GetId(), 26); 
    ASSERT_EQUAL(dModule.GetChannelFor(dModule.GetPixel(22)).GetId(), 10); 
  }


};

CPPUNIT_TEST_SUITE_REGISTRATION(MDetectorTest);