CTPPSFastTrackingProducer.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:    FastSimulation/CTPPSFastTrackingProducer
// Class:      CTPPSFastTrackingProducer
// 
//
// Original Author:  Sandro Fonseca De Souza
//         Created:  Thu, 29 Sep 2016 16:13:41 GMT
//
//


// system include files
#include <memory>

// user include files
#include "FastSimulation/CTPPSFastTrackingProducer/interface/CTPPSFastTrackingProducer.h"
#include "Utilities/PPS/interface/PPSUtilities.h"
#include "TLorentzVector.h"
// hector includes
#include "H_Parameters.h"
#include "H_BeamLine.h"
#include "H_RecRPObject.h"
#include "H_BeamParticle.h"
// constructors and destructor
//
CTPPSFastTrackingProducer::CTPPSFastTrackingProducer(const edm::ParameterSet& iConfig):
    m_verbosity(false), fBeamMomentum(0.), fCrossAngleCorr(false), fCrossingAngleBeam1(0.),fCrossingAngleBeam2(0.)
{
    //register your products
    produces<edm::CTPPSFastTrackContainer>("CTPPSFastTrack");
    using namespace edm;
    _recHitToken = consumes<CTPPSFastRecHitContainer>(iConfig.getParameter<edm::InputTag>("recHitTag"));
    m_verbosity = iConfig.getParameter<bool>("Verbosity");
    // User definitons

    // Read beam parameters needed for Hector reconstruction
    lengthctpps     = iConfig.getParameter<double>("BeamLineLengthCTPPS" );
    beam1filename   = iConfig.getParameter<string>("Beam1");
    beam2filename = iConfig.getParameter<string>("Beam2"); 
    fBeamEnergy = iConfig.getParameter<double>("BeamEnergy"); // beam energy in GeV
    fBeamMomentum = sqrt(fBeamEnergy*fBeamEnergy - PPSTools::ProtonMassSQ);
    fCrossingAngleBeam1 = iConfig.getParameter<double>("CrossingAngleBeam1");
    fCrossingAngleBeam2 = iConfig.getParameter<double>("CrossingAngleBeam2");
  
    if (fCrossingAngleBeam1!=0||fCrossingAngleBeam2!=0) fCrossAngleCorr = true;
    //Read detectors positions and parameters

    fz_tracker1   = iConfig.getParameter<double>("Z_Tracker1");
    fz_tracker2   = iConfig.getParameter<double>("Z_Tracker2");
    fz_timing =  iConfig.getParameter<double>("Z_Timing");   
  //
    fTrackerWidth       = iConfig.getParameter<double>("TrackerWidth");
    fTrackerHeight      = iConfig.getParameter<double>("TrackerHeight");
    fTrackerInsertion   = iConfig.getParameter<double>("TrackerInsertion");
    fBeamXRMS_Trk1 = iConfig.getParameter<double>("BeamXRMS_Trk1");
    fBeamXRMS_Trk2 = iConfig.getParameter<double>("BeamXRMS_Trk2");
    fTrk1XOffset = iConfig.getParameter<double>("Trk1XOffset");
    fTrk2XOffset = iConfig.getParameter<double>("Trk2XOffset");
    fToFCellWidth = iConfig.getUntrackedParameter<std::vector<double> >("ToFCellWidth");
    fToFCellHeight = iConfig.getParameter<double>("ToFCellHeight");
    fToFPitchX = iConfig.getParameter<double>("ToFPitchX");
    fToFPitchY = iConfig.getParameter<double>("ToFPitchY");
    fToFNCellX          = iConfig.getParameter<int>("ToFNCellX");
    fToFNCellY          = iConfig.getParameter<int>("ToFNCellY");
    fToFInsertion       = iConfig.getParameter<double>("ToFInsertion");
    fBeamXRMS_ToF =  iConfig.getParameter<double>("BeamXRMS_ToF");
    fToFXOffset =  iConfig.getParameter<double>("ToFXOffset");
    fTimeSigma =  iConfig.getParameter<double>("TimeSigma");
    fImpParcut =  iConfig.getParameter<double>("ImpParcut");    


    if(!SetBeamLine() ) {
        if ( m_verbosity ) LogDebug("CTPPSFastTrackingProducer") << "CTPPSFastTrackingProducer: WARNING: lengthctpps=  " << lengthctpps;
        return;
    } 

    // Create a particle to get the beam energy from the beam file
    // Take care: the z inside the station is in meters
    //
    //Tracker Detector Description
    det1F =std::unique_ptr<CTPPSTrkDetector>(new CTPPSTrkDetector(fTrackerWidth,fTrackerHeight,fTrackerInsertion*fBeamXRMS_Trk1+fTrk1XOffset));
    det2F =std::unique_ptr<CTPPSTrkDetector>(new CTPPSTrkDetector(fTrackerWidth,fTrackerHeight,fTrackerInsertion*fBeamXRMS_Trk2+fTrk2XOffset));     
    det1B =std::unique_ptr<CTPPSTrkDetector>(new CTPPSTrkDetector(fTrackerWidth,fTrackerHeight,fTrackerInsertion*fBeamXRMS_Trk1+fTrk1XOffset));
    det2B =std::unique_ptr<CTPPSTrkDetector>(new CTPPSTrkDetector(fTrackerWidth,fTrackerHeight,fTrackerInsertion*fBeamXRMS_Trk2+fTrk2XOffset)); 

    //Timing Detector Description
    std::vector<double> vToFCellWidth;
    for (int i = 0 ; i < 8 ; i++){
        vToFCellWidth.push_back(fToFCellWidth[i]);
    }
    double pos_tof = fToFInsertion*fBeamXRMS_ToF+fToFXOffset;
    detToF_F =std::unique_ptr<CTPPSToFDetector>(new CTPPSToFDetector(fToFNCellX,fToFNCellY,vToFCellWidth,fToFCellHeight,fToFPitchX,fToFPitchY,pos_tof,fTimeSigma)); 
    detToF_B =std::unique_ptr<CTPPSToFDetector>(new CTPPSToFDetector(fToFNCellX,fToFNCellY,vToFCellWidth,fToFCellHeight,fToFPitchX,fToFPitchY,pos_tof,fTimeSigma)); 
//
}
CTPPSFastTrackingProducer::~CTPPSFastTrackingProducer()
{
    for (std::map<unsigned int,H_BeamParticle*>::iterator it = m_beamPart.begin(); it != m_beamPart.end(); ++it ) {
        delete (*it).second;
    }
}
// ------------ method called to produce the data  ------------
    void
CTPPSFastTrackingProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup)
{
    using namespace edm;
    TrackerStationStarting();
    Handle<CTPPSFastRecHitContainer> recHits;
    iEvent.getByToken( _recHitToken,recHits);
    recCellId_F.clear();     recCellId_B.clear();  
    recTof_F.clear();     recTof_B.clear();  
    ReadRecHits(recHits);   
    Reconstruction();
    TrackerStationClear();

    std::unique_ptr<CTPPSFastTrackContainer> output_tracks(new CTPPSFastTrackContainer);
    int  n = 0;
    for ( std::vector<CTPPSFastTrack>::const_iterator i = theCTPPSFastTrack.begin();
            i != theCTPPSFastTrack.end(); i++ ) {
        output_tracks->push_back(*i);
        n += 1;
    }

    iEvent.put(std::move(output_tracks),"CTPPSFastTrack");
}//end
void CTPPSFastTrackingProducer::beginEvent(edm::Event& event, const edm::EventSetup& eventSetup)
{
    TrackerStationStarting();

}
void CTPPSFastTrackingProducer::endEvent(edm::Event& event, const edm::EventSetup& eventSetup)
{
    TrackerStationClear();
}

void CTPPSFastTrackingProducer::TrackerStationClear(){

    TrkStation_F->first.clear(); TrkStation_F->second.clear(); 
    TrkStation_B->first.clear(); TrkStation_B->second.clear();
}
void CTPPSFastTrackingProducer::TrackerStationStarting(){
    det1F->clear();
    det1B->clear();
    det2F->clear();
    det2B->clear();
    detToF_F->clear();
    detToF_B->clear();

}


    void 
