testArtificialShowerFile.cc

Go to the documentation of this file.

#include <io/ArtificialShowerFile.h>
#include <evt/Event.h>
#include <evt/ShowerSimData.h>
#include <utl/AugerException.h>

#include <string>
#include <fstream>
#include <iostream>

#include <io/IoCodes.h>
#include <evt/Event.h>
#include <evt/ShowerSimData.h>
#include <utl/AugerUnits.h>
#include <utl/Particle.h>
#include <utl/ShowerParticleIterator.h>
#include <fwk/CentralConfig.h>
#include <det/Detector.h>

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

#include <iostream>
#include <string>

using namespace fwk;
using namespace evt;
using namespace io;
using namespace utl;
using namespace std;
using namespace tst;
using tst::Expected;


class testArtificialShowerFile : public CppUnit::TestFixture {

private:
  CPPUNIT_TEST_SUITE(testArtificialShowerFile);
  CPPUNIT_TEST(testConstruct);
  CPPUNIT_TEST_EXCEPTION(testConstructException, utl::IOFailureException);
  CPPUNIT_TEST(testOpen);
  CPPUNIT_TEST_EXCEPTION(testOpenOpen, utl::IOFailureException);
  CPPUNIT_TEST_EXCEPTION(testOpenForWrite, utl::IOFailureException);
  CPPUNIT_TEST(testClose);
  CPPUNIT_TEST(testCloseClose);
  CPPUNIT_TEST_EXCEPTION(testWrite, utl::IOFailureException);
  CPPUNIT_TEST(testFindEvent);
  CPPUNIT_TEST(testGotoPosition);
  CPPUNIT_TEST(testGetNEvents);
  CPPUNIT_TEST(testRead);
  CPPUNIT_TEST(testParticleRead);
  CPPUNIT_TEST_EXCEPTION(testGetNEventsClosedException,
                         utl::IOFailureException);
  CPPUNIT_TEST_SUITE_END();

public:
  // shared data for tests

  ArtificialShowerFile* f;
  evt::Event event;

  void
  setUp()
  {
    CentralConfig::GetInstance(BOOTSTRAPFILE);
    f = new ArtificialShowerFile();
    event = evt::Event();
  }

  void
  tearDown()
  {
    delete f;
    f = 0;
  }

  void
  testConstruct()
  {
    ArtificialShowerFile* file;
    CPPUNIT_ASSERT(file = new ArtificialShowerFile("BLAHBLAH"));
    delete file;
  }

  void
  testConstructException()
  {
    Expected();
    ArtificialShowerFile ftest("BLAHBLAH",io::eWrite);
  }

  void testOpen()
  { f->Open("BLAHBLAH"); }


  void
  testOpenOpen()
  {
    f->Open("BLAHBLAH");
    Expected();
    f->Open("BLAHBLAH");
  }

  void
  testOpenForWrite()
  {
    Expected();
    f->Open("BLAHBLAH", io::eWrite);
  }

  void testClose()
  { f->Close(); }

  void
  testCloseClose()
  {
    f->Close();
    Expected();
    f->Close();
  }

  void
  testFindEvent()
  {
    f->Open("BLAH");
    CPPUNIT_ASSERT(Verify<Not<Equal> >(f->FindEvent(1), io::eFail));
    CPPUNIT_ASSERT(Verify<Equal>(f->FindEvent(0), io::eFail));
  }

  void
  testGotoPosition()
  {
    f->Open("BLAH");
    CPPUNIT_ASSERT(Verify<Not<Equal> >(f->GotoPosition(0), io::eFail));
  }

  void
  testWrite()
  {
    f->Open("BLAH");
    Expected();
    f->Write(event);
  }

  void
  testGetNEvents()
  {
    f->Open("BLAH");
    CPPUNIT_ASSERT(Verify<Equal>(f->GetNEvents(), 1));
  }

  void
  testGetNEventsClosedException()
  {
    Expected();
    f->GetNEvents();
  }

  void
  testRead()
  {
    f->Open("BLAH");
    int nEventsInFile = f->GetNEvents();
    int nEventsSeen = 0;
    while (f->Read(event) != io::eEOF) {
      ++nEventsSeen;

      evt::ShowerSimData& shower = event.GetSimShower();

      const CoordinateSystemPtr refCS = det::Detector::GetInstance().GetReferenceCoordinateSystem();
      shower.MakeGeometry(utl::Point(0,0,0,refCS));
      
      CPPUNIT_ASSERT(Verify<Equal>(shower.GetPrimaryParticle(),
                                 int(Particle::eProton)));
      CPPUNIT_ASSERT(Verify<CloseTo>(shower.GetEnergy(), 1e19*eV));

      const utl::CoordinateSystemPtr localCS = shower.GetLocalCoordinateSystem();
      const double zenith = (-shower.GetDirection()).GetTheta(localCS);
      const double azimuth = (-shower.GetDirection()).GetPhi(localCS); 

      CPPUNIT_ASSERT(Verify<CloseTo>(zenith, 45.0*deg));
      CPPUNIT_ASSERT(Verify<CloseTo>(azimuth, 0.0*deg));
      CPPUNIT_ASSERT(Verify<Equal>(shower.GetShowerNumber(),
                                 nEventsSeen));
      CPPUNIT_ASSERT(Verify<Equal>(shower.GetShowerRunId(), std::string("1")));
    }
    CPPUNIT_ASSERT(Verify<Equal>(nEventsInFile, nEventsSeen));
  }

  void
  testParticleRead()
  {
    f->Open("irrelevant.com");
    for (int i = 0; i < f->GetNEvents(); ++i) {
      event = evt::Event();  // clear event until readers do it.
      f->Read(event);
      evt::ShowerSimData& shower = event.GetSimShower();

      shower.MakeGeometry(
        Point(0,0,0, det::Detector::GetInstance().GetSiteCoordinateSystem())
      );

      long double nParticles = 0;
      for (ShowerParticleIterator p = shower.GroundParticlesBegin();
           p != shower.GroundParticlesEnd(); ++p) {
        nParticles += p->GetWeight();
      }
      CPPUNIT_ASSERT(Verify<Greater>(nParticles, 8e7L));
      CPPUNIT_ASSERT(Verify<Less>(nParticles, 9e7L));
    }
  }
};


CPPUNIT_TEST_SUITE_REGISTRATION(testArtificialShowerFile);


// Configure (x)emacs for this file ...
// Local Variables:
// mode: c++
// compile-command: "make -C .. -k testCorsika && (cd ..; testCorsika)"
// End: