packages/intt/InttBadChannelMap.cc

0001 #include "InttBadChannelMap.h"
0002 #include "InttMapping.h"
0003
0004 #include <cdbobjects/CDBTTree.h>
0005 #include <ffamodules/CDBInterface.h>
0006 #include <phool/phool.h>
0007
0008 #include <Rtypes.h> // For Int_t, Long64_t, etc
0009
0010 #include <filesystem>  // for exists
0011 #include <limits>
0012
0013 int InttBadChannelMap::Load(std::string const& name)
0014 {
0015   if (name.empty())
0016   {
0017     std::cout
0018       << PHWHERE << "\n"
0019       << "\tArgument 'name' is empty string\n"
0020       << std::flush;
0021     return 1;
0022   }
0023
0024   std::string filename = name.find(".root") != std::string::npos ? name : CDBInterface::instance()->getUrl(name);
0025
0026   if (filename.empty())
0027   {
0028     std::cout
0029       << PHWHERE << "\n"
0030       << "\tCalibration '" << name << "' not found in CDB\n"
0031       << std::flush;
0032     return 1;
0033   }
0034
0035   if (!std::filesystem::exists(filename))
0036   {
0037     std::cout
0038       << PHWHERE << "\n"
0039       << "\tFile '" << filename << "' not does not exist\n"
0040       << std::flush;
0041     return 1;
0042   }
0043
0044   CDBTTree cdbttree(filename);
0045   cdbttree.LoadCalibrations();
0046   return v_LoadFromCDBTTree(cdbttree);
0047 }
0048
0049 int InttBadChannelMap::v_LoadFromCDBTTree(CDBTTree& cdbttree)
0050 {
0051   m_offline_set.clear();
0052   m_rawdata_set.clear();
0053
0054   m_offline_loaded = true;
0055   m_rawdata_loaded = true;
0056   m_size = cdbttree.GetSingleIntValue("size");
0057
0058   if (m_size == 0) // Nothing to load, and we have loaded "nothing" successfully
0059   {
0060     return 0;
0061   }
0062
0063   // Check if the CDBTTree has branches corresponding to the offline convention
0064   m_offline_loaded = m_offline_loaded && (cdbttree.GetIntValue(0, "layer") != std::numeric_limits<int>::min());
0065   m_offline_loaded = m_offline_loaded && (cdbttree.GetIntValue(0, "ladder_phi") != std::numeric_limits<int>::min());
0066   m_offline_loaded = m_offline_loaded && (cdbttree.GetIntValue(0, "ladder_z") != std::numeric_limits<int>::min());
0067   m_offline_loaded = m_offline_loaded && (cdbttree.GetIntValue(0, "strip_z") != std::numeric_limits<int>::min());
0068   m_offline_loaded = m_offline_loaded && (cdbttree.GetIntValue(0, "strip_phi") != std::numeric_limits<int>::min());
0069
0070   // Check if the CDBTTree has branches corresponding to the rawdata convention
0071   m_rawdata_loaded = m_rawdata_loaded && (cdbttree.GetIntValue(0, "felix_server") != std::numeric_limits<int>::min());
0072   m_rawdata_loaded = m_rawdata_loaded && (cdbttree.GetIntValue(0, "felix_channel") != std::numeric_limits<int>::min());
0073   m_rawdata_loaded = m_rawdata_loaded && (cdbttree.GetIntValue(0, "chip") != std::numeric_limits<int>::min());
0074   m_rawdata_loaded = m_rawdata_loaded && (cdbttree.GetIntValue(0, "channel") != std::numeric_limits<int>::min());
0075
0076   if (!m_offline_loaded && !m_rawdata_loaded)
0077   {
0078     std::cout
0079       << PHWHERE << "\n"
0080       << "\tCDBTTree does not have expected calibrations\n"
0081       << "\tAvailable calibrations:\n"
0082       << std::flush;
0083     cdbttree.Print();
0084
0085     return 1;
0086   }
0087
0088   for (Long64_t n = 0; n < m_size; ++n)
0089   {
0090     if (m_offline_loaded)
0091     {
0092       m_offline_set.insert((struct InttNameSpace::Offline_s){
0093         .layer = cdbttree.GetIntValue(n, "layer"),
0094         .ladder_phi = cdbttree.GetIntValue(n, "ladder_phi"),
0095         .ladder_z = cdbttree.GetIntValue(n, "ladder_z"),
0096         .strip_x = cdbttree.GetIntValue(n, "strip_phi"),
0097         .strip_y = cdbttree.GetIntValue(n, "strip_z"),
0098       });
0099     }
0100
0101     if (m_rawdata_loaded)
0102     {
0103       m_rawdata_set.insert((struct InttNameSpace::RawData_s){
0104         .felix_server = cdbttree.GetIntValue(n, "felix_server"),
0105         .felix_channel = cdbttree.GetIntValue(n, "felix_channel"),
0106         .chip = cdbttree.GetIntValue(n, "chip"),
0107         .channel = cdbttree.GetIntValue(n, "channel"),
0108       });
0109     }
0110   }
0111
0112   return 0;
0113 }
0114
0115 void InttBadChannelMap::identify(std::ostream& out) const
0116 {
0117   out
0118     << PHWHERE << "\n"
0119     << "\tsize: " << m_size << "\n"
0120     << std::flush;
0121 }
0122
0123 void InttBadChannelMap::Print(std::ostream& out) const
0124 {
0125   if (!m_offline_loaded && !m_rawdata_loaded)
0126   {
0127     out
0128       << PHWHERE << "\n"
0129       << "\tNo channels loaded\n"
0130       << std::flush;
0131     return;
0132   }
0133
0134   out
0135     << PHWHERE << "\n";
0136   if (m_rawdata_loaded)
0137   {
0138     out << "\tmasked channels (rawdata convention): " << m_rawdata_set.size() << "\n";
0139     for (auto const& raw : m_rawdata_set)
0140     {
0141       out << "\t" << raw << "\n";
0142     }
0143     out << std::flush;
0144   }
0145
0146   if (m_offline_loaded)
0147   {
0148     out << "\tmasked channels (offline convention): " << m_offline_set.size() << "\n";
0149     for (auto const& ofl : m_offline_set)
0150     {
0151       out << "\t" << ofl << "\n";
0152     }
0153     out << std::flush;
0154   }
0155 }
0156
0157 bool InttBadChannelMap::IsBad(InttNameSpace::Online_s const& /*unused*/) const
0158 {
0159   std::cout
0160     << PHWHERE << "\n"
0161     << "\tUnimplemented overload\n"
0162     << std::flush;
0163   return false;
0164 }
0165
0166 bool InttBadChannelMap::IsBad(InttNameSpace::Offline_s const& ofl) const
0167 {
0168   if(m_offline_loaded)
0169   {
0170     return m_offline_set.find(ofl) != m_offline_set.end();
0171   }
0172
0173   if (m_rawdata_loaded)
0174   {
0175     auto raw = InttNameSpace::ToRawData(ofl);
0176     return m_rawdata_set.find(raw) != m_rawdata_set.end();
0177   }
0178
0179   std::cout
0180     << PHWHERE << "\n"
0181     << "\tMap was not loaded with offline indexing convention\n"
0182     << "\t\t(layer, ladder_phi/z, strip_z/phi)\n"
0183     << "\tNor was it loaded with rawdata indexing convention\n"
0184     << "\t\t(felix_server/channel, chip, channel)\n"
0185     << "\tUse a different overload\n"
0186     << std::flush;
0187   return false;
0188 }
0189
0190 bool InttBadChannelMap::IsBad(InttNameSpace::RawData_s const& raw) const
0191 {
0192   if (m_rawdata_loaded)
0193   {
0194     return m_rawdata_set.find(raw) != m_rawdata_set.end();
0195   }
0196
0197   if (m_offline_loaded)
0198   {
0199     auto ofl = InttNameSpace::ToOffline(raw);
0200     return m_offline_set.find(ofl) != m_offline_set.end();
0201   }
0202
0203   std::cout
0204     << PHWHERE << "\n"
0205     << "\tMap was not loaded with rawdata indexing convention\n"
0206     << "\t\t(felix_server/channel, chip, channel)\n"
0207     << "\tNor was it loaded with offline indexing convention\n"
0208     << "\t\t(layer, ladder_phi/z, strip_z/phi)\n"
0209     << "\tUse a different overload\n"
0210     << std::flush;
0211   return false;
0212 }
0213