CTPPSFastTrackingProducer::ReadRecHits(edm::Handle<CTPPSFastRecHitContainer> &recHits)
{
    // DetId codification for PSimHit taken from CTPPSPixel- It will be replaced by CTPPSDetId
    // 2014314496 -> Tracker1 zPositive
    // 2014838784 -> Tracker2 zPositive
    // 2046820352 -> Timing   zPositive
    // 2031091712 -> Tracker1 zNegative
    // 2031616000 -> Tracker2 zNegative
    // 2063597568 -> Timing   zNegative

    for (unsigned int irecHits = 0; irecHits < recHits->size(); ++irecHits)
    {
        const CTPPSFastRecHit* recHitDet = &(*recHits)[irecHits];
        unsigned int detlayerId = recHitDet->detUnitId();
        double x = recHitDet->entryPoint().x();
        double y = recHitDet->entryPoint().y();
        double z = recHitDet->entryPoint().z();
        float tof = recHitDet->tof();  
        if(detlayerId == 2014314496) det1F->AddHit(detlayerId,x,y,z);
        else if(detlayerId == 2014838784) det2F->AddHit(detlayerId,x,y,z);
        else if(detlayerId == 2031091712) det1B->AddHit(detlayerId,x,y,z);
        else if(detlayerId == 2031616000) det2B->AddHit(detlayerId,x,y,z);
        else if(detlayerId == 2046820352) { detToF_F->AddHit(x,y,tof); recCellId_F.push_back(detToF_F->findCellId(x,y)); recTof_F.push_back(tof); } 
        else if(detlayerId == 2063597568) { detToF_B->AddHit(x,y,tof); recCellId_B.push_back(detToF_B->findCellId(x,y)); recTof_B.push_back(tof); }

    }//LOOP TRK
    //creating Stations
    TrkStation_F = std::unique_ptr<CTPPSTrkStation>(new std::pair<CTPPSTrkDetector,CTPPSTrkDetector>(*det1F,*det2F));
    TrkStation_B = std::unique_ptr<CTPPSTrkStation>(new std::pair<CTPPSTrkDetector,CTPPSTrkDetector>(*det1B,*det2B));
} // end function

void CTPPSFastTrackingProducer::Reconstruction()
{
    theCTPPSFastTrack.clear(); 
    int Direction;
    Direction=1; //cms positive Z / forward 
    FastReco(Direction,&*pps_stationF);
    Direction=-1; //cms negative Z / backward
    FastReco(Direction,&*pps_stationB);
}//end Reconstruction

bool CTPPSFastTrackingProducer::SearchTrack(int i,int j,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)
{
    // Given 1 hit in Tracker1 and 1 hit in Tracker2 try to make a track with Hector
    double theta=0.;
    xi = 0; t=0; partP=0; pt=0; x0=0.;y0=0.;xt =0.;yt =0.;X1d=0.;Y1d=0.;X2d=0.;Y2d=0.; 
    CTPPSTrkDetector* det1 = nullptr;
    CTPPSTrkDetector* det2 = nullptr;
    H_RecRPObject*  station = nullptr;
    // Separate in forward and backward stations according to direction
    if (Direction>0) {
        det1=&(TrkStation_F->first);det2=&(TrkStation_F->second);
        station = &*pps_stationF;
    } else {
        det1=&(TrkStation_B->first);det2=&(TrkStation_B->second);
        station = &*pps_stationB;
    }
    if (det1->ppsNHits_<=i||det2->ppsNHits_<=j) return false;
//
    double x1 = det1->ppsX_.at(i); double y1 = det1->ppsY_.at(i);
    double x2 = det2->ppsX_.at(j); double y2 = det2->ppsY_.at(j);
    double eloss;

    //thx and thy are returned in microrad
    ReconstructArm(station,Direction*x1,y1,Direction*x2,y2,thx,thy,eloss); // Pass the hits in the LHC ref. frame
    thx*=-Direction;//  invert to the CMS ref frame

    // Protect for unphysical results
    if (std::isnan(eloss)||std::isinf(eloss)||
            std::isnan(thx)  || std::isinf(thx) ||
            std::isnan(thy)  || std::isinf(thy)) return false;
    //
    
    if ( m_verbosity ) LogDebug("CTPPSFastTrackingProducer::SearchTrack:") << "thx " << thx << " thy " << thy << " eloss " << eloss;

    // Get the start point of the reconstructed track near the origin made by Hector in the CMS ref. frame
    x0 = -Direction*station->getX0()*um_to_cm;
    y0 = station->getY0()*um_to_cm;
    double ImpPar=sqrt(x0*x0+y0*y0);
    if (ImpPar>fImpParcut) return false;
    if (eloss<0.||eloss>fBeamEnergy) return false;
//
    // Calculate the reconstructed track parameters 
    theta = sqrt(thx*thx+thy*thy)*urad;
    xi    = eloss/fBeamEnergy;
    double energy= fBeamEnergy*(1.-xi);
    partP = sqrt(energy*energy-PPSTools::ProtonMassSQ);
    t     = -2.*(PPSTools::ProtonMassSQ- fBeamEnergy*energy + fBeamMomentum*partP*cos(theta));
    pt    = sqrt(pow(partP*thx*urad,2)+pow(partP*thy*urad,2));
    if (xi<0.||xi>1.||t<0.||t>10.||pt<=0.) {
        xi = 0.; t=0.; partP=0.; pt=0.; theta=0.; x0=0.;y0=0.;
        return false; // unphysical values 
    }
    //Try to include the timing detector in the track
    ProjectToToF(x1, y1, x2, y2, xt, yt); // the projections is done in the CMS ref frame
    X1d = x1;
    Y1d = y1;
    X2d = x2;
    Y2d = y2;
    return true;
}//end  SearchTrack

