DeepEcalProcessFilter.cxx

#include "Biasing/DeepEcalProcessFilter.h"
 
/*~~~~~~~~~~~~*/
/*   Geant4   */
/*~~~~~~~~~~~~*/
#include "G4EventManager.hh"
#include "G4RunManager.hh"
#include "G4Step.hh"
#include "G4String.hh"
#include "G4Track.hh"
 
/*~~~~~~~~~~~~~*/
/*   SimCore   */
/*~~~~~~~~~~~~~*/
#include "SimCore/G4User/UserEventInformation.h"
#include "SimCore/G4User/UserTrackInformation.h"
#include "SimCore/G4User/VolumeChecks.h"
 
namespace biasing {
 
DeepEcalProcessFilter::DeepEcalProcessFilter(
    const std::string& name, framework::config::Parameters& parameters)
    : simcore::UserAction(name, parameters) {
  bias_threshold_ = parameters.get<double>("bias_threshold");
  processes_ = parameters.get<std::vector<std::string>>("processes");
  ecal_min_z_ = parameters.get<double>("ecal_min_Z");
  require_photon_from_target_ =
      parameters.get<bool>("require_photon_fromTarget");
}
 
void DeepEcalProcessFilter::BeginOfEventAction(const G4Event* event) {
  has_deep_ecal_process_ = false;
  photon_from_target_ = false;
}
 
void DeepEcalProcessFilter::stepping(const G4Step* step) {
  // Get the track associated with this step.
  auto track{step->GetTrack()};
 
  // Check the creation process and PDG ID of the particle
  auto process_name = track->GetCreatorProcess()
                          ? track->GetCreatorProcess()->GetProcessName()
                          : "unknown";
  auto pd_gid = track->GetParticleDefinition()->GetPDGEncoding();
 
  // Skip the steps that are for the recoil electron
  // PrimaryToEcalFilter made sure there is a fiducial e-
  if (process_name.contains("unknown")) return;
 
  // Energy of the particle is below threshold, move to next step
  if (track->GetKineticEnergy() < bias_threshold_) {
    return;
  }
 
  // Check in which volume the particle is currently
  auto phys_vol{track->GetVolume()};
  auto volume{phys_vol ? phys_vol->GetLogicalVolume() : nullptr};
  auto volume_name{volume ? volume->GetName() : "undefined"};
 
  auto track_info{simcore::UserTrackInformation::get(track)};
  // Tag the brem photon from the primary electron
  if (process_name.contains("eBrem") and (track->GetParentID() == 1)) {
    track_info->tagBremCandidate();
    getEventInfo()->incBremCandidateCount();
    track_info->setSaveFlag(true);
    if (volume_name.contains("target")) {
      photon_from_target_ = true;
    }
  }
 
  // If we require that the photon comes from the target and
  // and if it does not, let's skip the event
  if (require_photon_from_target_ and !photon_from_target_) {
    return;
  }
 
  // Tag if the event has the processes we are looking for
  bool has_process_needed{false};
  for (auto& process : processes_) {
    // ldmx_log(debug) << "Allowed processed " << process << " now we have " <<
    // processName;
    if (process_name.contains(process)) {
      has_process_needed = true;
      break;
    }
  }
  // skip this step if it does not have any of the processes needed
  if (not has_process_needed) return;
 
  auto is_in_ecal =
      simcore::g4user::volumechecks::isInEcal(volume, volume_name);
 
  // Skip this step if it does not have the processes needed
  // or if it's not in the ECAL
  if (not is_in_ecal) return;
 
  // Check the z position of the particle, and
  // flag if it is deeper than the min Z we are considering (but in ECAL)
  auto z_position = step->GetPreStepPoint()->GetPosition().z();
  // Printout for testing
  if (z_position > (0.75 * ecal_min_z_)) {
    ldmx_log(debug) << " Particle ID " << pd_gid << " with energy "
                    << track->GetKineticEnergy() << " on " << volume << " from "
                    << process_name << " at Z = " << z_position;
    if (z_position > ecal_min_z_) {
      has_deep_ecal_process_ = true;
    }
  }
  return;
}
 
void DeepEcalProcessFilter::NewStage() {
  if (has_deep_ecal_process_) {
    ldmx_log(debug) << "> Event with a hard deep conversion found, yaaay!";
    ldmx_log(debug) << "> -----------------------------------------";
  } else {
    //    ldmx_log(debug) << "> -----------------------------------------";
    G4RunManager::GetRunManager()->AbortEvent();
  }
}
}  // namespace biasing
 
DECLARE_ACTION(biasing::DeepEcalProcessFilter)