CEvent/Station.cc

Go to the documentation of this file.

#include <cevt/Station.h>

#include <cevt/CEvent.h>
#include <cevt/Pad.h>
#include <cevt/StationSimData.h>
#include <cevt/StationRecData.h>
// #include <cevt/StationTriggerData.h>
// #include <cevt/StationCalibData.h>
// #include <cevt/StationGPSData.h>
#include <det/Detector.h>
#include <sdet/Station.h>

#include <utl/Particle.h>
#include <utl/ErrorLogger.h>
#include <utl/AugerException.h>
#include <cstddef>
#include <iostream>

using namespace std;
using namespace utl;
using namespace det;
using namespace cevt;


// move to static map which is created on first request
//
const string Station::fgSourceNameLookup[eLastSource + 1] = {
  "Total (shower + bkgnd)",
  "e+, e-",
  "photons",
  "mu+, mu- (shower)",
  "hadrons  (shower)",
  "decay electron",
  "delta ray",
  "e+,e- from shower e+,e-",
  "e+,e- from shower muon",
  "e+,e- from shower photon",
  "e+,e- from other source",
  "photon from shower e+,e-",
  "photon from shower muon",
  "photon from shower photon",
  "photon from other source",
  "e+, e- (bkgnd)",
  "photons (bkgnd)",
  "mu+, mu- (bkgnd)",
  "hadrons (bkgnd)",
  "other neutrals (neutrino,pi0)",
  "photon from muon decay in shower",
  "electron from muon decay in shower", // 22
  "","","","","","","", // 29
  "","","","","","","","","","", // 39
  "","","","","","","","","","", //49
  "User-defined source 0",
  "User-defined source 1",
  "User-defined source 2",
  "User-defined source 3",
  "User-defined source 4",
  "User-defined source 5",
  "User-defined source 6",
  "User-defined source 7",
  "User-defined source 8",
  "User-defined source 9"
};


string
Station::GetSignalComponentName(const Station::SignalComponent sc)
{
  return fgSourceNameLookup[sc];
}

#define PHOTON utl::Particle::ePhoton
#define ELECTRONS utl::Particle::eElectron: \
  case utl::Particle::ePositron
#define MUONS utl::Particle::eMuon: \
  case utl::Particle::eAntiMuon
#define HADRONS utl::Particle::eProton: \
  case utl::Particle::eAntiProton: \
  case utl::Particle::eNeutron: \
  case utl::Particle::eAntiNeutron: \
  case utl::Particle::ePiPlus: \
  case utl::Particle::ePiMinus: \
  case utl::Particle::eEta: \
  case utl::Particle::eKaon0L: \
  case utl::Particle::eKaon0S: \
  case utl::Particle::eKaonPlus: \
  case utl::Particle::eKaonMinus: \
  case utl::Particle::eLambda: \
  case utl::Particle::eAntiLambda: \
  case utl::Particle::eLambdac
#define NEUTRALS utl::Particle::eNuElectron: \
  case utl::Particle::eAntiNuElectron: \
  case utl::Particle::eNuMuon: \
  case utl::Particle::eAntiNuMuon: \
  case utl::Particle::eNuTau: \
  case utl::Particle::eAntiNuTau: \
  case utl::Particle::ePiZero: \
  case utl::Particle::eRhoZero