void CTPPSFastTrackingProducer::ReconstructArm(H_RecRPObject* pps_station, double x1, double y1, double x2, double y2, double& tx, double& ty, double& eloss)
{
    tx=0.;
    ty=0.;
    eloss=0.;
    if (!pps_station) return;
    x1*=mm_to_um;
    x2*=mm_to_um;
    y1*=mm_to_um;
    y2*=mm_to_um;
    pps_station->setPositions(x1,y1,x2,y2);
    double energy = pps_station->getE(AM); // dummy call needed to calculate some Hector internal parameter
    if (std::isnan(energy)||std::isinf(energy)) return;
    tx =  pps_station->getTXIP();  // change orientation to CMS
    ty =  pps_station->getTYIP();
    eloss = pps_station->getE();
}

void CTPPSFastTrackingProducer::MatchCellId(int cellId, std::vector<int> vrecCellId, std::vector<double> vrecTof, bool& match, double& recTof){
    for (unsigned int i = 0 ; i < vrecCellId.size(); i++){
        if(cellId == vrecCellId.at(i)) {
            match = true;
            recTof = vrecTof.at(i); 
            continue; 
        } 
    } 
}

void CTPPSFastTrackingProducer::FastReco(int Direction,H_RecRPObject* station)
{
    double theta = 0.;
    double xi,t,partP,pt,phi,x0,y0,thx,thy,xt,yt,X1d,Y1d,X2d,Y2d;
    CTPPSTrkDetector* Trk1 = nullptr;
    CTPPSTrkDetector* Trk2 = nullptr;
    double pos_tof = fToFInsertion*fBeamXRMS_ToF+fToFXOffset;
    int cellId = 0;
    std::vector<double> vToFCellWidth;
    for (int i = 0 ; i < 8 ; i++){
        vToFCellWidth.push_back(fToFCellWidth[i]);
    }
    CTPPSToFDetector* ToF = new CTPPSToFDetector(fToFNCellX,fToFNCellY,vToFCellWidth,fToFCellHeight,fToFPitchX,fToFPitchY,pos_tof,fTimeSigma);
    if (Direction>0) {
        Trk1=&(TrkStation_F->first);Trk2=&(TrkStation_F->second);
    } else {
        Trk1=&(TrkStation_B->first);Trk2=&(TrkStation_B->second);
    }
    // Make a track from EVERY pair of hits combining Tracker1 and Tracker2.
    // The tracks may not be independent as 1 hit may belong to more than 1 track.
    for(int i=0;i<(int)Trk1->ppsNHits_;i++) {
        for(int j=0;j<(int)Trk2->ppsNHits_;j++){
            if (SearchTrack(i,j,Direction,xi,t,partP,pt,thx,thy,x0,y0,xt,yt,X1d,Y1d,X2d,Y2d)) {
                // Check if the hitted timing cell matches the reconstructed track
                cellId = ToF->findCellId(xt,yt);
                double recTof = 0.; 
                bool matchCellId = false; 
                if (Direction > 0 ) {
                    theta = sqrt(thx*thx+thy*thy)*urad;
                    MatchCellId(cellId, recCellId_F, recTof_F, matchCellId, recTof); 
                } 
                else if (Direction<0) { 
                    theta = TMath::Pi() - sqrt(thx*thx+thy*thy)*urad;
                    MatchCellId(cellId, recCellId_B, recTof_B, matchCellId, recTof); 
                }
                phi = atan2(thy,thx); // at this point, thx is already in the cms ref. frame

                double px = partP*sin(theta)*cos(phi);
                double py = partP*sin(theta)*sin(phi);
                double pz = partP*cos(theta);
                double  e = sqrt(partP*partP+PPSTools::ProtonMassSQ);
                TLorentzVector p(px,py,pz,e);
                // Invert the Lorentz boost made to take into account the crossing angle during simulation
                if (fCrossAngleCorr) {
                  PPSTools::LorentzBoost(p,"MC", {fCrossingAngleBeam1,
                        fCrossingAngleBeam2,fBeamMomentum,fBeamEnergy});
                }
                //Getting the Xi and t (squared four momentum transferred) of the reconstructed track
                PPSTools::Get_t_and_xi(const_cast<TLorentzVector*>(&p),t,xi, {fBeamMomentum,fBeamEnergy});
                double pxx = p.Px(); double pyy = p.Py(); double pzz = p.Pz();
                math::XYZVector momentum (pxx,pyy,pzz);
                math::XYZPoint vertex (x0,y0,0);

                track.setp(momentum);
                track.setvertex(vertex);
                track.sett(t);
                track.setxi(xi);
                track.setx1(X1d);
                track.sety1(Y1d);
                track.setx2(X2d);
                track.sety2(Y2d);
                if (matchCellId) {
                    track.setcellid(cellId);
                    track.settof(recTof);
                } 
                else {
                    track.setcellid(0);
                    track.settof(0.);
                } 
                theCTPPSFastTrack.push_back(track);
            }
        } 
    }
}//end FastReco

