FdEventLogger.cc

Go to the documentation of this file.

#include <utl/Reader.h>
#include <utl/ErrorLogger.h>
#include <utl/AugerUnits.h>
#include <utl/MathConstants.h>
#include <utl/PhysicalConstants.h>
#include <utl/TabulatedFunction.h>
#include <utl/TabulatedFunctionErrors.h>
#include <utl/Trace.h>
#include <utl/MultiTabulatedFunction.h>
#include <utl/Point.h>
#include <utl/UTMPoint.h>
#include <utl/TimeInterval.h>

#include <fwk/CentralConfig.h>

#include <det/Detector.h>
#include <fdet/FDetector.h>
#include <fdet/Eye.h>
#include <fdet/Channel.h>
#include <fdet/Pixel.h>

#include <evt/Event.h>
#include <evt/ShowerSimData.h>
#include <fevt/FEvent.h>
#include <fevt/Eye.h>
#include <fevt/EyeHeader.h>
#include <fevt/EyeTriggerData.h>
#include <fevt/Telescope.h>
#include <fevt/TelescopeSimData.h>
#include <fevt/TelescopeTriggerData.h>
#include <fevt/PixelSimData.h>
#include <fevt/Pixel.h>
#include <fevt/ChannelSimData.h>
#include <fevt/Channel.h>

//++++++++++++++++++++++++++++++++++++++++
// Modified by D'Urso & Valore 02/03/06
#include <evt/LaserData.h>
//++++++++++++++++++++++++++++++++++++++++ end


// ROOT Headers
#include <TTree.h>
#include <TFile.h>
#include <TDirectory.h>


#include <io/FDasToOfflineEventConverter.h>

#include "FdEventLogger.h"

#include <AugerEvent.h>

//-- FD-Event-Lib
#include <MiEvent.hh>
#include <MiEventHeader.hh>
#include <MiRun.hh>
#include <EyeEvent.hh>

#include <FdNumbering.hh>
using namespace FdUtil;


using namespace FdEventLoggerGS;
using namespace std;
using namespace utl;
using namespace evt;
using namespace fwk;
using namespace det;
using namespace fevt;
using namespace fdet;
using namespace io;



FdEventLogger::FdEventLogger() {}
FdEventLogger::~FdEventLogger() {}


VModule::ResultFlag FdEventLogger::Init() {

  INFO ("FdEventLogger::Init()");

  CentralConfig* cc = CentralConfig::GetInstance();

  Branch topB = cc->GetTopBranch("FdEventLogger");
  topB.GetChild("fileName").GetData(fFileName);


  // Begin the output ROOT
  TDirectory *const save = gDirectory;
  fRootLogFile = new TFile(fFileName.c_str(), "RECREATE");
  int comp = 1;
  fRootLogFile->SetCompressionLevel(comp);

  // Init Root Tree
  InitTree();
  save->cd();

  return eSuccess;

}// end of Init




