FdEventSelector.cc

Go to the documentation of this file.

#include "FdEventSelector.h"
#include <utl/ErrorLogger.h>

#include <det/Detector.h>

#include <fdet/Pixel.h>
#include <fdet/Channel.h>

#include <utl/TimeStamp.h>
#include <utl/Reader.h>
#include <utl/TabulatedFunctionErrors.h>

#include <evt/Event.h>
#include <evt/ShowerRecData.h>
#include <evt/ShowerFRecData.h>

#include <fevt/FEvent.h>
#include <fevt/Header.h>
#include <fevt/Eye.h>
#include <fevt/Telescope.h>
#include <fevt/EyeHeader.h>
#include <fevt/EyeRecData.h>
#include <fevt/Pixel.h>
#include <fevt/PixelRecData.h>

#include <fwk/CentralConfig.h>

#include <AugerEvent.h>

// FDEvent stuff

#include "EyeEventHeader.hh"
#include <EyePixelData.hh>
#include <EyePixelList.hh>
#include <FdNumbering.hh>
#include <MiEvent.hh>
#include <EyeEvent.hh>
#include <FdNumbering.hh>
#include <TTimeStamp.hh>

// SD stuff

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


using namespace FdUtil;
using namespace det;
using namespace evt;
using namespace fevt;
using namespace std;
using namespace utl;
using namespace fwk;
using namespace sevt;

using namespace FdEventSelectorKG;


FdEventSelector::FdEventSelector() {}
FdEventSelector::~FdEventSelector() {}

VModule::ResultFlag
FdEventSelector::Init()
{
  // get data cards
  Branch topB =
    CentralConfig::GetInstance()->GetTopBranch ("FdEventSelector");

  if (!topB) {
    ERROR ("Could not find branch FdEventSelector");
    return eFailure;
  }

  topB.GetChild("verbosity").GetData(fVerbosity);
  topB.GetChild("minEyes").GetData(fMinEyes);
  topB.GetChild("minTOTs").GetData(fMinTOTs);
  topB.GetChild("minimumTrigPix").GetData(fMinFdTrigPix);
  topB.GetChild("maximumTrigPix").GetData(fMaxFdTrigPix);

  for (Branch cB = topB.GetFirstChild(); cB; cB = cB.GetNextSibling()) {
    if (cB.GetName() == "deselectLaser") {
      double mean=0, width=0;
      cB.GetChild("mean").GetData(mean);
      cB.GetChild("width").GetData(width);
      fDeselectLaser.push_back(deselectLaser(mean, width));
    }
    else if (cB.GetName() == "selectFdId") {
      int run=0, event=0;
      cB.GetChild("run").GetData(run);
      cB.GetChild("event").GetData(event);
      fSelectFdId.push_back(selectFdId(run, event));
    }
    else if (cB.GetName() == "deselectEye") {
      unsigned int eyeId = 0;
      cB.GetChild("eyeId").GetData(eyeId);
      fDeselectEyes.insert(eyeId);
    }
  }

  // info output
  ostringstream info;
  info << " Version: "
       << GetVersionInfo(VModule::eRevisionNumber) << "\n";
  if (fVerbosity >= 0) {
    info << " Parameters:\n"
            "       minimumTrigPix: " << fMinFdTrigPix << "\n"
            "       maximumTrigPix: " << fMaxFdTrigPix << "\n"
            "              minEyes: " << fMinEyes << "\n"
            "              minTOTs: " << fMinTOTs << "\n";
    for(vector<deselectLaser>::const_iterator i=fDeselectLaser.begin();
        i!=fDeselectLaser.end(); ++i) {
      info << "        deselectLaser: mean=" << int(i->mean) << "ns, width=" << int(i->width) << "ns \n";
    }
    for(vector<selectFdId>::const_iterator i=fSelectFdId.begin();
        i!=fSelectFdId.end(); ++i) {
      info << "  pick event by Fd Id: run=" << int(i->run) << ", event=" << int(i->event) << "\n";
    }
    info << "      deselected eyes:";
    if (fDeselectEyes.empty())
      info << " (none)\n";
    else {
      for (set<unsigned int>::const_iterator i = fDeselectEyes.begin();
           i != fDeselectEyes.end(); ++i)
        info << " " << *i;
      info << "\n";
    }
  }
  INFO(info);

  return eSuccess;
}


