ZDC_G4CalibSD Class Reference

#include <ZDC_G4CalibSD.h>

Inheritance diagram for ZDC_G4CalibSD:

Collaboration diagram for ZDC_G4CalibSD:

Public Member Functions
	ZDC_G4CalibSD (const G4String &a_name, const G4String &hitCollectionName, bool doPID=false)
virtual	~ZDC_G4CalibSD ()
	ZDC_G4CalibSD (const ZDC_G4CalibSD &)=delete
ZDC_G4CalibSD &	operator= (const ZDC_G4CalibSD &)=delete
G4bool	ProcessHits (G4Step *a_step, G4TouchableHistory *) override
G4bool	SpecialHit (G4Step *a_step, const std::vector< G4double > &a_energies)
void	EndOfAthenaEvent ()

Protected Member Functions
G4bool	SimpleHit (const Identifier &id, const std::vector< double > &energies)

Private Member Functions
	FRIEND_TEST (ZDC_G4CalibSDtest, ProcessHits)
	FRIEND_TEST (ZDC_G4CalibSDtest, EndOfAthenaEvent)
	FRIEND_TEST (ZDC_G4CalibSDtest, SpecialHit)
	FRIEND_TEST (ZDC_G4CalibSDtest, SimpleHit)

Private Attributes
SG::WriteHandle< CaloCalibrationHitContainer >	m_HitColl
std::map< uint32_t, CaloCalibrationHit * >	m_hitMap
std::vector< G4double >	m_energies
G4int	m_numberInvalidHits
G4bool	m_doPID
Identifier	m_id
CaloG4::SimulationEnergies *	m_simulationEnergies
ZDC_EscapedEnergyProcessing *	m_zdc_eep = nullptr

Detailed Description

Definition at line 23 of file ZDC_G4CalibSD.h.

Constructor & Destructor Documentation

ZDC_G4CalibSD() [1/2]

ZDC_G4CalibSD::ZDC_G4CalibSD	(	const G4String &	a_name,
		const G4String &	hitCollectionName,
		bool	doPID = false
	)

Definition at line 14 of file ZDC_G4CalibSD.cxx.

    : G4VSensitiveDetector(a_name), m_HitColl(hitCollectionName), m_numberInvalidHits(0), m_doPID(doPID)
{
  m_simulationEnergies = new CaloG4::SimulationEnergies();
}

~ZDC_G4CalibSD()

ZDC_G4CalibSD::~ZDC_G4CalibSD ( )

virtual

Definition at line 20 of file ZDC_G4CalibSD.cxx.

{
  if (verboseLevel > 5 && m_numberInvalidHits > 0)
  {
    G4cout << "Destructor: Sensitive Detector <" << SensitiveDetectorName << "> had " << m_numberInvalidHits
           << " G4Step energy deposits outside the region determined by its Calculator." << G4endl;
  }
  delete m_simulationEnergies;
}

ZDC_G4CalibSD() [2/2]

ZDC_G4CalibSD::ZDC_G4CalibSD ( const ZDC_G4CalibSD &  )

delete

Member Function Documentation

EndOfAthenaEvent()

void ZDC_G4CalibSD::EndOfAthenaEvent

(

)

Definition at line 125 of file ZDC_G4CalibSD.cxx.

{
 
  //Move the hits from the hit set to the hit container
  if (!m_HitColl.isValid())
    m_HitColl = std::make_unique<CaloCalibrationHitContainer>(m_HitColl.name());
 
  // Loop through the hits...
  for (auto hit : m_hitMap)
  {
    m_HitColl->push_back(hit.second);
  } // End of loop over hits
 
  // Clean up
  m_hitMap.clear();
}

FRIEND_TEST() [1/4]

ZDC_G4CalibSD::FRIEND_TEST ( ZDC_G4CalibSDtest  , EndOfAthenaEvent    )

private

FRIEND_TEST() [2/4]

ZDC_G4CalibSD::FRIEND_TEST ( ZDC_G4CalibSDtest  , ProcessHits    )

private

FRIEND_TEST() [3/4]

ZDC_G4CalibSD::FRIEND_TEST ( ZDC_G4CalibSDtest  , SimpleHit    )

private

FRIEND_TEST() [4/4]

ZDC_G4CalibSD::FRIEND_TEST ( ZDC_G4CalibSDtest  , SpecialHit    )

private

operator=()

ZDC_G4CalibSD& ZDC_G4CalibSD::operator= ( const ZDC_G4CalibSD &  )

delete

ProcessHits()

G4bool ZDC_G4CalibSD::ProcessHits ( G4Step *  a_step, G4TouchableHistory *    )

override

Definition at line 30 of file ZDC_G4CalibSD.cxx.

