TrajectorySeedProducer.h

Go to the documentation of this file.

#ifndef FastSimulation_Tracking_TrajectorySeedProducer_h
#define FastSimulation_Tracking_TrajectorySeedProducer_h

#include "FWCore/Framework/interface/stream/EDProducer.h"
#include "FWCore/Utilities/interface/InputTag.h"
#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/BeamSpot/interface/BeamSpot.h"
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "DataFormats/VertexReco/interface/VertexFwd.h"

#include "FastSimulation/Tracking/interface/TrajectorySeedHitCandidate.h"

#include "SimDataFormats/Track/interface/SimTrackContainer.h"
#include "SimDataFormats/Vertex/interface/SimVertexContainer.h"
#include "FastSimulation/Tracking/interface/TrajectorySeedHitCandidate.h"

#include "DataFormats/TrackerRecHit2D/interface/SiTrackerGSRecHit2DCollection.h"
#include "DataFormats/TrackerRecHit2D/interface/SiTrackerGSMatchedRecHit2DCollection.h"
#include "DataFormats/TrajectorySeed/interface/TrajectorySeedCollection.h"

#include "FastSimulation/Tracking/interface/SeedingTree.h"
#include "FastSimulation/Tracking/interface/TrackingLayer.h"
     //#include "DataFormats/BeamSpot/interface/BeamSpot.h"
     //#include "DataFormats/TrackReco/interface/TrackFwd.h"

#include <memory>
#include <vector>
#include <sstream>


class MagneticField;
class MagneticFieldMap;
class TrackerGeometry;
class PropagatorWithMaterial;

class TrajectorySeedProducer:
    public edm::stream::EDProducer<>
{
    private:
        SeedingTree<TrackingLayer> _seedingTree;

        const MagneticField* magneticField;
        const MagneticFieldMap* magneticFieldMap;
        const TrackerGeometry* trackerGeometry;
        const TrackerTopology* trackerTopology;

        std::shared_ptr<PropagatorWithMaterial> thePropagator;

        double simTrack_pTMin;
        double simTrack_maxD0;
        double simTrack_maxZ0;
        
        unsigned int minLayersCrossed;

        std::vector<std::vector<TrackingLayer>> seedingLayers;

        double originRadius;
        double ptMin;
        double originHalfLength;
        double nSigmaZ;
        
        bool testBeamspotCompatibility;
        const reco::BeamSpot* beamSpot;
        bool testPrimaryVertexCompatibility;
        const reco::VertexCollection* primaryVertices;
        // tokens
        edm::EDGetTokenT<reco::BeamSpot> beamSpotToken;
        edm::EDGetTokenT<edm::SimTrackContainer> simTrackToken;
        edm::EDGetTokenT<edm::SimVertexContainer> simVertexToken;
        edm::EDGetTokenT<SiTrackerGSMatchedRecHit2DCollection> recHitToken;
        edm::EDGetTokenT<reco::VertexCollection> recoVertexToken;
        std::vector<edm::EDGetTokenT<std::vector<unsigned int> > > skipSimTrackIdTokens;

    public:

    TrajectorySeedProducer(const edm::ParameterSet& conf);
    
    virtual ~TrajectorySeedProducer()
    {
    }

    virtual void beginRun(edm::Run const& run, const edm::EventSetup & es);
    virtual void produce(edm::Event& e, const edm::EventSetup& es);


    virtual bool passSimTrackQualityCuts(const SimTrack& theSimTrack, const SimVertex& theSimVertex) const;


    inline bool passHitTuplesCuts(
            const SeedingNode<TrackingLayer>& seedingNode,
            const std::vector<TrajectorySeedHitCandidate>& trackerRecHits,
            const std::vector<int>& hitIndicesInTree,
            const TrajectorySeedHitCandidate& currentTrackerHit
        ) const
    {
        switch (seedingNode.getDepth())
        {
            case 0:
            {
                return true;
                /* example for 1 hits
                const TrajectorySeedHitCandidate& hit1 = currentTrackerHit;
                return pass1HitsCuts(hit1,trackingAlgorithmId);
                */
            }

            case 1:
            {
                const SeedingNode<TrackingLayer>* parentNode = &seedingNode;
                parentNode = parentNode->getParent();
                const TrajectorySeedHitCandidate& hit1 = trackerRecHits[hitIndicesInTree[parentNode->getIndex()]];
                const TrajectorySeedHitCandidate& hit2 = currentTrackerHit;

                return pass2HitsCuts(hit1,hit2);
            }
            case 2:
            {
                return true;
                /* example for 3 hits
                const SeedingNode<LayerSpec>* parentNode = &seedingNode;
                parentNode = parentNode->getParent();
                const TrajectorySeedHitCandidate& hit2 = trackerRecHits[hitIndicesInTree[parentNode->getIndex()]];
                parentNode = parentNode->getParent();
                const TrajectorySeedHitCandidate& hit1 = trackerRecHits[hitIndicesInTree[parentNode->getIndex()]];
                const TrajectorySeedHitCandidate& hit3 = currentTrackerHit;
                return pass3HitsCuts(hit1,hit2,hit3,trackingAlgorithmId);
                */
            }
        }
        return true;
    }

    bool pass2HitsCuts(const TrajectorySeedHitCandidate& hit1, const TrajectorySeedHitCandidate& hit2) const;


    virtual std::vector<unsigned int> iterateHits(
            unsigned int start,
            const std::vector<TrajectorySeedHitCandidate>& trackerRecHits,
            std::vector<int> hitIndicesInTree,
            bool processSkippedHits
        ) const;

    inline bool isHitOnLayer(const TrajectorySeedHitCandidate& trackerRecHit, const TrackingLayer& layer) const
    {
        return layer==trackerRecHit.getTrackingLayer();
    }

    bool compatibleWithBeamSpot(
            const GlobalPoint& gpos1, 
            const GlobalPoint& gpos2,
            double error,
            bool forward
    ) const;

    bool compatibleWithPrimaryVertex(
            const GlobalPoint& gpos1,
            const GlobalPoint& gpos2,
            double error,
            bool forward
    ) const;


    const SeedingNode<TrackingLayer>* insertHit(
            const std::vector<TrajectorySeedHitCandidate>& trackerRecHits,
            std::vector<int>& hitIndicesInTree,
            const SeedingNode<TrackingLayer>* node, 
            unsigned int trackerHit
    ) const;


};

#endif