cevt::Station::SignalComponent
Station::GetSignalComponent(const utl::Particle& particle)
{
  switch (particle.GetType()) {
  case ELECTRONS:
    if (!particle.HasParent()) { // shower electrons arriving at RPC
      if (particle.GetSource() == Particle::eShower)
        return cevt::Station::eElectronFromShowerElectron;
      else if (particle.GetSource() == Particle::eShowerFromMuonDecay)
        return cevt::Station::eShowerMuonDecayElectron;
      else
        return cevt::Station::eBackgroundElectron;
    }
    else { // secondary electrons at RPC
      if (particle.GetParent().GetType() ==  Particle::eMuon || 
          particle.GetParent().GetType() ==  Particle::eAntiMuon) {
        return cevt::Station::eElectronFromShowerMuon;
      }
      else if (particle.GetParent().GetType() ==  Particle::eElectron || 
               particle.GetParent().GetType() ==  Particle::ePositron) {
        
        if (particle.GetParent().GetSource() == Particle::eShower)
          return cevt::Station::eElectronFromShowerElectron;
        else if (particle.GetParent().GetSource() == Particle::eShowerFromMuonDecay)
          return cevt::Station::eShowerMuonDecayElectron;
        else
          return cevt::Station::eBackgroundElectron;
      }
      else if (particle.GetParent().GetType() ==  Particle::ePhoton) {
        if (particle.GetParent().GetSource() == Particle::eShower)
          return cevt::Station::eElectronFromShowerPhoton;
        else if (particle.GetParent().GetSource() == Particle::eShowerFromMuonDecay)
          return cevt::Station::eShowerMuonDecayPhoton;
        else
          return cevt::Station::eBackgroundPhoton;
      }
      else
        return cevt::Station::eElectronFromOtherSource;
    }
  case PHOTON:
    if (!particle.HasParent()) { // shower photons arriving at RPC
      if (particle.GetSource() == Particle::eShower)
        return cevt::Station::ePhotonFromShowerPhoton;
      else if (particle.GetSource() == Particle::eShowerFromMuonDecay)
        return cevt::Station::eShowerMuonDecayPhoton;
      else
        return cevt::Station::eBackgroundPhoton;
    }
    else {   // secondary photons at RPC
      if (particle.GetParent().GetType() ==  Particle::eMuon || 
          particle.GetParent().GetType() ==  Particle::eAntiMuon) {
        return cevt::Station::ePhotonFromShowerMuon;
      }
      else if (particle.GetParent().GetType() ==  Particle::eElectron || 
               particle.GetParent().GetType() ==  Particle::ePositron) {
        if (particle.GetParent().GetSource() == Particle::eShower)
          return cevt::Station::ePhotonFromShowerElectron;
        else if (particle.GetParent().GetSource() == Particle::eShowerFromMuonDecay)
          return cevt::Station::eShowerMuonDecayElectron;
        else
          return cevt::Station::eBackgroundElectron;
      }
      else if (particle.GetParent().GetType() ==  Particle::ePhoton) {
        if (particle.GetParent().GetSource() == Particle::eShower)
          return cevt::Station::ePhotonFromShowerPhoton;
        else if (particle.GetParent().GetSource() == Particle::eShowerFromMuonDecay)
          return cevt::Station::eShowerMuonDecayPhoton;
        else
          return cevt::Station::eBackgroundPhoton;
      }
      else
        return cevt::Station::ePhotonFromOtherSource;
    }
  case MUONS:
    return cevt::Station::eMuon;
  case HADRONS:
    return cevt::Station::eHadron;
  case NEUTRALS:
    return cevt::Station::eOtherNeutrals;
  default:
    ERROR("Illegal Component in Station::GetSignalComponent; unknown particle !");
    return cevt::Station::eLastSource;
  }
}


Station::Station(const int id) :
  fId(id),
  fReconstructionStatus(eCandidate),
  fRejectionStatus(eNoRejection)
{
}


Station::Station(const Station& station) :
  fId(station.fId),
  // fPads below
  fSimData(station.fSimData),
  fRecData(station.fRecData),
//   fCalibData(station.fCalibData),
//   fTriggerData(station.fTriggerData),
//   fGPSData(station.fGPSData),
  fHitsStartTime(station.fHitsStartTime),
  fHits(station.fHits),
  fReconstructionStatus(station.fReconstructionStatus),
  fRejectionStatus(station.fRejectionStatus)
{
  for (InternalConstPadIterator padIt = station.fPads.begin();
       padIt != station.fPads.end(); ++padIt)
    fPads.push_back(new Pad(**padIt));
}