VModule::ResultFlag
FdEventSelector::Run (Event& event)
{
  if(!event.HasFEvent())  return eContinueLoop;

  int nGood=0;
  const fevt::FEvent& fevent = event.GetFEvent();

  int countEyes = 0;

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

    countEyes++;

    const unsigned int EyeId = iEye->GetId();
    int nTrigPix=0;

    // check ioAuger:
    if (!event.HasRawEvent()) {
      if (fVerbosity>-1) INFO(" no raw FD event - skipping ...");
      return eContinueLoop;
    }


    // check TEyeEvent
    AugerEvent::EyeIterator iRawEye;
    for (iRawEye = event.GetRawEvent().EyesBegin();
         iRawEye != event.GetRawEvent().EyesEnd();
         iRawEye++) {

      if (EyeId == iRawEye->GetEventHeader()->GetEyeNo()) {
        break;
      }
    }


    if (iRawEye == event.GetRawEvent().EyesEnd()) {
      if (fVerbosity>-1) INFO(" raw EyeEvent not found - skipping ...");
      return eContinueLoop;
    }

    TEyeEventHeader* fdEyeEventHeader = iRawEye->GetEventHeader();
    int RunNo = fdEyeEventHeader->GetRunNo();
    int EventNo = fdEyeEventHeader->GetEventNo();
    int EyeID = fdEyeEventHeader->GetEyeNo();

    if (fVerbosity > -1) {
      ostringstream info;
      info << " eye " << EyeID
           << " run " << RunNo
           << " event " << EventNo;
      INFO(info);
    }

    if (fDeselectEyes.find(EyeId) != fDeselectEyes.end()) {
      if (fVerbosity > -1)
        INFO("found deselected eye - skipping...");
      continue;
    }

    if (fSelectFdId.size() > 0) {
      bool found = false;
      for(vector<selectFdId>::const_iterator i=fSelectFdId.begin();
          i!=fSelectFdId.end(); ++i) {
        if (RunNo==i->run && EventNo==i->event) {
          found = true;
        }
      }
      if (!found) {
        INFO("Event not selected. Skipping.");
        continue;
        //return eContinueLoop;
      }
    }

    // check pixel data
    TEyePixelList* eye_pixel_list = iRawEye->GetPixelList();
    TEyePixelData* eye_pixel_data = iRawEye->GetPixelData();
    TMirrorPixelData * mipixeldata = 0;

    UInt_t NumPix = eye_pixel_list->GetNumPixels();
    int last_miID = -1;

    for (UInt_t i = 0; i < NumPix; i++) {

      Fd::FdPixelNumber fdpixel = eye_pixel_list->GetPixel (i);
      UInt_t pixel_no = Fd::GetMirrorPixelNo (fdpixel);
      Bool_t isv = (pixel_no >= 441);

      if (!isv) {         // discard virtual pixels
        int miID = Fd::GetEyeMirrorNo (fdpixel);
        if (last_miID!=miID){
          mipixeldata = eye_pixel_data->GetPixelData (miID);
          last_miID = miID;
        }

        int firsttrigd = mipixeldata-> GetFirstTriggeredTimeBin (fdpixel);
        if (firsttrigd>-1) {
          nTrigPix++;
        }
      }
    }

    if (fVerbosity>-1) {
      ostringstream info;
      info << " number of triggered pixels: " << nTrigPix;
      INFO(info);
    }

    if (nTrigPix<fMinFdTrigPix) continue;
    if (nTrigPix>fMaxFdTrigPix) {
      if (fVerbosity>-1) {
        ostringstream info;
        info << " skipping too large event : nPix= " << nTrigPix;
        INFO(info);
      }
      return eContinueLoop; // break event for stereo if one event is too large
    }


    if (fDeselectLaser.size()>0) {
      const FdRoot::TTimeStamp * timeStamp = fdEyeEventHeader->GetTimeStamp();
      unsigned int NanoTime = timeStamp->GetNanoSec();
      for(vector<deselectLaser>::const_iterator i=fDeselectLaser.begin();
          i!=fDeselectLaser.end(); ++i) {
        if (std::fabs(i->mean-NanoTime) < i->width) {
          if (fVerbosity>-1) {
            ostringstream info;
            info << " laser check: " << NanoTime << " " << i->mean
                 << " " <<  i->width;
            INFO(info);
          }
          continue;
        }
      }
    }
    nGood++;
  }

  if (countEyes<fMinEyes) {
    if (fVerbosity>-1) INFO(" not enough eyes in event - skipping ");
    return eContinueLoop;
  }

  // search for TOTs

  int nTOT=0;
  if ( nGood > 0 && fMinTOTs > 0 ) {
    if (event.HasSEvent()) {
      const sevt::SEvent& sevent = event.GetSEvent();
      SEvent::ConstStationIterator sditer;
      for(sditer=sevent.StationsBegin(); sditer != sevent.StationsEnd(); ++sditer) {
        if (sditer->HasTriggerData()) {
          const sevt::StationTriggerData& trigStation = sditer->GetTriggerData();
          if (trigStation.IsTimeOverThreshold())
            nTOT++;
        }
      }
    } // has sevent

    if (fVerbosity>-1) {
      ostringstream info;
      info << " number of TOT stations: " << nTOT;
      INFO(info);
    }
  }

  if(nGood>0 && nTOT>=fMinTOTs) {
    return eSuccess;
  } else {
    if (fVerbosity>-1) INFO(" skipping event ...");
    return eContinueLoop;
  }
}


VModule::ResultFlag
FdEventSelector::Finish()
{
  return eSuccess;
}