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/Framework/interface/FrameworkfwdMostUsed.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/ESGetToken.h"
#include "MagneticField/Engine/interface/MagneticField.h"
#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
#include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h"
#include "RecoTracker/TkDetLayers/interface/GeometricSearchTracker.h"

// Author: L. Vanelderen, S. Kurz
// Date: 29 May 2017

#include <vector>

namespace fastsim {
  class InteractionModel;


  class Geometry {
  public:
    Geometry(const edm::ParameterSet&, edm::ConsumesCollector&&);

    ~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_;  

    edm::ESGetToken<GeometricSearchTracker, TrackerRecoGeometryRecord> geometricSearchTrackerESToken_;
    edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> magneticFieldESToken_;
  };
  std::ostream& operator<<(std::ostream& os, const fastsim::Geometry& geometry);
}  // namespace fastsim

#endif