{
  // If there's no energy, there's no hit.  (Aside: Isn't this energy
  // the same as the energy from the calculator?  Not necessarily.
  // The calculator may include detector effects such as
  // charge-collection which are not modeled by Geant4.)
  if (a_step->GetTotalEnergyDeposit() == 0.)
    return false;
  
  // Convert the G4Step into (eta,phi,sampling).
  // Check that hit was valid.  (It might be invalid if, for example,
  // it occurred outside the sensitive region.  If such a thing
  // happens, it means that the geometry definitions in the
  // detector-construction routine and the calculator do not agree.)
  
  m_energies.clear();
  // classify different types of deposits (0: EM, 1: Non-EM, 2: Invisible, 3: Escaped)
 
  m_simulationEnergies->Energies(a_step, m_energies);
 
  // identifier needed to specify particular volme we're in. Used in HitCollection to make sure we don't have double hits
  Identifier id;
  id = a_step->GetPreStepPoint()->GetPhysicalVolume()->GetCopyNo();
 
  // build calibHit. check if we've had a hit in this cell already. if we havent add it to the set of cells. If we have add energies to existing energies. ie can't distinguish b/w different hits in single cell so must integrate all this information
  return SimpleHit (id, m_energies );
}

SimpleHit()

G4bool ZDC_G4CalibSD::SimpleHit ( const Identifier &  id, const std::vector< double > &  energies  )

protected

Definition at line 59 of file ZDC_G4CalibSD.cxx.

{
 
  // retreive particle ID
  int particleID = HepMC::UNDEFINED_ID;
  int particleUID = HepMC::UNDEFINED_ID;
  if( m_doPID ) {
    AtlasG4EventUserInfo * atlasG4EvtUserInfo = dynamic_cast<AtlasG4EventUserInfo*>(G4RunManager::GetRunManager()->GetCurrentEvent()->GetUserInformation());
    if (atlasG4EvtUserInfo) {
      particleID = HepMC::barcode(atlasG4EvtUserInfo->GetCurrentPrimaryGenParticle()); // FIXME Barcode-based
      particleUID = HepMC::uniqueID(atlasG4EvtUserInfo->GetCurrentPrimaryGenParticle());
    }
  }
 
 
  // Reject cases where invisible energy calculation produced values
  // of order 10e-12 instead of 0 due to rounding errors in that
  // calculation, or general cases where the energy deposits are
  // trivially small.
  if (energies[0] + energies[1] + energies[3] < 0.001 * CLHEP::eV && std::abs(energies[2]) < 0.001 * CLHEP::eV)
  {
    return true;
  }
 
  // Build the hit.
  CaloCalibrationHit *hit = new CaloCalibrationHit(id,
                                                   energies[0],
                                                   energies[1],
                                                   energies[2],
                                                   energies[3],
                                                   particleID,
                                                   particleUID);
 
  //Get the hash for this volume to keep track of hits
  uint32_t hash = id.get_identifier32().get_compact();
 
  std::map<uint32_t,CaloCalibrationHit*>::iterator it = m_hitMap.find(hash);
 
  if(it == m_hitMap.end()){
    //This is a new hit, insert it
    m_hitMap.insert(std::pair<uint32_t,CaloCalibrationHit*>(hash,hit));
  }else{
    //Add this hit to the existing one for this volume
    it->second->Add(hit);
    delete hit;
  }
  
  return true;
}

SpecialHit()

G4bool ZDC_G4CalibSD::SpecialHit	(	G4Step *	a_step,
		const std::vector< G4double > &	a_energies
	)

Definition at line 115 of file ZDC_G4CalibSD.cxx.

{
  // If we can't get the identifier, something is wrong.
  Identifier id;
  id = a_step->GetPreStepPoint()->GetPhysicalVolume()->GetCopyNo();
 
  return SimpleHit(id, a_energies);
}

Member Data Documentation

m_doPID

G4bool ZDC_G4CalibSD::m_doPID

private

Definition at line 60 of file ZDC_G4CalibSD.h.

m_energies

std::vector<G4double> ZDC_G4CalibSD::m_energies

private

Definition at line 55 of file ZDC_G4CalibSD.h.

m_HitColl

SG::WriteHandle<CaloCalibrationHitContainer> ZDC_G4CalibSD::m_HitColl

private

Definition at line 53 of file ZDC_G4CalibSD.h.

m_hitMap

std::map< uint32_t, CaloCalibrationHit* > ZDC_G4CalibSD::m_hitMap

private

Definition at line 54 of file ZDC_G4CalibSD.h.

m_id

Identifier ZDC_G4CalibSD::m_id

private

Definition at line 61 of file ZDC_G4CalibSD.h.

m_numberInvalidHits

G4int ZDC_G4CalibSD::m_numberInvalidHits

private

Definition at line 58 of file ZDC_G4CalibSD.h.

m_simulationEnergies

CaloG4::SimulationEnergies* ZDC_G4CalibSD::m_simulationEnergies

private

Definition at line 62 of file ZDC_G4CalibSD.h.

m_zdc_eep

ZDC_EscapedEnergyProcessing* ZDC_G4CalibSD::m_zdc_eep = nullptr

private

Definition at line 63 of file ZDC_G4CalibSD.h.

---

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

• ZDC_G4CalibSD.h
• ZDC_G4CalibSD.cxx