sPhenix code displayed by LXR master/​coresoftware/​offline/​framework/​fun4allraw/​MicromegasBcoMatchingInformation_v1.cc	Source navigation Diff markup Identifier search General search
	Version: master Revert   Change

File indexing completed on 2025-08-06 08:17:21

 
 /*!
  * \file MicromegasBcoMatchingInformation_v1.cc
  * \author Hugo Pereira Da Costa <hugo.pereira-da-costa@cea.fr>
  * \brief handles matching between GTM and FEE BCO clock
  */
 
 #include "MicromegasBcoMatchingInformation_v1.h"
 
 #include <Event/packet.h>
 
 #include <algorithm>
 #include <vector>
 
 namespace
 {
 
   // streamer for lists
   template <class T>
   std::ostream& operator<<(std::ostream& o, const std::list<T>& list)
   {
     if (list.empty())
     {
       o << "{}";
     }
     else
     {
       const bool is_hex = (o.flags() & std::ios_base::hex);
       o << "{ ";
       bool first = true;
       for (const auto& value : list)
       {
         if (!first)
         {
           o << ", ";
         }
         if (is_hex)
         {
           o << "0x";
         }
         o << value;
         first = false;
       }
       o << " }";
     }
     return o;
   }
 
   template <class T>
   std::ostream& operator<<(std::ostream& o, const std::vector<T>& list)
   {
     if (list.empty())
     {
       o << "{}";
     }
     else
     {
       const bool is_hex = (o.flags() & std::ios_base::hex);
       o << "{ ";
       bool first = true;
       for (const auto& value : list)
       {
         if (!first)
         {
           o << ", ";
         }
         if (is_hex)
         {
           o << "0x";
         }
         o << value;
         first = false;
       }
       o << " }";
     }
     return o;
   }
 
   // get the difference between two BCO.
   template <class T>
   inline static constexpr T get_bco_diff(const T& first, const T& second)
   {
     return first < second ? (second - first) : (first - second);
   }
 
   // define limit for matching two fee_bco
   static constexpr unsigned int m_max_multiplier_adjustment_count = 1000;
 
   // define limit for matching two fee_bco
   static constexpr unsigned int m_max_fee_bco_diff = 10;
 
   // define limit for matching fee_bco to fee_bco_predicted
   static constexpr unsigned int m_max_gtm_bco_diff = 100;
 
   // needed to avoid memory leak. Assumes that we will not be assembling more than 50 events at the same time
   static constexpr unsigned int m_max_matching_data_size = 50;
 
   //! copied from micromegas/MicromegasDefs.h, not available here
   static constexpr int m_nchannels_fee = 256;
 
   /* see: https://git.racf.bnl.gov/gitea/Instrumentation/sampa_data/src/branch/fmtv2/README.md */
   enum SampaDataType
   {
     HEARTBEAT_T = 0b000,
     TRUNCATED_DATA_T = 0b001,
     TRUNCATED_TRIG_EARLY_DATA_T = 0b011,
     NORMAL_DATA_T = 0b100,
     LARGE_DATA_T = 0b101,
     TRIG_EARLY_DATA_T = 0b110,
     TRIG_EARLY_LARGE_DATA_T = 0b111,
   };
 
   /* see: https://git.racf.bnl.gov/gitea/Instrumentation/sampa_data/src/branch/fmtv2/README.md */
   enum ModeBitType
   {
     BX_COUNTER_SYNC_T = 0,
     ELINK_HEARTBEAT_T = 1,
     SAMPA_EVENT_TRIGGER_T = 2,
     CLEAR_LV1_LAST_T = 6,
     CLEAR_LV1_ENDAT_T = 7
   };
 }  // namespace
 
 // this is the clock multiplier from lvl1 to fee clock
 /* todo: should replace with actual rational number for John K. */
 double MicromegasBcoMatchingInformation_v1::m_multiplier = 4.262916255;
 
 //___________________________________________________
 std::optional<uint32_t> MicromegasBcoMatchingInformation_v1::get_predicted_fee_bco(uint64_t gtm_bco) const
 {
   // check proper initialization
   if (!is_verified())
   {
     return std::nullopt;
   }
 
   // get gtm bco difference with proper rollover accounting
   const uint64_t gtm_bco_difference = (gtm_bco >= m_gtm_bco_first) ? (gtm_bco - m_gtm_bco_first) : (gtm_bco + (1ULL << 40U) - m_gtm_bco_first);
 
   // convert to fee bco, and truncate to 20 bits
   const uint64_t fee_bco_predicted = m_fee_bco_first + get_adjusted_multiplier() * gtm_bco_difference;
   return uint32_t(fee_bco_predicted & 0xFFFFFU);
 }
 
 //___________________________________________________
 void MicromegasBcoMatchingInformation_v1::print_gtm_bco_information() const
 {
   if (!m_gtm_bco_list.empty())
   {
     std::cout
         << "MicromegasBcoMatchingInformation_v1::print_gtm_bco_information -"
         << " gtm_bco: " << std::hex << m_gtm_bco_list << std::dec
         << std::endl;
 
     // also print predicted fee bco
     if (is_verified())
     {
       std::list<uint32_t> fee_bco_predicted_list;
       std::transform(
           m_gtm_bco_list.begin(),
           m_gtm_bco_list.end(),
           std::back_inserter(fee_bco_predicted_list),
           [this](const uint64_t& gtm_bco)
           { return get_predicted_fee_bco(gtm_bco).value(); });
 
       std::cout
           << "MicromegasBcoMatchingInformation_v1::print_gtm_bco_information -"
           << " fee_bco_predicted: " << std::hex << fee_bco_predicted_list << std::dec
           << std::endl;
     }
   }
 }
 
 //___________________________________________________
 void MicromegasBcoMatchingInformation_v1::save_gtm_bco_information(Packet* packet)
 {
   // append gtm_bco from taggers in this event to packet-specific list of available lv1_bco
   const int n_tagger = packet->lValue(0, "N_TAGGER");
   for (int t = 0; t < n_tagger; ++t)
   {
     // save level1 trigger bco
     const bool is_lvl1 = static_cast<uint8_t>(packet->lValue(t, "IS_LEVEL1_TRIGGER"));
     if (is_lvl1)
     {
       const uint64_t gtm_bco = static_cast<uint64_t>(packet->lValue(t, "BCO"));
       m_gtm_bco_list.push_back(gtm_bco);
       continue;
     }
 
     // also save ENDDAT bco
     const bool is_endat = static_cast<uint8_t>(packet->lValue(t, "IS_ENDAT"));
     if( is_endat )
     {
       const uint64_t gtm_bco = static_cast<uint64_t>(packet->lValue(t, "BCO"));
 
       // add to list if difference to last entry is big enough
       if( m_gtm_bco_list.empty() || (gtm_bco-m_gtm_bco_list.back()) > 10 )
       {  m_gtm_bco_list.push_back(gtm_bco); }
 
       continue;
     }
 
     // also save hearbeat bco
     const bool is_modebit = static_cast<uint8_t>(packet->lValue(t, "IS_MODEBIT"));
     if (is_modebit)
     {
       // get modebits
       uint64_t modebits = static_cast<uint8_t>(packet->lValue(t, "MODEBITS"));
       if (modebits & (1U << ELINK_HEARTBEAT_T))
       {
         const uint64_t gtm_bco = static_cast<uint64_t>(packet->lValue(t, "BCO"));
         m_gtm_bco_list.push_back(gtm_bco);
         continue;
       }
     }
   }
 }
 
 //___________________________________________________
 bool MicromegasBcoMatchingInformation_v1::find_reference_from_modebits(Packet* packet)
 {
   // append gtm_bco from taggers in this event to packet-specific list of available lv1_bco
   const int n_tagger = packet->lValue(0, "N_TAGGER");
   for (int t = 0; t < n_tagger; ++t)
   {
     const bool is_modebit = static_cast<uint8_t>(packet->lValue(t, "IS_MODEBIT"));
     if (is_modebit)
     {
       // get modebits
       uint64_t modebits = static_cast<uint8_t>(packet->lValue(t, "MODEBITS"));
       if (modebits & (1U << BX_COUNTER_SYNC_T))
       {
         std::cout << "MicromegasBcoMatchingInformation_v1::find_reference_from_modebits"
                   << " - packet: " << packet->getIdentifier()
                   << " found reference from modebits"
                   << std::endl;
 
         // get BCO and assign
         const uint64_t gtm_bco = static_cast<uint64_t>(packet->lValue(t, "BCO"));
         m_gtm_bco_first = gtm_bco;
         m_fee_bco_first = 0;
         m_verified_from_modebits = true;
         return true;
       }
     }
   }
 
   return false;
 }
 
 //___________________________________________________
 bool MicromegasBcoMatchingInformation_v1::find_reference_from_data(Packet* packet)
 {
   // store gtm bco and diff to previous in an array
   std::vector<uint64_t> gtm_bco_list;
   std::vector<uint64_t> gtm_bco_diff_list;
   for (const auto& gtm_bco : m_gtm_bco_list)
   {
     if (!gtm_bco_list.empty())
     {
       // add difference to last
       // get gtm bco difference with proper rollover accounting
       const uint64_t gtm_bco_difference = (gtm_bco >= gtm_bco_list.back()) ? (gtm_bco - gtm_bco_list.back()) : (gtm_bco + (1ULL << 40U) - gtm_bco_list.back());
 
       gtm_bco_diff_list.push_back(get_adjusted_multiplier() * gtm_bco_difference);
     }
 
     // append to list
     gtm_bco_list.push_back(gtm_bco);
   }
 
   // print all differences
   if (verbosity())
   {
     std::cout << "MicromegasBcoMatchingInformation_v1::find_reference_from_data - gtm_bco_diff_list: " << gtm_bco_diff_list << std::endl;
   }
 
   uint32_t fee_bco_prev = 0;
   bool has_fee_bco_prev = false;
 
   // get number of waveforms
   const int n_waveform = packet->iValue(0, "NR_WF");
   for (int iwf = 0; iwf < n_waveform; ++iwf)
   {
     // check type
     const unsigned short type = packet->iValue(iwf, "TYPE");
 
     // skip heartbeat waveforms
     if (type == HEARTBEAT_T)
     {
       continue;
     }
 
     // check channel
     const unsigned short channel = packet->iValue(iwf, "CHANNEL");
 
     // bound check
     if (channel >= m_nchannels_fee)
     {
       continue;
     }
 
     const uint32_t fee_bco = static_cast<uint32_t>(packet->iValue(iwf, "BCO"));
     if (!has_fee_bco_prev)
     {
       fee_bco_prev = fee_bco;
       has_fee_bco_prev = true;
     }
 
     // calculate difference
     const uint64_t fee_bco_diff = get_bco_diff(fee_bco, fee_bco_prev);
 
     // discard identical fee_bco
     if (fee_bco_diff < m_max_fee_bco_diff)
     {
       continue;
     }
 
     std::cout << "MicromegasBcoMatchingInformation_v1::find_reference_from_data - fee_bco_diff: " << fee_bco_diff << std::endl;
 
     // look for matching diff in gtm_bco array
     for (size_t i = 0; i < gtm_bco_diff_list.size(); ++i)
     {
       uint64_t sum = 0;
       for (size_t j = i; j < gtm_bco_diff_list.size(); ++j)
       {
         sum += gtm_bco_diff_list[j];
         if (get_bco_diff(sum, fee_bco_diff) < m_max_fee_bco_diff)
         {
           m_verified_from_data = true;
           m_gtm_bco_first = gtm_bco_list[i];
           m_fee_bco_first = fee_bco_prev;
 
           if (verbosity())
           {
             std::cout << "MicromegasBcoMatchingInformation_v1::find_reference_from_data - matching is verified" << std::endl;
             std::cout
                 << "MicromegasBcoMatchingInformation_v1::find_reference_from_data -"
                 << " m_gtm_bco_first: " << std::hex << m_gtm_bco_first << std::dec
                 << std::endl;
             std::cout
                 << "MicromegasBcoMatchingInformation_v1::find_reference_from_data -"
                 << " m_fee_bco_first: " << std::hex << m_fee_bco_first << std::dec
                 << std::endl;
           }
           return true;
         }
       }
     }
 
     // update previous fee_bco
     fee_bco_prev = fee_bco;
   }
   return false;
 }
 
 //___________________________________________________
 std::optional<uint64_t> MicromegasBcoMatchingInformation_v1::find_gtm_bco(uint32_t fee_bco)
 {
   // make sure the bco matching is properly initialized
   if (!is_verified())
   {
     return std::nullopt;
   }
   // find matching gtm bco in map
   const auto bco_matching_iter = std::find_if(
       m_bco_matching_list.begin(),
       m_bco_matching_list.end(),
       [fee_bco](const m_bco_matching_pair_t& pair)
       { return get_bco_diff(pair.first, fee_bco) < m_max_fee_bco_diff; });
 
   if (bco_matching_iter != m_bco_matching_list.end())
   {
     return bco_matching_iter->second;
   }
   else
   {
     // find element for which predicted fee_bco matches fee_bco, within limit
     const auto iter = std::find_if(
         m_gtm_bco_list.begin(),
         m_gtm_bco_list.end(),
         [this, fee_bco](const uint64_t& gtm_bco)
         { return get_bco_diff(get_predicted_fee_bco(gtm_bco).value(), fee_bco) < m_max_gtm_bco_diff; });
 
     // check
     if (iter != m_gtm_bco_list.end())
     {
       const auto gtm_bco = *iter;
       if (verbosity())
       {
         const auto fee_bco_predicted = get_predicted_fee_bco(gtm_bco).value();
         const auto fee_bco_diff = get_bco_diff(fee_bco_predicted, fee_bco);
 
         std::cout << "MicromegasBcoMatchingInformation_v1::find_gtm_bco -"
                   << std::hex
                   << " fee_bco: 0x" << fee_bco
                   << " predicted: 0x" << fee_bco_predicted
                   << " gtm_bco: 0x" << gtm_bco
                   << std::dec
                   << " difference: " << fee_bco_diff
                   << std::endl;
       }
 
       // save fee_bco and gtm_bco matching in map
       m_bco_matching_list.emplace_back(fee_bco, gtm_bco);
 
       // remove gtm bco from runing list
       m_gtm_bco_list.erase(iter);
 
       // update clock adjustment
       update_multiplier_adjustment(gtm_bco, fee_bco);
 
       return gtm_bco;
     }
     else
     {
       if (m_orphans.insert(fee_bco).second)
       {
         if (verbosity())
         {
           // find element for which predicted fee_bco is the closest to request
           const auto iter2 = std::min_element(
               m_gtm_bco_list.begin(),
               m_gtm_bco_list.end(),
               [this, fee_bco](const uint64_t& first, const uint64_t& second)
               { return get_bco_diff(get_predicted_fee_bco(first).value(), fee_bco) < get_bco_diff(get_predicted_fee_bco(second).value(), fee_bco); });
 
           const int fee_bco_diff = (iter2 != m_gtm_bco_list.end()) ? get_bco_diff(get_predicted_fee_bco(*iter2).value(), fee_bco) : -1;
 
           std::cout << "MicromegasBcoMatchingInformation_v1::find_gtm_bco -"
                     << std::hex
                     << " fee_bco: 0x" << fee_bco
                     << std::dec
                     << " gtm_bco: none"
                     << " difference: " << fee_bco_diff
                     << std::endl;
         }
       }
       return std::nullopt;
     }
   }
 
   // never reached
   return std::nullopt;
 }
 
 //___________________________________________________
 void MicromegasBcoMatchingInformation_v1::cleanup()
 {
   // remove old gtm_bco and matching
   while (m_gtm_bco_list.size() > m_max_matching_data_size)
   {
     m_gtm_bco_list.pop_front();
   }
   while (m_bco_matching_list.size() > m_max_matching_data_size)
   {
     m_bco_matching_list.pop_front();
   }
 
   // clear orphans
   m_orphans.clear();
 }
 
 //___________________________________________________
 void MicromegasBcoMatchingInformation_v1::cleanup(uint64_t ref_bco)
 {
   // erase all elements from bco_list that are less than or equal to ref_bco
   m_gtm_bco_list.erase( std::remove_if( m_gtm_bco_list.begin(), m_gtm_bco_list.end(), [ref_bco](const uint64_t& bco) { return bco<=ref_bco; }), m_gtm_bco_list.end() );
 
   // erase all elements from bco_list that are less than or equal to ref_bco
   m_bco_matching_list.erase( std::remove_if( m_bco_matching_list.begin(), m_bco_matching_list.end(), [ref_bco](const m_bco_matching_pair_t& pair) { return pair.second<=ref_bco; }), m_bco_matching_list.end() );
 
   // clear orphans
   m_orphans.clear();
 }
 
 //___________________________________________________
 double MicromegasBcoMatchingInformation_v1::get_adjusted_multiplier() const
 {
   return m_multiplier + m_multiplier_adjustment;
 }
 
 //___________________________________________________
 void MicromegasBcoMatchingInformation_v1::update_multiplier_adjustment(uint64_t gtm_bco, uint32_t fee_bco)
 {
   // check that references are valid
   if (!is_verified())
   {
     return;
   }
 
   // skip if trivial
   if (gtm_bco == m_gtm_bco_first)
   {
     return;
   }
 
   const uint32_t fee_bco_predicted = get_predicted_fee_bco(gtm_bco).value();
   const double delta_fee_bco = double(fee_bco) - double(fee_bco_predicted);
   const double gtm_bco_difference = (gtm_bco >= m_gtm_bco_first) ? (gtm_bco - m_gtm_bco_first) : (gtm_bco + (1ULL << 40U) - m_gtm_bco_first);
 
   m_multiplier_adjustment_numerator += gtm_bco_difference * delta_fee_bco;
   m_multiplier_adjustment_denominator += gtm_bco_difference * gtm_bco_difference;
   ++m_multiplier_adjustment_count;
 
   if (verbosity())
   {
     const auto default_precision{std::cout.precision()};
     std::cout << "MicromegasBcoMatchingInformation_v1::update_multiplier_adjustment -"
               << " m_multiplier_adjustment_count: " << m_multiplier_adjustment_count
               << std::setprecision(10)
               << " m_multiplier: " << get_adjusted_multiplier()
               << " adjustment: " << m_multiplier_adjustment_numerator / m_multiplier_adjustment_denominator
               << " m_multiplier_adjusted: " << get_adjusted_multiplier() + m_multiplier_adjustment_numerator / m_multiplier_adjustment_denominator
               << std::setprecision(default_precision)
               << std::endl;
   }
 
   // update multiplier
   if (m_multiplier_adjustment_count > m_max_multiplier_adjustment_count)
   {
     m_multiplier_adjustment += m_multiplier_adjustment_numerator / m_multiplier_adjustment_denominator;
     m_multiplier_adjustment_numerator = 0;
     m_multiplier_adjustment_denominator = 0;
     m_multiplier_adjustment_count = 0;
   }
 }

This page was automatically generated by the 2.3.7 LXR engine. The LXR team