G4XTankPMTAction.cc

Go to the documentation of this file.

#include "G4XTankPMTAction.h"
#include "G4XTankEventAction.h"
#include "G4XTankSimulator.h"
#include "G4XTankSteppingAction.h"

#include <sevt/PMT.h>
#include <sevt/PMTSimData.h>
#include <sevt/SEvent.h>
#include <sevt/Station.h>
#include <sevt/StationSimData.h>

#include <utl/ErrorLogger.h>
#include <utl/Particle.h>
#include <utl/ParticleCases.h>
#include <utl/Trace.h>

#include <fwk/RunController.h>

#include <G4Event.hh>
#include <G4HCofThisEvent.hh>
#include <G4SDManager.hh>
#include <G4Step.hh>
#include <G4TouchableHistory.hh>
#include <G4Track.hh>
#include <G4Trajectory.hh>
#include <G4TrajectoryContainer.hh>
#include <G4VHitsCollection.hh>

#include <iostream>

using namespace std;
using namespace G4XTankSimulatorAG;
using namespace sevt;
using namespace utl;
using namespace fwk;


G4XTankPMTAction::G4XTankPMTAction(const G4String name, const int pmtIndex) :
  G4VSensitiveDetector(name),
  fPMTIndex(pmtIndex)
{
  if (fPMTIndex < 1 || fPMTIndex > 3) {
    FATAL("G4PMTAction() : invalid PMT index.");
    exit(EXIT_FAILURE);
  }

  fG4XTankSimulator =
    dynamic_cast<G4XTankSimulator*>(&RunController::GetInstance().GetModule("G4XTankSimulatorAG"));
}


G4bool
G4XTankPMTAction::ProcessHits(G4Step* theStep, G4TouchableHistory* /*R0Hist*/)
{
  const double time = theStep->GetPreStepPoint()->GetGlobalTime();

  // get current particle from G4XTankStepping action.
  // use to reject hits registered in sensitive volume
  // in case the particle is not a photon
  const int currentParticle = G4XTankSteppingAction::GetCurrentParticleId();

  // This is related to bug #156
  if (time >= 1*utl::second || currentParticle)
    return true;

  const int particle = G4XTankEventAction::GetPrimaryId();

  sevt::Station& station = *fG4XTankSimulator->GetCurrentEventStationIt();

  PMTSimData& pmtSim = station.GetPMT(fPMTIndex).GetSimData();

  sevt::StationConstants::SignalComponent component = sevt::StationConstants::eTotal;

  switch (particle) {
  case OFFLINE_PHOTON:
    component = sevt::StationConstants::ePhoton;
    if (fG4XTankSimulator->GetCurrentParticleIt()->GetSource() == Particle::eShowerFromMuonDecay) {
      if (!pmtSim.HasPETimeDistribution(sevt::StationConstants::eShowerMuonDecayPhoton))
        pmtSim.MakePETimeDistribution(sevt::StationConstants::eShowerMuonDecayPhoton);
      pmtSim.GetPETimeDistribution(sevt::StationConstants::eShowerMuonDecayPhoton).AddTime(time);
    }
    break;
  case OFFLINE_ELECTRONS:
    component = sevt::StationConstants::eElectron;
    if (fG4XTankSimulator->GetCurrentParticleIt()->GetSource() == Particle::eShowerFromMuonDecay) {
      if (!pmtSim.HasPETimeDistribution(sevt::StationConstants::eShowerMuonDecayElectron))
        pmtSim.MakePETimeDistribution(sevt::StationConstants::eShowerMuonDecayElectron);
      pmtSim.GetPETimeDistribution(sevt::StationConstants::eShowerMuonDecayElectron).AddTime(time);
    }
    break;
  case OFFLINE_MUONS:
    component = sevt::StationConstants::eMuon;
    break;
  case OFFLINE_HADRONS:
    component = sevt::StationConstants::eHadron;
    break;
  default:
    {
      ostringstream warn;
      warn << "Unknown utl::Particle type " << particle << " encountered!";
      WARNING(warn);
    }
    pmtSim.GetPETimeDistribution().AddTime(time);
    return true;
  }

  if (!pmtSim.HasPETimeDistribution())
    pmtSim.MakePETimeDistribution();
  pmtSim.GetPETimeDistribution().AddTime(time);

  if (!pmtSim.HasPETimeDistribution(component))
    pmtSim.MakePETimeDistribution(component);
  pmtSim.GetPETimeDistribution(component).AddTime(time);

  return true;
}