packages/intt/InttSurveyMap.cc

0001 #include "InttSurveyMap.h"
0002
0003 #include <cdbobjects/CDBTTree.h>
0004 #include <ffamodules/CDBInterface.h>
0005 #include <phool/phool.h>
0006
0007 #include <Rtypes.h> // For Int_t, Long64_t, etc
0008
0009 #include <filesystem>  // for exists
0010 #include <utility>     // for pair
0011
0012 #include <boost/format.hpp>
0013
0014 InttSurveyMap::~InttSurveyMap()
0015 {
0016   delete m_absolute_transforms;
0017 }
0018
0019 int InttSurveyMap::LoadFromFile(std::string const& filename)
0020 {
0021   if (filename.empty())
0022   {
0023     std::cerr
0024       << PHWHERE << "\n"
0025       << "\tArgument 'filename' is empty string"
0026       << std::flush;
0027     return 1;
0028   }
0029
0030   if (!std::filesystem::exists(filename))
0031   {
0032     std::cerr
0033       << PHWHERE << "\n"
0034       << "\tFile '" << filename << "' does not exist\n"
0035       << std::flush;
0036     return 1;
0037   }
0038
0039   CDBTTree cdbttree(filename);
0040   cdbttree.LoadCalibrations();
0041
0042   return v_LoadFromCDBTTree(cdbttree);
0043 }
0044
0045 int InttSurveyMap::LoadFromCDB(
0046     std::string const& name)
0047 {
0048   if (name.empty())
0049   {
0050     std::cerr
0051       << PHWHERE << "\n"
0052       << "\tArgument 'name' is empty string\n"
0053       << std::flush;
0054     return 1;
0055   }
0056
0057   std::string database = CDBInterface::instance()->getUrl(name);
0058   CDBTTree cdbttree(database);
0059   cdbttree.LoadCalibrations();
0060
0061   return v_LoadFromCDBTTree(cdbttree);
0062 }
0063
0064 int InttSurveyMap::v_LoadFromCDBTTree(CDBTTree& cdbttree)
0065 {
0066   Eigen::Affine3d aff;
0067   InttNameSpace::Offline_s ofl;
0068
0069   delete m_absolute_transforms;
0070   m_absolute_transforms = new map_t;
0071
0072   Int_t N = cdbttree.GetSingleIntValue("size");
0073   for (Int_t n = 0; n < N; ++n)
0074   {
0075     ofl.layer = cdbttree.GetIntValue(n, "layer");
0076     ofl.ladder_phi = cdbttree.GetIntValue(n, "ladder_phi");
0077     ofl.ladder_z = cdbttree.GetIntValue(n, "ladder_z");
0078     ofl.strip_y = cdbttree.GetIntValue(n, "strip_z"); // The tree uses different suffixes
0079     ofl.strip_x = cdbttree.GetIntValue(n, "strip_phi"); // The tree uses different suffixes
0080
0081     for (int i = 0; i < 16; ++i)
0082     {
0083       std::string boost_formatted = boost::str(boost::format("m_abs_%01d_%01d") % (i / 4) % (i % 4));
0084       aff.matrix()(i / 4, i % 4) = cdbttree.GetDoubleValue(n, boost_formatted);
0085     }
0086     m_absolute_transforms->insert({ofl, aff});
0087   }
0088
0089   return 0;
0090 }
0091
0092 int InttSurveyMap::GetStripTransform(key_t const& k, val_t& v) const
0093 {
0094   val_t const* transform_ptr = nullptr;
0095   key_t ofl{
0096       k.layer,
0097       k.ladder_phi,
0098       k.ladder_z,
0099       Wildcard,
0100       Wildcard};
0101
0102   transform_ptr = GetAbsoluteTransform(ofl);
0103   if (!transform_ptr)
0104   {
0105     return 1;
0106   }
0107
0108   for (int i = 0; i < 16; ++i)
0109   {
0110     v.matrix()(i / 4, i % 4) = i / 4 == i % 4;
0111   }
0112
0113   // strip_y determines local z
0114   //  10, 16 are double the max range strip_y takes for the sensor type (ladder_z % 2)
0115   //  100, 128 are the lengths of the sensor type (ladder_z % 2) in mm
0116   v.matrix()(2, 3) = (2.0 * k.strip_y + 1.0) / ((k.ladder_z % 2) ? 10.0 : 16.0) - 0.5;
0117   v.matrix()(2, 3) *= (k.ladder_z % 2) ? 100.0 : 128.0;
0118
0119   // strip_x determines the local x
0120   // 512 is double the max range strip_x takes
0121   // 19.968 is the sensor width in mm
0122   v.matrix()(0, 3) = (2.0 * k.strip_x + 1.0) / 512.0 - 0.5;
0123   v.matrix()(0, 3) *= 19.968;
0124
0125   v = *transform_ptr * v;
0126
0127   return 0;
0128 }
0129
0130 int InttSurveyMap::GetSensorTransform(key_t const& k, val_t& v) const
0131 {
0132   val_t const* transform_ptr = nullptr;
0133   key_t ofl{
0134       k.layer,
0135       k.ladder_phi,
0136       k.ladder_z,
0137       Wildcard,
0138       Wildcard};
0139
0140   transform_ptr = GetAbsoluteTransform(ofl);
0141   if (!transform_ptr)
0142   {
0143     return 1;
0144   }
0145
0146   v = *transform_ptr;
0147
0148   return 0;
0149 }
0150
0151 int InttSurveyMap::GetLadderTransform(key_t const& k, val_t& v) const
0152 {
0153   val_t const* transform_ptr = nullptr;
0154   key_t ofl{
0155       k.layer,
0156       k.ladder_phi,
0157       Wildcard,
0158       Wildcard,
0159       Wildcard};
0160
0161   transform_ptr = GetAbsoluteTransform(ofl);
0162   if (!transform_ptr)
0163   {
0164     return 1;
0165   }
0166
0167   v = *transform_ptr;
0168
0169   return 0;
0170 }
0171
0172 void InttSurveyMap::identify(std::ostream& out) const
0173 {
0174   out
0175     << PHWHERE << "\n"
0176     << std::flush;
0177 }
0178
0179 std::size_t InttSurveyMap::size() const
0180 {
0181   return m_absolute_transforms ? m_absolute_transforms->size() : 0;
0182 }
0183
0184 InttSurveyMap::val_t const* InttSurveyMap::GetAbsoluteTransform(key_t const& k) const
0185 {
0186   if (!m_absolute_transforms)
0187   {
0188     return nullptr;
0189   }
0190   map_t::const_iterator itr = m_absolute_transforms->find(k);
0191   return itr != m_absolute_transforms->end() ? &itr->second : nullptr;
0192 }
0193