l1t::demo::codecs Namespace Reference

Functions
std::vector< l1t::EtSum >	decodeEtSums (const std::vector< ap_uint< 64 >> &)
std::vector< l1t::EtSum >	decodeHtSums (const std::vector< ap_uint< 64 >> &)
std::vector< l1t::TkJetWord >	decodeTkJets (const std::vector< ap_uint< 64 >> &)
std::vector< TTTrack_TrackWord >	decodeTracks (const std::vector< ap_uint< 64 >> &)
std::array< std::vector< TTTrack_TrackWord >, 18 >	decodeTracks (const std::array< std::vector< ap_uint< 64 >>, 18 > &)
std::vector< l1t::VertexWord >	decodeVertices (const std::vector< ap_uint< 64 >> &)
ap_uint< 64 >	encodeEtSum (const l1t::EtSum &v)
std::array< std::vector< ap_uint< 64 > >, 1 >	encodeEtSums (const edm::View< l1t::EtSum > &)
ap_uint< 64 >	encodeHtSum (const l1t::EtSum &v)
std::array< std::vector< ap_uint< 64 > >, 1 >	encodeHtSums (const edm::View< l1t::EtSum > &)
size_t	encodeLinks (std::array< std::vector< ap_uint< 96 >>, 18 > &trackWords, std::array< std::vector< ap_uint< 64 >>, 18 > &linkData)
ap_uint< 64 >	encodeTkJet (const l1t::TkJetWord &t)
std::array< std::vector< ap_uint< 64 > >, 1 >	encodeTkJets (const edm::View< l1t::TkJetWord > &)
ap_uint< 96 >	encodeTrack (const TTTrack_TrackWord &t)
std::array< std::vector< ap_uint< 64 > >, 18 >	encodeTracks (const edm::View< TTTrack< Ref_Phase2TrackerDigi_ >> &, int debug=0)
std::array< std::vector< ap_uint< 64 > >, 18 >	encodeTracks (const edm::Handle< std::vector< TTTrack< Ref_Phase2TrackerDigi_ >>> &, const edm::Handle< edm::RefVector< std::vector< TTTrack< Ref_Phase2TrackerDigi_ >>>> &, int debug=0)
ap_uint< 64 >	encodeVertex (const l1t::VertexWord &v)
std::array< std::vector< ap_uint< 64 > >, 1 >	encodeVertices (const edm::View< l1t::VertexWord > &)
std::array< std::vector< ap_uint< 96 > >, 18 >	getTrackWords (const edm::View< TTTrack< Ref_Phase2TrackerDigi_ >> &)
std::array< std::vector< ap_uint< 96 > >, 18 >	getTrackWords (const edm::Handle< std::vector< TTTrack< Ref_Phase2TrackerDigi_ >>> &, const edm::Handle< edm::RefVector< std::vector< TTTrack< Ref_Phase2TrackerDigi_ >>>> &)
bool	trackInCollection (const edm::Ref< std::vector< TTTrack< Ref_Phase2TrackerDigi_ >>> &, const edm::Handle< edm::RefVector< std::vector< TTTrack< Ref_Phase2TrackerDigi_ >>>> &)

Function Documentation

decodeEtSums()

std::vector< l1t::EtSum > l1t::demo::codecs::decodeEtSums

(

const std::vector< ap_uint< 64 >> &

frames

)

Definition at line 34 of file codecs_etsums.cc.

References l1tmetemu::kMETPhiSize, l1tmetemu::kMETSize, L1Analysis::kMissingEt, alignCSCRings::s, findQualityFiles::v, and x.

                                                                         {
    std::vector<l1t::EtSum> etSums;

    for (const auto& x : frames) {
      if (not x.test(0))
        break;

      math::XYZTLorentzVector v(0, 0, 0, 0);
      l1t::EtSum s(v,
                   l1t::EtSum::EtSumType::kMissingEt,
                   l1tmetemu::METWord_t(x(1 + l1tmetemu::kMETSize, 1)),
                   0,
                   l1tmetemu::METWordphi_t(x(1 + l1tmetemu::kMETSize + l1tmetemu::kMETPhiSize, 17)).to_int(),
                   0);
      etSums.push_back(s);
    }

    return etSums;
  }

decodeHtSums()

std::vector< l1t::EtSum > l1t::demo::codecs::decodeHtSums

(

const std::vector< ap_uint< 64 >> &

frames

)

