Constructs a tracker layer according to entry in python config (incl interaction models). More...

#include <SimplifiedGeometryFactory.h>

Public Types
enum	LayerType { BARREL, POSFWD, NEGFWD }
	Each layer is either a barrel layer, or a forward layer (either at ppositive or negative Z). More...

Public Member Functions
std::unique_ptr< BarrelSimplifiedGeometry >	createBarrelSimplifiedGeometry (const edm::ParameterSet &cfg) const
	Helper method for createSimplifiedGeometry(..) to create a barrel layer (BarrelSimplifiedGeometry). More...

std::unique_ptr< ForwardSimplifiedGeometry >	createForwardSimplifiedGeometry (LayerType type, const edm::ParameterSet &cfg) const
	Helper method for createSimplifiedGeometry(..) to create a forward layer (ForwardSimplifiedGeometry). More...

std::unique_ptr< SimplifiedGeometry >	createSimplifiedGeometry (LayerType type, const edm::ParameterSet &cfg) const
	Main method of this class. Creates a new detector layer (SimplifiedGeometry). More...

	SimplifiedGeometryFactory (const GeometricSearchTracker geometricSearchTracker, const MagneticField &magneticField, const std::map< std::string, fastsim::InteractionModel > &interactionModelMap, double magneticFieldHistMaxR, double magneticFieldHistMaxZ)
	Constructor. More...

Private Member Functions
const DetLayer *	getDetLayer (const std::string &detLayerName, const GeometricSearchTracker &geometricSearchTracker) const
	Method returns a pointer to a DetLayer according to the string that was passed. More...

Private Attributes
std::map< std::string, const std::vector< BarrelDetLayer const * > * >	barrelDetLayersMap_
	A map of strings and pointers to detLayers. More...

std::map< std::string, const std::vector< ForwardDetLayer const * > * >	forwardDetLayersMap_
	A map of strings and pointers to detLayers. More...

const GeometricSearchTracker *const	geometricSearchTracker_
	The full tracker geometry. More...

const std::map< std::string, fastsim::InteractionModel * > *	interactionModelMap_
	Map of interaction models. More...

const MagneticField *const	magneticField_
	The full magnetic field. More...

const double	magneticFieldHistMaxR_
	Limit in R for histogram of magnetic field. More...

const double	magneticFieldHistMaxZ_
	Limit in +-Z for histogram of magnetic field. More...

Detailed Description

Constructs a tracker layer according to entry in python config (incl interaction models).

Also creates links to DetLayer (if active layer) and stores strength of magnetic field along the layer. If some parameters are not stored in the config file, tries to get them from the full detector geometry (GeometricSearchTracker). This is however only possible for active layers.

See also: Geometry(); SimplifiedGeometry()

Definition at line 44 of file SimplifiedGeometryFactory.h.

Member Enumeration Documentation

enum fastsim::SimplifiedGeometryFactory::LayerType

Each layer is either a barrel layer, or a forward layer (either at ppositive or negative Z).

Enumerator
BARREL
POSFWD
NEGFWD

Definition at line 62 of file SimplifiedGeometryFactory.h.

62 {BARREL, POSFWD, NEGFWD};

fastsim::SimplifiedGeometryFactory::POSFWD

Definition: SimplifiedGeometryFactory.h:62

fastsim::SimplifiedGeometryFactory::BARREL

Definition: SimplifiedGeometryFactory.h:62

fastsim::SimplifiedGeometryFactory::NEGFWD

Definition: SimplifiedGeometryFactory.h:62

Constructor & Destructor Documentation

fastsim::SimplifiedGeometryFactory::SimplifiedGeometryFactory	(	const GeometricSearchTracker *	geometricSearchTracker,
		const MagneticField &	magneticField,
		const std::map< std::string, fastsim::InteractionModel * > &	interactionModelMap,
		double	magneticFieldHistMaxR,
		double	magneticFieldHistMaxZ
	)

