testSDenseDetectorZenith.cc

Go to the documentation of this file.

#include <det/Detector.h>
#include <sdet/SDetector.h>
#include <fwk/CentralConfig.h>
#include <utl/TimeStamp.h>
#include <utl/UTCDateTime.h>
#include <utl/TabulatedFunction.h>
#include <utl/Reader.h>
#include <utl/CoordinateSystem.h>
#include <utl/Point.h>
#include <utl/AugerException.h>
#include <utl/ErrorLogger.h>

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

#include <evt/Event.h>
#include <evt/ShowerSimData.h>
#include <evt/DefaultShowerGeometryProducer.h>

#include <sevt/SEvent.h>
#include <sevt/Station.h>

#include <tst/Verify.h>

#include <cppunit/extensions/HelperMacros.h>

#include <map>
#include <sstream>
#include <iostream>
#include <string>
#include <vector>

using namespace det;
using namespace std;
using namespace fwk;
using namespace utl;
using namespace tst;
using namespace sdet;
using namespace evt;


// This file contains a few additional tests of the dense array
// geometry.  These tests are run separately from the other geometry
// tests as the SDenseArrayXMLManager accesses
// shower info through RunController::GetCurrentEvent(), and the
// RunController is a singleton.  There are probably other ways to
// deal with this, but this was convenient and quick to implement.

class SDenseDetectorTestZenith : public CppUnit::TestFixture {

  CPPUNIT_TEST_SUITE(SDenseDetectorTestZenith);
  CPPUNIT_TEST(testBasicZenith);
  CPPUNIT_TEST_SUITE_END();

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

    // CentralConfig must be created first.
    CentralConfig::GetInstance(BOOTSTRAPFILE);

    // Create a detector
    Detector::GetInstance().Update(UTCDateTime(2005,1,1).GetTimeStamp());
  }

  void tearDown() { }

  void
  testBasicZenith()
  {
    const auto& det = Detector::GetInstance();

    // get reference coordinate system of detector (usually PampaAmarilla)
    const utl::CoordinateSystemPtr pampaCS = det.GetReferenceCoordinateSystem();

    // Set a sim shower data so that dense station position can
    // be computed relative to it
    Event& evt = RunController::GetInstance().GetCurrentEvent();
    if (!evt.HasSimShower())
      evt.MakeSimShower(DefaultShowerGeometryProducer());

    ShowerSimData& simShower = evt.GetSimShower();
    simShower.SetGroundParticleCoordinateSystemAzimuth(0);
    const double theta = 45*degree;
    simShower.SetGroundParticleCoordinateSystemZenith(theta);
    const double x = -10*km;
    const double y = 17*km;
    const double z = 0;
    const Point core(x, y, z, pampaCS);
    simShower.MakeGeometry(core);

    const auto& sDet = det.GetSDetector();
    const int refStationId = 860;
    const auto& ref = sDet.GetStation(refStationId).GetPosition();

    const double xyTol = 3*m;
    const double zTol = 0.8*m;
    // dense in the center
    const Point& p0 = sDet.GetStation(99999).GetPosition();
    CPPUNIT_ASSERT(Verify<CloseTo>(p0.GetX(pampaCS), core.GetX(pampaCS), xyTol));
    CPPUNIT_ASSERT(Verify<CloseTo>(p0.GetY(pampaCS), core.GetY(pampaCS), xyTol));
    CPPUNIT_ASSERT(Verify<CloseTo>(p0.GetZ(pampaCS), ref.GetZ(pampaCS), zTol));

#define DUMP(_x_) #_x_ " (" << (_x_.GetX(pampaCS) - core.GetX(pampaCS)) << ", " \
                            << (_x_.GetY(pampaCS) - core.GetY(pampaCS)) << ", " \
                            << (_x_.GetZ(pampaCS) - ref.GetZ(pampaCS)) << ")\n"

    cout << DUMP(core)
         << DUMP(ref)
         << DUMP(p0);

    // dense in the 1000m ring
    for (int i = 1; i < 10; ++i) {
      const int id = 99999 - i;
      const double phi = 45 * i * degree;
      const double x = 1000 * cos(phi) / cos(theta);
      const double y = 1000 * sin(phi);
      const Point& p1 = sDet.GetStation(id).GetPosition();
      cout << "dense " << id << " (" << (p1.GetX(pampaCS) - core.GetX(pampaCS) - x)/m << ", "
                                     << (p1.GetY(pampaCS) - core.GetY(pampaCS) - y)/m << ", "
                                     << (p1.GetZ(pampaCS) - ref.GetZ(pampaCS))/m << ")\n";
      CPPUNIT_ASSERT(Verify<CloseTo>(p1.GetX(pampaCS) - core.GetX(pampaCS), x, xyTol));
      CPPUNIT_ASSERT(Verify<CloseTo>(p1.GetY(pampaCS) - core.GetY(pampaCS), y, xyTol));
      CPPUNIT_ASSERT(Verify<CloseTo>(p1.GetZ(pampaCS), ref.GetZ(pampaCS), zTol));
    }
    cout << flush;
  }

};


CPPUNIT_TEST_SUITE_REGISTRATION(SDenseDetectorTestZenith);