biasing::DeepEcalProcessFilter Class Reference

User action that allows a user to filter out events where the interaction happened deep in the ECAL. More...

#include <DeepEcalProcessFilter.h>

Public Member Functions
	DeepEcalProcessFilter (const std::string &name, framework::config::Parameters &parameters)
	Constructor.
virtual	~DeepEcalProcessFilter ()=default
	Destructor.
void	BeginOfEventAction (const G4Event *event) override
	Method to set flags in the beginning of the event.
void	stepping (const G4Step *step) override
	Implement the stepping action which performs the target volume biasing.
void	NewStage () override
	Method called at the end of every event.
std::vector< simcore::TYPE >	getTypes () override
	Retrieve the type of actions this class defines.
Public Member Functions inherited from simcore::UserAction
	UserAction (const std::string &name, framework::config::Parameters &parameters)
	Constructor.
	DECLARE_FACTORY (UserAction, std::shared_ptr< UserAction >, const std::string &, framework::config::Parameters &)
	factory for user actions
virtual	~UserAction ()=default
	Destructor.
virtual void	EndOfEventAction (const G4Event *)
	Method called at the end of every event.
virtual void	BeginOfRunAction (const G4Run *)
	Method called at the beginning of a run.
virtual void	EndOfRunAction (const G4Run *)
	Method called at the end of a run.
virtual void	PreUserTrackingAction (const G4Track *)
	Method called before the UserTrackingAction.
virtual void	PostUserTrackingAction (const G4Track *)
	Method called after the UserTrackingAction.
virtual G4ClassificationOfNewTrack	ClassifyNewTrack (const G4Track *, const G4ClassificationOfNewTrack &cl)
	Method called when a track is updated.
virtual void	PrepareNewEvent ()
	Method called at the beginning of a new event.

Private Attributes
double	bias_threshold_ {1500.}
	Minimal energy the products should have.
std::vector< std::string >	processes_ {"conv", "phot"}
	The allowed processes that can happen deep inside the ECAL, default is conversion (conv) and photoelectron (photo)
double	ecal_min_z_ {400.}
	Minimum Z location where the deep process should happen.
bool	require_photon_from_target_ {false}
	Require that the hard brem photon originates from the target.
bool	photon_from_target_ {false}
	member used to help tag events where the photon comes from the target
bool	has_deep_ecal_process_ {false}
	member used to help tag events that have a deep-ecal process ocurr

Additional Inherited Members
Protected Member Functions inherited from simcore::UserAction
UserEventInformation *	getEventInfo () const
	Get a handle to the event information.
const std::map< int, ldmx::SimParticle > &	getCurrentParticleMap () const
	Get the current particle map.
Protected Attributes inherited from simcore::UserAction
std::string	name_ {""}
	Name of the UserAction.
framework::config::Parameters	parameters_
	The set of parameters used to configure this class.
mutable::framework::logging::logger	the_log_
	the logging channel user actions can use ldmx_log with

Detailed Description

User action that allows a user to filter out events where the interaction happened deep in the ECAL.

Definition at line 35 of file DeepEcalProcessFilter.h.

Constructor & Destructor Documentation

DeepEcalProcessFilter()

DeepEcalProcessFilter::DeepEcalProcessFilter	(	const std::string &	name,
		framework::config::Parameters &	parameters )

Constructor.

Definition at line 21 of file DeepEcalProcessFilter.cxx.

    : 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");
}

References bias_threshold_, ecal_min_z_, framework::config::Parameters::get(), processes_, and require_photon_from_target_.

Member Function Documentation

BeginOfEventAction()

void DeepEcalProcessFilter::BeginOfEventAction ( const G4Event * event )

overridevirtual

Method to set flags in the beginning of the event.

Reimplemented from simcore::UserAction.

Definition at line 31 of file DeepEcalProcessFilter.cxx.

                                                                   {
  has_deep_ecal_process_ = false;
  photon_from_target_ = false;
}

References has_deep_ecal_process_, and photon_from_target_.

getTypes()

std::vector< simcore::TYPE > biasing::DeepEcalProcessFilter::getTypes ( )

inlineoverridevirtual

Retrieve the type of actions this class defines.

Implements simcore::UserAction.

Definition at line 62 of file DeepEcalProcessFilter.h.

                                             {
    return {simcore::TYPE::STACKING, simcore::TYPE::STEPPING,
            simcore::TYPE::EVENT};
  }

NewStage()

void DeepEcalProcessFilter::NewStage ( )

overridevirtual

Method called at the end of every event.

Parameters

event

Geant4 event object.

Reimplemented from simcore::UserAction.

Definition at line 112 of file DeepEcalProcessFilter.cxx.

                                     {
  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();
  }
}

References has_deep_ecal_process_.

stepping()

void DeepEcalProcessFilter::stepping ( const G4Step * step )

overridevirtual

Implement the stepping action which performs the target volume biasing.

Parameters

step	The Geant4 step.

Reimplemented from simcore::UserAction.

Definition at line 36 of file DeepEcalProcessFilter.cxx.

                                                       {
  // 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;
}

References bias_threshold_, ecal_min_z_, simcore::UserTrackInformation::get(), simcore::UserAction::getEventInfo(), has_deep_ecal_process_, simcore::UserEventInformation::incBremCandidateCount(), photon_from_target_, processes_, and require_photon_from_target_.

Member Data Documentation

bias_threshold_

double biasing::DeepEcalProcessFilter::bias_threshold_ {1500.}

private

Minimal energy the products should have.

Definition at line 69 of file DeepEcalProcessFilter.h.

{1500.};

Referenced by DeepEcalProcessFilter(), and stepping().

ecal_min_z_

double biasing::DeepEcalProcessFilter::ecal_min_z_ {400.}

private

Minimum Z location where the deep process should happen.

Definition at line 74 of file DeepEcalProcessFilter.h.

{400.};

Referenced by DeepEcalProcessFilter(), and stepping().

has_deep_ecal_process_

bool biasing::DeepEcalProcessFilter::has_deep_ecal_process_ {false}

private

member used to help tag events that have a deep-ecal process ocurr

Definition at line 80 of file DeepEcalProcessFilter.h.

{false};

Referenced by BeginOfEventAction(), NewStage(), and stepping().

photon_from_target_

bool biasing::DeepEcalProcessFilter::photon_from_target_ {false}

private

member used to help tag events where the photon comes from the target

Definition at line 78 of file DeepEcalProcessFilter.h.

{false};

Referenced by BeginOfEventAction(), and stepping().

processes_

std::vector<std::string> biasing::DeepEcalProcessFilter::processes_ {"conv", "phot"}

private

The allowed processes that can happen deep inside the ECAL, default is conversion (conv) and photoelectron (photo)

Definition at line 72 of file DeepEcalProcessFilter.h.

{"conv", "phot"};

Referenced by DeepEcalProcessFilter(), and stepping().

require_photon_from_target_

bool biasing::DeepEcalProcessFilter::require_photon_from_target_ {false}

private

Require that the hard brem photon originates from the target.

Definition at line 76 of file DeepEcalProcessFilter.h.

{false};

Referenced by DeepEcalProcessFilter(), and stepping().

---

The documentation for this class was generated from the following files:

• Biasing/include/Biasing/DeepEcalProcessFilter.h
• Biasing/src/Biasing/DeepEcalProcessFilter.cxx