Constructor.

Parameters

geometricSearchTracker	The full tracker geometry (needed for links to active detLayers).
magneticField	The full magnetic field.
interactionModelMap	Map of interaction models that should be assigned for that layer.
magneticFieldHistMaxR	Max Radius for initialization of magnetic field histogram (TH1, limit of axis).
magneticFieldHistMaxZ	Max Z for initialization of magnetic field histogram (TH1, limit of axis).

Definition at line 14 of file SimplifiedGeometryFactory.cc.

References barrelDetLayersMap_, forwardDetLayersMap_, geometricSearchTracker_, GeometricSearchTracker::negPixelForwardLayers(), GeometricSearchTracker::negTecLayers(), GeometricSearchTracker::negTidLayers(), GeometricSearchTracker::pixelBarrelLayers(), GeometricSearchTracker::posPixelForwardLayers(), GeometricSearchTracker::posTecLayers(), GeometricSearchTracker::posTidLayers(), GeometricSearchTracker::tibLayers(), and GeometricSearchTracker::tobLayers().

     : geometricSearchTracker_(geometricSearchTracker)
     , magneticField_(&magneticField)
     , interactionModelMap_(&interactionModelMap)
     , magneticFieldHistMaxR_(magneticFieldHistMaxR)
     , magneticFieldHistMaxZ_(magneticFieldHistMaxZ)
 {
     // naming convention for barrel DetLayer lists
     barrelDetLayersMap_["BPix"] = &geometricSearchTracker_->pixelBarrelLayers();
     barrelDetLayersMap_["TIB"] = &geometricSearchTracker_->tibLayers();
     barrelDetLayersMap_["TOB"] = &geometricSearchTracker_->tobLayers();
 
     // naming convention for forward DetLayer lists
     forwardDetLayersMap_["negFPix"] = &geometricSearchTracker_->negPixelForwardLayers();
     forwardDetLayersMap_["posFPix"] = &geometricSearchTracker_->posPixelForwardLayers();
     forwardDetLayersMap_["negTID"] = &geometricSearchTracker_->negTidLayers();
     forwardDetLayersMap_["posTID"] = &geometricSearchTracker_->posTidLayers();
     forwardDetLayersMap_["negTEC"] = &geometricSearchTracker_->negTecLayers();
     forwardDetLayersMap_["posTEC"] = &geometricSearchTracker_->posTecLayers();
 }

Member Function Documentation

std::unique_ptr< fastsim::BarrelSimplifiedGeometry > fastsim::SimplifiedGeometryFactory::createBarrelSimplifiedGeometry ( const edm::ParameterSet & cfg ) const

Helper method for createSimplifiedGeometry(..) to create a barrel layer (BarrelSimplifiedGeometry).

Returns: A BarrelSimplifiedGeometry

See also: createSimplifiedGeometry(LayerType type, const edm::ParameterSet & cfg)

Definition at line 39 of file SimplifiedGeometryFactory.cc.

References BARREL, and createSimplifiedGeometry().

Referenced by fastsim::Geometry::update().

 {
     std::unique_ptr<fastsim::SimplifiedGeometry> layer = createSimplifiedGeometry(BARREL,cfg);
     return std::unique_ptr<fastsim::BarrelSimplifiedGeometry>(static_cast<fastsim::BarrelSimplifiedGeometry *>(layer.release()));
 }

std::unique_ptr< fastsim::ForwardSimplifiedGeometry > fastsim::SimplifiedGeometryFactory::createForwardSimplifiedGeometry	(	LayerType	type,
		const edm::ParameterSet &	cfg
	)		const

Helper method for createSimplifiedGeometry(..) to create a forward layer (ForwardSimplifiedGeometry).

Parameters

type	Either POSFWD or NEGFWD.

Returns: A ForwardSimplifiedGeometry

See also: createSimplifiedGeometry(LayerType type, const edm::ParameterSet & cfg)