VModule::ResultFlag FdEventLogger::Run(evt::Event& event){

  INFO("FdEventLogger::Run");

  if (!event.HasFEvent()) {
    ERROR ("Event has no FEvent.");
    return eContinueLoop;
  }

  FEvent&  fevent = event.GetFEvent();
  int eventId = fevent.GetHeader().GetId();

  bool drumCalibMode = !event.HasSimShower();

  if (drumCalibMode) {
    INFO ("Drum calibration mode!");
  }

  primary = 0;
  energy  = 0;
  XMax = 0;

  azimuth = 0;
  zenith = 0;

  XG = 0;
  YG = 0;

  laser_wavelength = 0;
  laser_polarization_angle = 0;

  if (!drumCalibMode) {

    // Shower parameters for the Output Tree
    evt::ShowerSimData& shower = event.GetSimShower();

    //++++++++++++++++++++++++++++++++++++++++
    // Modified by D'Urso & Valore 02/03/06
    bool LaserProcessing = shower.HasLaserData();
    if (LaserProcessing == true) {
      cout<<endl<<"...PROCESSING LASER EVENT..."<<endl;
      laser_wavelength = shower.GetLaserData().GetLaserWavelength();
      bool ispol = shower.GetLaserData().IsPolarized();
      if (ispol == true) {
        laser_polarization_angle = 0; //to be implemented
      } else {
        laser_polarization_angle = 0;
      }
    }
    //++++++++++++++++++++++++++++++++++++++++ end



    //++++++++++++++++++++++++++++++++++++++++
    // Modified by D'Urso & Valore 02/03/06
    if (LaserProcessing==false) { //shower
      energy  = log10(shower.GetEnergy());
      primary = shower.GetPrimaryParticle();
      const evt::VGaisserHillasParameter& GHpointer = shower.GetGHParameters();
      XMax = GHpointer.GetXMax() /(g/cm/cm);
    } else { //laser
      primary = 0;
      energy  = shower.GetEnergy()/utl::joule;
      XMax = 0;
    }
    //++++++++++++++++++++++++++++++++++++++++ end

    if (shower.HasDirection()) {
      const CoordinateSystemPtr localCS = shower.GetLocalCoordinateSystem();
      zenith = (-shower.GetDirection()).GetTheta(localCS)/degree; // converted to degree
      azimuth = (-shower.GetDirection()).GetPhi(localCS)/degree; // degree
    }

    if (shower.HasPosition()) {

      const Point& core = shower.GetPosition();
      const UTMPoint utm(core, ReferenceEllipsoid::eWGS84);
      XG = utm.GetEasting();
      YG = utm.GetNorthing();
    }
  }



  T2time = 0;
  tslot = 1;

  fTimeOffset = 0;
  fSLTWord[0] = 0;


  for (FEvent::ConstEyeIterator iEye = fevent.EyesBegin(ComponentSelector::eHasData);
       iEye != fevent.EyesEnd(ComponentSelector::eHasData);
       ++iEye) {

    int eyeId = iEye->GetId();

    fIsT3 = false;
    if (iEye->HasTriggerData()) {
      fIsT3 = iEye->GetTriggerData().IsT3Accepted();
    }

    for (fevt::Eye::ConstTelescopeIterator iTel =  iEye->TelescopesBegin(ComponentSelector::eHasData);
         iTel != iEye->TelescopesEnd(ComponentSelector::eHasData);
         ++iTel) {

      int telId = iTel->GetId();
      evtmir = 1000 * eventId + (eyeId - 1) * 6 + telId;

      if (!iTel->HasSimData()) {
        INFO("Skipping telescope with no sim data");
        continue;
      }
      const TelescopeSimData& telSim = iTel->GetSimData();
      PixOn = telSim.GetNumberOfFltPixels();
      PixOnFD = telSim.GetNumberOfFltPixelsFromShower();
      PixOnBg = telSim.GetNumberOfFltPixelsFromBackground();
      PixFromFD = telSim.GetNumberOfPixelsWithShowerPhotons();
      PixRO = telSim.GetNumberOfReadOutPixels();
      T2time = telSim.GetSltTriggerTime();
      fTimeOffset = telSim.GetSltTimeShift();
      tslot = 1;
      fIsTLT = false;
      if (iTel->HasTriggerData()) {
        fIsTLT = iTel->GetTriggerData().IsTLTAccepted();
        tslot = iTel->GetTriggerData().GetSLTData().size();
        for(int i=0; i<tslot; i++) {
          const int ncol = 20;
          for(int col=0; col<ncol; col++) {
            fSLTWord[i+ncol*col] = iTel->GetTriggerData().GetSLTData()[i].GetSLTDataWord(col+1);
          }
        }
      }


      // fill SLT tree
      fT2trig->Fill();


      for (fevt::Telescope::ConstPixelIterator iPixel = iTel->PixelsBegin(ComponentSelector::eHasData);
           iPixel != iTel->PixelsEnd(ComponentSelector::eHasData);
           ++iPixel) {

        int pixelId = iPixel->GetId();

        if (!iPixel->HasSimData()) {
          INFO("Skip pixel with no sim data");
        }
        const PixelSimData& pixelSim = iPixel->GetSimData();

        //        bool pixelTrigger = false;
        // if (iPixel->HasTriggerData()) {
        //   pixelTrigger = true;
        // } // unused

        pixel    = pixelId;
        thresh   = pixelSim.GetThreshold();
        summax   = pixelSim.GetMaxBoxcarsum();
        T1       = pixelSim.GetFltTime();
        T1_delta = pixelSim.GetFltDuration();
        mean     = pixelSim.GetMeanBoxcarsum();
        rms      = pixelSim.GetRmsBoxcarsum();
        FDSpix   = pixelSim.HasPhotonTrace(fevt::FdConstants::eTotal);


        //fill the pixel trigger tree
        fTtrig->Fill();

      } // end loop over pixels

    } // end loop over Telescopes

  } // end loop over Eyes

  return eSuccess;

}// end of RunDefault




