ALFA_SensitiveDetector Class Reference

#include <ALFA_SensitiveDetector.h>

Inheritance diagram for ALFA_SensitiveDetector:

Collaboration diagram for ALFA_SensitiveDetector:

Public Member Functions
	ALFA_SensitiveDetector (const std::string &name, const std::string &hitCollectionName, const std::string &ODhitCollectionName)
	~ALFA_SensitiveDetector ()
void	Initialize (G4HCofThisEvent *) override final
void	StartOfAthenaEvent ()
G4bool	ProcessHits (G4Step *, G4TouchableHistory *) override final
void	EndOfAthenaEvent ()

Private Member Functions
	FRIEND_TEST (ALFA_SensitiveDetectortest, Initialize)
	FRIEND_TEST (ALFA_SensitiveDetectortest, ProcessHits1)
	FRIEND_TEST (ALFA_SensitiveDetectortest, ProcessHits2)
	FRIEND_TEST (ALFA_SensitiveDetectortest, ProcessHits3)
	FRIEND_TEST (ALFA_SensitiveDetectortest, StartOfAthenaEvent)
	FRIEND_TEST (ALFA_SensitiveDetectortest, EndOfAthenaEvent)

Private Attributes
int	m_hitID {}
	Templated method to stuff a single hit into the sensitive detector class. More...
int	m_eventNumber {}
int	m_numberOfHits {}
int	m_numberOfODHits {}
SG::WriteHandle< ALFA_HitCollection >	m_HitCollection
SG::WriteHandle< ALFA_ODHitCollection >	m_ODHitCollection
int	m_pos1 {}
int	m_pos2 {}
int	m_num [3] {}

Detailed Description

Definition at line 23 of file ALFA_SensitiveDetector.h.

Constructor & Destructor Documentation

ALFA_SensitiveDetector()

ALFA_SensitiveDetector::ALFA_SensitiveDetector	(	const std::string &	name,
		const std::string &	hitCollectionName,
		const std::string &	ODhitCollectionName
	)

Definition at line 23 of file ALFA_SensitiveDetector.cxx.

  : G4VSensitiveDetector( name ),
    m_HitCollection(hitCollectionName),
    m_ODHitCollection(ODhitCollectionName)
{
 
  m_hitID = -1;
 
  m_eventNumber = 0;
  m_numberOfHits = 0;
  m_numberOfODHits = 0;
 
  m_pos1 = 0;
  m_pos2 = 0;
 
  m_num[0] = 0;
  m_num[1] = 0;
  m_num[2] = 0;
 
}

~ALFA_SensitiveDetector()

ALFA_SensitiveDetector::~ALFA_SensitiveDetector ( )

inline

Definition at line 36 of file ALFA_SensitiveDetector.h.

{}

Member Function Documentation

EndOfAthenaEvent()

void ALFA_SensitiveDetector::EndOfAthenaEvent

(

)

Definition at line 259 of file ALFA_SensitiveDetector.cxx.

{
  G4cout << " Total number of hits in MD: " << m_numberOfHits << G4endl;
  G4cout << " Total number of hits in OD: " << m_numberOfODHits << G4endl;
  G4cout << "*************************************************************" << G4endl;
 
  ++m_eventNumber;
 
  m_numberOfHits = 0;
  m_numberOfODHits = 0;
}

FRIEND_TEST() [1/6]

ALFA_SensitiveDetector::FRIEND_TEST ( ALFA_SensitiveDetectortest  , EndOfAthenaEvent    )

private

FRIEND_TEST() [2/6]

ALFA_SensitiveDetector::FRIEND_TEST ( ALFA_SensitiveDetectortest  , Initialize    )

private

FRIEND_TEST() [3/6]

ALFA_SensitiveDetector::FRIEND_TEST ( ALFA_SensitiveDetectortest  , ProcessHits1    )

private

FRIEND_TEST() [4/6]

ALFA_SensitiveDetector::FRIEND_TEST ( ALFA_SensitiveDetectortest  , ProcessHits2    )

private

FRIEND_TEST() [5/6]

ALFA_SensitiveDetector::FRIEND_TEST ( ALFA_SensitiveDetectortest  , ProcessHits3    )

private

FRIEND_TEST() [6/6]

ALFA_SensitiveDetector::FRIEND_TEST ( ALFA_SensitiveDetectortest  , StartOfAthenaEvent    )

private

Initialize()

void ALFA_SensitiveDetector::Initialize ( G4HCofThisEvent *  )

finaloverride

Definition at line 51 of file ALFA_SensitiveDetector.cxx.

{
  if (!m_HitCollection.isValid()) m_HitCollection = std::make_unique<ALFA_HitCollection>(m_HitCollection.name());
  if (!m_ODHitCollection.isValid()) m_ODHitCollection = std::make_unique<ALFA_ODHitCollection>(m_ODHitCollection.name());
}

