packages/TrackerMillepedeAlignment/AlignmentDefs.cc

0001 #include "AlignmentDefs.h"
0002
0003 #include <trackbase/TpcDefs.h>
0004 #include <trackbase/InttDefs.h>
0005 #include <trackbase/MvtxDefs.h>
0006 #include <trackbase/TrkrDefs.h>  // for cluskey, getTrkrId, tpcId
0007
0008 void AlignmentDefs::getMvtxGlobalLabels(const Surface& surf, int glbl_label[], AlignmentDefs::mvtxGrp grp)
0009 {
0010   Acts::GeometryIdentifier id = surf->geometryId();
0011   int group = 0;
0012   switch (grp)
0013   {
0014   case AlignmentDefs::mvtxGrp::snsr:
0015     group = 0;
0016     break;
0017   case AlignmentDefs::mvtxGrp::stv:
0018     group = 1;
0019     break;
0020   case AlignmentDefs::mvtxGrp::mvtxlyr:
0021     group = 2;
0022     break;
0023   case AlignmentDefs::mvtxGrp::clamshl:
0024     group = 3;
0025     break;
0026   }
0027
0028   int label_base = getLabelBase(id, 0, group);
0029   for (int i = 0; i < NGL; ++i)
0030   {
0031     glbl_label[i] = label_base + i;
0032   }
0033 }
0034
0035 void AlignmentDefs::getMvtxGlobalLabels(const Surface& surf, TrkrDefs::cluskey cluskey, int glbl_label[], AlignmentDefs::mvtxGrp grp)
0036 {
0037   Acts::GeometryIdentifier id = surf->geometryId();
0038   int group = 0;
0039   switch (grp)
0040   {
0041   case AlignmentDefs::mvtxGrp::snsr:
0042     group = 0;
0043     break;
0044   case AlignmentDefs::mvtxGrp::stv:
0045     group = 1;
0046     break;
0047   case AlignmentDefs::mvtxGrp::mvtxlyr:
0048     group = 2;
0049     break;
0050   case AlignmentDefs::mvtxGrp::clamshl:
0051     group = 3;
0052     break;
0053   }
0054
0055   int label_base = getLabelBase(id, cluskey, group);
0056   for (int i = 0; i < NGL; ++i)
0057   {
0058     glbl_label[i] = label_base + i;
0059   }
0060 }
0061
0062 void AlignmentDefs::getInttGlobalLabels(const Surface& surf, int glbl_label[], AlignmentDefs::inttGrp grp)
0063 {
0064   Acts::GeometryIdentifier id = surf->geometryId();
0065   int group = 0;
0066   switch (grp)
0067   {
0068   case AlignmentDefs::inttGrp::chp:
0069     group = 4;
0070     break;
0071   case AlignmentDefs::inttGrp::lad:
0072     group = 5;
0073     break;
0074   case AlignmentDefs::inttGrp::inttlyr:
0075     group = 6;
0076     break;
0077   case AlignmentDefs::inttGrp::inttbrl:
0078     group = 7;
0079     break;
0080   }
0081
0082   int label_base = getLabelBase(id, 0, group);
0083   for (int i = 0; i < NGL; ++i)
0084   {
0085     glbl_label[i] = label_base + i;
0086   }
0087 }
0088 void AlignmentDefs::getInttGlobalLabels(const Surface& surf, TrkrDefs::cluskey cluskey, int glbl_label[], AlignmentDefs::inttGrp grp)
0089 {
0090   Acts::GeometryIdentifier id = surf->geometryId();
0091   int group = 0;
0092   switch (grp)
0093   {
0094   case AlignmentDefs::inttGrp::chp:
0095     group = 4;
0096     break;
0097   case AlignmentDefs::inttGrp::lad:
0098     group = 5;
0099     break;
0100   case AlignmentDefs::inttGrp::inttlyr:
0101     group = 6;
0102     break;
0103   case AlignmentDefs::inttGrp::inttbrl:
0104     group = 7;
0105     break;
0106   }
0107
0108   int label_base = getLabelBase(id, cluskey, group);
0109   for (int i = 0; i < NGL; ++i)
0110   {
0111     glbl_label[i] = label_base + i;
0112   }
0113 }
0114
0115 void AlignmentDefs::getTpcGlobalLabels(const Surface& surf, TrkrDefs::cluskey cluskey, int glbl_label[], AlignmentDefs::tpcGrp grp)
0116 {
0117   Acts::GeometryIdentifier id = surf->geometryId();
0118   int group = 0;
0119   switch (grp)
0120   {
0121   case AlignmentDefs::tpcGrp::htst:
0122     group = 8;
0123     break;
0124   case AlignmentDefs::tpcGrp::sctr:
0125     group = 9;
0126     break;
0127   case AlignmentDefs::tpcGrp::tp:
0128     group = 10;
0129     break;
0130   }
0131
0132   int label_base = getLabelBase(id, cluskey, group);
0133   for (int i = 0; i < NGL; ++i)
0134   {
0135     glbl_label[i] = label_base + i;
0136   }
0137 }
0138 void AlignmentDefs::getMMGlobalLabels(const Surface& surf, int glbl_label[], AlignmentDefs::mmsGrp grp)
0139 {
0140   Acts::GeometryIdentifier id = surf->geometryId();
0141   int group = 0;
0142   switch (grp)
0143   {
0144   case AlignmentDefs::mmsGrp::tl:
0145     group = 11;
0146     break;
0147   case AlignmentDefs::mmsGrp::mm:
0148     group = 12;
0149     break;
0150   }
0151
0152   int label_base = getLabelBase(id, 0, group);
0153   for (int i = 0; i < NGL; ++i)
0154   {
0155     glbl_label[i] = label_base + i;
0156   }
0157 }
0158
0159 int AlignmentDefs::getTpcRegion(int layer)
0160 {
0161   int region = 0;
0162   if (layer > 22 && layer < 39)
0163   {
0164     region = 1;
0165   }
0166   if (layer > 38 && layer < 55)
0167   {
0168     region = 2;
0169   }
0170
0171   return region;
0172 }
0173
0174 int AlignmentDefs::getMvtxClamshell(int layer, int stave)
0175 {
0176   for (int istave = 0; istave < nstaves_layer_mvtx[layer]; ++istave)
0177   {
0178     for (int ishell = 0; ishell < 2; ++ishell)
0179     {
0180       int stave_ref = clamshell_stave_list[layer][ishell][istave];
0181       if (stave == stave_ref)
0182       {
0183         return ishell;
0184       }
0185     }
0186   }
0187
0188   std::cout << " AlignmentDefs::getMvtxClamshell: did not find stave " << stave << std::endl;
0189   return 0;
0190 }
0191
0192 int AlignmentDefs::getLabelBase(Acts::GeometryIdentifier id, TrkrDefs::cluskey cluskey, int group)
0193 {
0194   int layer =  TrkrDefs::getLayer(cluskey);
0195
0196   int label_base = 1;  // Mille wants to start at 1
0197
0198   // decide what level of grouping we want
0199   if (layer < 3)
0200     {
0201       int stave = MvtxDefs::getStaveId(cluskey);
0202       int sensor = MvtxDefs::getChipId(cluskey);
0203
0204       if (group == 0)
0205     {
0206       // every sensor has a different label
0207       label_base += layer * 1000000 + stave * 10000 + sensor * 10;
0208       return label_base;
0209     }
0210       if (group == 1)
0211     {
0212       // layer and stave, assign all sensors to the stave number
0213       label_base += layer * 1000000 + stave * 10000;
0214       //      std::cout << "     label base = " << label_base << " layer " << layer << " stave " << stave << " sensor " << sensor << std::endl;
0215       return label_base;
0216     }
0217       if (group == 2)
0218     {
0219       // layer only, assign all sensors to sensor 0 in each clamshell
0220       int clamshell = getMvtxClamshell(layer, stave);
0221       label_base += layer * 1000000 + clamshell * 10000;
0222
0223
0224       return label_base;
0225     }
0226       if (group == 3)
0227     {
0228       // group by half-barrel, or clamshell
0229       // Assume for now low staves are in clamshell 0 - check!!!
0230       //int breakat = nstaves_layer_mvtx[layer] / 2;
0231     int clamshell = getMvtxClamshell(layer, stave);
0232       //int clamshell = 1;
0233       //if (stave < breakat)
0234       //  {
0235       //    clamshell = 0;
0236       //  }
0237       label_base += 0 * 1000000 + clamshell * 10000;
0238
0239       return label_base;
0240     }
0241     }
0242   else if (layer > 2 && layer < 7)
0243     {
0244       // get label base from hitsetkey
0245       int stave = InttDefs::getLadderPhiId(cluskey);
0246       int sensor = InttDefs::getLadderZId(cluskey);
0247
0248       if (group == 4)
0249     {
0250       // every sensor has a different label
0251       label_base += layer * 1000000 + stave * 10000 + sensor * 10;
0252       return label_base;
0253     }
0254       if (group == 5)
0255     {
0256       // layer and stave, assign all sensors to the stave number
0257       label_base += layer * 1000000 + stave * 10000;
0258       return label_base;
0259     }
0260       if (group == 6)
0261     {
0262       // layer only, assign all sensors to sensor 0 for this layer
0263       label_base += layer * 1000000 + 0;
0264       return label_base;
0265     }
0266       if (group == 7)
0267     {
0268       // entire INTT
0269       // assign all sensors to layer 3
0270       label_base += 3 * 1000000 + 0;
0271       return label_base;
0272     }
0273     }
0274   else if (layer > 6 && layer < 55)
0275     {
0276       unsigned int sensor = id.sensitive() - 1;  // Acts starts at 1
0277
0278       if (group == 8)
0279     {
0280       // want every hitset (layer, sector, side) to have a separate label
0281       // each group of 12 subsurfaces (sensors) is in a single hitset
0282       int hitset = sensor / 12;  // 0-11 on side 0, 12-23 on side 1
0283       label_base += layer * 1000000 + hitset * 10000;
0284       return label_base;
0285     }
0286       if (group == 9)
0287     {
0288       // group all tpc layers in each region and sector, assign layer 7 and side and sector number to all layers and hitsets
0289       int side = TpcDefs::getSide(cluskey);
0290       int sector = TpcDefs::getSectorId(cluskey);
0291
0292       int region = getTpcRegion(layer);  // inner, mid, outer
0293
0294       // for a given layer there are only 12 sectors x 2 sides
0295       // The following gives the sectors in the inner, mid, outer regions unique group labels
0296       label_base += 7 * 1000000 + (region * 24 + side * 12 + sector) * 10000;
0297       return label_base;
0298     }
0299       if (group == 10)
0300     {
0301       // all tpc layers and all sectors, assign layer 7 and sensor 0 to all layers and sensors
0302       label_base += 7 * 1000000 + 0;
0303       return label_base;
0304     }
0305     }
0306   else
0307     {
0308       unsigned int sensor = id.sensitive() - 1;  // Acts starts at 1
0309
0310       if (group == 11)
0311     {
0312       // every tile has different label
0313       int tile = sensor;
0314       label_base += layer * 1000000 + tile * 10000 + sensor * 10;
0315       return label_base;
0316     }
0317       if (group == 12)
0318     {
0319       // assign layer 55 and tile 0 to all
0320       label_base += 55 * 1000000 + 0;
0321       return label_base;
0322     }
0323     }
0324   return -1;
0325 }
0326
0327 std::vector<int> AlignmentDefs::getAllMvtxGlobalLabels(int grp)
0328 {
0329   std::vector<int> label_base;
0330
0331   if (grp == mvtxGrp::clamshl)
0332   {
0333     for (int ishl = 0; ishl < 2; ++ishl)
0334     {
0335       int label = 1 + 0 * 1000000 + ishl * 10000;
0336       label_base.push_back(label);
0337     }
0338   }
0339   else if (grp == mvtxGrp::mvtxlyr)
0340   {
0341     for (int ishl = 0; ishl < 2; ++ishl)
0342     {
0343       for (int ilyr = 0; ilyr < 3; ++ilyr)
0344       {
0345         int label = 1 + ilyr * 1000000 + ishl * 10000;
0346         label_base.push_back(label);
0347       }
0348     }
0349   }
0350   else if (grp == mvtxGrp::stv)
0351   {
0352     for (int ilyr = 0; ilyr < 3; ++ilyr)
0353     {
0354       for (int istv = 0; istv < nstaves_layer_mvtx[ilyr]; ++istv)
0355       {
0356         int label = 1 + ilyr * 1000000 + istv * 10000;
0357         label_base.push_back(label);
0358       }
0359     }
0360   }
0361   else if (grp == mvtxGrp::snsr)
0362   {
0363     for (int ilyr = 0; ilyr < 3; ++ilyr)
0364     {
0365       for (int istv = 0; istv < nstaves_layer_mvtx[ilyr]; ++istv)
0366       {
0367         for (int isnsr = 0; isnsr < nsensors_stave[ilyr]; ++isnsr)
0368         {
0369           int label = 1 + ilyr * 1000000 + istv * 10000 + isnsr * 10;
0370           label_base.push_back(label);
0371         }
0372       }
0373     }
0374   }
0375
0376   auto labels = makeLabelsFromBase(label_base);
0377
0378   return labels;
0379 }
0380
0381 std::vector<int> AlignmentDefs::getAllInttGlobalLabels(int grp)
0382 {
0383   std::vector<int> label_base;
0384
0385   if (grp == inttGrp::inttbrl)
0386   {
0387     int label = 1 + 3 * 1000000 + 0;
0388     label_base.push_back(label);
0389   }
0390   else if (grp == inttGrp::inttlyr)
0391   {
0392     for (int ilyr = 3; ilyr < 7; ++ilyr)
0393     {
0394       int label = 1 + ilyr * 1000000 + 0;
0395       label_base.push_back(label);
0396     }
0397   }
0398   else if (grp == inttGrp::lad)
0399   {
0400     for (int ilyr = 3; ilyr < 7; ++ilyr)
0401     {
0402       for (int istv = 0; istv < nstaves_layer_intt[ilyr - 3]; ++istv)
0403       {
0404         int label = 1 + ilyr * 1000000 + istv * 10000;
0405         label_base.push_back(label);
0406       }
0407     }
0408   }
0409   else if (grp == inttGrp::chp)
0410   {
0411     for (int ilyr = 3; ilyr < 7; ++ilyr)
0412     {
0413       for (int istv = 0; istv < nstaves_layer_intt[ilyr - 3]; ++istv)
0414       {
0415         for (int isnsr = 0; isnsr < nsensors_stave[ilyr]; ++isnsr)
0416         {
0417           int label = 1 + ilyr * 1000000 + istv * 10000 + isnsr * 10;
0418           label_base.push_back(label);
0419         }
0420       }
0421     }
0422   }
0423
0424   auto labels = makeLabelsFromBase(label_base);
0425
0426   return labels;
0427 }
0428
0429 std::vector<int> AlignmentDefs::getAllTpcGlobalLabels(int grp)
0430 {
0431   std::vector<int> label_base;
0432
0433   if (grp == tpcGrp::sctr)
0434   {
0435     for (int isec = 0; isec < 72; ++isec)
0436     {
0437       int label = 1 + 7 * 1000000 + isec * 10000;
0438       label_base.push_back(label);
0439     }
0440   }
0441
0442   auto labels = makeLabelsFromBase(label_base);
0443
0444   return labels;
0445 }
0446
0447 std::vector<int> AlignmentDefs::makeLabelsFromBase(std::vector<int>& label_base)
0448 {
0449   std::vector<int> labels;
0450   for (int ilbl : label_base)
0451   {
0452     for (int ipar = 0; ipar < 6; ++ipar)
0453     {
0454       int label_plus = ilbl + ipar;
0455       labels.push_back(label_plus);
0456     }
0457   }
0458
0459   return labels;
0460 }
0461
0462 void AlignmentDefs::printBuffers(int index, Acts::Vector2 residual, Acts::Vector2 clus_sigma, float lcl_derivative[], float glbl_derivative[], int glbl_label[])
0463 {
0464   std::cout << " float buffer: "
0465             << " residual "
0466             << "  " << residual(index);
0467   for (int il = 0; il < NLC; ++il)
0468   {
0469     if (lcl_derivative[il] != 0)
0470     {
0471       std::cout << " lcl_deriv[" << il << "] " << lcl_derivative[il] << "  ";
0472     }
0473   }
0474   std::cout << " sigma "
0475             << "  " << clus_sigma(index) << "  ";
0476   for (int ig = 0; ig < NGL; ++ig)
0477   {
0478     if (glbl_derivative[ig] != 0)
0479     {
0480       std::cout << " glbl_deriv[" << ig << "] " << glbl_derivative[ig] << "  ";
0481     }
0482   }
0483   std::cout << " int buffer: "
0484             << " 0 "
0485             << " 0 "
0486             << " ";  // spacer, rmeas placeholder
0487   for (int il = 0; il < NLC; ++il)
0488   {
0489     if (lcl_derivative[il] != 0)
0490     {
0491       std::cout << " lcl_label[" << il << "] " << il + 1 << "  ";
0492     }
0493   }
0494   std::cout << " 0 "
0495             << "  ";
0496   for (int ig = 0; ig < NGL; ++ig)
0497   {
0498     if (glbl_derivative[ig] != 0)
0499     {
0500       std::cout << " glbl_label[" << ig << "] " << glbl_label[ig] << "  ";
0501     }
0502   }
0503   std::cout << " end of meas " << std::endl;
0504 }