fastsim::SimplifiedGeometryFactory Class Reference

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 40 of file SimplifiedGeometryFactory.h.

Member Enumeration Documentation

LayerType

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 57 of file SimplifiedGeometryFactory.h.

{ BARREL, POSFWD, NEGFWD };

Constructor & Destructor Documentation

SimplifiedGeometryFactory()

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

createBarrelSimplifiedGeometry()

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 looper::cfg.

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()));
}

createForwardSimplifiedGeometry()

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 46 of file SimplifiedGeometryFactory.cc.

References looper::cfg, and Exception.

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()));
}

createSimplifiedGeometry()

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 57 of file SimplifiedGeometryFactory.cc.

References BARREL, CaloMaterial_cfi::caloType, looper::cfg, fastsim::SimplifiedGeometry::ECAL, Exception, getDetLayer(), fastsim::SimplifiedGeometry::HCAL, mps_fire::i, ecaldqm::isForward(), label, TH2PolyOfflineMaps::limits, point, GeometricSearchDet::position(), position, fastsim::SimplifiedGeometry::PRESHOWER1, fastsim::SimplifiedGeometry::PRESHOWER2, AlCaHLTBitMon_QueryRunRegistry::string, Calorimetry_cff::thickness, fastsim::SimplifiedGeometry::VFCAL, and PV3DBase< T, PVType, FrameType >::z().

                                                                                                 {
  // 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 = std::make_unique<fastsim::ForwardSimplifiedGeometry>(position);
  } else {
    layer = std::make_unique<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_ = std::make_unique<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_ =
      std::make_unique<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;
}

getDetLayer()

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 222 of file SimplifiedGeometryFactory.cc.

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

                                                                                               {
  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;
  }
}

Member Data Documentation

barrelDetLayersMap_

std::map<std::string, const std::vector<BarrelDetLayer const *> *> fastsim::SimplifiedGeometryFactory::barrelDetLayersMap_

private

A map of strings and pointers to detLayers.

Definition at line 102 of file SimplifiedGeometryFactory.h.

Referenced by SimplifiedGeometryFactory().

forwardDetLayersMap_

std::map<std::string, const std::vector<ForwardDetLayer const *> *> fastsim::SimplifiedGeometryFactory::forwardDetLayersMap_

private

A map of strings and pointers to detLayers.

Definition at line 104 of file SimplifiedGeometryFactory.h.

Referenced by SimplifiedGeometryFactory().

geometricSearchTracker_

const GeometricSearchTracker* const fastsim::SimplifiedGeometryFactory::geometricSearchTracker_

private

The full tracker geometry.

Definition at line 96 of file SimplifiedGeometryFactory.h.

Referenced by SimplifiedGeometryFactory().

interactionModelMap_

const std::map<std::string, fastsim::InteractionModel *>* fastsim::SimplifiedGeometryFactory::interactionModelMap_

private

Map of interaction models.

Definition at line 98 of file SimplifiedGeometryFactory.h.

magneticField_

const MagneticField* const fastsim::SimplifiedGeometryFactory::magneticField_

private

The full magnetic field.

Definition at line 97 of file SimplifiedGeometryFactory.h.

magneticFieldHistMaxR_

const double fastsim::SimplifiedGeometryFactory::magneticFieldHistMaxR_

private

Limit in R for histogram of magnetic field.

Definition at line 99 of file SimplifiedGeometryFactory.h.

magneticFieldHistMaxZ_

const double fastsim::SimplifiedGeometryFactory::magneticFieldHistMaxZ_

private

Limit in +-Z for histogram of magnetic field.

Definition at line 100 of file SimplifiedGeometryFactory.h.