Definition at line 35 of file codecs_htsums.cc.

References l1tmhtemu::kHTLSB, l1tmhtemu::kHTMSB, l1tmhtemu::kMHTLSB, l1tmhtemu::kMHTMSB, l1tmhtemu::kMHTPhiLSB, l1tmhtemu::kMHTPhiMSB, L1Analysis::kMissingHt, alignCSCRings::s, findQualityFiles::v, and x.

                                                                         {
    std::vector<l1t::EtSum> htSums;

    for (const auto& x : frames) {
      if (not x.test(0))
        break;

      math::XYZTLorentzVector v(0, 0, 0, l1tmhtemu::MHT_t(x(l1tmhtemu::kMHTMSB, l1tmhtemu::kMHTLSB)).to_int());
      l1t::EtSum s(v,
                   l1t::EtSum::EtSumType::kMissingHt,
                   l1tmhtemu::MHT_t(x(l1tmhtemu::kHTMSB, l1tmhtemu::kHTLSB)),
                   0,
                   l1tmhtemu::MHTphi_t(x(l1tmhtemu::kMHTPhiMSB, l1tmhtemu::kMHTPhiLSB)).to_int(),
                   0);
      htSums.push_back(s);
    }

    return htSums;
  }

decodeTkJets()

std::vector< l1t::TkJetWord > l1t::demo::codecs::decodeTkJets

(

const std::vector< ap_uint< 64 >> &

frames

)

Definition at line 28 of file codecs_tkjets.cc.

References f, dqmiolumiharvest::j, l1t::TkJetWord::kGlbEtaLSB, l1t::TkJetWord::kGlbEtaMSB, l1t::TkJetWord::kGlbPhiLSB, l1t::TkJetWord::kGlbPhiMSB, l1t::TkJetWord::kNtLSB, l1t::TkJetWord::kNtMSB, l1t::TkJetWord::kPtLSB, l1t::TkJetWord::kPtMSB, l1t::TkJetWord::kUnassignedLSB, l1t::TkJetWord::kUnassignedMSB, l1t::TkJetWord::kXtLSB, l1t::TkJetWord::kXtMSB, l1t::TkJetWord::kZ0LSB, and l1t::TkJetWord::kZ0MSB.

                                                                             {
    std::vector<l1t::TkJetWord> tkJets;

    for (size_t f = 0; f < frames.size(); f += 2) {
      // There is no valid bit in the definition right now.
      // Uncomment the next two lines when this is available.
      //if (not x.test(TkJetWord::kValidLSB))
      //  break;

      TkJetWord j(TkJetWord::pt_t(frames[f](TkJetWord::kPtMSB, TkJetWord::kPtLSB)),
                  TkJetWord::glbeta_t(frames[f](TkJetWord::kGlbEtaMSB, TkJetWord::kGlbEtaLSB)),
                  TkJetWord::glbphi_t(frames[f](TkJetWord::kGlbPhiMSB, TkJetWord::kGlbPhiLSB)),
                  TkJetWord::z0_t(frames[f](TkJetWord::kZ0MSB, TkJetWord::kZ0LSB)),
                  TkJetWord::nt_t(frames[f](TkJetWord::kNtMSB, TkJetWord::kNtLSB)),
                  TkJetWord::nx_t(frames[f](TkJetWord::kXtMSB, TkJetWord::kXtLSB)),
                  TkJetWord::tkjetunassigned_t(frames[f](TkJetWord::kUnassignedMSB, TkJetWord::kUnassignedLSB)));
      tkJets.push_back(j);
    }

    return tkJets;
  }

decodeTracks() [1/2]

std::vector< TTTrack_TrackWord > l1t::demo::codecs::decodeTracks

(

const std::vector< ap_uint< 64 >> &

frames

)

Definition at line 110 of file codecs_tracks.cc.

