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


#endif