// ------------ method called once each stream before processing any runs, lumis or events  ------------

void CTPPSFastTrackingProducer::beginStream(edm::StreamID)
{
}

// ------------ method called once each stream after processing all runs, lumis and events  ------------

void CTPPSFastTrackingProducer::endStream() 
{
}
bool CTPPSFastTrackingProducer::SetBeamLine()
{
    edm::FileInPath b1(beam1filename.c_str());
    edm::FileInPath b2(beam2filename.c_str());
    if (lengthctpps<=0) return false;
    m_beamlineCTPPS1 = std::unique_ptr<H_BeamLine>(new H_BeamLine( -1, lengthctpps + 0.1)); // (direction, length)
    m_beamlineCTPPS1->fill( b2.fullPath(), 1, "IP5");
    m_beamlineCTPPS2 = std::unique_ptr<H_BeamLine>(new H_BeamLine( 1, lengthctpps + 0.1 )); //
    m_beamlineCTPPS2->fill( b1.fullPath(), 1, "IP5");
    m_beamlineCTPPS1->offsetElements( 120, 0.097 );
    m_beamlineCTPPS2->offsetElements( 120,-0.097 );
    pps_stationF = std::unique_ptr<H_RecRPObject>(new H_RecRPObject(fz_tracker1,fz_tracker2,*m_beamlineCTPPS1));
    pps_stationB = std::unique_ptr<H_RecRPObject>(new H_RecRPObject(fz_tracker1,fz_tracker2,*m_beamlineCTPPS2));
    return true;
}
//define this as a plug-in
DEFINE_FWK_MODULE(CTPPSFastTrackingProducer);