ZDC_FiberSD Class Reference

#include <ZDC_FiberSD.h>

Inheritance diagram for ZDC_FiberSD:

Collaboration diagram for ZDC_FiberSD:

Public Member Functions
	ZDC_FiberSD (const G4String &name, const G4String &hitCollectionName, const float &readoutPos)
	~ZDC_FiberSD ()
void	Initialize (G4HCofThisEvent *) override final
G4bool	ProcessHits (G4Step *, G4TouchableHistory *) override final
void	EndOfAthenaEvent ()

Private Member Functions
	FRIEND_TEST (ZDC_FiberSDtest, ProcessHits)
	FRIEND_TEST (ZDC_FiberSDtest, Initialize)
	FRIEND_TEST (ZDC_FiberSDtest, StartOfAthenaEvent)
	FRIEND_TEST (ZDC_FiberSDtest, EndOfAthenaEvent)

Private Attributes
SG::WriteHandle< ZDC_SimFiberHit_Collection >	m_HitColl
std::map< uint32_t, ZDC_SimFiberHit * >	m_hitMap
float	m_readoutPos

Detailed Description

Definition at line 24 of file ZDC_FiberSD.h.

Constructor & Destructor Documentation

ZDC_FiberSD()

ZDC_FiberSD::ZDC_FiberSD	(	const G4String &	name,
		const G4String &	hitCollectionName,
		const float &	readoutPos
	)

Definition at line 19 of file ZDC_FiberSD.cxx.

    : G4VSensitiveDetector(name), m_HitColl(hitCollectionName), m_readoutPos(readoutPos)
{
    
}

~ZDC_FiberSD()

ZDC_FiberSD::~ZDC_FiberSD

(

)

Definition at line 26 of file ZDC_FiberSD.cxx.

                         {
    
}

Member Function Documentation

EndOfAthenaEvent()

void ZDC_FiberSD::EndOfAthenaEvent

(

)

Definition at line 164 of file ZDC_FiberSD.cxx.

{
    
    //Move the hits from the hit set to the hit container
    if (!m_HitColl.isValid())
        m_HitColl = std::make_unique<ZDC_SimFiberHit_Collection>(m_HitColl.name());
 
    for(auto hit : m_hitMap){
        m_HitColl->Emplace(*(hit.second));
    }
 
 
    if (verboseLevel > 5){
        G4cout << "ZDC_FiberSD::EndOfAthenaEvent(): Printing Final Energy(eV) deposited in Fibers " << G4endl;
        
        int photonCount = 0;
        float energyTotal = 0;
        for(auto hit : m_hitMap){
            photonCount += hit.second->getNPhotons();
            energyTotal += hit.second->getEdep();
        }
 
        G4cout << "ZDC_FiberSD::EndOfAthenaEvent(): Final Energy(eV) deposited in Fiber "
            << energyTotal << " ev and Number of Photons deposited = " << photonCount 
            << " across " << m_hitMap.size() << " volumes" << G4endl;
 
    }
    //Reset hit container
    m_hitMap.clear();
 
    return;
}

FRIEND_TEST() [1/4]

ZDC_FiberSD::FRIEND_TEST ( ZDC_FiberSDtest  , EndOfAthenaEvent    )

private

FRIEND_TEST() [2/4]

ZDC_FiberSD::FRIEND_TEST ( ZDC_FiberSDtest  , Initialize    )

private

FRIEND_TEST() [3/4]

ZDC_FiberSD::FRIEND_TEST ( ZDC_FiberSDtest  , ProcessHits    )

private

FRIEND_TEST() [4/4]

ZDC_FiberSD::FRIEND_TEST ( ZDC_FiberSDtest  , StartOfAthenaEvent    )

private

Initialize()

void ZDC_FiberSD::Initialize ( G4HCofThisEvent *  )

finaloverride

Definition at line 30 of file ZDC_FiberSD.cxx.

{
}

ProcessHits()

G4bool ZDC_FiberSD::ProcessHits ( G4Step *  aStep, G4TouchableHistory *    )

finaloverride

Definition at line 41 of file ZDC_FiberSD.cxx.

