ITS3: alignment for inextionsial surfaces

f3sch · f3sch · commit 37b40524ad06 · 2026-04-03T20:33:46.000+02:00
Signed-off-by: Felix Schlepper &lt;felix.schlepper@cern.ch&gt;
diff --git a/Detectors/Upgrades/ITS3/alignment/README.md b/Detectors/Upgrades/ITS3/alignment/README.md
@@ -27,4 +27,38 @@ dofSet.json:
       "calib": { "type": "legendre", "order": 1, "fix": [0, 2] }
     }
   ]
-}```
+}
+```
+
+
+## In-existensional modes
+```json
+{
+  "defaults": { "rigidBody": "fixed" },
+  "rules": [
+    {
+      "match": "ITS3Layer1/ITS3CarbonForm0",
+      "calib": {
+        "type": "inextensional",
+        "order": 2,
+        "free": ["a_2", "b_2", "c_2", "d_2", "alpha", "beta"]
+      }
+    }
+  ]
+}
+```
+
+```json
+[
+  {
+    "id": 2,
+    "inextensional": {
+      "modes": {
+        "2": [0.0008, -0.0005, 0.0006, -0.0007]
+      },
+      "alpha": 0.0004,
+      "beta": -0.0003
+    }
+  }
+]
+```
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentDOF.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentDOF.h
@@ -21,8 +21,11 @@
 class DOFSet
 {
  public:
-  enum class Type : uint8_t { RigidBody,
-                              Legendre };
+  enum class Type : uint8_t {
+    RigidBody,
+    Legendre,
+    Inextensional
+  };
   virtual ~DOFSet() = default;
   virtual Type type() const = 0;
   int nDOFs() const { return static_cast<int>(mFree.size()); }
@@ -102,4 +105,50 @@ class LegendreDOFSet final : public DOFSet
   int mOrder;
 };
 
+// In-extensional deformation DOFs for cylindrical half-shells
+// Fourier modes n=2..N: 4 params each (a_n, b_n, c_n, d_n)
+// Plus 2 non-periodic modes (alpha, beta) for the half-cylinder open edges
+// Total: 4*(N-1) + 2
+class InextensionalDOFSet final : public DOFSet
+{
+ public:
+  explicit InextensionalDOFSet(int maxOrder) : DOFSet((4 * (maxOrder - 1)) + 2), mMaxOrder(maxOrder)
+  {
+    if (maxOrder < 2) {
+      // the rest is eq. to rigid body
+      throw std::invalid_argument("InextensionalDOFSet requires maxOrder >= 2");
+    }
+  }
+  Type type() const override { return Type::Inextensional; }
+  int maxOrder() const { return mMaxOrder; }
+
+  // number of periodic DOFs (before alpha, beta)
+  int nPeriodic() const { return 4 * (mMaxOrder - 1); }
+
+  // flat index layout: [a_2, b_2, c_2, d_2, a_3, b_3, c_3, d_3, ..., alpha, beta]
+  // index of first DOF for mode n
+  static int modeOffset(int n) { return 4 * (n - 2); }
+
+  // indices of the non-periodic modes
+  int alphaIdx() const { return nPeriodic(); }
+  int betaIdx() const { return nPeriodic() + 1; }
+
+  std::string dofName(int idx) const override
+  {
+    if (idx == alphaIdx()) {
+      return "alpha";
+    }
+    if (idx == betaIdx()) {
+      return "beta";
+    }
+    int n = (idx / 4) + 2;
+    int sub = idx % 4;
+    static constexpr const char* subNames[] = {"a", "b", "c", "d"};
+    return std::format("{}_{}", subNames[sub], n);
+  }
+
+ private:
+  int mMaxOrder;
+};
+
 #endif
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentParams.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentParams.h
@@ -38,9 +38,10 @@ struct AlignmentParams : public o2::conf::ConfigurableParamHelper<AlignmentParam
   float extraClsErrZ[6] = {0};
 
   // misalignment simulation
-  bool doMisalignmentLeg = false; // simulate Legendre deformation on ITS3 layers
-  bool doMisalignmentRB = false;  // simulate rigid body misalignment on ITS3 layers
-  std::string misAlgJson;         // JSON file with deformation and/or rigid body params
+  bool doMisalignmentLeg = false;  // simulate Legendre deformation on ITS3 layers
+  bool doMisalignmentRB = false;   // simulate rigid body misalignment on ITS3 layers
+  bool doMisalignmentInex = false; // simulate in-extensional deformation on ITS3 layers
+  std::string misAlgJson;          // JSON file with deformation and/or rigid body params
 
   // DOF configuration (JSON file defining which volumes have which DOFs)
   std::string dofConfigJson; // if empty, no DOFs are configured
