TrackingMaterialProducer.cc File Reference

#include <iostream>
#include <vector>
#include <string>
#include <cassert>
#include <exception>
#include <tuple>
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "SimG4Core/Notification/interface/BeginOfJob.h"
#include "SimG4Core/Notification/interface/BeginOfEvent.h"
#include "SimG4Core/Notification/interface/BeginOfTrack.h"
#include "SimG4Core/Notification/interface/EndOfTrack.h"
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "G4Step.hh"
#include "G4Track.hh"
#include "G4VSolid.hh"
#include "G4LogicalVolumeStore.hh"
#include "G4TouchableHistory.hh"
#include "G4VPhysicalVolume.hh"
#include "G4AffineTransform.hh"
#include "TrackingMaterialProducer.h"
#include "SimG4Core/Watcher/interface/SimWatcherFactory.h"
#include "FWCore/Framework/interface/MakerMacros.h"

Go to the source code of this file.

Macros
#define	DEBUG_G4_VOLUMES

Functions
std::tuple< const G4VPhysicalVolume *, int >	GetSensitiveVolume (const G4VTouchable *touchable)
static const G4AffineTransform &	GetTransform (const G4TouchableHistory *touchable, int depth)
static const G4LogicalVolume *	GetVolume (const std::string &name)
static const SimWatcherFactory ::PMaker< SimWatcherMaker< TrackingMaterialProducer > >	s_maker__LINE__ ("TrackingMaterialProducer")

Macro Definition Documentation

DEBUG_G4_VOLUMES

#define DEBUG_G4_VOLUMES

Definition at line 35 of file TrackingMaterialProducer.cc.

Function Documentation

GetSensitiveVolume()

std::tuple<const G4VPhysicalVolume*, int> GetSensitiveVolume

(

const G4VTouchable *

touchable

)

Definition at line 68 of file TrackingMaterialProducer.cc.

                                                                                          {
  int depth = touchable->GetHistoryDepth();
  for (int level = 0; level < depth; ++level) {  // 0 is self
    const G4VPhysicalVolume* volume = touchable->GetVolume(level);
    if (volume->GetLogicalVolume()->GetSensitiveDetector() != nullptr) {
      return std::make_tuple(volume, level);
    }
  }
  return std::tuple<const G4VPhysicalVolume*, int>(nullptr, 0);
}

References LEDCalibrationChannels::depth, and personalPlayback::level.

Referenced by TrackingMaterialProducer::update().

GetTransform()

static const G4AffineTransform& GetTransform ( const G4TouchableHistory *  touchable, int  depth  )

inlinestatic

Definition at line 58 of file TrackingMaterialProducer.cc.

                                                                                                    {
  return touchable->GetHistory()->GetTransform(touchable->GetHistory()->GetDepth() - depth);
}

References LEDCalibrationChannels::depth.

Referenced by FWGeoTopNode::paintShape(), and TrackingMaterialProducer::update().

GetVolume()

static const G4LogicalVolume* GetVolume ( const std::string &  name )

static

Definition at line 41 of file TrackingMaterialProducer.cc.

                                                               {
  const G4LogicalVolumeStore* lvs = G4LogicalVolumeStore::GetInstance();
 
#ifdef DEBUG_G4_VOLUMES
  for (G4LogicalVolumeStore::const_iterator volume = lvs->begin(); volume != lvs->end(); ++volume)
    LogInfo("TrackingMaterialProducer") << "TrackingMaterialProducer: G4 registered volumes " << (*volume)->GetName()
                                        << std::endl;
#endif
 
  for (G4LogicalVolumeStore::const_iterator volume = lvs->begin(); volume != lvs->end(); ++volume) {
    if ((const std::string&)(*volume)->GetName() == name)
      return (*volume);
  }
  return nullptr;
}

References Skims_PA_cff::name, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by GflashEMShowerModel::ModelTrigger(), and TrackingMaterialProducer::update().

s_maker__LINE__()

static const SimWatcherFactory ::PMaker< SimWatcherMaker< TrackingMaterialProducer > > s_maker__LINE__ ( "TrackingMaterialProducer"  )

static