TrackClassifier.h

Go to the documentation of this file.

#ifndef TrackClassifier_h
#define TrackClassifier_h

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/Utilities/interface/InputTag.h"

#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
#include "MagneticField/Engine/interface/MagneticField.h"

#include "DataFormats/BeamSpot/interface/BeamSpot.h"

#include "SimGeneral/HepPDTRecord/interface/ParticleDataTable.h"

#include "SimTracker/TrackHistory/interface/TrackCategories.h"
#include "SimTracker/TrackHistory/interface/TrackHistory.h"
#include "SimTracker/TrackHistory/interface/TrackQuality.h"

#include "TrackingTools/PatternTools/interface/TSCPBuilderNoMaterial.h"
#include "TrackingTools/Records/interface/TransientTrackRecord.h"
#include "TrackingTools/TrajectoryState/interface/FreeTrajectoryState.h"
#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"


class TrackTopology;

class TrackClassifier : public TrackCategories
{

public:

    typedef TrackCategories Categories;

    TrackClassifier(edm::ParameterSet const &);

    void newEvent(edm::Event const &, edm::EventSetup const &);

    TrackClassifier const & evaluate (reco::TrackBaseRef const &);

    TrackClassifier const & evaluate (TrackingParticleRef const &);

    TrackClassifier const & evaluate (reco::TrackRef const & track)
    {
      return evaluate( reco::TrackBaseRef(track));
    }

    TrackHistory const & history() const
    {
        return tracer_;
    }

    TrackQuality const & quality() const
    {
        return quality_;
    }

private:

    const edm::InputTag hepMCLabel_;
    const edm::InputTag beamSpotLabel_;

    double badPull_;
    double longLivedDecayLength_;
    double vertexClusteringSqDistance_;
    unsigned int numberOfInnerLayers_;
    unsigned int minTrackerSimHits_;

    struct G4
    {
        enum Process
        {
            Undefined = 0,
            Unknown,
            Primary,
            Hadronic,
            Decay,
            Compton,
            Annihilation,
            EIoni,
            HIoni,
            MuIoni,
            Photon,
            MuPairProd,
            Conversions,
            EBrem,
            SynchrotronRadiation,
            MuBrem,
            MuNucl
        };
    };

    TrackHistory tracer_;

    TrackQuality quality_;

    edm::ESHandle<MagneticField> magneticField_;

    edm::Handle<edm::HepMCProduct> mcInformation_;

    edm::ESHandle<ParticleDataTable> particleDataTable_;

    edm::ESHandle<TransientTrackBuilder> transientTrackBuilder_;

    edm::Handle<reco::BeamSpot> beamSpot_;

    const TrackerTopology *tTopo_;

    void reconstructionInformation(reco::TrackBaseRef const &);

    void simulationInformation();

    void qualityInformation(reco::TrackBaseRef const &);

    void hadronFlavor();

    void processesAtGenerator();

    void processesAtSimulation();

    void vertexInformation();

    struct GeneratedPrimaryVertex
    {

        GeneratedPrimaryVertex(double x1,double y1,double z1): x(x1), y(y1), z(z1), ptsq(0), nGenTrk(0) {}

        bool operator< ( GeneratedPrimaryVertex const & reference) const
        {
            return ptsq < reference.ptsq;
        }

        double x, y, z;
        double ptsq;
        int nGenTrk;

        HepMC::FourVector ptot;

        std::vector<int> finalstateParticles;
        std::vector<int> simTrackIndex;
        std::vector<int> genVertex;
    };

    std::vector<GeneratedPrimaryVertex> genpvs_;

    // Auxiliary function to get the generated primary vertex
    bool isFinalstateParticle(const HepMC::GenParticle *);
    bool isCharged(const HepMC::GenParticle *);
    void genPrimaryVertices();

};

#endif