diff --git a/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentSpec.h b/Detectors/Upgrades/ITS3/alignment/include/ITS3Align/AlignmentSpec.h
@@ -24,6 +24,7 @@ enum class OutputOpt : uint8_t {
   MilleData,
   MilleSteer,
   MilleRes,
+  MisRes,
   Debug,
 };
 using OutputEnum = utils::EnumFlags<OutputOpt>;
diff --git a/Detectors/Upgrades/ITS3/alignment/src/AlignmentHierarchy.cxx b/Detectors/Upgrades/ITS3/alignment/src/AlignmentHierarchy.cxx
@@ -178,21 +178,23 @@ void AlignableVolume::writeParameters(std::ostream& os) const
   if (isRoot()) {
     os << "Parameter\n";
   }
-  if (mRigidBody) {
-    for (int iDOF = 0; iDOF < mRigidBody->nDOFs(); ++iDOF) {
-      os << std::format("{:<10} {:>+15g} {:>+15g} ! {} {} ",
-                        mLabel.raw(iDOF), 0.0, (mRigidBody->isFree(iDOF) ? 0.0 : -1.0),
-                        (mRigidBody->isFree(iDOF) ? 'V' : 'F'), mRigidBody->dofName(iDOF))
-         << mSymName << '\n';
+  if (!mIsPseudo) {
+    if (mRigidBody) {
+      for (int iDOF = 0; iDOF < mRigidBody->nDOFs(); ++iDOF) {
+        os << std::format("{:<10} {:>+15g} {:>+15g} ! {} {} ",
+                          mLabel.raw(iDOF), 0.0, (mRigidBody->isFree(iDOF) ? 0.0 : -1.0),
+                          (mRigidBody->isFree(iDOF) ? 'V' : 'F'), mRigidBody->dofName(iDOF))
+           << mSymName << '\n';
+      }
     }
-  }
-  if (mCalib) {
-    auto calibLbl = mLabel.asCalib();
-    for (int iDOF = 0; iDOF < mCalib->nDOFs(); ++iDOF) {
-      os << std::format("{:<10} {:>+15g} {:>+15g} ! {} {} ",
-                        calibLbl.raw(iDOF), 0.0, (mCalib->isFree(iDOF) ? 0.0 : -1.0),
-                        (mCalib->isFree(iDOF) ? 'V' : 'F'), mCalib->dofName(iDOF))
-         << mSymName << '\n';
+    if (mCalib) {
+      auto calibLbl = mLabel.asCalib();
+      for (int iDOF = 0; iDOF < mCalib->nDOFs(); ++iDOF) {
+        os << std::format("{:<10} {:>+15g} {:>+15g} ! {} {:<5} ",
+                          calibLbl.raw(iDOF), 0.0, (mCalib->isFree(iDOF) ? 0.0 : -1.0),
+                          (mCalib->isFree(iDOF) ? 'V' : 'F'), mCalib->dofName(iDOF))
+           << mSymName << '\n';
+      }
     }
   }
   for (const auto& c : mChildren) {
@@ -266,6 +268,9 @@ void applyDOFConfig(AlignableVolume* root, const std::string& jsonPath)
   }
 
   root->traverse([&](AlignableVolume* vol) {
+    if (vol->isPseudo()) {
+      return;
+    }
     const std::string& sym = vol->getSymName();
     for (const auto& rule : rules) {
       const auto pattern = rule["match"].get<std::string>();
@@ -357,6 +362,41 @@ void applyDOFConfig(AlignableVolume* root, const std::string& jsonPath)
             }
           }
           vol->setCalib(std::move(dofSet));
+        } else if (calType == "inextensional") {
+          int maxOrder = cal.value("order", 2);
+          auto dofSet = std::make_unique<InextensionalDOFSet>(maxOrder);
+          bool fixed = cal.value("fixed", false);
+          if (fixed) {
+            dofSet->setAllFree(false);
+          }
+          if (cal.contains("free")) {
+            dofSet->setAllFree(false);
+            for (const auto& item : cal["free"]) {
+              if (item.is_number_integer()) {
+                dofSet->setFree(item.get<int>(), true);
+              } else if (item.is_string()) {
+                for (int k = 0; k < dofSet->nDOFs(); ++k) {
+                  if (dofSet->dofName(k) == item.get<std::string>()) {
+                    dofSet->setFree(k, true);
+                  }
+                }
+              }
+            }
+          }
+          if (cal.contains("fix")) {
+            for (const auto& item : cal["fix"]) {
+              if (item.is_number_integer()) {
+                dofSet->setFree(item.get<int>(), false);
+              } else if (item.is_string()) {
+                for (int k = 0; k < dofSet->nDOFs(); ++k) {
+                  if (dofSet->dofName(k) == item.get<std::string>()) {
+                    dofSet->setFree(k, false);
+                  }
+                }
+              }
+            }
+          }
+          vol->setCalib(std::move(dofSet));
         }
       }
     }
@@ -398,6 +438,12 @@ void writeMillepedeResults(AlignableVolume* root, const std::string& milleResPat
   // indexed by sensorID
   std::map<int, std::vector<double>> injRB;
   std::map<int, std::vector<std::vector<double>>> injMatrix;
+  struct InjInex {
+    std::map<int, std::array<double, 4>> modes;
+    double alpha{0.};
+    double beta{0.};
+  };
+  std::map<int, InjInex> injInex;
   if (!injectedJsonPath.empty()) {
     std::ifstream injFile(injectedJsonPath);
     if (injFile.is_open()) {
@@ -410,6 +456,22 @@ void writeMillepedeResults(AlignableVolume* root, const std::string& milleResPat
         if (item.contains("matrix")) {
           injMatrix[id] = item["matrix"].get<std::vector<std::vector<double>>>();
         }
+        if (item.contains("inextensional")) {
+          InjInex ii;
+          const auto& inex = item["inextensional"];
+          if (inex.contains("modes")) {
+            for (auto& [key, val] : inex["modes"].items()) {
+              ii.modes[std::stoi(key)] = val.get<std::array<double, 4>>();
+            }
+          }
+          if (inex.contains("alpha")) {
+            ii.alpha = inex["alpha"].get<double>();
+          }
+          if (inex.contains("beta")) {
+            ii.beta = inex["beta"].get<double>();
+          }
+          injInex[id] = ii;
+        }
       }
       LOGP(info, "Loaded injected misalignment for {} sensors", injData.size());
     } else {
@@ -468,6 +530,43 @@ void writeMillepedeResults(AlignableVolume* root, const std::string& milleResPat
         matrix.push_back(row);
       }
       entry["matrix"] = matrix;
+    } else if (cal && cal->nFreeDOFs() && cal->type() == DOFSet::Type::Inextensional) {
+      write = true;
+      auto* inexSet = static_cast<const InextensionalDOFSet*>(cal);
+      int maxN = inexSet->maxOrder();
+      auto calibLbl = vol->getLabel().asCalib();
+      const auto& inj = injInex.contains(id) ? injInex[id] : InjInex{};
+
+      json inexEntry;
+      json modesObj = json::object();
+      for (int n = 2; n <= maxN; ++n) {
+        int off = InextensionalDOFSet::modeOffset(n);
+        std::array<double, 4> injCoeffs = {0., 0., 0., 0.};
+        if (inj.modes.contains(n)) {
+          injCoeffs = inj.modes.at(n);
+        }
+        json modeArr = json::array();
+        for (int k = 0; k < 4; ++k) {
+          uint32_t raw = calibLbl.raw(off + k);
+          auto it = labelToValue.find(raw);
+          double fitted = it != labelToValue.end() ? it->second : 0.0;
+          modeArr.push_back(fitted - injCoeffs[k]);
+        }
+        modesObj[std::to_string(n)] = modeArr;
+      }
+      inexEntry["modes"] = modesObj;
+
+      // alpha
+      uint32_t rawAlpha = calibLbl.raw(inexSet->alphaIdx());
+      auto itA = labelToValue.find(rawAlpha);
+      inexEntry["alpha"] = (itA != labelToValue.end() ? itA->second : 0.0) - inj.alpha;
+
+      // beta
+      uint32_t rawBeta = calibLbl.raw(inexSet->betaIdx());
+      auto itB = labelToValue.find(rawBeta);
+      inexEntry["beta"] = (itB != labelToValue.end() ? itB->second : 0.0) - inj.beta;
+
+      entry["inextensional"] = inexEntry;
     }
     if (write) {
       output.push_back(entry);
diff --git a/Detectors/Upgrades/ITS3/alignment/src/AlignmentSpec.cxx b/Detectors/Upgrades/ITS3/alignment/src/AlignmentSpec.cxx