Definition at line 45 of file SimplifiedGeometryFactory.cc.

References createSimplifiedGeometry(), Exception, NEGFWD, and POSFWD.

Referenced by fastsim::Geometry::update().

 {
     if(layerType != NEGFWD && layerType != POSFWD)
     {
        throw cms::Exception("fastsim::SimplifiedGeometry::createForwardLayer") << " called with forbidden layerType. Allowed layerTypes are NEGFWD and POSFWD";
     }
     std::unique_ptr<fastsim::SimplifiedGeometry> layer = createSimplifiedGeometry(layerType,cfg);
     return std::unique_ptr<fastsim::ForwardSimplifiedGeometry>(static_cast<fastsim::ForwardSimplifiedGeometry *>(layer.release()));
 }

std::unique_ptr< fastsim::SimplifiedGeometry > fastsim::SimplifiedGeometryFactory::createSimplifiedGeometry	(	LayerType	type,
		const edm::ParameterSet &	cfg
	)		const

Main method of this class. Creates a new detector layer (SimplifiedGeometry).

Reads the config file, does all the initialization etc. and creates either a forward or a barrel layer (depends on LayerType type).

Parameters

type	Either BARREL, POSFWD or NEGFWD.

Returns: A SimplifiedGeometry (either ForwardSimplifiedGeometry or BarrelSimplifiedGeometry).

Definition at line 56 of file SimplifiedGeometryFactory.cc.

References edm::ParameterSet::allToString(), BARREL, fastsim::SimplifiedGeometry::ECAL, Exception, edm::ParameterSet::exists(), geometricSearchTracker_, getDetLayer(), edm::ParameterSet::getUntrackedParameter(), fastsim::SimplifiedGeometry::HCAL, mps_fire::i, interactionModelMap_, MagneticField::inTesla(), ecaldqm::isForward(), label, magneticField_, magneticFieldHistMaxR_, magneticFieldHistMaxZ_, point, POSFWD, GeometricSearchDet::position(), position, fastsim::SimplifiedGeometry::PRESHOWER1, fastsim::SimplifiedGeometry::PRESHOWER2, AlCaHLTBitMon_QueryRunRegistry::string, fastsim::SimplifiedGeometry::VFCAL, and PV3DBase< T, PVType, FrameType >::z().

