src/SensitiveDetector.cc

Go to the documentation of this file.

#include "SensitiveDetector.hh"
#include "DetectorConstruction.hh"
#include "RunAction.hh"

#include "G4Step.hh"
#include "Randomize.hh"
#include "G4RunManager.hh"

#include "G4HCofThisEvent.hh"

#include "G4HCtable.hh"
#include "G4SDManager.hh"

#include "G4Proton.hh"


SensitiveDetector::SensitiveDetector(G4String SDname)
  : G4VSensitiveDetector(SDname)
{
  // -- obtain detector construction and run action pointers through the run manager
  m_detector = (DetectorConstruction*)(G4RunManager::GetRunManager()->GetUserDetectorConstruction());
  m_runAction = (RunAction*)(G4RunManager::GetRunManager()->GetUserRunAction());

  // -->> jour4b2:
  // ----------------------------------------------------------------------------------
  // -- 'collectionName' is a protected data member of base class G4VSensitiveDetector.
  // -- Here we declare the name of the collection we will be using.
  // ----------------------------------------------------------------------------------
  collectionName.insert("AstronautCollection");
 
  // -- Note that we may add as many collection names we would wish: ie
  // -- a sensitive detector can have many collections.
}

SensitiveDetector::~SensitiveDetector()
{}

G4bool SensitiveDetector::ProcessHits(G4Step *step, G4TouchableHistory *)
{
  // -- step is garanteed to be is astronaut's volume : no need to check for volume
  
  G4TouchableHandle touchable = step->GetPreStepPoint()->GetTouchableHandle();
  // energy deposit in this step 
  G4double edep = step->GetTotalEnergyDeposit();

  if (edep <= 0.) return false;

  // get step points in world coordinate system
  G4ThreeVector point1 = step->GetPreStepPoint()->GetPosition();
  G4ThreeVector point2 = step->GetPostStepPoint()->GetPosition();
  
  // randomize point of energy deposition
  G4ThreeVector pointE = point1 + G4UniformRand()*(point2 - point1);      
  // transform it in local coordinate system
  G4ThreeVector localPointE 
    = touchable->GetHistory()->GetTopTransform().TransformPoint(pointE);
  
  // extract z and offset
  G4double zLocal = 0.5*(m_detector->GetAstronautHeight()) - localPointE.z();
  

  // -------------
  // -->> jour4b2:
  // -------------

  // sum edep in RunAction (in SD vector):
  // -->> we remove this call from here : m_runAction->SumDepthDoseSD(zLocal,edep);
  
  // -- obtain the slice number corresponding to the zLocal
  // -- coordinate. This will be used to to label the hit:
  G4int k = m_runAction->GetSliceNumber(zLocal); // <<-- new method of run action, added for this exercise
  // ------------------------------------------------
  // -- Get or create, if necessary, hit for slice k:
  // ------------------------------------------------
  if (k > -1) { // << -- "-1" corresponds to an error code, should not happen ;-)
    AstroHit* hit(0);
    if (m_hitIndex[k] == -1)  // <<-- means hit for slice k was not created, so created
      {
        // -- Create a new hit, for slice k:
        hit = new AstroHit(k);
        // -- Flag the creation of this new hit, for slice k.
        // -- For this, we replace the "-1" at position k in the
        // -- index table, the index of this hit in the hit collection:
        m_hitIndex[k] = m_hitCollection->insert(hit) - 1; // size of collection is returned by insert(..), so index of new hit is size - 1
      }
    else                      // <<-- hit was already created, just get its pointer
      {
        hit =  (*m_hitCollection)[m_hitIndex[k]];
      }
    // -----------------------------------------------------
    // -- finally we accumulate this step energy in the hit:
    // -----------------------------------------------------
    hit->addE(edep);
    // -- get G4Track pointer:
    G4Track* track = step->GetTrack();
    // -- check this track is a proton:
    if (track->GetDefinition() == G4Proton::ProtonDefinition())
      {
        hit->accumulateProton(track->GetKineticEnergy());
      }
  }
  

  return true;

}

void SensitiveDetector::Initialize(G4HCofThisEvent* HCE)
{
  // -- G4cout << "Initialize method of SD `" << GetName() << "' called." << G4endl;

  // ------------------------------
  // -- Creation of the collection
  // ------------------------------
  // -- collectionName[0] is "AstronautCollection", as declared in constructor
  m_hitCollection = new AstroHitCollection(GetName(), collectionName[0]);

  // ----------------------------------------------------------------------------
  // -- and attachment of this collection to the "Hits Collection of this Event":
  // ----------------------------------------------------------------------------
  // -- To insert the collection, we need to get an index for it. This index
  // -- is unique to the collection. It is provided by the GetCollectionID(...)
  // -- method (which calls what is needed in the kernel to get this index).
  static G4int HCID = -1;
  if (HCID<0) HCID = GetCollectionID(0); // <<-- this is to get an ID for collectionName[0]
  HCE->AddHitsCollection(HCID, m_hitCollection);

  // -- Question : what are these lines made for ?
  m_hitIndex.clear();
  m_hitIndex.resize(m_runAction->GetNumberOfSlices(), -1);

}

void SensitiveDetector::EndOfEvent(G4HCofThisEvent*)
{
  //--  G4cout << "EndOfEvent method of SD `" << GetName() << "' called." << G4endl;

  // -- we could have attached the collection to the G4HCofThisEvent in this
  // -- method as well (instead of Initialize).
}

---