Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-07-01 00:07:40 

0001 #include "FWCore/Framework/interface/global/EDProducer.h"
0002 #include "FWCore/Framework/interface/Event.h"
0003 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0004 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0005 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0006 #include "FWCore/Utilities/interface/InputTag.h"
0007 #include "DataFormats/BeamSpot/interface/BeamSpot.h"
0008 #include "TrackingTools/TransientTrack/interface/TransientTrack.h"
0009 #include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
0010 #include "TrackingTools/Records/interface/TransientTrackRecord.h"
0011 
0012 #include "MagneticField/Engine/interface/MagneticField.h"
0013 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
0014 
0015 #include <vector>
0016 #include <memory>
0017 #include <map>
0018 #include <string>
0019 #include "DataFormats/PatCandidates/interface/PackedCandidate.h"
0020 #include "CommonTools/Utils/interface/StringCutObjectSelector.h"
0021 #include "DataFormats/PatCandidates/interface/CompositeCandidate.h"
0022 #include "DataFormats/Candidate/interface/Candidate.h"
0023 #include "DataFormats/Math/interface/deltaR.h"
0024 #include "CommonTools/Statistics/interface/ChiSquaredProbability.h"
0025 #include "helper.h"
0026 #include <limits>
0027 #include <algorithm>
0028 #include "KinVtxFitter.h"
0029 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0030 
0031 using namespace std;
0032 
0033 class BToV0TrkDisplacedLLBuilder : public edm::global::EDProducer<> {
0034   // perhaps we need better structure here (begin run etc)
0035 public:
0036   typedef std::vector<reco::TransientTrack> TransientTrackCollection;
0037   explicit BToV0TrkDisplacedLLBuilder(const edm::ParameterSet &cfg)
0038       :  // selections
0039         pre_vtx_selection_{cfg.getParameter<std::string>("preVtxSelection")},
0040         post_vtx_selection_{cfg.getParameter<std::string>("postVtxSelection")},
0041         //inputs
0042         dileptons_{consumes<pat::CompositeCandidateCollection>(cfg.getParameter<edm::InputTag>("dileptons"))},
0043         leptons_ttracks_{consumes<TransientTrackCollection>(cfg.getParameter<edm::InputTag>("leptonTransientTracks"))},
0044         V0s_ttracks_{consumes<TransientTrackCollection>(cfg.getParameter<edm::InputTag>("V0s_ttracks"))},
0045         V0s_{consumes<pat::CompositeCandidateCollection>(cfg.getParameter<edm::InputTag>("V0s"))},
0046         pions_{consumes<pat::CompositeCandidateCollection>(cfg.getParameter<edm::InputTag>("pions"))},
0047         pions_ttracks_{consumes<TransientTrackCollection>(cfg.getParameter<edm::InputTag>("pionsTransientTracks"))},
0048         beamspot_{consumes<reco::BeamSpot>(cfg.getParameter<edm::InputTag>("beamSpot"))},
0049         vertex_src_{consumes<reco::VertexCollection>(cfg.getParameter<edm::InputTag>("offlinePrimaryVertexSrc"))} {
0050     //output
0051     produces<pat::CompositeCandidateCollection>();
0052   }
0053 
0054   ~BToV0TrkDisplacedLLBuilder() override {}
0055 
0056   void produce(edm::StreamID, edm::Event &, const edm::EventSetup &) const override;
0057 
0058   static void fillDescriptions(edm::ConfigurationDescriptions &descriptions) {}
0059 
0060 private:
0061   // selections
0062   const StringCutObjectSelector<pat::CompositeCandidate> pre_vtx_selection_;   // cut on the di-lepton before the SV fit
0063   const StringCutObjectSelector<pat::CompositeCandidate> post_vtx_selection_;  // cut on the di-lepton after the SV fit
0064 
0065   const edm::EDGetTokenT<pat::CompositeCandidateCollection> dileptons_;
0066   const edm::EDGetTokenT<TransientTrackCollection> leptons_ttracks_;
0067   const edm::EDGetTokenT<TransientTrackCollection> V0s_ttracks_;
0068   const edm::EDGetTokenT<pat::CompositeCandidateCollection> V0s_;
0069   const edm::EDGetTokenT<pat::CompositeCandidateCollection> pions_;
0070   const edm::EDGetTokenT<TransientTrackCollection> pions_ttracks_;
0071 
0072   const edm::EDGetTokenT<reco::BeamSpot> beamspot_;
0073   const edm::EDGetTokenT<reco::VertexCollection> vertex_src_;
0074 };
0075 
0076 void BToV0TrkDisplacedLLBuilder::produce(edm::StreamID, edm::Event &evt, edm::EventSetup const &iSetup) const {
0077   //input
0078   edm::Handle<pat::CompositeCandidateCollection> dileptons;
0079   evt.getByToken(dileptons_, dileptons);
0080 
0081   edm::Handle<TransientTrackCollection> leptons_ttracks;
0082   evt.getByToken(leptons_ttracks_, leptons_ttracks);
0083   edm::Handle<pat::CompositeCandidateCollection> pions;
0084   evt.getByToken(pions_, pions);
0085 
0086   edm::Handle<TransientTrackCollection> pions_ttracks;
0087   evt.getByToken(pions_ttracks_, pions_ttracks);
0088 
0089   edm::Handle<pat::CompositeCandidateCollection> V0s;
0090   evt.getByToken(V0s_, V0s);
0091 
0092   edm::Handle<TransientTrackCollection> V0s_ttracks;
0093   evt.getByToken(V0s_ttracks_, V0s_ttracks);
0094 
0095   edm::Handle<reco::BeamSpot> beamspot;
0096   evt.getByToken(beamspot_, beamspot);
0097 
0098   edm::Handle<reco::VertexCollection> pvtxs;
0099   evt.getByToken(vertex_src_, pvtxs);
0100 
0101   edm::ESHandle<MagneticField> fieldHandle;
0102   const MagneticField *fMagneticField = fieldHandle.product();
0103   AnalyticalImpactPointExtrapolator extrapolator(fMagneticField);
0104 
0105   std::vector<int> used_lep1_id, used_lep2_id, used_pi_id, used_V0_id;
0106 
0107   // output
0108   std::unique_ptr<pat::CompositeCandidateCollection> ret_val(new pat::CompositeCandidateCollection());
0109   for (size_t V0_idx = 0; V0_idx < V0s->size(); ++V0_idx) {
0110     edm::Ptr<pat::CompositeCandidate> V0_ptr(V0s, V0_idx);
0111     math::PtEtaPhiMLorentzVector V0_p4(V0_ptr->userFloat("fitted_pt"),
0112                                        V0_ptr->userFloat("fitted_eta"),
0113                                        V0_ptr->userFloat("fitted_phi"),
0114                                        V0_ptr->userFloat("fitted_mass"));
0115     edm::Ptr<reco::Candidate> pi1_ptr = V0_ptr->userCand("trk1");
0116     edm::Ptr<reco::Candidate> pi2_ptr = V0_ptr->userCand("trk2");
0117     unsigned int pi1_idx = V0_ptr->userInt("trk1_idx");
0118     unsigned int pi2_idx = V0_ptr->userInt("trk2_idx");
0119     //    float pi1_dr = V0_ptr->userFloat("trk1_dr");
0120     //    float pi2_dr = V0_ptr->userFloat("trk2_dr");
0121     for (size_t pi_idx = 0; pi_idx < pions->size(); ++pi_idx) {
0122       edm::Ptr<pat::CompositeCandidate> pi_ptr(pions, pi_idx);
0123       if (pi1_idx == pi_idx || pi2_idx == pi_idx)
0124         continue;
0125       edm::Ptr<reco::Candidate> pi1_ptr(pions, pi1_idx);
0126       edm::Ptr<reco::Candidate> pi2_ptr(pions, pi2_idx);
0127       math::PtEtaPhiMLorentzVector pi_p4(pi_ptr->pt(), pi_ptr->eta(), pi_ptr->phi(), bph::PI_MASS);
0128       pat::CompositeCandidate cand;
0129       cand.setP4(pi_ptr->p4() + V0_p4);
0130       //      cand.setCharge(V0_ptr->userInt("fit_trk1_charge") + V0_ptr->userInt("fit_trk2_charge") + pi_ptr->charge());
0131       //      cand.addUserInt("fitted_charge",V0_ptr->userInt("fit_trk1_charge") + V0_ptr->userInt("fit_trk2_charge") + pi_ptr->charge());
0132       cand.addUserInt("pi_idx", pi_idx);
0133       cand.addUserInt("V0_idx", V0_idx);
0134       cand.addUserCand("pi", pi_ptr);
0135       cand.addUserCand("V0", V0_ptr);
0136       float dr = deltaR(pi_ptr->eta(), pi_ptr->phi(), V0_ptr->userFloat("fitted_eta"), V0_ptr->userFloat("fitted_phi"));
0137       cand.addUserFloat("V0pi_dr", dr);
0138       for (size_t ll_idx = 0; ll_idx < dileptons->size(); ++ll_idx) {
0139         edm::Ptr<pat::CompositeCandidate> ll_ptr(dileptons, ll_idx);
0140         edm::Ptr<reco::Candidate> l1_ptr = ll_ptr->userCand("l1");
0141         edm::Ptr<reco::Candidate> l2_ptr = ll_ptr->userCand("l2");
0142         int l1_idx = ll_ptr->userInt("l1_idx");
0143         int l2_idx = ll_ptr->userInt("l2_idx");
0144         cand.addUserCand("l1", l1_ptr);
0145         cand.addUserCand("l2", l2_ptr);
0146         cand.addUserCand("dilepton", ll_ptr);
0147         cand.addUserInt("l1_idx", l1_idx);
0148         cand.addUserInt("l2_idx", l2_idx);
0149         cand.addUserInt("ll_idx", ll_idx);
0150         cand.addUserCand("l1_ptr", l1_ptr);
0151         cand.addUserCand("l2_ptr", l2_ptr);
0152         auto lep1_p4 = l1_ptr->polarP4();
0153         auto lep2_p4 = l2_ptr->polarP4();
0154         lep1_p4.SetM(l1_ptr->mass());
0155         lep2_p4.SetM(l2_ptr->mass());
0156         auto pi_p4 = pi_ptr->polarP4();
0157         auto V0_p4 = V0_ptr->polarP4();
0158         pi_p4.SetM(bph::PI_MASS);
0159         V0_p4.SetM(V0_ptr->mass());
0160         cand.setP4(ll_ptr->p4() + pi_p4 + V0_p4);
0161         cand.setCharge(ll_ptr->charge() + V0_ptr->userInt("fit_trk1_charge") + V0_ptr->userInt("fit_trk2_charge") +
0162                        pi_ptr->charge());
0163         cand.addUserFloat("ll_V0_deltaR", reco::deltaR(*ll_ptr, *V0_ptr));
0164         cand.addUserFloat("ll_pi_deltaR", reco::deltaR(*ll_ptr, *pi_ptr));
0165         auto V0_dr_info = bph::min_max_dr({l1_ptr, l2_ptr, V0_ptr});
0166         cand.addUserFloat("V0_min_dr", V0_dr_info.first);
0167         cand.addUserFloat("V0_max_dr", V0_dr_info.second);
0168         auto pi_dr_info = bph::min_max_dr({l1_ptr, l2_ptr, pi_ptr});
0169         cand.addUserFloat("pi_min_dr", pi_dr_info.first);
0170         cand.addUserFloat("pi_max_dr", pi_dr_info.second);
0171         cand.addUserFloat("mIntermediate_unfitted", (pi_p4 + V0_p4).M());
0172         if (!pre_vtx_selection_(cand))
0173           continue;
0174 
0175         KinVtxFitter xifitter;
0176         try {
0177           xifitter = KinVtxFitter({pions_ttracks->at(pi_idx), V0s_ttracks->at(V0_idx)},
0178                                   {bph::PI_MASS, V0_ptr->mass()},
0179                                   {bph::PI_SIGMA, V0_ptr->userFloat("massErr")});
0180         } catch (const VertexException &e) {
0181           edm::LogWarning("KinematicFit") << "Xi Builder: Skipping candidate due to fit failure: " << e.what();
0182           continue;
0183         }
0184         if (!xifitter.success())
0185           continue;
0186         const auto &XiTT = xifitter.fitted_candidate_ttrk();
0187         float ximass = xifitter.fitted_candidate().mass();
0188         float ximassErr = sqrt(xifitter.fitted_candidate().kinematicParametersError().matrix()(6, 6));
0189         cand.addUserFloat("Xi_sv_chi2", xifitter.chi2());
0190         cand.addUserFloat("Xi_sv_ndof", xifitter.dof());
0191         cand.addUserFloat("Xi_sv_prob", xifitter.prob());
0192         cand.addUserFloat("Xi_vtx_x", xifitter.fitted_vtx().x());
0193         cand.addUserFloat("Xi_vtx_y", xifitter.fitted_vtx().y());
0194         cand.addUserFloat("Xi_vtx_z", xifitter.fitted_vtx().z());
0195         cand.addUserFloat("Xi_vtx_ex", sqrt(xifitter.fitted_vtx_uncertainty().cxx()));
0196         cand.addUserFloat("Xi_vtx_ey", sqrt(xifitter.fitted_vtx_uncertainty().cyy()));
0197         cand.addUserFloat("Xi_vtx_ez", sqrt(xifitter.fitted_vtx_uncertainty().czz()));
0198         auto Xi_fit_p4 = xifitter.fitted_p4();
0199         cand.addUserFloat("Xi_fitted_cos_theta_2D", bph::cos_theta_2D(xifitter, *beamspot, Xi_fit_p4));
0200         auto Xi_lxy = bph::l_xy(xifitter, *beamspot);
0201         cand.addUserFloat("Xi_l_xy", Xi_lxy.value());
0202         cand.addUserFloat("Xi_l_xy_unc", Xi_lxy.error());
0203         cand.addUserFloat("Xi_mass", ximass);
0204         cand.addUserFloat("Xi_massErr", ximassErr);
0205 
0206         KinVtxFitter fitter;
0207         try {
0208           fitter = KinVtxFitter({leptons_ttracks->at(l1_idx), leptons_ttracks->at(l2_idx), XiTT},
0209                                 {l1_ptr->mass(), l2_ptr->mass(), ximass},
0210                                 {bph::LEP_SIGMA, bph::LEP_SIGMA, ximassErr});
0211         } catch (const VertexException &e) {
0212           edm::LogWarning("KinematicFit") << "BToXiLL Builder: Skipping candidate due to fit failure: " << e.what();
0213           continue;
0214         }
0215         if (!fitter.success())
0216           continue;
0217         cand.setVertex(
0218             reco::Candidate::Point(fitter.fitted_vtx().x(), fitter.fitted_vtx().y(), fitter.fitted_vtx().z()));
0219 
0220         TrajectoryStateOnSurface Xitsos = extrapolator.extrapolate(XiTT.impactPointState(), fitter.fitted_vtx());
0221         cand.addUserFloat("Xi_dz", XiTT.track().vz() - fitter.fitted_vtx().z());  //
0222         cand.addUserFloat("Xi_x", XiTT.track().vx());                             //pitsos.globalPosition().x());
0223         cand.addUserFloat("Xi_y", XiTT.track().vy());                             //pitsos.globalPosition().y());
0224         cand.addUserFloat("Xi_z", XiTT.track().vz());                             //pitsos.globalPosition().z());
0225                                                                                   // vertex vars
0226         cand.addUserFloat("sv_chi2", fitter.chi2());
0227         cand.addUserFloat("sv_ndof", fitter.dof());
0228         cand.addUserFloat("sv_prob", fitter.prob());
0229         // refitted kinematic vars
0230         auto fit_p4 = fitter.fitted_p4();
0231         cand.addUserFloat("fitted_mass", fit_p4.mass());
0232         cand.addUserFloat("fitted_massErr", sqrt(fitter.fitted_candidate().kinematicParametersError().matrix()(6, 6)));
0233         cand.addUserFloat("fitted_mll_mass", (fitter.daughter_p4(0) + fitter.daughter_p4(1)).mass());
0234         cand.addUserFloat("fitted_mll_pt", (fitter.daughter_p4(0) + fitter.daughter_p4(1)).pt());
0235         cand.addUserFloat("fitted_mll_eta", (fitter.daughter_p4(0) + fitter.daughter_p4(1)).eta());
0236         cand.addUserFloat("fitted_mll_phi", (fitter.daughter_p4(0) + fitter.daughter_p4(1)).phi());
0237         cand.addUserFloat("fitted_pt", fit_p4.pt());
0238         cand.addUserFloat("fitted_eta", fit_p4.eta());
0239         cand.addUserFloat("fitted_phi", fit_p4.phi());
0240         const reco::BeamSpot &beamSpot = *beamspot;
0241         TrajectoryStateClosestToPoint theDCAXBS = fitter.fitted_candidate_ttrk().trajectoryStateClosestToPoint(
0242             GlobalPoint(beamSpot.position().x(), beamSpot.position().y(), beamSpot.position().z()));
0243         double DCAB0BS = -99.;
0244         double DCAB0BSErr = -99.;
0245 
0246         if (theDCAXBS.isValid() == true) {
0247           DCAB0BS = theDCAXBS.perigeeParameters().transverseImpactParameter();
0248           DCAB0BSErr = theDCAXBS.perigeeError().transverseImpactParameterError();
0249         }
0250         cand.addUserFloat("dca", DCAB0BS);
0251         cand.addUserFloat("dcaErr", DCAB0BSErr);
0252         cand.addUserFloat("vtx_x", cand.vx());
0253         cand.addUserFloat("vtx_y", cand.vy());
0254         cand.addUserFloat("vtx_z", cand.vz());
0255         cand.addUserFloat("vtx_ex", sqrt(fitter.fitted_vtx_uncertainty().cxx()));
0256         cand.addUserFloat("vtx_ey", sqrt(fitter.fitted_vtx_uncertainty().cyy()));
0257         cand.addUserFloat("vtx_ez", sqrt(fitter.fitted_vtx_uncertainty().czz()));
0258         // refitted daughters (leptons/tracks)
0259         std::vector<std::string> dnames{"l1", "l2", "Xi"};
0260         for (size_t idaughter = 0; idaughter < dnames.size(); idaughter++) {
0261           cand.addUserFloat("fitted_" + dnames[idaughter] + "_pt", fitter.daughter_p4(idaughter).pt());
0262           cand.addUserFloat("fitted_" + dnames[idaughter] + "_eta", fitter.daughter_p4(idaughter).eta());
0263           cand.addUserFloat("fitted_" + dnames[idaughter] + "_phi", fitter.daughter_p4(idaughter).phi());
0264         }
0265         // other vars
0266         cand.addUserFloat("cos_theta_2D", bph::cos_theta_2D(fitter, *beamspot, cand.p4()));
0267         cand.addUserFloat("fitted_cos_theta_2D", bph::cos_theta_2D(fitter, *beamspot, fit_p4));
0268         auto lxy = bph::l_xy(fitter, *beamspot);
0269         cand.addUserFloat("l_xy", lxy.value());
0270         cand.addUserFloat("l_xy_unc", lxy.error());
0271 
0272         std::pair<bool, Measurement1D> cur2DIP_Xi =
0273             bph::signedTransverseImpactParameter(Xitsos, fitter.fitted_refvtx(), *beamspot);
0274         std::pair<bool, Measurement1D> cur3DIP_Xi =
0275             bph::signedImpactParameter3D(Xitsos, fitter.fitted_refvtx(), *beamspot, (*pvtxs)[0].position().z());
0276         cand.addUserFloat("Xi_svip2d", cur2DIP_Xi.second.value());
0277         cand.addUserFloat("Xi_svip2d_err", cur2DIP_Xi.second.error());
0278         cand.addUserFloat("Xi_svip3d", cur3DIP_Xi.second.value());
0279         cand.addUserFloat("Xi_svip3d_err", cur3DIP_Xi.second.error());
0280         if (!post_vtx_selection_(cand))
0281           continue;
0282 
0283         //  std::cout << "                                      post" << endl;
0284 
0285         // /////////////////////////////////////////////////////////////////
0286         // ///     Mass constrained fit START                            ///
0287         // /////////////////////////////////////////////////////////////////
0288 
0289         // Define variables
0290         bool sv_OK_withMC = false;
0291         float sv_chi2_withMC = cand.userFloat("sv_chi2");
0292         float sv_ndof_withMC = cand.userFloat("sv_ndof");
0293         float sv_prob_withMC = cand.userFloat("sv_prob");
0294         float fitted_mll_withMC = cand.userFloat("fitted_mll_mass");
0295         float fitted_pt_withMC = cand.userFloat("fitted_pt");
0296         float fitted_eta_withMC = cand.userFloat("fitted_eta");
0297         float fitted_phi_withMC = cand.userFloat("fitted_phi");
0298         float fitted_mass_withMC = cand.userFloat("fitted_mass");
0299         float fitted_massErr_withMC = cand.userFloat("fitted_massErr");
0300         float fitted_cos_theta_2D_withMC = cand.userFloat("fitted_cos_theta_2D");
0301         float l_xy_withMC = cand.userFloat("l_xy");
0302         float l_xy_unc_withMC = cand.userFloat("l_xy_unc");
0303         float vtx_x_withMC = cand.userFloat("vtx_x");
0304         float vtx_y_withMC = cand.userFloat("vtx_y");
0305         float vtx_z_withMC = cand.userFloat("vtx_z");
0306         float vtx_ex_withMC = cand.userFloat("vtx_ex");
0307         float vtx_ey_withMC = cand.userFloat("vtx_ey");
0308         float vtx_ez_withMC = cand.userFloat("vtx_ez");
0309         float fitted_l1_pt_withMC = cand.userFloat("fitted_l1_pt");
0310         float fitted_l1_eta_withMC = cand.userFloat("fitted_l1_eta");
0311         float fitted_l1_phi_withMC = cand.userFloat("fitted_l1_phi");
0312         float fitted_l2_pt_withMC = cand.userFloat("fitted_l2_pt");
0313         float fitted_l2_eta_withMC = cand.userFloat("fitted_l2_eta");
0314         float fitted_l2_phi_withMC = cand.userFloat("fitted_l2_phi");
0315         float fitted_Xi_pt_withMC = cand.userFloat("fitted_Xi_pt");
0316         float fitted_Xi_eta_withMC = cand.userFloat("fitted_Xi_eta");
0317         float fitted_Xi_phi_withMC = cand.userFloat("fitted_Xi_phi");
0318 
0319         // Check dilepton mass from Bparticles to be in the jpsi bin
0320         const double dilepton_mass = ll_ptr->userFloat("fitted_mass");
0321         // const double dilepton_mass = (fitter.daughter_p4(0) + fitter.daughter_p4(1)).mass();
0322         const double jpsi_bin[2] = {2.8,
0323                                     3.2};  // {2.9, 3.2}; Start bin from 2.8 to be able to measure systematics later
0324         const double psi2s_bin[2] = {3.55, 3.8};
0325         if ((dilepton_mass > jpsi_bin[0] && dilepton_mass < jpsi_bin[1]) ||
0326             (dilepton_mass > psi2s_bin[0] && dilepton_mass < psi2s_bin[1])) {
0327           // JPsi  mass constrait
0328           // do mass constrained vertex fit
0329 
0330           ParticleMass JPsi_mass = 3.0969;   // Jpsi mass 3.096900±0.000006
0331           ParticleMass Psi2S_mass = 3.6861;  // Psi2S mass 3.6861093±0.0000034
0332           ParticleMass mass_constraint = (dilepton_mass < jpsi_bin[1]) ? JPsi_mass : Psi2S_mass;
0333           // Mass constraint is applied to the first two particles in the "particles" vector
0334           // Make sure that the first two particles are the ones you want to constrain
0335 
0336           KinVtxFitter constrained_fitter;
0337           try {
0338             constrained_fitter = KinVtxFitter({leptons_ttracks->at(l1_idx), leptons_ttracks->at(l2_idx), XiTT},
0339                                               {l1_ptr->mass(), l2_ptr->mass(), ximass},
0340                                               {bph::LEP_SIGMA, bph::LEP_SIGMA, ximassErr},
0341                                               mass_constraint);
0342           } catch (const VertexException &e) {
0343             edm::LogWarning("KinematicFit") << "BToXiLL Builder: Skipping candidate due to fit failure: " << e.what();
0344             continue;
0345           }
0346 
0347           if (!constrained_fitter.success()) {
0348             // Save default values and continue
0349             cand.addUserInt("sv_OK_withMC", sv_OK_withMC);
0350             cand.addUserFloat("sv_chi2_withMC", sv_chi2_withMC);
0351             cand.addUserFloat("sv_ndof_withMC", sv_ndof_withMC);
0352             cand.addUserFloat("sv_prob_withMC", sv_prob_withMC);
0353             cand.addUserFloat("fitted_mll_withMC", fitted_mll_withMC);
0354             cand.addUserFloat("fitted_pt_withMC", fitted_pt_withMC);
0355             cand.addUserFloat("fitted_eta_withMC", fitted_eta_withMC);
0356             cand.addUserFloat("fitted_phi_withMC", fitted_phi_withMC);
0357             cand.addUserFloat("fitted_mass_withMC", fitted_mass_withMC);
0358             cand.addUserFloat("fitted_massErr_withMC", fitted_massErr_withMC);
0359             cand.addUserFloat("fitted_cos_theta_2D_withMC", fitted_cos_theta_2D_withMC);
0360             cand.addUserFloat("l_xy_withMC", l_xy_withMC);
0361             cand.addUserFloat("l_xy_unc_withMC", l_xy_unc_withMC);
0362             cand.addUserFloat("vtx_x_withMC", vtx_x_withMC);
0363             cand.addUserFloat("vtx_y_withMC", vtx_y_withMC);
0364             cand.addUserFloat("vtx_z_withMC", vtx_z_withMC);
0365             cand.addUserFloat("vtx_ex_withMC", vtx_ex_withMC);
0366             cand.addUserFloat("vtx_ey_withMC", vtx_ey_withMC);
0367             cand.addUserFloat("vtx_ez_withMC", vtx_ez_withMC);
0368             cand.addUserFloat("fitted_l1_pt_withMC", fitted_l1_pt_withMC);
0369             cand.addUserFloat("fitted_l1_eta_withMC", fitted_l1_eta_withMC);
0370             cand.addUserFloat("fitted_l1_phi_withMC", fitted_l1_phi_withMC);
0371             cand.addUserFloat("fitted_l2_pt_withMC", fitted_l2_pt_withMC);
0372             cand.addUserFloat("fitted_l2_eta_withMC", fitted_l2_eta_withMC);
0373             cand.addUserFloat("fitted_l2_phi_withMC", fitted_l2_phi_withMC);
0374             cand.addUserFloat("fitted_Xi_pt_withMC", fitted_Xi_pt_withMC);
0375             cand.addUserFloat("fitted_Xi_eta_withMC", fitted_Xi_eta_withMC);
0376             cand.addUserFloat("fitted_Xi_phi_withMC", fitted_Xi_phi_withMC);
0377             ret_val->push_back(cand);
0378             continue;
0379           }
0380           auto fit_p4_withMC = constrained_fitter.fitted_p4();
0381           sv_OK_withMC = constrained_fitter.success();
0382           sv_chi2_withMC = constrained_fitter.chi2();
0383           sv_ndof_withMC = constrained_fitter.dof();
0384           sv_prob_withMC = constrained_fitter.prob();
0385           fitted_mll_withMC = (constrained_fitter.daughter_p4(0) + constrained_fitter.daughter_p4(1)).mass();
0386           fitted_pt_withMC = fit_p4_withMC.pt();
0387           fitted_eta_withMC = fit_p4_withMC.eta();
0388           fitted_phi_withMC = fit_p4_withMC.phi();
0389           fitted_mass_withMC = constrained_fitter.fitted_candidate().mass();
0390           fitted_massErr_withMC = sqrt(constrained_fitter.fitted_candidate().kinematicParametersError().matrix()(6, 6));
0391           fitted_cos_theta_2D_withMC = bph::cos_theta_2D(constrained_fitter, *beamspot, fit_p4_withMC);
0392           auto lxy_withMC = bph::l_xy(constrained_fitter, *beamspot);
0393           l_xy_withMC = lxy_withMC.value();
0394           l_xy_unc_withMC = lxy_withMC.error();
0395           vtx_x_withMC = cand.vx();
0396           vtx_y_withMC = cand.vy();
0397           vtx_z_withMC = cand.vz();
0398           vtx_ex_withMC = sqrt(constrained_fitter.fitted_vtx_uncertainty().cxx());
0399           vtx_ey_withMC = sqrt(constrained_fitter.fitted_vtx_uncertainty().cyy());
0400           vtx_ez_withMC = sqrt(constrained_fitter.fitted_vtx_uncertainty().czz());
0401           fitted_l1_pt_withMC = constrained_fitter.daughter_p4(0).pt();
0402           fitted_l1_eta_withMC = constrained_fitter.daughter_p4(0).eta();
0403           fitted_l1_phi_withMC = constrained_fitter.daughter_p4(0).phi();
0404           fitted_l2_pt_withMC = constrained_fitter.daughter_p4(1).pt();
0405           fitted_l2_eta_withMC = constrained_fitter.daughter_p4(1).eta();
0406           fitted_l2_phi_withMC = constrained_fitter.daughter_p4(1).phi();
0407           fitted_Xi_pt_withMC = constrained_fitter.daughter_p4(2).pt();
0408           fitted_Xi_eta_withMC = constrained_fitter.daughter_p4(2).eta();
0409           fitted_Xi_phi_withMC = constrained_fitter.daughter_p4(2).phi();
0410         }
0411         cand.addUserInt("sv_OK_withMC", sv_OK_withMC);
0412         cand.addUserFloat("sv_chi2_withMC", sv_chi2_withMC);
0413         cand.addUserFloat("sv_ndof_withMC", sv_ndof_withMC);
0414         cand.addUserFloat("sv_prob_withMC", sv_prob_withMC);
0415         cand.addUserFloat("fitted_mll_withMC", fitted_mll_withMC);
0416         cand.addUserFloat("fitted_pt_withMC", fitted_pt_withMC);
0417         cand.addUserFloat("fitted_eta_withMC", fitted_eta_withMC);
0418         cand.addUserFloat("fitted_phi_withMC", fitted_phi_withMC);
0419         cand.addUserFloat("fitted_mass_withMC", fitted_mass_withMC);
0420         cand.addUserFloat("fitted_massErr_withMC", fitted_massErr_withMC);
0421         cand.addUserFloat("fitted_cos_theta_2D_withMC", fitted_cos_theta_2D_withMC);
0422         cand.addUserFloat("l_xy_withMC", l_xy_withMC);
0423         cand.addUserFloat("l_xy_unc_withMC", l_xy_unc_withMC);
0424         cand.addUserFloat("vtx_x_withMC", vtx_x_withMC);
0425         cand.addUserFloat("vtx_y_withMC", vtx_y_withMC);
0426         cand.addUserFloat("vtx_z_withMC", vtx_z_withMC);
0427         cand.addUserFloat("vtx_ex_withMC", vtx_ex_withMC);
0428         cand.addUserFloat("vtx_ey_withMC", vtx_ey_withMC);
0429         cand.addUserFloat("vtx_ez_withMC", vtx_ez_withMC);
0430         cand.addUserFloat("fitted_l1_pt_withMC", fitted_l1_pt_withMC);
0431         cand.addUserFloat("fitted_l1_eta_withMC", fitted_l1_eta_withMC);
0432         cand.addUserFloat("fitted_l1_phi_withMC", fitted_l1_phi_withMC);
0433         cand.addUserFloat("fitted_l2_pt_withMC", fitted_l2_pt_withMC);
0434         cand.addUserFloat("fitted_l2_eta_withMC", fitted_l2_eta_withMC);
0435         cand.addUserFloat("fitted_l2_phi_withMC", fitted_l2_phi_withMC);
0436         cand.addUserFloat("fitted_Xi_pt_withMC", fitted_Xi_pt_withMC);
0437         cand.addUserFloat("fitted_Xi_eta_withMC", fitted_Xi_eta_withMC);
0438         cand.addUserFloat("fitted_Xi_phi_withMC", fitted_Xi_phi_withMC);
0439 
0440         // /////////////////////////////////////////////////////////////////
0441         // ///     Mass constrained fit END                              ///
0442         // /////////////////////////////////////////////////////////////////
0443         ret_val->push_back(cand);
0444         //  std::cout << "BGIKE" << endl;
0445       }  //     for(size_t ll_idx = 0; ll_idx < dileptons->size(); ++ll_idx)
0446     }  //   for(size_t pi_idx = 0; pi_idx < pions->size(); ++V0_idx)
0447   }  // for(size_t V0_idx = 0; V0_idx < V0s->size(); ++V0_idx)
0448   for (auto &cand : *ret_val) {
0449     cand.addUserInt("n_pi_used", std::count(used_pi_id.begin(), used_pi_id.end(), cand.userInt("pi_idx")));
0450     cand.addUserInt("n_V0_used", std::count(used_V0_id.begin(), used_V0_id.end(), cand.userInt("V0_idx")));
0451     cand.addUserInt("n_l1_used",
0452                     std::count(used_lep1_id.begin(), used_lep1_id.end(), cand.userInt("l1_idx")) +
0453                         std::count(used_lep2_id.begin(), used_lep2_id.end(), cand.userInt("l1_idx")));
0454     cand.addUserInt("n_l2_used",
0455                     std::count(used_lep1_id.begin(), used_lep1_id.end(), cand.userInt("l2_idx")) +
0456                         std::count(used_lep2_id.begin(), used_lep2_id.end(), cand.userInt("l2_idx")));
0457   }
0458   evt.put(std::move(ret_val));
0459 }
0460 #include "FWCore/Framework/interface/MakerMacros.h"
0461 DEFINE_FWK_MODULE(BToV0TrkDisplacedLLBuilder);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!