ProcessHits()

bool ALFA_SensitiveDetector::ProcessHits ( G4Step *  pStep, G4TouchableHistory *    )

finaloverride

Definition at line 57 of file ALFA_SensitiveDetector.cxx.

{
 
  const double energyDeposit(pStep->GetTotalEnergyDeposit());
 
  // Get kinetic energy of depositing particle
 
  const G4StepPoint *pPreStepPoint(pStep->GetPreStepPoint());
  const G4StepPoint *pPostStepPoint(pStep->GetPostStepPoint());
 
  const double kineticEnergy(pPreStepPoint->GetKineticEnergy());
 
  const G4ThreeVector preStepPoint(pPreStepPoint->GetPosition());
  const G4ThreeVector postStepPoint(pPostStepPoint->GetPosition());
 
  // Get name of physical volume
  const G4String vol_name(pPreStepPoint->GetTouchableHandle()->GetVolume()->GetName());
 
  const double preStepX(preStepPoint.x());
  const double preStepY(preStepPoint.y());
  const double preStepZ(preStepPoint.z());
 
  const double postStepX(postStepPoint.x());
  const double postStepY(postStepPoint.y());
  const double postStepZ(postStepPoint.z());
 
  int n_plate(0);
  int n_fiber(0);
  int n_station(0);
 
  m_hitID++;
 
  // particle encoding
  const G4Track *pTrack(pStep->GetTrack());
  const int particleEncoding(pTrack->GetDefinition()->GetPDGEncoding());
 
  const double globalTime(pTrack->GetGlobalTime());
  const int trackID(pTrack->GetTrackID()); //DC 2-29-04 use it as barcode
 
  std::string vol_test_str = vol_name.substr(0,7);
 
 
  if(vol_name.find("GVS") != std::string::npos)
    {
 
      if(vol_name.find("B7L1") != std::string::npos) n_station=0;
      else if(vol_name.find("A7L1") != std::string::npos) n_station=1;
      else if(vol_name.find("A7R1") != std::string::npos) n_station=2;
      else if(vol_name.find("B7R1") != std::string::npos) n_station=3;
      else n_station=-1;
      if(m_HitCollection.isValid())
        {
          m_HitCollection->Emplace(m_hitID, trackID, particleEncoding, (float) kineticEnergy,
                                   (float) energyDeposit,(float) preStepX, (float) preStepY, (float) preStepZ,
                                   (float) postStepX, (float) postStepY, (float) postStepZ,(float) globalTime,
                                   -1, 100, -1, (int) n_station);
          m_numberOfHits++;
        }
      else
        {
          G4ExceptionDescription description;
          description << "ProcessHits: Can't access HitCollection with key " << m_HitCollection.key() << " from store " << m_HitCollection.store();
          G4Exception("ALFA_SensitiveDetector", "InvalidHitColl1", FatalException, description);
          return false; //The G4Exception call above should abort the job, but Coverity does not seem to pick this up.
        }
    }
 
  if (vol_test_str.compare("ALFA_Fi") == 0)
    {
      if (std::abs(energyDeposit)<std::numeric_limits<double>::epsilon()) { return true; }
      m_pos2 = 10;
      std::string substring (vol_name);
      std::string num_string (vol_name);
 
 
      std::string test_str ("A");
      test_str = substring.substr(m_pos2,1);
      int sign_fiber(0);
      if (test_str.compare("U") == 0)
        {
          sign_fiber = 1;
        }
 
      if (test_str.compare("V") == 0)
        {
          sign_fiber = -1;
        }
 
 
      for ( int k = 0; k < 3; k++ )
        {
          substring = substring.substr(m_pos2+1);
          m_pos1 = int(substring.find('['));
          m_pos2 = int(substring.find(']'));
          num_string = substring.substr(m_pos1+1,m_pos2-1);
          std::istringstream is(num_string);
          is >> m_num[k];
        }
 
      n_station = m_num[0];
      n_plate   = m_num[1];
      n_fiber   = m_num[2];
 
 
      if(m_HitCollection.isValid())
        {
          m_HitCollection->Emplace(m_hitID,
                                   trackID,
                                   particleEncoding,
                                   (float) kineticEnergy,
                                   (float) energyDeposit,
                                   (float) preStepX, (float) preStepY, (float) preStepZ,
                                   (float) postStepX, (float) postStepY, (float) postStepZ,
                                   (float) globalTime,
                                   (int) sign_fiber, (int) n_plate, (int) n_fiber, (int) n_station
                                   );
          ++m_numberOfHits;
        }
      else
        {
          G4ExceptionDescription description;
          description << "ProcessHits: Can't access HitCollection with key " << m_HitCollection.key() << " from store " << m_HitCollection.store();
          G4Exception("ALFA_SensitiveDetector", "InvalidHitColl2", FatalException, description);
          return false; //The G4Exception call above should abort the job, but Coverity does not seem to pick this up.
        }
    }
 
  if (vol_test_str.compare("ODFiber") == 0)
    {
      if (std::abs(energyDeposit)<std::numeric_limits<double>::epsilon()) { return true; }
      m_pos2 = 7;
      std::string substring (vol_name);
      std::string num_string (std::move(vol_name));
 
      std::string test_str = substring.substr(m_pos2,1);
      int sign_fiber(0);
      if (test_str.compare("U") == 0)
        {
          sign_fiber = 1;
        }
 
      if (test_str.compare("V") == 0)
        {
          sign_fiber = -1;
        }
 
      std::string test_str_side ("A");
      test_str_side = substring.substr(m_pos2+1,1);
 
      int OD_side(0);
      if (test_str_side.compare("0") == 0)
        {
          OD_side = 0;
        }
 
      if (test_str_side.compare("1") == 0)
        {
          OD_side = 1;
        }
 
      for ( int k = 0; k < 3; k++ )
        {
          substring = substring.substr(m_pos2+1);
          m_pos1 = int(substring.find('['));
          m_pos2 = int(substring.find(']'));
          num_string = substring.substr(m_pos1+1,m_pos2-1);
          std::istringstream is(num_string);
          is >> m_num[k];
        }
 
      n_station = m_num[0];
      n_plate   = m_num[1];
      n_fiber   = m_num[2];
 
      if(m_ODHitCollection.isValid())
        {
          m_ODHitCollection->Emplace(m_hitID,
                                     trackID,
                                     particleEncoding,
                                     (float) kineticEnergy,
                                     (float) energyDeposit,
                                     (float) preStepX, (float) preStepY, (float) preStepZ,
                                     (float) postStepX, (float) postStepY, (float) postStepZ,
                                     (float) globalTime,
                                     (int) sign_fiber, (int) OD_side, (int) n_plate, (int) n_fiber, (int) n_station
                                     );
          ++m_numberOfODHits;
        }
      else
        {
          G4ExceptionDescription description;
          description << "ProcessHits: Can't access HitCollection with key " << m_ODHitCollection.key() << " from store " << m_ODHitCollection.store();
          G4Exception("ALFA_SensitiveDetector", "InvalidHitColl3", FatalException, description);
          return false; //The G4Exception call above should abort the job, but Coverity does not seem to pick this up.
        }
 
    }
 
 
  return true;
}