Station::~Station()
{
  for (InternalPadIterator padIt = fPads.begin();
       padIt != fPads.end(); ++padIt)
    delete *padIt;
} 


Station&
Station::operator=(const Station& station)
{
  if (this != &station) {

    fId = station.fId;

    for (InternalPadIterator padIt = fPads.begin();
         padIt != fPads.end(); ++padIt)
      delete *padIt;

    fPads.clear();

    for (ConstPadIterator padIt = station.PadsBegin();
         padIt != station.PadsEnd(); ++padIt)
      fPads.push_back(new Pad(*padIt));

    fSimData = station.fSimData;
    fRecData = station.fRecData;
//     fCalibData = station.fCalibData;
//     fTriggerData = station.fTriggerData;
//     fGPSData = station.fGPSData;
    fHitsStartTime = station.fHitsStartTime;
    fHits = station.fHits;
    fReconstructionStatus = station.fReconstructionStatus;
    fRejectionStatus = station.fRejectionStatus;
  }

  return *this;
}


bool
Station::HasPad(const unsigned int padId)
  const
{
  for (InternalConstPadIterator padIt = fPads.begin();
       padIt != fPads.end(); ++padIt) 
    if ((*padIt)->GetId() == padId) 
      return true;
  
  
  return false;
  
}


Pad&
Station::GetPad(const unsigned int padId)
{
  for (InternalPadIterator padIt = fPads.begin(); 
       padIt != fPads.end(); ++padIt) 
    if ((*padIt)->GetId() == padId) 
      return **padIt;
  
  std::ostringstream err;
  err << "Invalid Pad id " << padId;
  ERROR(err);
  throw (utl::NonExistentComponentException(err.str()));
}


const Pad&
Station::GetPad(const unsigned int padId)
  const
{
  for (InternalConstPadIterator padIt = fPads.begin();
       padIt != fPads.end(); ++padIt) 
    if ((*padIt)->GetId() == padId) 
      return **padIt; 

  std::ostringstream err;
  err << "Invalid Pad id " << padId;
  ERROR(err);
  throw (utl::NonExistentComponentException(err.str()));
}


void
Station::MakePad(const unsigned int padId)
{
  if (HasPad(padId)) {
    std::ostringstream err;
    err << "Pad id " << padId << " already exists - Not replacing !";
    ERROR(err);
    
  }
  else
    fPads.push_back(new Pad(fId, padId));
}


void
Station::MakeSimData()
{
  if (fSimData) {
    ERROR("SimData already exists - Not Replacing");
  }
  else
    fSimData = new StationSimData;
}


void
Station::MakeRecData()
{
  if (fRecData) {
    ERROR("Rec Data already exists - Not Replacing");
  }
  else
    fRecData = new StationRecData;
}


// void
// Station::MakeTriggerData()
// {
//   if (fTriggerData) {
//     ERROR("Trigger Data already exists - Not Replacing");
//   }
//   else
//     fTriggerData = new StationTriggerData;
// }


// void
// Station::MakeCalibData()
// {
//   if (fCalibData) {
//     ERROR("Calib Data already exists - Not Replacing");
//   }
//   else
//     fCalibData = new StationCalibData;
// }


// void
// Station::MakeGPSData()
// {
//   if (fGPSData) {
//     ERROR("GPS Data already exists - Not Replacing");
//   }
//   else
//     fGPSData = new StationGPSData;
// }


void
Station::MakeHits(const SignalComponent source)
{
 fHits->AddTimeDistribution(1*ns, source);
}


unsigned int Station::GetTotalHits(const SignalComponent source) const
{
  if (fHits->HasLabel(source)) {
    const TimeDistributionI& hits = fHits->GetTimeDistribution(source); 
    return static_cast<unsigned int>(TimeDistributionAlgorithm::Sum(hits,hits.GetStart(),hits.GetStop()));
  }
  else 
    return 0;
}



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