References mps_fire::i, TTTrack_TrackWord::kBendChi2LSB, TTTrack_TrackWord::kBendChi2MSB, TTTrack_TrackWord::kChi2RPhiLSB, TTTrack_TrackWord::kChi2RPhiMSB, TTTrack_TrackWord::kChi2RZLSB, TTTrack_TrackWord::kChi2RZMSB, TTTrack_TrackWord::kD0LSB, TTTrack_TrackWord::kD0MSB, TTTrack_TrackWord::kHitPatternLSB, TTTrack_TrackWord::kHitPatternMSB, TTTrack_TrackWord::kMVAOtherLSB, TTTrack_TrackWord::kMVAOtherMSB, TTTrack_TrackWord::kMVAQualityLSB, TTTrack_TrackWord::kMVAQualityMSB, TTTrack_TrackWord::kPhiLSB, TTTrack_TrackWord::kPhiMSB, TTTrack_TrackWord::kRinvLSB, TTTrack_TrackWord::kRinvMSB, TTTrack_TrackWord::kTanlLSB, TTTrack_TrackWord::kTanlMSB, TTTrack_TrackWord::kValidLSB, TTTrack_TrackWord::kValidMSB, TTTrack_TrackWord::kZ0LSB, TTTrack_TrackWord::kZ0MSB, TTTrack_TrackWord::setTrackWord(), and l1t::tracks.

Referenced by decodeTracks().

                                                                                  {
    std::vector<TTTrack_TrackWord> tracks;

    if ((frames.size() % 3) != 0) {
      std::stringstream message;
      message << "The number of track frames (" << frames.size() << ") is not evenly divisible by 3";
      throw std::runtime_error(message.str());
    }

    for (size_t i = 0; i < frames.size(); i += 3) {
      TTTrack_TrackWord::tkword_t combination1 = (ap_uint<32>(frames.at(i + 1)(31, 0)), frames.at(i)(63, 0));
      TTTrack_TrackWord::tkword_t combination2 = (frames.at(i + 2)(63, 0), ap_uint<32>(frames.at(i + 1)(63, 32)));
      TTTrack_TrackWord track1, track2;
      track1.setTrackWord(
          TTTrack_TrackWord::valid_t(combination1(TTTrack_TrackWord::kValidMSB, TTTrack_TrackWord::kValidLSB)),
          TTTrack_TrackWord::rinv_t(combination1(TTTrack_TrackWord::kRinvMSB, TTTrack_TrackWord::kRinvLSB)),
          TTTrack_TrackWord::phi_t(combination1(TTTrack_TrackWord::kPhiMSB, TTTrack_TrackWord::kPhiLSB)),
          TTTrack_TrackWord::tanl_t(combination1(TTTrack_TrackWord::kTanlMSB, TTTrack_TrackWord::kTanlLSB)),
          TTTrack_TrackWord::z0_t(combination1(TTTrack_TrackWord::kZ0MSB, TTTrack_TrackWord::kZ0LSB)),
          TTTrack_TrackWord::d0_t(combination1(TTTrack_TrackWord::kD0MSB, TTTrack_TrackWord::kD0LSB)),
          TTTrack_TrackWord::chi2rphi_t(combination1(TTTrack_TrackWord::kChi2RPhiMSB, TTTrack_TrackWord::kChi2RPhiLSB)),
          TTTrack_TrackWord::chi2rz_t(combination1(TTTrack_TrackWord::kChi2RZMSB, TTTrack_TrackWord::kChi2RZLSB)),
          TTTrack_TrackWord::bendChi2_t(combination1(TTTrack_TrackWord::kBendChi2MSB, TTTrack_TrackWord::kBendChi2LSB)),
          TTTrack_TrackWord::hit_t(combination1(TTTrack_TrackWord::kHitPatternMSB, TTTrack_TrackWord::kHitPatternLSB)),
          TTTrack_TrackWord::qualityMVA_t(
              combination1(TTTrack_TrackWord::kMVAQualityMSB, TTTrack_TrackWord::kMVAQualityLSB)),
          TTTrack_TrackWord::otherMVA_t(
              combination1(TTTrack_TrackWord::kMVAOtherMSB, TTTrack_TrackWord::kMVAOtherLSB)));
      track2.setTrackWord(
          TTTrack_TrackWord::valid_t(combination2(TTTrack_TrackWord::kValidMSB, TTTrack_TrackWord::kValidLSB)),
          TTTrack_TrackWord::rinv_t(combination2(TTTrack_TrackWord::kRinvMSB, TTTrack_TrackWord::kRinvLSB)),
          TTTrack_TrackWord::phi_t(combination2(TTTrack_TrackWord::kPhiMSB, TTTrack_TrackWord::kPhiLSB)),
          TTTrack_TrackWord::tanl_t(combination2(TTTrack_TrackWord::kTanlMSB, TTTrack_TrackWord::kTanlLSB)),
          TTTrack_TrackWord::z0_t(combination2(TTTrack_TrackWord::kZ0MSB, TTTrack_TrackWord::kZ0LSB)),
          TTTrack_TrackWord::d0_t(combination2(TTTrack_TrackWord::kD0MSB, TTTrack_TrackWord::kD0LSB)),
          TTTrack_TrackWord::chi2rphi_t(combination2(TTTrack_TrackWord::kChi2RPhiMSB, TTTrack_TrackWord::kChi2RPhiLSB)),
          TTTrack_TrackWord::chi2rz_t(combination2(TTTrack_TrackWord::kChi2RZMSB, TTTrack_TrackWord::kChi2RZLSB)),
          TTTrack_TrackWord::bendChi2_t(combination2(TTTrack_TrackWord::kBendChi2MSB, TTTrack_TrackWord::kBendChi2LSB)),
          TTTrack_TrackWord::hit_t(combination2(TTTrack_TrackWord::kHitPatternMSB, TTTrack_TrackWord::kHitPatternLSB)),
          TTTrack_TrackWord::qualityMVA_t(
              combination2(TTTrack_TrackWord::kMVAQualityMSB, TTTrack_TrackWord::kMVAQualityLSB)),
          TTTrack_TrackWord::otherMVA_t(
              combination2(TTTrack_TrackWord::kMVAOtherMSB, TTTrack_TrackWord::kMVAOtherLSB)));
      tracks.push_back(track1);
      tracks.push_back(track2);
    }

    return tracks;
  }

