CTPPSFastTrackingProducer.h

Go to the documentation of this file.

#ifndef FastSimulation_CTPPSFastTrackingProducer_h
#define FastSimulation_CTPPSFastTrackingProducer_h

// user include files
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/stream/EDProducer.h"

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/Framework/interface/MakerMacros.h"

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

#include "FWCore/Framework/interface/ConsumesCollector.h"

#include "FastSimDataFormats/CTPPSFastSim/interface/CTPPSFastRecHit.h"
#include "FastSimDataFormats/CTPPSFastSim/interface/CTPPSFastRecHitContainer.h"
#include "DataFormats/Common/interface/Handle.h"

#include "FastSimDataFormats/CTPPSFastSim/interface/CTPPSFastTrack.h"
#include "FastSimDataFormats/CTPPSFastSim/interface/CTPPSFastTrackContainer.h"

#include "FastSimulation/CTPPSFastGeometry/interface/CTPPSTrkDetector.h"
#include "FastSimulation/CTPPSFastGeometry/interface/CTPPSToFDetector.h"

#include "FWCore/ParameterSet/interface/FileInPath.h"
#include "Utilities/PPS/interface/PPSUnitConversion.h"

#include "Utilities/PPS/interface/PPSUtilities.h"

//C++ library
#include <iostream>
#include <fstream>
#include <string>
#include <cmath>
#include <cmath>
#include <map>
#include <vector>
#include <utility>
#include <cmath>

#include "DataFormats/Math/interface/Vector.h"
#include "DataFormats/Math/interface/Vector3D.h"
#include "DataFormats/Math/interface/Point3D.h"



//
// class declaration
//
class H_BeamParticle;
class H_RecRPObject;
class H_BeamLine;

class CTPPSFastTrackingProducer : public edm::stream::EDProducer<> {
    public:
        explicit CTPPSFastTrackingProducer(const edm::ParameterSet&);
        ~CTPPSFastTrackingProducer() override;

    private:
        void beginStream(edm::StreamID) override;
        void produce(edm::Event&, const edm::EventSetup&) override;
        void endStream() override;
        //this function will only be called once per event
        virtual void beginEvent(edm::Event& event, const edm::EventSetup& eventSetup);
        virtual void endEvent(edm::Event& event, const edm::EventSetup& eventSetup);

        // ----------member data ---------------------------

        typedef std::vector<CTPPSFastRecHit> CTPPSFastRecHitContainer;
        edm::EDGetTokenT< CTPPSFastRecHitContainer > _recHitToken;
        void ReadRecHits(edm::Handle<CTPPSFastRecHitContainer> &);
        void FastReco(int Direction,H_RecRPObject* station);
        void Reconstruction();  
        void ReconstructArm(H_RecRPObject* pps_station, double x1,double y1,double x2,double y2, double& tx, double& ty,double& eloss);
        void MatchCellId(int cellId, std::vector<int> vrecCellId, std::vector<double> vrecTof, bool& match, double& recTof);
        bool SearchTrack(int ,int ,int Direction,double& xi,double& t,double& partP,double& pt,double& thx,double& thy,
                        double& x0,double& y0, double& xt, double& yt, double& X1d, double& Y1d, double& X2d, double& Y2d);
        void TrackerStationClear();
        void TrackerStationStarting();
        void ProjectToToF(const double x1, const double y1, const double x2, const double y2, double& xt, double& yt) {    
            xt = ((fz_timing-fz_tracker2)*(x2-x1)/(fz_tracker2-fz_tracker1)) + x2;
            yt = ((fz_timing-fz_tracker2)*(y2-y1)/(fz_tracker2-fz_tracker1)) + y2;
        };
        // Hector objects
        bool SetBeamLine();

        std::map<unsigned int, H_BeamParticle*> m_beamPart;
    std::unique_ptr<H_BeamLine> m_beamlineCTPPS1;
        std::unique_ptr<H_BeamLine> m_beamlineCTPPS2;
        std::unique_ptr<H_RecRPObject> pps_stationF;
        std::unique_ptr<H_RecRPObject> pps_stationB;

        std::string beam1filename;
        std::string beam2filename;

        // Defaults
        double lengthctpps ;
        bool   m_verbosity;
        double fBeamEnergy;
        double fBeamMomentum;
        bool   fCrossAngleCorr;
        double fCrossingAngleBeam1;
        double fCrossingAngleBeam2;
        std::unique_ptr<CTPPSTrkStation> TrkStation_F; // auxiliary object with the tracker geometry
        std::unique_ptr<CTPPSTrkStation> TrkStation_B;
        std::unique_ptr<CTPPSTrkDetector> det1F; 
        std::unique_ptr<CTPPSTrkDetector> det1B;
        std::unique_ptr<CTPPSTrkDetector> det2F; 
        std::unique_ptr<CTPPSTrkDetector> det2B;
        std::unique_ptr<CTPPSToFDetector> detToF_F;
        std::unique_ptr<CTPPSToFDetector> detToF_B;

        std::vector<CTPPSFastTrack> theCTPPSFastTrack;

        CTPPSFastTrack track;

        std::vector<int> recCellId_F, recCellId_B ; 
        std::vector<double> recTof_F, recTof_B ; 
    
    double fz_tracker1, fz_tracker2, fz_timing;
    double fTrackerWidth,fTrackerHeight,fTrackerInsertion,fBeamXRMS_Trk1,fBeamXRMS_Trk2,fTrk1XOffset,fTrk2XOffset;
        std::vector<double> fToFCellWidth;
        double fToFCellHeight,fToFPitchX,fToFPitchY;
        int fToFNCellX,fToFNCellY;
        double fToFInsertion,fBeamXRMS_ToF,fToFXOffset,fTimeSigma,fImpParcut;       


};
#endif