SimG4FluxProducer.cc

Go to the documentation of this file.

#include "SimG4FluxProducer.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

#include "G4Track.hh"
#include "G4TouchableHistory.hh"
#include "G4TransportationManager.hh"
#include "CLHEP/Units/GlobalSystemOfUnits.h"
#include "CLHEP/Units/GlobalPhysicalConstants.h"

#include <cmath>
#include <iostream>
#include <iomanip>
#include <memory>
#include <utility>  

//#define EDM_ML_DEBUG

SimG4FluxProducer::SimG4FluxProducer(const edm::ParameterSet &p) : count_(0), init_(false) {

  edm::ParameterSet m_FP = p.getParameter<edm::ParameterSet>("SimG4FluxProducer");
  LVNames_  = m_FP.getUntrackedParameter<std::vector<std::string> >("LVNames");
  LVTypes_  = m_FP.getUntrackedParameter<std::vector<int> >("LVTypes");

  for (unsigned int k=0; k<LVNames_.size(); ++k) {
    produces<ParticleFlux>(Form("%sParticleFlux",LVNames_[k].c_str()));
#ifdef EDM_ML_DEBUG
    std::cout << "Collection name[" << k << "] ParticleFlux" << LVNames_[k] 
          << " and type " << LVTypes_[k] << std::endl;
#endif
  }
} 
   
SimG4FluxProducer::~SimG4FluxProducer() { }

void SimG4FluxProducer::produce(edm::Event& e, const edm::EventSetup&) {
  
  for (unsigned int k=0; k<LVNames_.size(); ++k) {
    std::unique_ptr<ParticleFlux> pflux(new ParticleFlux);
    endOfEvent(*pflux, k);
    std::string name = LVNames_[k] + "ParticleFlux";
    e.put(std::move(pflux),name);
  }
}

void SimG4FluxProducer::update(const BeginOfRun * run) {

  topPV_ = getTopPV();
  if (topPV_ == 0) {
    edm::LogWarning("SimG4FluxProducer") << "Cannot find top level volume\n";
  } else {
    init_ = true;
    const G4LogicalVolumeStore * lvs = G4LogicalVolumeStore::GetInstance();
    for (auto lvcite : *lvs) {
      findLV(lvcite);
    } 

#ifdef EDM_ML_DEBUG
    std::cout << "SimG4FluxProducer::Finds " << mapLV_.size() << " logical volumes\n";
    unsigned int k(0);
    for (const auto& lvs : mapLV_) {
      std::cout << "Entry[" << k << "] " << lvs.first << ": (" 
        << (lvs.second).first << ", " << (lvs.second).second << ")\n";
      ++k;
    }
#endif
  }
}

void SimG4FluxProducer::update(const BeginOfEvent * evt) {
 
  int iev = (*evt)()->GetEventID();
  edm::LogInfo("ValidHGCal") << "SimG4FluxProducer: =====> Begin event = "
                 << iev << std::endl;
  ++count_;
  store_.clear();
}

void SimG4FluxProducer::update(const G4Step * aStep) {

  if (aStep != NULL) {

    G4TouchableHistory* touchable = (G4TouchableHistory*)aStep->GetPreStepPoint()->GetTouchable();
    G4LogicalVolume* plv = (G4LogicalVolume*)touchable->GetVolume()->GetLogicalVolume();
    auto it = (init_) ? mapLV_.find(plv) : findLV(plv);
//  std::cout << plv->GetName() << " Flag " << (it != mapLV_.end()) << " step " << aStep->IsFirstStepInVolume() << ":"  << aStep->IsLastStepInVolume() << std::endl;
    if (it != mapLV_.end()) {
      int type = LVTypes_[(it->second).first];
      if ((type == 0 && aStep->IsFirstStepInVolume()) ||
      (type == 1 && aStep->IsLastStepInVolume())) {
    unsigned int copy = (unsigned int)(touchable->GetReplicaNumber(0));
    std::pair<G4LogicalVolume*,unsigned int> key(plv,copy);
    auto itr = store_.find(key);
    if (itr == store_.end()) {
      store_[key] = ParticleFlux((it->second).second,copy);
      itr         = store_.find(key);
    }
    G4Track* track = aStep->GetTrack();
    int      pdgid = track->GetDefinition()->GetPDGEncoding();
    int      vxtyp = (track->GetCreatorProcess() == nullptr) ? 0 : 1;
    double   time  = (aStep->GetPostStepPoint()->GetGlobalTime());
    const double mmTocm(0.1), MeVToGeV(0.001);
    ParticleFlux::flux flx(pdgid,vxtyp,time);
    flx.vertex   = math::GlobalPoint(mmTocm*track->GetVertexPosition().x(),
                     mmTocm*track->GetVertexPosition().y(),
                     mmTocm*track->GetVertexPosition().z());
    flx.hitPoint = math::GlobalPoint(mmTocm*track->GetPosition().x(),
                     mmTocm*track->GetPosition().y(),
                     mmTocm*track->GetPosition().z());
    flx.momentum = math::GlobalVector(MeVToGeV*track->GetMomentum().x(),
                      MeVToGeV*track->GetMomentum().y(),
                      MeVToGeV*track->GetMomentum().z());
    (itr->second).addFlux(flx);
#ifdef EDM_ML_DEBUG
    std::cout << "SimG4FluxProducer: Element " << (it->second).first << ":"
          << (it->second).second << ":" << copy << " ID " << pdgid
          << " VxType " << vxtyp << " TOF " << time << " Hit Point "
          << flx.hitPoint << " p " << flx.momentum << " Vertex "
          << flx.vertex << std::endl;
#endif
      }//if(Step ok)
    }//if( it != map.end() )
  }//if (aStep != NULL)

}

void SimG4FluxProducer::endOfEvent(ParticleFlux& flux, unsigned int k) {

  bool done(false);
  for (const auto& element : store_) {
    G4LogicalVolume* lv = (element.first).first;
    auto it = mapLV_.find(lv);
    if (it != mapLV_.end()) {
      if ((it->second).first == k) {
    flux = element.second;
    done = true;
#ifdef EDM_ML_DEBUG
    std::cout << "SimG4FluxProducer[" << k << "] Flux " << flux.getName()
          << ":" << flux.getId() << " with " << flux.getComponents()
          << " elements" << std::endl;
    std::vector<ParticleFlux::flux> fluxes = flux.getFlux() ;
    unsigned int k(0);
    for (auto element : fluxes) {
      std::cout << "Flux[" << k << "] PDGId " << element.pdgId << " VT "
            << element.vxType << " ToF " << element.tof << " Vertex "
            << element.vertex << " Hit " << element.hitPoint << " p "
            << element.momentum << std::endl;
      ++k;
    }
#endif
      }
    }
    if (done) break;
  }
}

G4VPhysicalVolume * SimG4FluxProducer::getTopPV() {
  return G4TransportationManager::GetTransportationManager()->GetNavigatorForTracking()->GetWorldVolume();
}

std::map<G4LogicalVolume*,std::pair<unsigned int,std::string>>::iterator SimG4FluxProducer::findLV(G4LogicalVolume * plv) {
  auto itr = mapLV_.find(plv);
  if (itr == mapLV_.end()) {
    std::string name = plv->GetName();
    for (unsigned int k=0; k<LVNames_.size(); ++k) {
      if (name.find(LVNames_[k]) != std::string::npos) {
    mapLV_[plv] = std::pair<unsigned int,std::string>(k,name);
    itr = mapLV_.find(plv);
    break;
      }
    }
  }
  return itr;
}