decodeTracks() [2/2]

std::array< std::vector< TTTrack_TrackWord >, 18 > l1t::demo::codecs::decodeTracks

(

const std::array< std::vector< ap_uint< 64 >>, 18 > &

frames

)

Definition at line 161 of file codecs_tracks.cc.

References decodeTracks(), mps_fire::i, and l1t::tracks.

                                                                                                              {
    std::array<std::vector<TTTrack_TrackWord>, 18> tracks;

    for (size_t i = 0; i < tracks.size(); i++) {
      tracks.at(i) = decodeTracks(frames.at(i));
    }

    return tracks;
  }

decodeVertices()

std::vector< l1t::VertexWord > l1t::demo::codecs::decodeVertices

(

const std::vector< ap_uint< 64 >> &

frames

)

Definition at line 26 of file codecs_vertices.cc.

References l1t::VertexWord::kNTrackInPVLSB, l1t::VertexWord::kNTrackInPVMSB, l1t::VertexWord::kNTrackOutPVLSB, l1t::VertexWord::kNTrackOutPVMSB, l1t::VertexWord::kQualityLSB, l1t::VertexWord::kQualityMSB, l1t::VertexWord::kSumPtLSB, l1t::VertexWord::kSumPtMSB, l1t::VertexWord::kUnassignedLSB, l1t::VertexWord::kUnassignedMSB, l1t::VertexWord::kValidLSB, l1t::VertexWord::kZ0LSB, l1t::VertexWord::kZ0MSB, findQualityFiles::v, AlignmentTracksFromVertexSelector_cfi::vertices, and x.

Referenced by GTTFileReader::produce().

                                                                                {
    std::vector<l1t::VertexWord> vertices;

    for (const auto& x : frames) {
      if (not x.test(VertexWord::kValidLSB))
        break;

      VertexWord v(VertexWord::vtxvalid_t(1),
                   VertexWord::vtxz0_t(x(VertexWord::kZ0MSB, VertexWord::kZ0LSB)),
                   VertexWord::vtxmultiplicity_t(x(VertexWord::kNTrackInPVMSB, VertexWord::kNTrackInPVLSB)),
                   VertexWord::vtxsumpt_t(x(VertexWord::kSumPtMSB, VertexWord::kSumPtLSB)),
                   VertexWord::vtxquality_t(x(VertexWord::kQualityMSB, VertexWord::kQualityLSB)),
                   VertexWord::vtxinversemult_t(x(VertexWord::kNTrackOutPVMSB, VertexWord::kNTrackOutPVLSB)),
                   VertexWord::vtxunassigned_t(x(VertexWord::kUnassignedMSB, VertexWord::kUnassignedLSB)));
      vertices.push_back(v);
    }

    return vertices;
  }

encodeEtSum()

ap_uint< 64 > l1t::demo::codecs::encodeEtSum

(

const l1t::EtSum &

v

)

Definition at line 6 of file codecs_etsums.cc.