{
    G4ThreeVector pos = aStep->GetTrack()->GetPosition();
    G4ThreeVector momentum = aStep->GetPreStepPoint()->GetMomentum();
 
    /*************************************************
    * Reject everything but optical photons
    **************************************************/
    if (aStep->GetTrack()->GetDefinition() != G4OpticalPhoton::OpticalPhotonDefinition()){
        return true;
    }
 
 
    /*************************************************
    * Reject downward going photons
    **************************************************/
    if (momentum.y() < 0.0){
        aStep->GetTrack()->SetTrackStatus(fStopAndKill);
        return true;
    }
 
 
    /*************************************************
    * Reject photons not at the boundary of two volumes
    **************************************************/
    G4StepPoint *endPoint = aStep->GetPostStepPoint();
    if (endPoint->GetStepStatus() != fGeomBoundary)
        return true;
 
    
    /*************************************************
    * Reject photons that are reflected back down 
    * from the top of the fiber
    **************************************************/
 
    // Get the refractive index
    G4MaterialPropertiesTable *MPT = aStep->GetPreStepPoint()->GetMaterial()->GetMaterialPropertiesTable();
    if (!MPT) //Safety check
        return true;
    G4MaterialPropertyVector *RindexMPV = MPT->GetProperty(kRINDEX);
    if (!RindexMPV)//Safety check
        return true;
 
    G4double Rindex;
    size_t index = 0;
    double photonEnergy = aStep->GetTrack()->GetDynamicParticle()->GetTotalMomentum();
    Rindex = RindexMPV->Value(photonEnergy, index);
 
    //Determine the photon's angle from the vertical axis
    G4ThreeVector momDir = aStep->GetPreStepPoint()->GetMomentumDirection();
    G4double angleFromY = atan(sqrt(1 - pow(momDir.y(), 2.0)) / momDir.y());
 
    // kill the photon if angle is greater than TIR critical angle
    // We're assuming the fiber's top face's normal vector is parallel to the y axis
    if (angleFromY > asin(1.0 / Rindex)){ 
        aStep->GetTrack()->SetTrackStatus(fStopAndKill);
        return true;
    }
 
    /*************************************************
    * Reject photons that are not totally internally 
    * reflected inside the fiber
    **************************************************/
 
    G4bool isTIR = false;
    G4ProcessVector *postStepDoItVector = G4OpticalPhoton::OpticalPhotonDefinition()->GetProcessManager()->GetPostStepProcessVector(typeDoIt);
    G4int n_proc = postStepDoItVector->entries();
    for (G4int i = 0; i < n_proc; ++i){
        G4OpBoundaryProcess *opProc = dynamic_cast<G4OpBoundaryProcess *>((*postStepDoItVector)[i]);
        if (opProc && opProc->GetStatus() == TotalInternalReflection){
            isTIR = true;
            break;
        }
    }
 
    if(!isTIR){ 
        aStep->GetTrack()->SetTrackStatus(fStopAndKill);
        return true;
    }
 
    /*************************************************
    * Simulate absorption by calculating the photon's
    * remaining path length and rolling a random number
    * against its absorption chance
    **************************************************/
    G4MaterialPropertyVector *AbsMPV = MPT->GetProperty(kABSLENGTH);
    G4double Absorption = AbsMPV->Value(aStep->GetTrack()->GetDynamicParticle()->GetTotalMomentum(), index);
 
    G4double pathLength = (m_readoutPos - pos.y()) / cos(angleFromY);
    G4double absChance = 1 - exp(-pathLength / Absorption);
 
    // This check amounts to if(absorbed)
    if (CLHEP::RandFlat::shoot(0.0, 1.0) < absChance){
        aStep->GetTrack()->SetTrackStatus(fStopAndKill);
        return true;
    }
 
    /*************************************************
    * Record the survivors
    **************************************************/
 
    //Get the hash for this volume to keep track of hits
    Identifier id;
    id = aStep->GetPreStepPoint()->GetPhysicalVolume()->GetCopyNo();
    uint32_t hash = id.get_identifier32().get_compact();
 
    std::map<uint32_t,ZDC_SimFiberHit*>::iterator it = m_hitMap.find(hash);
 
    if(it == m_hitMap.end()){
        //This is a new hit
        ZDC_SimFiberHit *hit = new ZDC_SimFiberHit(id, 1, photonEnergy);
        m_hitMap.insert(std::pair<uint32_t,ZDC_SimFiberHit*>(hash,hit));
    }else{
        it->second->Add(1, photonEnergy);
    }
 
    /*************************************************
    * Put the survivors out of their misery
    **************************************************/
    aStep->GetTrack()->SetTrackStatus(fStopAndKill);
    return true;
}

Member Data Documentation

m_HitColl

SG::WriteHandle<ZDC_SimFiberHit_Collection> ZDC_FiberSD::m_HitColl

private

Definition at line 43 of file ZDC_FiberSD.h.

m_hitMap

std::map< uint32_t, ZDC_SimFiberHit* > ZDC_FiberSD::m_hitMap

private

Definition at line 44 of file ZDC_FiberSD.h.

m_readoutPos

float ZDC_FiberSD::m_readoutPos

private

Definition at line 45 of file ZDC_FiberSD.h.

---

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

• ZDC_FiberSD.h
• ZDC_FiberSD.cxx