Added back useEqualMeanUMeanVRotZConstraints.

cms-sw · Aug 27, 2020 · 09db248 · 09db248
1 parent 474106a
commit 09db248
Show file tree

Hide file tree

Showing 3 changed files with 119 additions and 52 deletions.
diff --git a/Alignment/PPSTrackBased/interface/AlignmentTask.h b/Alignment/PPSTrackBased/interface/AlignmentTask.h
@@ -35,6 +35,9 @@ class AlignmentTask
     /// whether to resolve only 1 rot_z per RP
     bool oneRotZPerPot;
 
+    /// whether to apply the constraint mean U = mean V RotZ for strips ("standard" set of constraints only)
+    bool useEqualMeanUMeanVRotZConstraints;
+
     /// fixed detectors constraints from config file
     edm::ParameterSet fixedDetectorsConstraints;
 
@@ -121,6 +124,9 @@ class AlignmentTask
     /// adds constraints such that only 1 rot_z per RP is left
     void buildOneRotZPerPotConstraints(std::vector<AlignmentConstraint>&) const;
 
+    /// adds constraints such that only mean-U and mean-V RotZ are equal for each strip RP
+    void buildEqualMeanUMeanVRotZConstraints(std::vector<AlignmentConstraint> &constraints) const;
+
 
     // -------------------- constructors --------------------
 

diff --git a/Alignment/PPSTrackBased/python/ppsStraightTrackAligner_cfi.py b/Alignment/PPSTrackBased/python/ppsStraightTrackAligner_cfi.py
@@ -57,8 +57,8 @@
     # choices: fixedDetectors, standard
     constraintsType = cms.string("standard"),
 
-    useExtendedRPShZConstraint = cms.bool(True),
     oneRotZPerPot = cms.bool(False),