Referenced by createBarrelSimplifiedGeometry(), and createForwardSimplifiedGeometry().

 {
 
     // some flags for internal usage
     bool isForward = true;
     bool isOnPositiveSide = false;
     if(layerType == BARREL)
     {
        isForward = false;
     }
     else if(layerType == POSFWD)
     {
        isOnPositiveSide = true;
     }
 
     // -------------------------------
     // extract DetLayer (i.e. full geometry of tracker modules)
     // -------------------------------
 
     std::string detLayerName = cfg.getUntrackedParameter<std::string>("activeLayer","");
     const DetLayer * detLayer = nullptr;
 
     if(!detLayerName.empty() && geometricSearchTracker_)
     {
         if(isForward)
         {
             detLayerName = (isOnPositiveSide ? "pos" : "neg") + detLayerName;
         }
         detLayer = getDetLayer(detLayerName,*geometricSearchTracker_);
     }
 
     // ------------------------------
     // radius / z of layers
     // ------------------------------
     
     // first try to get it from the configuration
     double position = 0;
     std::string positionParameterName = (isForward ? "z" : "radius");
     if(cfg.exists(positionParameterName))
     {
         position = fabs(cfg.getUntrackedParameter<double>(positionParameterName));
         if(isForward && !isOnPositiveSide)
         {
             position = -position;
         }
     }
     // then try extracting from detLayer
     else if(detLayer)
     {
         if(isForward)
         {
             position = static_cast<ForwardDetLayer const*>(detLayer)->surface().position().z();
         }
         else
         {
             position = static_cast<BarrelDetLayer const*>(detLayer)->specificSurface().radius();
         }
     }
     // then throw error
     else
     {
         std::string cfgString;
         cfg.allToString(cfgString);
         throw cms::Exception("fastsim::SimplifiedGeometry") << "Cannot extract a " 
                                   << (isForward ? "position" : "radius") << " for this " 
                                   << (isForward ? "forward" : "barrel") << " layer:\n"
                                   << cfgString;
     }
     
     // -----------------------------
     // create the layers
     // -----------------------------
 
     std::unique_ptr<fastsim::SimplifiedGeometry> layer;
     if(isForward)
     {
        layer.reset(new fastsim::ForwardSimplifiedGeometry(position));
     }
     else
     {
        layer.reset(new fastsim::BarrelSimplifiedGeometry(position));
     }
     layer->detLayer_ = detLayer;
 
     // -----------------------------
     // thickness histogram
     // -----------------------------
 
     // Get limits
     const std::vector<double> & limits = cfg.getUntrackedParameter<std::vector<double> >("limits");
     // and check order.
     for(unsigned index = 1;index < limits.size();index++)
     {
         if(limits[index] < limits[index-1])
         {
             std::string cfgString;
             cfg.allToString(cfgString);
             throw cms::Exception("fastsim::SimplifiedGeometryFactory") 
                 << "limits must be provided in increasing order. error in:\n"
                 << cfgString;
         }
     }
     // Get thickness values
     const std::vector<double> & thickness = cfg.getUntrackedParameter<std::vector<double> >("thickness");
     // and check compatibility with limits
     if(limits.size() < 2 || thickness.size() != limits.size() - 1)
     {
         std::string cfgString;
         cfg.allToString(cfgString);
         throw cms::Exception("fastim::SimplifiedGeometryFactory") 
             << "layer thickness and limits not configured properly! error in:"
             << cfgString;
     }
     // create the histogram
     layer->thicknessHist_.reset(new TH1F("h", "h", limits.size()-1, &limits[0]));
     layer->thicknessHist_->SetDirectory(nullptr);
     for(unsigned i = 1; i < limits.size(); ++i){
        layer->thicknessHist_->SetBinContent(i, thickness[i-1]);
     }
     
     // -----------------------------
     // nuclear interaction thickness factor
     // -----------------------------
 
     layer->nuclearInteractionThicknessFactor_ = cfg.getUntrackedParameter<double>("nuclearInteractionThicknessFactor",1.);
 
     // -----------------------------
     // magnetic field
     // -----------------------------
     
     layer->magneticFieldHist_.reset(new TH1F("h", "h", 100, 0., isForward ? magneticFieldHistMaxR_ : magneticFieldHistMaxZ_));
     layer->magneticFieldHist_->SetDirectory(nullptr);
     for(int i = 1; i <= 101; i++)
     {
         GlobalPoint point = isForward ? 
             GlobalPoint(layer->magneticFieldHist_->GetXaxis()->GetBinCenter(i), 0.,position)
             : GlobalPoint(position, 0.,layer->magneticFieldHist_->GetXaxis()->GetBinCenter(i));
         layer->magneticFieldHist_->SetBinContent(i, magneticField_->inTesla(point).z());
     }
     
     // -----------------------------
     // list of interaction models
     // -----------------------------
 
     std::vector<std::string> interactionModelLabels = cfg.getUntrackedParameter<std::vector<std::string> >("interactionModels");
     for(const auto & label : interactionModelLabels)
     {
         std::map<std::string,fastsim::InteractionModel *>::const_iterator interactionModel = interactionModelMap_->find(label);
         if(interactionModel == interactionModelMap_->end())
         {
             throw cms::Exception("fastsim::SimplifiedGeometryFactory") << "unknown interaction model '" << label << "'";
         }
         layer->interactionModels_.push_back(interactionModel->second);
     }
 
     // -----------------------------
     // Hack to interface "old" calorimetry with "new" propagation in tracker
     // -----------------------------
 
     if(cfg.exists("caloType"))
     {
         std::string caloType = cfg.getUntrackedParameter<std::string>("caloType");
 
         if(caloType == "PRESHOWER1"){
             layer->setCaloType(SimplifiedGeometry::PRESHOWER1);
         }else if(caloType == "PRESHOWER2"){
             layer->setCaloType(SimplifiedGeometry::PRESHOWER2);
         }else if(caloType == "ECAL"){
             layer->setCaloType(SimplifiedGeometry::ECAL);
         }else if(caloType == "HCAL"){
             layer->setCaloType(SimplifiedGeometry::HCAL);
         }else if(caloType == "VFCAL"){
             layer->setCaloType(SimplifiedGeometry::VFCAL);
         }else{
             throw cms::Exception("fastsim::SimplifiedGeometryFactory") << "unknown caloType '" << caloType << "' (defined PRESHOWER1, PRESHOWER2, ECAL, HCAL, VFCAL)";
         }
     }
 
 
     // -----------------------------
     // and return the layer!
     // -----------------------------
 
     return layer;
 } 

