ONNXRuntime/src/tensor_fillers.cc

0001 #include "RecoBTag/ONNXRuntime/interface/tensor_fillers.h"
0002
0003 namespace btagbtvdeep {
0004
0005   void jet_tensor_filler(float*& ptr, const btagbtvdeep::DeepFlavourFeatures& features) {
0006     // jet variables
0007     const auto& jet_features = features.jet_features;
0008     *ptr = jet_features.pt;
0009     *(++ptr) = jet_features.eta;
0010     // number of elements in different collections
0011     *(++ptr) = features.c_pf_features.size();
0012     *(++ptr) = features.n_pf_features.size();
0013     *(++ptr) = features.sv_features.size();
0014     *(++ptr) = features.npv;
0015     // variables from ShallowTagInfo
0016     const auto& tag_info_features = features.tag_info_features;
0017     *(++ptr) = tag_info_features.trackSumJetEtRatio;
0018     *(++ptr) = tag_info_features.trackSumJetDeltaR;
0019     *(++ptr) = tag_info_features.vertexCategory;
0020     *(++ptr) = tag_info_features.trackSip2dValAboveCharm;
0021     *(++ptr) = tag_info_features.trackSip2dSigAboveCharm;
0022     *(++ptr) = tag_info_features.trackSip3dValAboveCharm;
0023     *(++ptr) = tag_info_features.trackSip3dSigAboveCharm;
0024     *(++ptr) = tag_info_features.jetNSelectedTracks;
0025     *(++ptr) = tag_info_features.jetNTracksEtaRel;
0026   }
0027
0028   void cpf_tensor_filler(float*& ptr, const btagbtvdeep::ChargedCandidateFeatures& c_pf_features) {
0029     *ptr = c_pf_features.btagPf_trackEtaRel;
0030     *(++ptr) = c_pf_features.btagPf_trackPtRel;
0031     *(++ptr) = c_pf_features.btagPf_trackPPar;
0032     *(++ptr) = c_pf_features.btagPf_trackDeltaR;
0033     *(++ptr) = c_pf_features.btagPf_trackPParRatio;
0034     *(++ptr) = c_pf_features.btagPf_trackSip2dVal;
0035     *(++ptr) = c_pf_features.btagPf_trackSip2dSig;
0036     *(++ptr) = c_pf_features.btagPf_trackSip3dVal;
0037     *(++ptr) = c_pf_features.btagPf_trackSip3dSig;
0038     *(++ptr) = c_pf_features.btagPf_trackJetDistVal;
0039     *(++ptr) = c_pf_features.ptrel;
0040     *(++ptr) = c_pf_features.drminsv;
0041     *(++ptr) = c_pf_features.vtx_ass;
0042     *(++ptr) = c_pf_features.puppiw;
0043     *(++ptr) = c_pf_features.chi2;
0044     *(++ptr) = c_pf_features.quality;
0045   }
0046
0047   void npf_tensor_filler(float*& ptr, const btagbtvdeep::NeutralCandidateFeatures& n_pf_features) {
0048     *ptr = n_pf_features.ptrel;
0049     *(++ptr) = n_pf_features.deltaR;
0050     *(++ptr) = n_pf_features.isGamma;
0051     *(++ptr) = n_pf_features.hadFrac;
0052     *(++ptr) = n_pf_features.drminsv;
0053     *(++ptr) = n_pf_features.puppiw;
0054   }
0055
0056   void sv_tensor_filler(float*& ptr, const btagbtvdeep::SecondaryVertexFeatures& sv_features) {
0057     *ptr = sv_features.pt;
0058     *(++ptr) = sv_features.deltaR;
0059     *(++ptr) = sv_features.mass;
0060     *(++ptr) = sv_features.ntracks;
0061     *(++ptr) = sv_features.chi2;
0062     *(++ptr) = sv_features.normchi2;
0063     *(++ptr) = sv_features.dxy;
0064     *(++ptr) = sv_features.dxysig;
0065     *(++ptr) = sv_features.d3d;
0066     *(++ptr) = sv_features.d3dsig;
0067     *(++ptr) = sv_features.costhetasvpv;
0068     *(++ptr) = sv_features.enratio;
0069   }
0070
0071   void jet4vec_tensor_filler(float*& ptr, const btagbtvdeep::JetFeatures& jet_features) {
0072     *ptr = jet_features.pt;
0073     *(++ptr) = jet_features.eta;
0074     *(++ptr) = jet_features.phi;
0075     *(++ptr) = jet_features.mass;
0076   }
0077
0078   void seedTrack_tensor_filler(float*& ptr, const btagbtvdeep::SeedingTrackFeatures& seed_features) {
0079     *ptr = seed_features.pt;
0080     *(++ptr) = seed_features.eta;
0081     *(++ptr) = seed_features.phi;
0082     *(++ptr) = seed_features.mass;
0083     *(++ptr) = seed_features.dz;
0084     *(++ptr) = seed_features.dxy;
0085     *(++ptr) = seed_features.ip3D;
0086     *(++ptr) = seed_features.sip3D;
0087     *(++ptr) = seed_features.ip2D;
0088     *(++ptr) = seed_features.sip2D;
0089     *(++ptr) = seed_features.signedIp3D;
0090     *(++ptr) = seed_features.signedSip3D;
0091     *(++ptr) = seed_features.signedIp2D;
0092     *(++ptr) = seed_features.signedSip2D;
0093     *(++ptr) = seed_features.trackProbability3D;
0094     *(++ptr) = seed_features.trackProbability2D;
0095     *(++ptr) = seed_features.chi2reduced;
0096     *(++ptr) = seed_features.nPixelHits;
0097     *(++ptr) = seed_features.nHits;
0098     *(++ptr) = seed_features.jetAxisDistance;
0099     *(++ptr) = seed_features.jetAxisDlength;
0100   }
0101
0102   void neighbourTrack_tensor_filler(float*& ptr, const btagbtvdeep::TrackPairFeatures& neighbourTrack_features) {
0103     *ptr = neighbourTrack_features.pt;
0104     *(++ptr) = neighbourTrack_features.eta;
0105     *(++ptr) = neighbourTrack_features.phi;
0106     *(++ptr) = neighbourTrack_features.dz;
0107     *(++ptr) = neighbourTrack_features.dxy;
0108     *(++ptr) = neighbourTrack_features.mass;
0109     *(++ptr) = neighbourTrack_features.ip3D;
0110     *(++ptr) = neighbourTrack_features.sip3D;
0111     *(++ptr) = neighbourTrack_features.ip2D;
0112     *(++ptr) = neighbourTrack_features.sip2D;
0113     *(++ptr) = neighbourTrack_features.distPCA;
0114     *(++ptr) = neighbourTrack_features.dsigPCA;
0115     *(++ptr) = neighbourTrack_features.x_PCAonSeed;
0116     *(++ptr) = neighbourTrack_features.y_PCAonSeed;
0117     *(++ptr) = neighbourTrack_features.z_PCAonSeed;
0118     *(++ptr) = neighbourTrack_features.xerr_PCAonSeed;
0119     *(++ptr) = neighbourTrack_features.yerr_PCAonSeed;
0120     *(++ptr) = neighbourTrack_features.zerr_PCAonSeed;
0121     *(++ptr) = neighbourTrack_features.x_PCAonTrack;
0122     *(++ptr) = neighbourTrack_features.y_PCAonTrack;
0123     *(++ptr) = neighbourTrack_features.z_PCAonTrack;
0124     *(++ptr) = neighbourTrack_features.xerr_PCAonTrack;
0125     *(++ptr) = neighbourTrack_features.yerr_PCAonTrack;
0126     *(++ptr) = neighbourTrack_features.zerr_PCAonTrack;
0127     *(++ptr) = neighbourTrack_features.dotprodTrack;
0128     *(++ptr) = neighbourTrack_features.dotprodSeed;
0129     *(++ptr) = neighbourTrack_features.dotprodTrackSeed2D;
0130     *(++ptr) = neighbourTrack_features.dotprodTrackSeed3D;
0131     *(++ptr) = neighbourTrack_features.dotprodTrackSeedVectors2D;
0132     *(++ptr) = neighbourTrack_features.dotprodTrackSeedVectors3D;
0133     *(++ptr) = neighbourTrack_features.pvd_PCAonSeed;
0134     *(++ptr) = neighbourTrack_features.pvd_PCAonTrack;
0135     *(++ptr) = neighbourTrack_features.dist_PCAjetAxis;
0136     *(++ptr) = neighbourTrack_features.dotprod_PCAjetMomenta;
0137     *(++ptr) = neighbourTrack_features.deta_PCAjetDirs;
0138     *(++ptr) = neighbourTrack_features.dphi_PCAjetDirs;
0139   }
0140
0141   std::vector<float> inputs_parT(const btagbtvdeep::ChargedCandidateFeatures& c_pf_features,
0142                                  parT::InputFeatures ifeature) {
0143     std::vector<float> inputs;
0144     if (ifeature == parT::kChargedCandidates) {
0145       inputs.push_back(c_pf_features.btagPf_trackEtaRel);
0146       inputs.push_back(c_pf_features.btagPf_trackPtRel);
0147       inputs.push_back(c_pf_features.btagPf_trackPPar);
0148       inputs.push_back(c_pf_features.btagPf_trackDeltaR);
0149       inputs.push_back(c_pf_features.btagPf_trackPParRatio);
0150       inputs.push_back(c_pf_features.btagPf_trackSip2dVal);
0151       inputs.push_back(c_pf_features.btagPf_trackSip2dSig);
0152       inputs.push_back(c_pf_features.btagPf_trackSip3dVal);
0153       inputs.push_back(c_pf_features.btagPf_trackSip3dSig);
0154       inputs.push_back(c_pf_features.btagPf_trackJetDistVal);
0155       inputs.push_back(c_pf_features.ptrel);
0156       inputs.push_back(c_pf_features.drminsv);
0157       inputs.push_back(c_pf_features.vtx_ass);
0158       inputs.push_back(c_pf_features.puppiw);
0159       inputs.push_back(c_pf_features.chi2);
0160       inputs.push_back(c_pf_features.quality);
0161     } else if (ifeature == parT::kChargedCandidates4Vec) {
0162       inputs.push_back(c_pf_features.px);
0163       inputs.push_back(c_pf_features.py);
0164       inputs.push_back(c_pf_features.pz);
0165       inputs.push_back(c_pf_features.e);
0166     }
0167     return inputs;
0168   }
0169
0170   std::vector<float> inputs_parT(const btagbtvdeep::NeutralCandidateFeatures& n_pf_features,
0171                                  parT::InputFeatures ifeature) {
0172     std::vector<float> inputs;
0173     if (ifeature == parT::kNeutralCandidates) {
0174       inputs.push_back(n_pf_features.ptrel);
0175       inputs.push_back(n_pf_features.etarel);
0176       inputs.push_back(n_pf_features.phirel);
0177       inputs.push_back(n_pf_features.deltaR);
0178       inputs.push_back(n_pf_features.isGamma);
0179       inputs.push_back(n_pf_features.hadFrac);
0180       inputs.push_back(n_pf_features.drminsv);
0181       inputs.push_back(n_pf_features.puppiw);
0182     } else if (ifeature == parT::kNeutralCandidates4Vec) {
0183       inputs.push_back(n_pf_features.px);
0184       inputs.push_back(n_pf_features.py);
0185       inputs.push_back(n_pf_features.pz);
0186       inputs.push_back(n_pf_features.e);
0187     }
0188     return inputs;
0189   }
0190
0191   std::vector<float> inputs_parT(const btagbtvdeep::SecondaryVertexFeatures& sv_features,
0192                                  parT::InputFeatures ifeature) {
0193     std::vector<float> inputs;
0194     if (ifeature == parT::kVertices) {
0195       inputs.push_back(sv_features.pt);
0196       inputs.push_back(sv_features.deltaR);
0197       inputs.push_back(sv_features.mass);
0198       inputs.push_back(sv_features.etarel);
0199       inputs.push_back(sv_features.phirel);
0200       inputs.push_back(sv_features.ntracks);
0201       inputs.push_back(sv_features.chi2);
0202       inputs.push_back(sv_features.normchi2);
0203       inputs.push_back(sv_features.dxy);
0204       inputs.push_back(sv_features.dxysig);
0205       inputs.push_back(sv_features.d3d);
0206       inputs.push_back(sv_features.d3dsig);
0207       inputs.push_back(sv_features.costhetasvpv);
0208       inputs.push_back(sv_features.enratio);
0209     } else if (ifeature == parT::kVertices4Vec) {
0210       inputs.push_back(sv_features.px);
0211       inputs.push_back(sv_features.py);
0212       inputs.push_back(sv_features.pz);
0213       inputs.push_back(sv_features.e);
0214     }
0215     return inputs;
0216   }
0217
0218   std::vector<float> inputs_UparT(const btagbtvdeep::ChargedCandidateFeatures& c_pf_features,
0219                                   UparT::InputFeatures ifeature) {
0220     std::vector<float> inputs;
0221     if (ifeature == UparT::kChargedCandidates) {
0222       inputs.push_back(c_pf_features.btagPf_trackEtaRel);
0223       inputs.push_back(c_pf_features.btagPf_trackPtRel);
0224       inputs.push_back(c_pf_features.btagPf_trackPPar);
0225       inputs.push_back(c_pf_features.btagPf_trackDeltaR);
0226       inputs.push_back(c_pf_features.btagPf_trackPParRatio);
0227       inputs.push_back(c_pf_features.btagPf_trackSip2dVal);
0228       inputs.push_back(c_pf_features.btagPf_trackSip2dSig);
0229       inputs.push_back(c_pf_features.btagPf_trackSip3dVal);
0230       inputs.push_back(c_pf_features.btagPf_trackSip3dSig);
0231       inputs.push_back(c_pf_features.btagPf_trackJetDistVal);
0232       inputs.push_back(c_pf_features.ptrel);
0233       inputs.push_back(c_pf_features.drminsv);
0234       inputs.push_back(c_pf_features.vtx_ass);
0235       inputs.push_back(c_pf_features.puppiw);
0236       inputs.push_back(c_pf_features.chi2);
0237       inputs.push_back(c_pf_features.quality);
0238       inputs.push_back(c_pf_features.charge);
0239       inputs.push_back(c_pf_features.dz);
0240       inputs.push_back(c_pf_features.btagPf_trackDecayLen);
0241       inputs.push_back(c_pf_features.HadFrac);
0242       inputs.push_back(c_pf_features.CaloFrac);
0243       inputs.push_back(c_pf_features.pdgID);
0244       inputs.push_back(c_pf_features.lostInnerHits);
0245       inputs.push_back(c_pf_features.numberOfPixelHits);
0246       inputs.push_back(c_pf_features.numberOfStripHits);
0247     } else if (ifeature == UparT::kChargedCandidates4Vec) {
0248       inputs.push_back(c_pf_features.px);
0249       inputs.push_back(c_pf_features.py);
0250       inputs.push_back(c_pf_features.pz);
0251       inputs.push_back(c_pf_features.e);
0252     }
0253     return inputs;
0254   }
0255
0256   std::vector<float> inputs_UparT(const btagbtvdeep::LostTracksFeatures& lt_features, UparT::InputFeatures ifeature) {
0257     std::vector<float> inputs;
0258     if (ifeature == UparT::kLostTracks) {
0259       inputs.push_back(lt_features.btagPf_trackEtaRel);
0260       inputs.push_back(lt_features.btagPf_trackPtRel);
0261       inputs.push_back(lt_features.btagPf_trackPPar);
0262       inputs.push_back(lt_features.btagPf_trackDeltaR);
0263       inputs.push_back(lt_features.btagPf_trackPParRatio);
0264       inputs.push_back(lt_features.btagPf_trackSip2dVal);
0265       inputs.push_back(lt_features.btagPf_trackSip2dSig);
0266       inputs.push_back(lt_features.btagPf_trackSip3dVal);
0267       inputs.push_back(lt_features.btagPf_trackSip3dSig);
0268       inputs.push_back(lt_features.btagPf_trackJetDistVal);
0269       inputs.push_back(lt_features.drminsv);
0270       inputs.push_back(lt_features.charge);
0271       inputs.push_back(lt_features.puppiw);
0272       inputs.push_back(lt_features.chi2);
0273       inputs.push_back(lt_features.quality);
0274       inputs.push_back(lt_features.lostInnerHits);
0275       inputs.push_back(lt_features.numberOfPixelHits);
0276       inputs.push_back(lt_features.numberOfStripHits);
0277     } else if (ifeature == UparT::kLostTracks4Vec) {
0278       inputs.push_back(lt_features.pt);
0279       inputs.push_back(lt_features.eta);
0280       inputs.push_back(lt_features.phi);
0281       inputs.push_back(lt_features.e);
0282     }
0283     return inputs;
0284   }
0285
0286   std::vector<float> inputs_UparT(const btagbtvdeep::NeutralCandidateFeatures& n_pf_features,
0287                                   UparT::InputFeatures ifeature) {
0288     std::vector<float> inputs;
0289     if (ifeature == UparT::kNeutralCandidates) {
0290       inputs.push_back(n_pf_features.ptrel);
0291       inputs.push_back(n_pf_features.etarel);
0292       inputs.push_back(n_pf_features.phirel);
0293       inputs.push_back(n_pf_features.deltaR);
0294       inputs.push_back(n_pf_features.isGamma);
0295       inputs.push_back(n_pf_features.hadFrac);
0296       inputs.push_back(n_pf_features.drminsv);
0297       inputs.push_back(n_pf_features.puppiw);
0298     } else if (ifeature == UparT::kNeutralCandidates4Vec) {
0299       inputs.push_back(n_pf_features.px);
0300       inputs.push_back(n_pf_features.py);
0301       inputs.push_back(n_pf_features.pz);
0302       inputs.push_back(n_pf_features.e);
0303     }
0304     return inputs;
0305   }
0306
0307   std::vector<float> inputs_UparT(const btagbtvdeep::SecondaryVertexFeatures& sv_features,
0308                                   UparT::InputFeatures ifeature) {
0309     std::vector<float> inputs;
0310     if (ifeature == UparT::kVertices) {
0311       inputs.push_back(sv_features.pt);
0312       inputs.push_back(sv_features.deltaR);
0313       inputs.push_back(sv_features.mass);
0314       inputs.push_back(sv_features.etarel);
0315       inputs.push_back(sv_features.phirel);
0316       inputs.push_back(sv_features.ntracks);
0317       inputs.push_back(sv_features.chi2);
0318       inputs.push_back(sv_features.normchi2);
0319       inputs.push_back(sv_features.dxy);
0320       inputs.push_back(sv_features.dxysig);
0321       inputs.push_back(sv_features.d3d);
0322       inputs.push_back(sv_features.d3dsig);
0323       inputs.push_back(sv_features.costhetasvpv);
0324       inputs.push_back(sv_features.enratio);
0325     } else if (ifeature == UparT::kVertices4Vec) {
0326       inputs.push_back(sv_features.px);
0327       inputs.push_back(sv_features.py);
0328       inputs.push_back(sv_features.pz);
0329       inputs.push_back(sv_features.e);
0330     }
0331     return inputs;
0332   }
0333 }  // namespace btagbtvdeep