StartOfAthenaEvent()

void ALFA_SensitiveDetector::StartOfAthenaEvent

(

)

Definition at line 44 of file ALFA_SensitiveDetector.cxx.

{
  m_numberOfHits = 0;
  m_numberOfODHits = 0;
}

Member Data Documentation

m_eventNumber

int ALFA_SensitiveDetector::m_eventNumber {}

private

Definition at line 54 of file ALFA_SensitiveDetector.h.

m_HitCollection

SG::WriteHandle<ALFA_HitCollection> ALFA_SensitiveDetector::m_HitCollection

private

Definition at line 59 of file ALFA_SensitiveDetector.h.

m_hitID

int ALFA_SensitiveDetector::m_hitID {}

private

Templated method to stuff a single hit into the sensitive detector class.

This could get rather tricky, but the idea is to allow fast simulations to use the very same SD classes as the standard simulation.

Definition at line 52 of file ALFA_SensitiveDetector.h.

m_num

int ALFA_SensitiveDetector::m_num[3] {}

private

Definition at line 64 of file ALFA_SensitiveDetector.h.

m_numberOfHits

int ALFA_SensitiveDetector::m_numberOfHits {}

private

Definition at line 55 of file ALFA_SensitiveDetector.h.

m_numberOfODHits

int ALFA_SensitiveDetector::m_numberOfODHits {}

private

Definition at line 56 of file ALFA_SensitiveDetector.h.

m_ODHitCollection

SG::WriteHandle<ALFA_ODHitCollection> ALFA_SensitiveDetector::m_ODHitCollection

private

Definition at line 60 of file ALFA_SensitiveDetector.h.

m_pos1

int ALFA_SensitiveDetector::m_pos1 {}

private

Definition at line 62 of file ALFA_SensitiveDetector.h.

m_pos2

int ALFA_SensitiveDetector::m_pos2 {}

private

Definition at line 62 of file ALFA_SensitiveDetector.h.

---

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

• ALFA_SensitiveDetector.h
• ALFA_SensitiveDetector.cxx