VModule::ResultFlag FdEventLogger::Finish() {

  TDirectory* const save = gDirectory;

  INFO("Closing Analysis output Tree");
  // Close Analysis output tree
  fRootLogFile->cd();
  fTtrig->Write();
  fT2trig->Write();
  fRootLogFile->Close();

  save->cd();

  return eSuccess;

}// end of Finish



void FdEventLogger::InitTree() {

  // Analysis output tree
  TDirectory* const save = gDirectory;
  fRootLogFile->cd();

  fTtrig = new TTree("pix","FirstLevelTrigger");
  fTtrig->Branch("pixel",&pixel,"pixel/I");
  fTtrig->Branch("evtmir",&evtmir,"evtmir/I");
  fTtrig->Branch("thresh",&thresh,"thresh/I");
  fTtrig->Branch("mean",&mean,"mean/F");
  fTtrig->Branch("rms",&rms,"rms/F");
  fTtrig->Branch("summax",&summax,"summax/I");
  fTtrig->Branch("T1",&T1,"T1/I");
  fTtrig->Branch("T1_delta",&T1_delta,"T1_delta/I");
  fTtrig->Branch("FDSpix",&FDSpix,"FDSpix/b");


  fT2trig = new TTree("SLT","SecondLevelTrigger");

  fT2trig->Branch("evtmir",&evtmir,"evtmir/I");
  fT2trig->Branch("energy",&energy,"energy/D");
  fT2trig->Branch("primary",&primary,"primary/I");
  fT2trig->Branch("XMax",&XMax,"XMax/D");
  fT2trig->Branch("azimuth",&azimuth,"azimuth/D");
  fT2trig->Branch("zenith",&zenith,"zenith/D");
  fT2trig->Branch("XG",&XG,"XG/D");
  fT2trig->Branch("YG",&YG,"YG/D");
  fT2trig->Branch("PixOn",&PixOn,"PixOn/I");
  fT2trig->Branch("PixOnFD",&PixOnFD,"PixOnFD/I");
  fT2trig->Branch("PixOnBg",&PixOnBg,"PixOnBg/I");
  fT2trig->Branch("PixFromFD",&PixFromFD,"PixFromFD/I");
  fT2trig->Branch("PixRO",&PixRO,"PixRO/I");
  fT2trig->Branch("T2time",&T2time,"T2time/I");
  fT2trig->Branch("T_offset",&fTimeOffset,"T_offset/I");
  fT2trig->Branch("tslot",&tslot,"tslot/I");
  fT2trig->Branch("SLTdataword",&fSLTWord,"SLTdataword[tslot]/i");
  //++++++++++++++++++++++++++++++++++++++++
  // Modified by D'Urso & Valore 02/03/06
  fT2trig->Branch("LaserWavelength",&laser_wavelength,"LaserWavelength/D");
  fT2trig->Branch("LaserPolarizationAngle",&laser_polarization_angle,"LaserPolarizationAngle/D");
  //++++++++++++++++++++++++++++++++++++++++ end
  fT2trig->Branch("isTLT", &fIsTLT, "isTLT/I");
  fT2trig->Branch("isT3", &fIsT3, "isT3/I");

  save->cd();
}// end of InitTree


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