const DetLayer * fastsim::SimplifiedGeometryFactory::getDetLayer	(	const std::string &	detLayerName,
		const GeometricSearchTracker &	geometricSearchTracker
	)		const

private

Method returns a pointer to a DetLayer according to the string that was passed.

A convention for the name of the layer is used. For barrel layers this is "XXX?" where XXX is a part of the tracker and ? is the index of the layer (starting at one). For forward layers one has to add neg/pos in front to distinguish between the disk at -Z and +Z spatial position, so the convention is "xxxXXX?" Valid names: BPix, TIB, TOB, negFPix, posFPix, negTID, posTID, negTEC, posTEC Accordingly, the innermost layer of the barrel pixel detector is "BPix1".

Parameters

detLayerName A string following the naming convention.

Definition at line 244 of file SimplifiedGeometryFactory.cc.

References barrelDetLayersMap_, relativeConstraints::error, Exception, forwardDetLayersMap_, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by createSimplifiedGeometry().

 {
     if(detLayerName.empty())
     {
        return nullptr;
     }
 
     // obtain the index from the detLayerName
     unsigned pos = detLayerName.size();
     while(isdigit(detLayerName[pos-1]))
     {
        pos -= 1;
     }
     if(pos == detLayerName.size())
     {
        throw cms::Exception("fastsim::SimplifiedGeometry::getDetLayer") << "last part of detLayerName must be index of DetLayer in list. Error in detLayerName" << detLayerName << std::endl;
     }
     int index = atoi(detLayerName.substr(pos).c_str());
     std::string detLayerListName = detLayerName.substr(0,pos);
 
     try 
     {
         // try to find the detLayer in the barrel map
         if(barrelDetLayersMap_.find(detLayerListName) != barrelDetLayersMap_.end())
         {
             auto detLayerList = barrelDetLayersMap_.find(detLayerListName)->second;
             return detLayerList->at(index-1); // use at, to provoce the throwing of an error in case of a bad index
         }
         
         // try to find the detLayer in the forward map
         else if(forwardDetLayersMap_.find(detLayerListName) != forwardDetLayersMap_.end())
         {
             auto detLayerList = forwardDetLayersMap_.find(detLayerListName)->second;
             return detLayerList->at(index-1); // use at, to provoce the throwing of an error in case of a bad index
         }
         // throw an error
         else
         {
             throw cms::Exception("fastsim::SimplifiedGeometry::getDetLayer") << " could not find list of detLayers corresponding to detLayerName " << detLayerName << std::endl;
         }
     }
     catch (const std::out_of_range& error)
     {
        throw cms::Exception("fastsim::SimplifiedGeometry::getDetLayer") << " index out of range for detLayerName: " << detLayerName << " " << error.what() << std::endl;
     }
 }