References l1tmetemu::EtMiss::Et, l1t::L1Candidate::hwPhi(), l1t::L1Candidate::hwPt(), l1t::L1Candidate::hwQual(), l1tmetemu::kMETPhiSize, l1tmetemu::kMETSize, l1tmetemu::EtMiss::Phi, and validateGeometry_cfg::valid.

Referenced by encodeEtSums().

                                                 {
    l1tmetemu::EtMiss etMiss;
    etMiss.Et.V = etSum.hwPt();
    etMiss.Phi = etSum.hwPhi();
    ap_uint<1> valid = (etSum.hwQual() > 0);
    ap_uint<64 - (l1tmetemu::kMETSize + l1tmetemu::kMETPhiSize + 1)> unassigned = 0;
    ap_uint<64> etSumWord = (unassigned, etMiss.Phi, etMiss.Et.range(), valid);
    return etSumWord;
  }

encodeEtSums()

std::array< std::vector< ap_uint< 64 > >, 1 > l1t::demo::codecs::encodeEtSums

(

const edm::View< l1t::EtSum > &

etSums

)

Definition at line 17 of file codecs_etsums.cc.

References encodeEtSum(), and mps_fire::i.

Referenced by GTTFileWriter::analyze().

                                                                                    {
    std::vector<ap_uint<64>> etSumWords;

    for (const auto& etSum : etSums)
      etSumWords.push_back(encodeEtSum(etSum));

    std::array<std::vector<ap_uint<64>>, 1> linkData;

    for (size_t i = 0; i < linkData.size(); i++) {
      // Pad etsum vectors -> full packet length (48 frames, but only 1 etsum max)
      etSumWords.resize(1, 0);
      linkData.at(i) = etSumWords;
    }

    return linkData;
  }

encodeHtSum()

ap_uint< 64 > l1t::demo::codecs::encodeHtSum

(

const l1t::EtSum &

v

)

Definition at line 6 of file codecs_htsums.cc.

References l1tmhtemu::EtMiss::Et, tmtt::Utility::HT, l1t::L1Candidate::hwPhi(), l1t::L1Candidate::hwPt(), l1t::L1Candidate::hwQual(), reco::LeafCandidate::p4(), l1tmhtemu::EtMiss::Phi, and validateGeometry_cfg::valid.

Referenced by encodeHtSums().

                                                 {
    l1tmhtemu::EtMiss htMiss;
    htMiss.Et = htSum.p4().energy();
    htMiss.Phi = htSum.hwPhi();
    ap_uint<l1tmhtemu::kMHTSize> HT = htSum.hwPt();
    ap_uint<l1tmhtemu::kValidSize> valid = (htSum.hwQual() > 0);
    ap_uint<l1tmhtemu::kUnassignedSize> unassigned = 0;
    ap_uint<64> htSumWord = (unassigned, HT, htMiss.Phi, htMiss.Et.range(), valid);
    return htSumWord;
  }

encodeHtSums()

std::array< std::vector< ap_uint< 64 > >, 1 > l1t::demo::codecs::encodeHtSums

(

const edm::View< l1t::EtSum > &

htSums

)

Definition at line 18 of file codecs_htsums.cc.

References encodeHtSum(), and mps_fire::i.

Referenced by GTTFileWriter::analyze().

                                                                                    {
    std::vector<ap_uint<64>> htSumWords;

    for (const auto& htSum : htSums)
      htSumWords.push_back(encodeHtSum(htSum));

    std::array<std::vector<ap_uint<64>>, 1> linkData;

    for (size_t i = 0; i < linkData.size(); i++) {
      // Pad etsum vectors -> full packet length (48 frames, but only 1 htsum max)
      htSumWords.resize(1, 0);
      linkData.at(i) = htSumWords;
    }

    return linkData;
  }

encodeLinks()

size_t l1t::demo::codecs::encodeLinks	(	std::array< std::vector< ap_uint< 96 >>, 18 > &	trackWords,
		std::array< std::vector< ap_uint< 64 >>, 18 > &	linkData
	)

Definition at line 52 of file codecs_tracks.cc.

References counter, mps_fire::i, and dqmiolumiharvest::j.

