269 lines
11 KiB
C++
269 lines
11 KiB
C++
//
|
|
// ********************************************************************
|
|
// * License and Disclaimer *
|
|
// * *
|
|
// * The Geant4 software is copyright of the Copyright Holders of *
|
|
// * the Geant4 Collaboration. It is provided under the terms and *
|
|
// * conditions of the Geant4 Software License, included in the file *
|
|
// * LICENSE and available at http://cern.ch/geant4/license . These *
|
|
// * include a list of copyright holders. *
|
|
// * *
|
|
// * Neither the authors of this software system, nor their employing *
|
|
// * institutes,nor the agencies providing financial support for this *
|
|
// * work make any representation or warranty, express or implied, *
|
|
// * regarding this software system or assume any liability for its *
|
|
// * use. Please see the license in the file LICENSE and URL above *
|
|
// * for the full disclaimer and the limitation of liability. *
|
|
// * *
|
|
// * This code implementation is the result of the scientific and *
|
|
// * technical work of the GEANT4 collaboration. *
|
|
// * By using, copying, modifying or distributing the software (or *
|
|
// * any work based on the software) you agree to acknowledge its *
|
|
// * use in resulting scientific publications, and indicate your *
|
|
// * acceptance of all terms of the Geant4 Software license. *
|
|
// ********************************************************************
|
|
//
|
|
// ********************************************************************
|
|
//
|
|
// CaTS (Calorimetry and Tracking Simulation)
|
|
//
|
|
// Authors : Hans Wenzel
|
|
// Soon Yung Jun
|
|
// (Fermi National Accelerator Laboratory)
|
|
//
|
|
// History
|
|
// October 18th, 2021 : first implementation
|
|
//
|
|
// ********************************************************************
|
|
//
|
|
/// \file EventAction.cc
|
|
/// \brief Implementation of the CaTS::EventAction class
|
|
|
|
// Geant4 headers
|
|
#include <G4UserEventAction.hh>
|
|
#include <G4ios.hh>
|
|
#include "G4Event.hh"
|
|
#include "G4HCofThisEvent.hh"
|
|
#include <G4String.hh>
|
|
#include <G4Types.hh>
|
|
#include <G4VHit.hh>
|
|
#include <G4VHitsCollection.hh>
|
|
#include "G4SDManager.hh"
|
|
|
|
// project headers:
|
|
#include "EventAction.hh"
|
|
#include "ConfigurationManager.hh"
|
|
#include "Event.hh"
|
|
#include "PhotonSD.hh"
|
|
#include "PhotonHit.hh"
|
|
#include "InteractionHit.hh"
|
|
#include "lArTPCHit.hh"
|
|
#include "TrackerHit.hh"
|
|
#include "MscHit.hh"
|
|
#include "CalorimeterHit.hh"
|
|
#include "DRCalorimeterHit.hh"
|
|
#ifdef WITH_ROOT
|
|
#include "RootIO.hh"
|
|
#endif
|
|
// stl headers
|
|
#include <map>
|
|
#include <utility>
|
|
#include <algorithm>
|
|
#include <istream>
|
|
#ifdef WITH_G4OPTICKS
|
|
#include "OpticksFlags.hh"
|
|
#include "G4Opticks.hh"
|
|
#include "G4OpticksHit.hh"
|
|
#endif
|
|
|
|
#ifdef WITH_ROOT
|
|
namespace {
|
|
// Mutex to lock updating the global ion map
|
|
G4Mutex ionIdMapMutex = G4MUTEX_INITIALIZER;
|
|
} // namespace
|
|
#endif
|
|
|
|
EventAction::EventAction()
|
|
: G4UserEventAction() {
|
|
#ifdef WITH_ROOT
|
|
RootIO::GetInstance();
|
|
#endif
|
|
}
|
|
|
|
void EventAction::BeginOfEventAction(const G4Event*) {
|
|
}
|
|
|
|
void EventAction::EndOfEventAction(const G4Event* event) {
|
|
G4bool verbose = ConfigurationManager::getInstance()->isEnable_verbose();
|
|
if (verbose)
|
|
G4cout << "EventAction::EndOfEventAction Event: " << event->GetEventID()
|
|
<< G4endl;
|
|
G4HCofThisEvent* HCE = event->GetHCofThisEvent();
|
|
if (HCE == nullptr)
|
|
return;
|
|
#ifdef WITH_ROOT
|
|
Event* CaTSEvt = new Event();
|
|
CaTSEvt->SetEventNr(event->GetEventID());
|
|
std::map<G4String, std::vector < G4VHit*>>*hcmap = CaTSEvt->GetHCMap();
|
|
#endif // end WITH_ROOT
|
|
#ifdef WITH_G4OPTICKS
|
|
if (ConfigurationManager::getInstance()->isEnable_opticks()) {
|
|
G4Opticks* g4ok = G4Opticks::Get();
|
|
G4int eventid = event->GetEventID();
|
|
g4ok->propagateOpticalPhotons(eventid);
|
|
unsigned num_hits = g4ok->getNumHit();
|
|
G4cout << "EndOfEventAction: num_hits: " << num_hits << G4endl;
|
|
if (num_hits > 0) {
|
|
G4HCtable* hctable = G4SDManager::GetSDMpointer()->GetHCtable();
|
|
for (G4int i = 0; i < hctable->entries(); ++i) {
|
|
std::string sdn = hctable->GetSDname(i);
|
|
std::size_t found = sdn.find("Photondetector");
|
|
if (found != std::string::npos) {
|
|
PhotonSD* aSD =
|
|
(PhotonSD*) G4SDManager::GetSDMpointer()->FindSensitiveDetector(
|
|
sdn);
|
|
aSD->AddOpticksHits();
|
|
}
|
|
}
|
|
}
|
|
if (verbose) {
|
|
G4cout << "***********************************************************"
|
|
"********************************************************"
|
|
<< G4endl;
|
|
G4cout << " EndOfEventAction: numphotons: " << g4ok->getNumPhotons()
|
|
<< " Gensteps: " << g4ok->getNumGensteps()
|
|
<< " Maxgensteps: " << g4ok->getMaxGensteps() << G4endl;
|
|
G4cout << " EndOfEventAction: num_hits: " << g4ok->getNumHit() << G4endl;
|
|
G4cout << g4ok->dbgdesc() << G4endl;
|
|
}
|
|
g4ok->reset();
|
|
if (verbose) {
|
|
G4cout << "========================== After reset: " << G4endl;
|
|
G4cout << " EndOfEventAction: numphotons: " << g4ok->getNumPhotons()
|
|
<< " Gensteps: " << g4ok->getNumGensteps()
|
|
<< " Maxgensteps: " << g4ok->getMaxGensteps() << G4endl;
|
|
G4cout << "EndOfEventAction: num_hits: " << g4ok->getNumHit() << G4endl;
|
|
G4cout << g4ok->dbgdesc() << G4endl;
|
|
G4cout << "***********************************************************"
|
|
"********************************************************"
|
|
<< G4endl;
|
|
}
|
|
} // end isEnable_opticks
|
|
#endif // end WITH_G4OPTICKS
|
|
//
|
|
// Now we deal with the Geant4 Hit collections.
|
|
//
|
|
if (verbose)
|
|
G4cout << "Number of collections: " << HCE->GetNumberOfCollections()
|
|
<< G4endl;
|
|
#ifdef WITH_ROOT
|
|
if (ConfigurationManager::getInstance()->isWriteHits()) {
|
|
for (int i = 0; i < HCE->GetNumberOfCollections(); i++) {
|
|
G4VHitsCollection* hc = HCE->GetHC(i);
|
|
G4String hcname = hc->GetName();
|
|
std::vector<std::string> y = split(hcname, '_');
|
|
std::string Classname = y[1];
|
|
if (verbose)
|
|
G4cout << "Classname: " << Classname << G4endl;
|
|
if (Classname == "lArTPC") {
|
|
std::vector<G4VHit*> hitsVector;
|
|
G4int NbHits = hc->GetSize();
|
|
for (G4int ii = 0; ii < NbHits; ii++) {
|
|
G4VHit* hit = hc->GetHit(ii);
|
|
lArTPCHit* tpcHit = dynamic_cast<lArTPCHit*> (hit);
|
|
hitsVector.push_back(tpcHit);
|
|
}
|
|
hcmap->insert(std::make_pair(hcname, hitsVector));
|
|
} else if (Classname == "Photondetector") {
|
|
std::vector<G4VHit*> hitsVector;
|
|
G4int NbHits = hc->GetSize();
|
|
if (verbose)
|
|
G4cout << "Photondetector size: " << hc->GetSize() << G4endl;
|
|
for (G4int ii = 0; ii < NbHits; ii++) {
|
|
G4VHit* hit = hc->GetHit(ii);
|
|
PhotonHit* pHit = dynamic_cast<PhotonHit*> (hit);
|
|
hitsVector.push_back(pHit);
|
|
}
|
|
hcmap->insert(std::make_pair(hcname, hitsVector));
|
|
} else if (Classname == "Target") {
|
|
std::vector<G4VHit*> hitsVector;
|
|
G4int NbHits = hc->GetSize();
|
|
if (verbose)
|
|
G4cout << "Interaction size: " << hc->GetSize() << G4endl;
|
|
for (G4int ii = 0; ii < NbHits; ii++) {
|
|
G4VHit* hit = hc->GetHit(ii);
|
|
InteractionHit* iaHit = dynamic_cast<InteractionHit*> (hit);
|
|
hitsVector.push_back(iaHit);
|
|
}
|
|
hcmap->insert(std::make_pair(hcname, hitsVector));
|
|
} else if (Classname == "Tracker") {
|
|
std::vector<G4VHit*> hitsVector;
|
|
G4int NbHits = hc->GetSize();
|
|
if (verbose)
|
|
G4cout << "Tracker size: " << hc->GetSize() << G4endl;
|
|
for (G4int ii = 0; ii < NbHits; ii++) {
|
|
G4VHit* hit = hc->GetHit(ii);
|
|
TrackerHit* tHit = dynamic_cast<TrackerHit*> (hit);
|
|
hitsVector.push_back(tHit);
|
|
}
|
|
hcmap->insert(std::make_pair(hcname, hitsVector));
|
|
} else if (Classname == "Msc") {
|
|
std::vector<G4VHit*> hitsVector;
|
|
G4int NbHits = hc->GetSize();
|
|
if (verbose)
|
|
G4cout << "Msc size: " << hc->GetSize() << G4endl;
|
|
for (G4int ii = 0; ii < NbHits; ii++) {
|
|
G4VHit* hit = hc->GetHit(ii);
|
|
MscHit* mscHit = dynamic_cast<MscHit*> (hit);
|
|
hitsVector.push_back(mscHit);
|
|
}
|
|
hcmap->insert(std::make_pair(hcname, hitsVector));
|
|
} else if (Classname == "Calorimeter") {
|
|
std::vector<G4VHit*> hitsVector;
|
|
G4int NbHits = hc->GetSize();
|
|
if (verbose)
|
|
G4cout << "Calorimeter size: " << hc->GetSize() << G4endl;
|
|
for (G4int ii = 0; ii < NbHits; ii++) {
|
|
G4VHit* hit = hc->GetHit(ii);
|
|
CalorimeterHit* cHit = dynamic_cast<CalorimeterHit*> (hit);
|
|
hitsVector.push_back(cHit);
|
|
}
|
|
hcmap->insert(std::make_pair(hcname, hitsVector));
|
|
} else if (Classname == "DRCalorimeter") {
|
|
std::vector<G4VHit*> hitsVector;
|
|
G4int NbHits = hc->GetSize();
|
|
if (verbose)
|
|
G4cout << "DRCalorimeter size: " << hc->GetSize() << G4endl;
|
|
for (G4int ii = 0; ii < NbHits; ii++) {
|
|
G4VHit* hit = hc->GetHit(ii);
|
|
DRCalorimeterHit* drHit = dynamic_cast<DRCalorimeterHit*> (hit);
|
|
hitsVector.push_back(drHit);
|
|
}
|
|
hcmap->insert(std::make_pair(hcname, hitsVector));
|
|
} else {
|
|
G4cout << "SD type: " << Classname << " unknown" << G4endl;
|
|
}
|
|
}
|
|
G4AutoLock lock(&ionIdMapMutex);
|
|
RootIO::GetInstance()->Write(CaTSEvt);
|
|
CaTSEvt->Reset();
|
|
delete CaTSEvt;
|
|
} // end enableio
|
|
#endif
|
|
}
|
|
|
|
std::vector<std::string>& EventAction::split(const std::string& s, char delim,
|
|
std::vector<std::string>& elems) {
|
|
std::stringstream ss(s);
|
|
std::string item;
|
|
while (std::getline(ss, item, delim)) {
|
|
elems.push_back(item);
|
|
}
|
|
return elems;
|
|
}
|
|
|
|
std::vector<std::string> EventAction::split(const std::string& s, char delim) {
|
|
std::vector<std::string> elems;
|
|
return split(s, delim, elems);
|
|
}
|