+    useEqualMeanUMeanVRotZConstraints = cms.bool(True),
 
     # values in um and m rad
     fixedDetectorsConstraints = cms.PSet(

diff --git a/Alignment/PPSTrackBased/src/AlignmentTask.cc b/Alignment/PPSTrackBased/src/AlignmentTask.cc
@@ -27,6 +27,7 @@ AlignmentTask::AlignmentTask(const ParameterSet& ps) :
   resolveRotZ(ps.getParameter<bool>("resolveRotZ")),
 
   oneRotZPerPot(ps.getParameter<bool>("oneRotZPerPot")),
+  useEqualMeanUMeanVRotZConstraints(ps.getParameter<bool>("useEqualMeanUMeanVRotZConstraints")),
 
   fixedDetectorsConstraints(ps.getParameterSet("fixedDetectorsConstraints")),
   standardConstraints(ps.getParameterSet("standardConstraints"))
@@ -305,57 +306,6 @@ void AlignmentTask::buildFixedDetectorsConstraints(vector<AlignmentConstraint> &
 
 //----------------------------------------------------------------------------------------------------
 
-void AlignmentTask::buildOneRotZPerPotConstraints(std::vector<AlignmentConstraint> &constraints) const
-{
-  // build map rp id --> sensor ids
-  map<unsigned int, vector<unsigned int>> m;
-  for (const auto &p : geometry.getSensorMap())
-  {
-    CTPPSDetId detId(p.first);
-    CTPPSDetId rpId = detId.rpId();
-    unsigned int decRPId = rpId.arm()*100 + rpId.station()*10 + rpId.rp();
-    m[decRPId].push_back(p.first);
-  }
-
-  // traverse all RPs
-  for (const auto &p : m)
-  {
-    // build n_planes-1 constraints
-    unsigned int prev_detId = 0;
-    for (const auto &detId : p.second)
-    {
-      if (prev_detId != 0)
-      {
-        AlignmentConstraint ac;
-
-        char buf[100];
-        sprintf(buf, "RotZ: RP %u, %u = %u", p.first, prev_detId, detId);
-        ac.name = buf;
-
-        ac.val = 0;
-
-        for (auto &qcit : quantityClasses)
-        {
-          ac.coef[qcit].ResizeTo(quantitiesOfClass(qcit));
-          ac.coef[qcit].Zero();
-        }
-
-        signed int qIdx1 = getQuantityIndex(qcRotZ, prev_detId);
-        signed int qIdx2 = getQuantityIndex(qcRotZ, detId);
-
-        ac.coef[qcRotZ][qIdx1] = +1.;
-        ac.coef[qcRotZ][qIdx2] = -1.;
-
-        constraints.push_back(ac);
-      }
-
-      prev_detId = detId;
-    }
-  }
-}
-
-//----------------------------------------------------------------------------------------------------
-
 void AlignmentTask::buildStandardConstraints(vector<AlignmentConstraint> &constraints) const
 {
   const vector<unsigned int> &decUnitIds = standardConstraints.getParameter<vector<unsigned int>>("units");
@@ -509,4 +459,115 @@ void AlignmentTask::buildStandardConstraints(vector<AlignmentConstraint> &constr
 
   if (resolveRotZ && oneRotZPerPot)
     buildOneRotZPerPotConstraints(constraints);
+
+  if (resolveRotZ && useEqualMeanUMeanVRotZConstraints)
+    buildEqualMeanUMeanVRotZConstraints(constraints);
+}
+
+//----------------------------------------------------------------------------------------------------
+
+void AlignmentTask::buildOneRotZPerPotConstraints(std::vector<AlignmentConstraint> &constraints) const
+{
+  // build map rp id --> sensor ids
+  map<unsigned int, vector<unsigned int>> m;
+  for (const auto &p : geometry.getSensorMap())
+  {
+    CTPPSDetId detId(p.first);
+    CTPPSDetId rpId = detId.rpId();
+    unsigned int decRPId = rpId.arm()*100 + rpId.station()*10 + rpId.rp();
+    m[decRPId].push_back(p.first);
+  }
+
+  // traverse all RPs
+  for (const auto &p : m)
+  {
+    // build n_planes-1 constraints
+    unsigned int prev_detId = 0;
+    for (const auto &detId : p.second)
+    {
+      if (prev_detId != 0)
+      {
+        AlignmentConstraint ac;
+
+        char buf[100];
+        sprintf(buf, "RotZ: RP %u, plane %u = plane %u", p.first, prev_detId, detId);
+        ac.name = buf;
+
+        ac.val = 0;
+
+        for (auto &qcit : quantityClasses)
+        {
+          ac.coef[qcit].ResizeTo(quantitiesOfClass(qcit));
+          ac.coef[qcit].Zero();
+        }
+
+        signed int qIdx1 = getQuantityIndex(qcRotZ, prev_detId);
+        signed int qIdx2 = getQuantityIndex(qcRotZ, detId);
+
+        ac.coef[qcRotZ][qIdx1] = +1.;
+        ac.coef[qcRotZ][qIdx2] = -1.;
+
+        constraints.push_back(ac);
+      }
+
+      prev_detId = detId;
+    }
+  }
+}
+
+//----------------------------------------------------------------------------------------------------
+
+void AlignmentTask::buildEqualMeanUMeanVRotZConstraints(vector<AlignmentConstraint> &constraints) const
+{
+  // build map strip rp id --> pair( vector of U planes, vector of V planes )
+  map<unsigned int, pair<vector<unsigned int>, vector<unsigned int>> > m;
+  for (const auto &p : geometry.getSensorMap())
+  {
+    CTPPSDetId detId(p.first);
+
+    if (detId.subdetId() != CTPPSDetId::sdTrackingStrip)
+      continue;
+
+    CTPPSDetId rpId = detId.rpId();
+    unsigned int decRPId = rpId.arm()*100 + rpId.station()*10 + rpId.rp();
+
+    if (p.second.isU)
+      m[decRPId].first.push_back(p.first);
+    else
+      m[decRPId].second.push_back(p.first);
+  }
+
+  // loop over RPs
+  for (const auto &p : m)
+  {
+    AlignmentConstraint ac;
+
+    char buf[100];
+    sprintf(buf, "RotZ: RP %u, MeanU = MeanV", p.first);
+    ac.name = buf;
+
+    ac.val = 0;
+
+    for (auto &qcit : quantityClasses)
+    {
+      ac.coef[qcit].ResizeTo(quantitiesOfClass(qcit));
+      ac.coef[qcit].Zero();
+    }
+
+    for (const string &proj : {"U", "V"})
+    {
+      const auto &planes = (proj == "U") ? p.second.first : p.second.second;
+      const double c = ((proj == "U") ? -1. : +1.) / planes.size();
+
+      for (const auto &plane : planes)
+      {
+        signed int qIdx = getQuantityIndex(qcRotZ, plane);
+        ac.coef[qcRotZ][qIdx] = c;
+
+        TotemRPDetId plId(plane);
+      }
+    }
+
+    constraints.push_back(ac);
+  }
 }