Geometry.h

Go to the documentation of this file.

#ifndef FASTSIM_GEOMETRY_H
#define FASTSIM_GEOMETRY_H
 
#include "DataFormats/Math/interface/LorentzVector.h"
#include "FastSimulation/SimplifiedGeometryPropagator/interface/ForwardSimplifiedGeometry.h"
#include "FastSimulation/SimplifiedGeometryPropagator/interface/BarrelSimplifiedGeometry.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
 
// Author: L. Vanelderen, S. Kurz
// Date: 29 May 2017
 
class GeometricSearchTracker;
class MagneticField;
 
#include <vector>
 
namespace edm {
  //class ParameterSet;
  class EventSetup;
}  // namespace edm
 
namespace fastsim {
  class InteractionModel;
 
 
  class Geometry {
  public:
    Geometry(const edm::ParameterSet& cfg);
 
    ~Geometry();
 
 
    void update(const edm::EventSetup& iSetup, const std::map<std::string, InteractionModel*>& interactionModelMap);
 
 
    double getMagneticFieldZ(const math::XYZTLorentzVector& position) const;
 
 
    const std::vector<std::unique_ptr<BarrelSimplifiedGeometry>>& barrelLayers() const { return barrelLayers_; }
 
 
    const std::vector<std::unique_ptr<ForwardSimplifiedGeometry>>& forwardLayers() const { return forwardLayers_; }
 
 
    double getMaxRadius() { return maxRadius_; }
 
 
    double getMaxZ() { return maxZ_; }
 
    friend std::ostream& operator<<(std::ostream& o, const fastsim::Geometry& geometry);
 
 
    const BarrelSimplifiedGeometry* nextLayer(const BarrelSimplifiedGeometry* layer) const {
      if (layer == nullptr) {
        return nullptr;
      }
      unsigned nextLayerIndex = layer->index() + 1;
      return nextLayerIndex < barrelLayers_.size() ? barrelLayers_[nextLayerIndex].get() : nullptr;
    }
 
 
    const ForwardSimplifiedGeometry* nextLayer(const ForwardSimplifiedGeometry* layer) const {
      if (layer == nullptr) {
        return nullptr;
      }
      unsigned nextLayerIndex = layer->index() + 1;
      return nextLayerIndex < forwardLayers_.size() ? forwardLayers_[nextLayerIndex].get() : nullptr;
    }
 
 
    const BarrelSimplifiedGeometry* previousLayer(const BarrelSimplifiedGeometry* layer) const {
      if (layer == nullptr) {
        return barrelLayers_.back().get();
      }
      return layer->index() > 0 ? barrelLayers_[layer->index() - 1].get() : nullptr;
    }
 
 
    const ForwardSimplifiedGeometry* previousLayer(const ForwardSimplifiedGeometry* layer) const {
      if (layer == nullptr) {
        return forwardLayers_.back().get();
      }
      return layer->index() > 0 ? forwardLayers_[layer->index() - 1].get() : nullptr;
    }
 
  private:
    std::vector<std::unique_ptr<BarrelSimplifiedGeometry>>
        barrelLayers_;  
    std::vector<std::unique_ptr<ForwardSimplifiedGeometry>>
        forwardLayers_;  
    std::unique_ptr<MagneticField>
        ownedMagneticField_;  
 
    unsigned long long cacheIdentifierTrackerRecoGeometry_;  
    unsigned long long cacheIdentifierIdealMagneticField_;   
 
    const GeometricSearchTracker* geometricSearchTracker_;  
    const MagneticField* magneticField_;                    
    const bool useFixedMagneticFieldZ_;  
    const double fixedMagneticFieldZ_;   
    const bool
        useTrackerRecoGeometryRecord_;  
    const std::string trackerAlignmentLabel_;  
    const std::vector<edm::ParameterSet>
        barrelLayerCfg_;  
    const std::vector<edm::ParameterSet>
        forwardLayerCfg_;     
    const double maxRadius_;  
    const double maxZ_;       
 
    const bool barrelBoundary_;                          
    const bool forwardBoundary_;                         
    const edm::ParameterSet trackerBarrelBoundaryCfg_;   
    const edm::ParameterSet trackerForwardBoundaryCfg_;  
  };
  std::ostream& operator<<(std::ostream& os, const fastsim::Geometry& geometry);
}  // namespace fastsim
 
#endif