AlignTools.cc

Go to the documentation of this file.

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "Alignment/CommonAlignment/interface/Alignable.h"
#include "Alignment/CommonAlignment/interface/SurveyDet.h"
#include "Alignment/CommonAlignment/interface/AlignTools.h"
 
#include <iostream>
#include <fstream>
 
//Finds the TR between two alignables - first alignable is reference
AlgebraicVector align::diffAlignables(Alignable* refAli,
                                      Alignable* curAli,
                                      const std::string& weightBy,
                                      bool weightById,
                                      const std::vector<unsigned int>& weightByIdVector) {
  //check they are the same
  if (refAli->alignableObjectId() != curAli->alignableObjectId()) {
    if (refAli->id() != curAli->id()) {
      throw cms::Exception("Geometry Error") << "[AlignTools] Error, Alignables do not match";
    }
  }
 
  //create points
  align::GlobalVectors refVs;
  align::GlobalVectors curVs;
  align::createPoints(&refVs, refAli, weightBy, weightById, weightByIdVector);
  align::createPoints(&curVs, curAli, weightBy, weightById, weightByIdVector);
 
  //redefine the set of points
  //find the translational difference
  align::GlobalVector theR = align::diffR(curVs, refVs);
 
  //CM difference (needed below in rotational transformation)
  align::GlobalVector pointsCM = align::centerOfMass(curVs);
  align::PositionType alignableCM = curAli->globalPosition();
  align::GlobalVector cmdiff(
      alignableCM.x() - pointsCM.x(), alignableCM.y() - pointsCM.y(), alignableCM.z() - pointsCM.z());
 
  //readjust points before finding rotation
  align::GlobalVector CMref = align::centerOfMass(refVs);
  align::GlobalVector CMcur = align::centerOfMass(curVs);
  for (unsigned int k = 0; k < refVs.size(); ++k) {
    refVs[k] -= CMref;
    curVs[k] -= CMcur;
  }
 
  //find rotational difference (global)
  align::RotationType rot = align::diffRot(curVs, refVs);
  align::EulerAngles theW = align::toAngles(rot);
  //convert to local rotation
  align::RotationType localrot = refAli->surface().toLocal(rot);
  align::EulerAngles theLocalW = align::toAngles(localrot);
 
  //adjust translational difference factoring in different rotational CM
  //needed because rotateInGlobalFrame is about CM of alignable, not points
  const align::GlobalVector::BasicVectorType& lpvgf = cmdiff.basicVector();
  align::GlobalVector moveV(rot.multiplyInverse(lpvgf) - lpvgf);
  align::GlobalVector theRprime(theR + moveV);
  //convert to local movement
  align::LocalVector theLocalRprime = refAli->surface().toLocal(theRprime);
 
  AlgebraicVector deltaRW(12);
  // global values
  deltaRW(1) = theRprime.x();
  deltaRW(2) = theRprime.y();
  deltaRW(3) = theRprime.z();
  deltaRW(4) = theW(1);
  deltaRW(5) = theW(2);
  deltaRW(6) = theW(3);
  // local values
  deltaRW(7) = theLocalRprime.x();
  deltaRW(8) = theLocalRprime.y();
  deltaRW(9) = theLocalRprime.z();
  deltaRW(10) = theLocalW(1);
  deltaRW(11) = theLocalW(2);
  deltaRW(12) = theLocalW(3);
 
  refVs.clear();
  curVs.clear();
 
  return deltaRW;
}
 
//Moves the alignable by the AlgebraicVector
void align::moveAlignable(Alignable* ali, AlgebraicVector diff) {
  GlobalVector dR(diff[0], diff[1], diff[2]);
  align::EulerAngles dOmega(3);
  dOmega[0] = diff[3];
  dOmega[1] = diff[4];
  dOmega[2] = diff[5];
  align::RotationType dRot = align::toMatrix(dOmega);
  ali->move(dR);
  ali->rotateInGlobalFrame(dRot);
}
 
//Creates the points which are used in diffAlignables
void align::createPoints(align::GlobalVectors* Vs,
                         Alignable* ali,
                         const std::string& weightBy,
                         bool weightById,
                         const std::vector<unsigned int>& weightByIdVector) {
  std::string copy = weightBy;
  std::transform(copy.begin(), copy.end(), copy.begin(), (int (*)(int))toupper);
  if (copy != "SELF") {
    const auto& comp = ali->components();
    unsigned int nComp = comp.size();
    for (unsigned int i = 0; i < nComp; ++i)
      align::createPoints(Vs, comp[i], weightBy, weightById, weightByIdVector);
    // double the weight for SS modules if weight by Det
    if ((ali->alignableObjectId() == align::AlignableDet) && (weightBy == "Det")) {
      for (unsigned int i = 0; i < nComp; ++i)
        align::createPoints(Vs, comp[i], weightBy, weightById, weightByIdVector);
    }
 
    //only create points for lowest hiearchical level
    if (ali->alignableObjectId() == align::AlignableDetUnit) {
      //check if the raw id or the mother's raw id is on the list
      bool createPointsForDetUnit = true;
      if (weightById)
        createPointsForDetUnit = align::readModuleList(ali->id(), ali->mother()->id(), weightByIdVector);
      if (createPointsForDetUnit) {
        //if no survey information, create local points
        if (!(ali->survey())) {
          align::ErrorMatrix error;
          ali->setSurvey(new SurveyDet(ali->surface(), error * 1e-6));
        }
        const align::GlobalPoints& points = ali->surface().toGlobal(ali->survey()->localPoints());
        for (unsigned int j = 0; j < points.size(); ++j) {
          align::GlobalVector dummy(points[j].x(), points[j].y(), points[j].z());
          Vs->push_back(dummy);
        }
      }
    }
  } else {
    bool createPointsForDetUnit = true;
    if (weightById)
      createPointsForDetUnit = align::readModuleList(ali->id(), ali->mother()->id(), weightByIdVector);
    if (createPointsForDetUnit) {
      //if no survey information, create local points
      if (!(ali->survey())) {
        align::ErrorMatrix error;
        ali->setSurvey(new SurveyDet(ali->surface(), error * 1e-6));
      }
      const align::GlobalPoints& points = ali->surface().toGlobal(ali->survey()->localPoints());
      for (unsigned int j = 0; j < points.size(); ++j) {
        align::GlobalVector dummy(points[j].x(), points[j].y(), points[j].z());
        Vs->push_back(dummy);
      }
    }
  }
}
 
bool align::readModuleList(unsigned int aliId,
                           unsigned int motherId,
                           const std::vector<unsigned int>& weightByIdVector) {
  bool foundId = false;
 
  unsigned int sizeVector = weightByIdVector.size();
 
  for (unsigned int i = 0; i < sizeVector; ++i) {
    unsigned int listId = weightByIdVector[i];
 
    if (listId == aliId) {
      foundId = true;
      break;
    }
    if (listId == motherId) {
      foundId = true;
      break;
    }
  }
 
  return foundId;
}