packages/trackbase/alignmentTransformationContainer.cc

0001 /**
0002  * @file trackbase/TrkrHitTruthAssocv1.cc
0003  * @author R. Boucher
0004  * @date August 2022
0005  * @brief Implementation of alignmentTransformationContainer
0006  */
0007
0008 #include "alignmentTransformationContainer.h"
0009
0010 #include <Eigen/Dense>
0011 #include <Eigen/Geometry>
0012
0013 #include <algorithm>
0014 #include <ostream>
0015 #include <utility>
0016
0017 bool alignmentTransformationContainer::use_alignment = false;
0018
0019 alignmentTransformationContainer::alignmentTransformationContainer()
0020 {
0021   for (uint8_t layer = 0; layer < 57; layer++)
0022   {
0023     m_misalignmentFactor.insert(std::make_pair(layer, 1.));
0024   }
0025 }
0026 void alignmentTransformationContainer::setMisalignmentFactor(uint8_t layer, double factor)
0027 {
0028   auto it = m_misalignmentFactor.find(layer);
0029   if (it != m_misalignmentFactor.end())
0030   {
0031     it->second = factor;
0032     return;
0033   }
0034   std::cout << "You provided a nonexistent layer in alignmentTransformationContainer::setMisalignmentFactor..."
0035             << std::endl;
0036 }
0037 void alignmentTransformationContainer::Reset()
0038 {
0039   if (transformVec.size() == 0)
0040   {
0041     return;
0042   }
0043
0044   // loop over the transformVec
0045   for (auto& i : transformVec)
0046   {
0047     i.clear();
0048     std::vector<Acts::Transform3> emptyLayerVec;
0049     i.swap(emptyLayerVec);
0050   }
0051
0052   transformVec.clear();
0053   std::vector<std::vector<Acts::Transform3>> emptyVec;
0054   transformVec.swap(emptyVec);
0055 }
0056
0057 void alignmentTransformationContainer::identify(std::ostream& os)
0058 {
0059   os << "-----alignmentTransformationContainer-----" << std::endl;
0060   for (unsigned int i = 0; i < transformVec.size(); ++i)
0061   {
0062     auto& layerVec = transformVec[i];
0063     if (layerVec.size() == 0)
0064     {
0065       continue;
0066     }
0067
0068     os << " Layer: " << i << std::endl;
0069
0070     for (unsigned int il = 0; il < layerVec.size(); ++il)
0071     {
0072       os << " Sensor Id: " << il + 1
0073          << " Transform: " << layerVec[il].matrix()
0074          << std::endl;
0075     }
0076   }
0077   os << "------------------------------" << std::endl;
0078
0079   return;
0080 }
0081
0082 void alignmentTransformationContainer::addTransform(const Acts::GeometryIdentifier id, const Acts::Transform3& transform)
0083 {
0084   unsigned int sphlayer = getsphlayer(id);
0085   unsigned int sensor = id.sensitive() - 1;  // Acts sensor numbering starts at 1
0086
0087   // We are filling a super-vector of layer-vectors
0088   // first check that the layer-vector for sphlayer is present
0089
0090   if (sphlayer < transformVec.size())
0091   {
0092     // There will be a layer-vector, it may be empty
0093     auto& layerVec = transformVec[sphlayer];
0094
0095     if (sensor < layerVec.size())
0096     {
0097       layerVec[sensor] = transform;
0098     }
0099     else if (sensor == layerVec.size())
0100     {
0101       layerVec.push_back(transform);
0102     }
0103     else
0104     {
0105       layerVec.resize(sensor + 1, transform);
0106     }
0107   }
0108   else if (sphlayer == transformVec.size())
0109   {
0110     // add new layer-vector to transformVec and put transform in it
0111     std::vector<Acts::Transform3> newVec;
0112     newVec.resize(sensor + 1, transform);
0113     transformVec.push_back(newVec);
0114   }
0115   else
0116   {
0117     transformVec.resize(sphlayer + 1);  // pad the missing layers with empty vectors
0118     // Add this transform to the last layer
0119     std::vector<Acts::Transform3> newVec;
0120     newVec.resize(sensor + 1, transform);
0121     transformVec[sphlayer] = newVec;
0122   }
0123 }
0124
0125 Acts::Transform3& alignmentTransformationContainer::getTransform(const Acts::GeometryIdentifier id)
0126 {
0127   unsigned int sphlayer = getsphlayer(id);
0128   unsigned int sensor = id.sensitive() - 1;  // Acts sensor numbering starts at 1
0129
0130   auto& layerVec = transformVec[sphlayer];
0131   if (layerVec.size() > sensor)
0132   {
0133     return layerVec[sensor];
0134   }
0135
0136   std::cout << "Unable to find Acts Id: " << id << " in alignmentTransformationContainer" << std::endl;
0137   exit(1);
0138 }
0139
0140 void alignmentTransformationContainer::replaceTransform(const Acts::GeometryIdentifier id, Acts::Transform3 transform)
0141 {
0142   unsigned int sphlayer = getsphlayer(id);
0143   unsigned int sensor = id.sensitive() - 1;  // Acts sensor numbering starts at 1
0144
0145   auto& layerVec = transformVec[sphlayer];
0146   if (layerVec.size() > sensor)
0147   {
0148     layerVec[sensor] = std::move(transform);
0149     return;
0150   }
0151
0152   std::cout << "Unable to find Acts Id: " << id << " in alignmentTransformationContainer" << std::endl;
0153   exit(1);
0154 }
0155
0156 const std::vector<std::vector<Acts::Transform3>>& alignmentTransformationContainer::getMap() const
0157 {
0158   return transformVec;
0159 }
0160
0161 unsigned int alignmentTransformationContainer::getsphlayer(Acts::GeometryIdentifier id)
0162 {
0163   unsigned int layer = id.layer();
0164   unsigned int volume = id.volume();
0165   unsigned int sphlayer = base_layer_map.find(volume)->second + layer / 2 - 1;
0166
0167   return sphlayer;
0168 }