Referenced by encodeTracks().

                                                                     {
    size_t counter = 0;
    for (size_t i = 0; i < linkData.size(); i++) {
      // Pad track vectors -> full packet length (156 frames = 104 tracks)
      trackWords.at(i).resize(104, 0);
      linkData.at(i).resize(156, {0});

      for (size_t j = 0; (j < trackWords.at(i).size()); j += 2) {
        linkData.at(i).at(3 * j / 2) = trackWords.at(i).at(j)(63, 0);
        linkData.at(i).at(3 * j / 2 + 1) =
            (ap_uint<32>(trackWords.at(i).at(j + 1)(31, 0)), ap_uint<32>(trackWords.at(i).at(j)(95, 64)));
        linkData.at(i).at(3 * j / 2 + 2) = trackWords.at(i).at(j + 1)(95, 32);
        counter += trackWords.at(i).at(j)(95, 95) + trackWords.at(i).at(j + 1)(95, 95);
      }
    }
    return counter;
  }

encodeTkJet()

ap_uint< 64 > l1t::demo::codecs::encodeTkJet

(

const l1t::TkJetWord &

t

)

Definition at line 6 of file codecs_tkjets.cc.

References dqmiolumiharvest::j.

Referenced by encodeTkJets().

{ return j.tkJetWord(); }

encodeTkJets()

std::array< std::vector< ap_uint< 64 > >, 1 > l1t::demo::codecs::encodeTkJets

(

const edm::View< l1t::TkJetWord > &

tkJets

)

Definition at line 9 of file codecs_tkjets.cc.

References encodeTkJet(), and mps_fire::i.

Referenced by GTTFileWriter::analyze().

                                                                                        {
    std::vector<ap_uint<64>> tkJetWords;

    for (const auto& tkJet : tkJets) {
      tkJetWords.push_back(encodeTkJet(tkJet));
      tkJetWords.push_back(ap_uint<64>(0));
    }

    std::array<std::vector<ap_uint<64>>, 1> linkData;

    for (size_t i = 0; i < linkData.size(); i++) {
      // Pad TkJet vectors -> full packet length (48 frames, but only 12 TkJets max, two words per jet)
      tkJetWords.resize(24, 0);
      linkData.at(i) = tkJetWords;
    }

    return linkData;
  }

encodeTrack()

ap_uint< 96 > l1t::demo::codecs::encodeTrack

(

const TTTrack_TrackWord &

t

)

Definition at line 21 of file codecs_tracks.cc.

References submitPVValidationJobs::t.

Referenced by getTrackWords().

{ return t.getTrackWord(); }

encodeTracks() [1/2]

std::array< std::vector< ap_uint< 64 > >, 18 > l1t::demo::codecs::encodeTracks	(	const edm::View< TTTrack< Ref_Phase2TrackerDigi_ >> &	tracks,
		int	debug = 0
	)

Definition at line 72 of file codecs_tracks.cc.

References debug, encodeLinks(), getTrackWords(), and l1t::tracks.

Referenced by GTTFileWriter::analyze().

                                                                   {
    if (debug > 0) {
      edm::LogInfo("l1t::demo::codecs") << "encodeTrack::Encoding " << tracks.size() << " tracks";
    }

    std::array<std::vector<ap_uint<96>>, 18> trackWords = getTrackWords(tracks);
    std::array<std::vector<ap_uint<64>>, 18> linkData;
    size_t counter = encodeLinks(trackWords, linkData);

    if (debug > 0) {
      edm::LogInfo("l1t::demo::codecs") << "encodeTrack::Encoded " << counter << " tracks";
    }

    return linkData;
  }

encodeTracks() [2/2]

std::array< std::vector< ap_uint< 64 > >, 18 > l1t::demo::codecs::encodeTracks	(	const edm::Handle< std::vector< TTTrack< Ref_Phase2TrackerDigi_ >>> &	referenceTracks,
		const edm::Handle< edm::RefVector< std::vector< TTTrack< Ref_Phase2TrackerDigi_ >>>> &	tracks,
		int	debug = 0
	)

Definition at line 91 of file codecs_tracks.cc.

References debug, encodeLinks(), getTrackWords(), and l1t::tracks.

                 {
    if (debug > 0) {
      edm::LogInfo("l1t::demo::codecs") << "encodeTrack::Encoding " << tracks->size() << " tracks";
    }

    std::array<std::vector<ap_uint<96>>, 18> trackWords = getTrackWords(referenceTracks, tracks);
    std::array<std::vector<ap_uint<64>>, 18> linkData;
    size_t counter = encodeLinks(trackWords, linkData);

    if (debug > 0) {
      edm::LogInfo("l1t::demo::codecs") << "encodeTrack::Encoded " << counter << " tracks";
    }

    return linkData;
  }

encodeVertex()

ap_uint< 64 > l1t::demo::codecs::encodeVertex

(

const l1t::VertexWord &

v

)

Definition at line 6 of file codecs_vertices.cc.

References findQualityFiles::v.

Referenced by encodeVertices().

{ return v.vertexWord(); }

encodeVertices()

std::array< std::vector< ap_uint< 64 > >, 1 > l1t::demo::codecs::encodeVertices

(

const edm::View< l1t::VertexWord > &

vertices

)

Definition at line 9 of file codecs_vertices.cc.

References encodeVertex(), mps_fire::i, bphysicsOniaDQM_cfi::vertex, and AlignmentTracksFromVertexSelector_cfi::vertices.

Referenced by GTTFileWriter::analyze().

                                                                                             {
    std::vector<ap_uint<64>> vertexWords;

    for (const auto& vertex : vertices)
      vertexWords.push_back(encodeVertex(vertex));

    std::array<std::vector<ap_uint<64>>, 1> linkData;

    for (size_t i = 0; i < linkData.size(); i++) {
      // Pad vertex vectors -> full packet length (48 frames, but only 10 vertices max)
      vertexWords.resize(10, 0);
      linkData.at(i) = vertexWords;
    }

    return linkData;
  }

getTrackWords() [1/2]

std::array< std::vector< ap_uint< 96 > >, 18 > l1t::demo::codecs::getTrackWords

(

const edm::View< TTTrack< Ref_Phase2TrackerDigi_ >> &

tracks

)

Definition at line 24 of file codecs_tracks.cc.

References encodeTrack(), HLT_2023v12_cff::track, and l1t::tracks.

Referenced by encodeTracks().

                                                                                                             {
    std::array<std::vector<ap_uint<96>>, 18> trackWords;
    for (const auto& track : tracks) {
      trackWords.at((track.eta() >= 0 ? 1 : 0) + (2 * track.phiSector())).push_back(encodeTrack(track));
    }
    return trackWords;
  }

getTrackWords() [2/2]

std::array< std::vector< ap_uint< 96 > >, 18 > l1t::demo::codecs::getTrackWords	(	const edm::Handle< std::vector< TTTrack< Ref_Phase2TrackerDigi_ >>> &	referenceTracks,
		const edm::Handle< edm::RefVector< std::vector< TTTrack< Ref_Phase2TrackerDigi_ >>>> &	tracks
	)

Definition at line 33 of file codecs_tracks.cc.

References encodeTrack(), BTVHLTOfflineSource_cfi::referenceTrack, trackInCollection(), and l1t::tracks.

                                                                                         {
    std::array<std::vector<ap_uint<96>>, 18> trackWords;
    for (unsigned int itrack = 0; itrack < referenceTracks->size(); itrack++) {
      const auto& referenceTrack = referenceTracks->at(itrack);
      edm::Ref<std::vector<TTTrack<Ref_Phase2TrackerDigi_>>> referenceTrackRef(referenceTracks, itrack);

      if (trackInCollection(referenceTrackRef, tracks)) {
        trackWords.at((referenceTrack.eta() >= 0 ? 1 : 0) + (2 * referenceTrack.phiSector()))
            .push_back(encodeTrack(referenceTrack));
      } else {
        trackWords.at((referenceTrack.eta() >= 0 ? 1 : 0) + (2 * referenceTrack.phiSector())).push_back(ap_uint<96>(0));
      }
    }
    return trackWords;
  }

trackInCollection()

bool l1t::demo::codecs::trackInCollection	(	const edm::Ref< std::vector< TTTrack< Ref_Phase2TrackerDigi_ >>> &	trackRef,
		const edm::Handle< edm::RefVector< std::vector< TTTrack< Ref_Phase2TrackerDigi_ >>>> &	trackRefCollection
	)

Definition at line 7 of file codecs_tracks.cc.

References getGTfromDQMFile::obj.

Referenced by getTrackWords().

                                                                                                     {
    auto it = std::find_if(
        trackRefCollection->begin(),
        trackRefCollection->end(),
        [&trackRef](edm::Ref<std::vector<TTTrack<Ref_Phase2TrackerDigi_>>> const& obj) { return obj == trackRef; });
    if (it != trackRefCollection->end())
      return true;
    else
      return false;
  }