align Namespace Reference

Classes
class	TrackerNameSpace

Typedefs
typedef std::vector< Alignable * >	Alignables
typedef std::vector< std::unique_ptr< AlignmentLevel > >	AlignmentLevels
typedef math::Vector< 6 >::type	AlignParams
typedef std::map< std::pair< Alignable *, Alignable * >, AlgebraicMatrix >	Correlations
using	Counter = std::function< unsigned int(align::ID)>
typedef AlgebraicMatrix	Derivatives
typedef math::Error< 6 >::type	ErrorMatrix
typedef AlgebraicVector	EulerAngles
typedef Point3DBase< Scalar, GlobalTag >	GlobalPoint
typedef std::vector< GlobalPoint >	GlobalPoints
typedef Vector3DBase< Scalar, GlobalTag >	GlobalVector
typedef std::vector< GlobalVector >	GlobalVectors
typedef uint32_t	ID
typedef Point3DBase< Scalar, LocalTag >	LocalPoint
typedef std::vector< LocalPoint >	LocalPoints
typedef Vector3DBase< Scalar, LocalTag >	LocalVector
typedef std::vector< LocalVector >	LocalVectors
typedef std::vector< AlignmentParameters * >	Parameters
typedef Point3DBase< Scalar, GlobalTag >	PositionType
typedef TkRotation< Scalar >	RotationType
using	RunNumber = cond::RealTimeType< cond::runnumber >::type
using	RunRange = std::pair< RunNumber, RunNumber >
using	RunRanges = std::vector< RunRange >
typedef double	Scalar
typedef std::vector< Scalar >	Scalars

Enumerations
enum	StructureType {   notfound = -1, invalid = 0, AlignableDetUnit, AlignableDet,   TPBModule, TPBLadder, TPBLayer, TPBHalfBarrel,   TPBBarrel, TPEModule, TPEPanel, TPEBlade,   TPEHalfDisk, TPEHalfCylinder, TPEEndcap, TIBModule,   TIBString, TIBSurface, TIBHalfShell, TIBLayer,   TIBHalfBarrel, TIBBarrel, TIDModule, TIDSide,   TIDRing, TIDDisk, TIDEndcap, TOBModule,   TOBRod, TOBLayer, TOBHalfBarrel, TOBBarrel,   TECModule, TECRing, TECPetal, TECSide,   TECDisk, TECEndcap, Pixel, Strip,   Tracker, AlignableDTBarrel = 100, AlignableDTWheel, AlignableDTStation,   AlignableDTChamber, AlignableDTSuperLayer, AlignableDTLayer, AlignableCSCEndcap,   AlignableCSCStation, AlignableCSCRing, AlignableCSCChamber, AlignableCSCLayer,   AlignableMuon, Detector, Extras = 1000, BeamSpot }

Functions
GlobalVector	centerOfMass (const GlobalVectors &theVs)
	Find the CM of a set of points. More...
void	createPoints (GlobalVectors *Vs, Alignable *ali, const std::string &weightBy, bool weightById, const std::vector< unsigned int > &weightByIdVector)
const AlignTransform &	DetectorGlobalPosition (const Alignments &allGlobals, const DetId &id)
AlgebraicVector	diffAlignables (Alignable *refAli, Alignable *curAli, const std::string &weightBy, bool weightById, const std::vector< unsigned int > &weightByIdVector)
GlobalVector	diffR (const GlobalVectors &current, const GlobalVectors &nominal)
RotationType	diffRot (const GlobalVectors &current, const GlobalVectors &nominal)
RunRanges	makeNonOverlappingRunRanges (const edm::VParameterSet &runRanges, const RunNumber &defaultRun)
RunRanges	makeUniqueRunRanges (const edm::VParameterSet &runRanges, const RunNumber &defaultRun)
PositionType	motherPosition (const std::vector< const PositionType * > &dauPos)
	Find mother's position from the average of its daughters' positions. More...
void	moveAlignable (Alignable *ali, AlgebraicVector diff)
	Moves the alignable by the AlgebraicVector. More...
bool	readModuleList (unsigned int, unsigned int, const std::vector< unsigned int > &)
void	rectify (RotationType &)
	Correct a rotation matrix for rounding errors. More...
EulerAngles	toAngles (const RotationType &)
	Convert rotation matrix to angles about x-, y-, z-axes (frame rotation). More...
RotationType	toMatrix (const EulerAngles &)
	Convert rotation angles about x-, y-, z-axes to matrix. More...

Detailed Description

Tools for comparing alignables

Date

2008/06/17 12:46:54

Revision

1.5

Author

Nhan Tran

Namespace for common calculations in alignment.

Date

2007/10/08 15:22:08

Revision

1.10

Author

Chung Khim Lae

Namespace for common type definitions used in alignment.

Date

2007/04/09 00:26:08

Revision

1.2

Author

Chung Khim Lae

Typedef Documentation

typedef std::vector<Alignable*> align::Alignables

Definition at line 32 of file Utilities.h.

typedef std::vector<std::unique_ptr<AlignmentLevel> > align::AlignmentLevels

Definition at line 34 of file Utilities.h.

typedef math::Vector<6>::type align::AlignParams

Definition at line 38 of file Definitions.h.

typedef std::map<std::pair<Alignable*, Alignable*>, AlgebraicMatrix> align::Correlations

Definition at line 36 of file Utilities.h.

using align::Counter = typedef std::function<unsigned int(align::ID)>

Definition at line 32 of file AlignableIndexer.h.

typedef AlgebraicMatrix align::Derivatives

Definition at line 37 of file Definitions.h.

typedef math::Error<6>::type align::ErrorMatrix

Definition at line 39 of file Definitions.h.

typedef AlgebraicVector align::EulerAngles

Definition at line 36 of file Definitions.h.

typedef Point3DBase<Scalar, GlobalTag> align::GlobalPoint

Definition at line 31 of file Definitions.h.

typedef std::vector<GlobalPoint> align::GlobalPoints

Definition at line 28 of file Utilities.h.

typedef Vector3DBase<Scalar, GlobalTag> align::GlobalVector

Definition at line 33 of file Definitions.h.

typedef std::vector<GlobalVector> align::GlobalVectors

Definition at line 29 of file Utilities.h.

typedef uint32_t align::ID

Definition at line 26 of file Definitions.h.

typedef Point3DBase<Scalar, LocalTag> align::LocalPoint

Definition at line 32 of file Definitions.h.

typedef std::vector<LocalPoint> align::LocalPoints

Definition at line 30 of file Utilities.h.

typedef Vector3DBase<Scalar, LocalTag> align::LocalVector

Definition at line 34 of file Definitions.h.

typedef std::vector<LocalVector> align::LocalVectors

Definition at line 31 of file Utilities.h.

typedef std::vector<AlignmentParameters*> align::Parameters

Definition at line 33 of file Utilities.h.

typedef Point3DBase<Scalar, GlobalTag> align::PositionType

Definition at line 30 of file Definitions.h.

typedef TkRotation<Scalar> align::RotationType

Definition at line 29 of file Definitions.h.

using align::RunNumber = typedef cond::RealTimeType<cond::runnumber>::type

Definition at line 38 of file Utilities.h.

using align::RunRange = typedef std::pair<RunNumber, RunNumber>

Definition at line 39 of file Utilities.h.

using align::RunRanges = typedef std::vector<RunRange>

Definition at line 40 of file Utilities.h.

typedef double align::Scalar

Definition at line 27 of file Definitions.h.

typedef std::vector<Scalar> align::Scalars

Definition at line 27 of file Utilities.h.

Enumeration Type Documentation

enum align::StructureType

Enumerate the types of structure an alignable can be.

Basically list the levels in the detector's hierarchy.

Date

2010/09/10 10:28:38

Revision

1.5

Author

Chung Khim Lae

Enumerator
notfound
invalid
AlignableDetUnit
AlignableDet
TPBModule
TPBLadder
TPBLayer
TPBHalfBarrel
TPBBarrel
TPEModule
TPEPanel
TPEBlade
TPEHalfDisk
TPEHalfCylinder
TPEEndcap
TIBModule
TIBString
TIBSurface
TIBHalfShell
TIBLayer
TIBHalfBarrel
TIBBarrel
TIDModule
TIDSide
TIDRing
TIDDisk
TIDEndcap
TOBModule
TOBRod
TOBLayer
TOBHalfBarrel
TOBBarrel
TECModule
TECRing
TECPetal
TECSide
TECDisk
TECEndcap
Pixel
Strip
Tracker
AlignableDTBarrel
AlignableDTWheel
AlignableDTStation
AlignableDTChamber
AlignableDTSuperLayer
AlignableDTLayer
AlignableCSCEndcap
AlignableCSCStation
AlignableCSCRing
AlignableCSCChamber
AlignableCSCLayer
AlignableMuon
Detector
Extras
BeamSpot

Definition at line 17 of file StructureType.h.

  { 
    notfound = -1,
    invalid = 0,
    AlignableDetUnit,
    AlignableDet,

    // Barrel Pixel
    TPBModule,
    TPBLadder,
    TPBLayer, // = 5
    TPBHalfBarrel,
    TPBBarrel,

    // Forward Pixel
    TPEModule,
    TPEPanel,
    TPEBlade, // = 10
    TPEHalfDisk,
    TPEHalfCylinder,
    TPEEndcap,

    // Tracker Inner Barrel
    TIBModule,
    TIBString, // = 15
    TIBSurface,
    TIBHalfShell,
    TIBLayer,
    TIBHalfBarrel,
    TIBBarrel, // = 20

    // Tracker Inner Disks
    TIDModule,
    TIDSide,
    TIDRing,
    TIDDisk,
    TIDEndcap, // = 25

    // Tracker Outer Barrel
    TOBModule,
    TOBRod,
    TOBLayer,
    TOBHalfBarrel,
    TOBBarrel, // = 30

    // Tracker Endcaps
    TECModule,
    TECRing,
    TECPetal,
    TECSide,
    TECDisk, // = 35
    TECEndcap,

    Pixel,
    Strip,
    Tracker, // = 39

    // Muon Detector, not touching these now
    AlignableDTBarrel = 100,
    AlignableDTWheel,
    AlignableDTStation,
    AlignableDTChamber,
    AlignableDTSuperLayer,
    AlignableDTLayer, // = 105
    AlignableCSCEndcap,
    AlignableCSCStation,
    AlignableCSCRing,
    AlignableCSCChamber,
    AlignableCSCLayer, // = 110
    AlignableMuon,

    Detector, // = 112 (what for?)

    Extras = 1000,
    BeamSpot
  };

Function Documentation

align::GlobalVector align::centerOfMass

(

const GlobalVectors &

theVs

)

Find the CM of a set of points.

Definition at line 187 of file Utilities.cc.

Referenced by MuonGeometryArrange::compareGeometries(), and diffAlignables().

{
  unsigned int nPoints = theVs.size();

  GlobalVector CM(0,0,0);

  for (unsigned int j = 0; j < nPoints; ++j) CM += theVs[j];

  return CM /= static_cast<Scalar>(nPoints);
}

void align::createPoints	(	align::GlobalVectors *	Vs,
		Alignable *	ali,
		const std::string &	weightBy,
		bool	weightById,
		const std::vector< unsigned int > &	weightByIdVector
	)

Creates the points which are used in diffAlignables A set of points corresponding to lowest daughters

Definition at line 92 of file AlignTools.cc.

References AlignableDet, AlignableDetUnit, Alignable::alignableObjectId(), AlCaHLTBitMon_QueryRunRegistry::comp, Alignable::components(), popcon2dropbox::copy(), MillePedeFileConverter_cfg::e, relativeConstraints::error, mps_fire::i, Alignable::id(), createfilelist::int, SurveyDet::localPoints(), Alignable::mother(), hiPixelPairStep_cff::points, readModuleList(), Alignable::setSurvey(), AlCaHLTBitMon_QueryRunRegistry::string, Alignable::surface(), Alignable::survey(), AlignableSurface::toGlobal(), create_public_lumi_plots::transform, vertices_cff::x, detailsBasic3DVector::y, and detailsBasic3DVector::z.

Referenced by MuonGeometryArrange::compareGeometries(), and diffAlignables().

                                                                                                                                                             {
    
    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);
            }
        }
    }
}

const AlignTransform & align::DetectorGlobalPosition	(	const Alignments &	allGlobals,
		const DetId &	id
	)

Definition at line 10 of file DetectorGlobalPosition.cc.

References Exception, and Alignments::m_align.

Referenced by TrackerSystematicMisalignments::analyze(), AlignmentMonitorAsAnalyzer::analyze(), TrackerGeometryIntoNtuples::analyze(), AlignmentProducerBase::applyAlignmentsToDB(), MuonAlignmentInputDB::newAlignableMuon(), MTDDigiGeometryESModule::produce(), TrackerDigiGeometryESModule::produce(), CSCGeometryESModule::produce(), DTGeometryESModule::produce(), and AlignmentProducerBase::writeForRunRange().

                                                                                              {
    for (std::vector<AlignTransform>::const_iterator iter = allGlobals.m_align.begin();
     iter != allGlobals.m_align.end();
     ++iter) {
      if (iter->rawId() == id.rawId()) {
    return *iter;
      }
    }

    throw cms::Exception("RecordNotFound")
      << "DetId(" << id.rawId() << ") not found in GlobalPositionRcd" << std::endl;
  }

AlgebraicVector align::diffAlignables	(	Alignable *	refAli,
		Alignable *	curAli,
		const std::string &	weightBy,
		bool	weightById,
		const std::vector< unsigned int > &	weightByIdVector
	)

Finds the TR between two alignables - first alignable is reference. Returns a vector with 12 components. First six are global, second six are local.

Definition at line 10 of file AlignTools.cc.

References Alignable::alignableObjectId(), centerOfMass(), createPoints(), diffR(), diffRot(), Exception, Alignable::globalPosition(), Alignable::id(), gen::k, TkRotation< T >::multiplyInverse(), makeMuonMisalignmentScenario::rot, Alignable::surface(), theW, toAngles(), AlignableSurface::toLocal(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by MuonGeometryArrange::compareGeometries(), TrackerGeometryCompare::compareGeometries(), and TrackerGeometryCompare::diffCommonTrackerSystem().

                                                                                                                                                                       {
    
    //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; 
}

align::GlobalVector align::diffR	(	const GlobalVectors &	current,
		const GlobalVectors &	nominal
	)

Definition at line 168 of file Utilities.cc.

Referenced by diffAlignables(), and CreateSurveyRcds::setGeometry().

{
  GlobalVector nCM(0,0,0);
  GlobalVector cCM(0,0,0);

  unsigned int nPoints = nominal.size();

  for (unsigned int j = 0; j < nPoints; ++j)
  {
    nCM += nominal[j];
    cCM += current[j];
  }

  nCM -= cCM;

  return nCM /= static_cast<Scalar>(nPoints);
}

align::RotationType align::diffRot	(	const GlobalVectors &	current,
		const GlobalVectors &	nominal
	)

Find matrix to rotate from nominal to current vectors. Assume both sets of vectors have the same size and order.

Definition at line 73 of file Utilities.cc.

References EnergyCorrector::c, KineDebug3::count(), gather_cfg::cout, MillePedeFileConverter_cfg::e, Exhume::I, TkRotation< T >::multiplyInverse(), alignCSCRings::r, makeMuonMisalignmentScenario::rot, tolerance, toMatrix(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by SurveyResidual::calculate(), MuonGeometryArrange::compareGeometries(), diffAlignables(), and SurveyResidual::sensorResidual().

{
// Find the matrix needed to rotate the nominal surface to the current one
// using small angle approximation through the equation:
//
//   I * dOmega = dr * r (sum over points)
//
// where dOmega is a vector of small rotation angles about (x, y, z)-axes,
//   and I is the inertia tensor defined as
//
//   I_ij = delta_ij * r^2 - r_i * r_j (sum over points)
//
// delta_ij is the identity matrix. i, j are indices for (x, y, z).
//
// On the rhs of the first eq, r * dr is the cross product of r and dr.
// In this case, r is the nominal vector and dr is the displacement of the
// current point from its nominal point (current vector - nominal vector).
// 
// Since the solution of dOmega (by inverting I) gives angles that are small,
// we rotate the current surface by -dOmega and repeat the process until the
// dOmega^2 is less than a certain tolerance value.
// (In other words, we move the current surface by small angular steps till
// it matches the nominal surface.)
// The full rotation is found by adding up the rotations (given by dOmega)
// in each step. (More precisely, the product of all the matrices.)
//
// Note that, in some cases, if the angular displacement between current and
// nominal is pi, the algorithm can return an identity (no rotation).
// This is because dr = -r and r * dr is all zero.
// This is not a problem since we are dealing with small angles in alignment.

  static const double tolerance = 1e-12;

  RotationType rot; // rotation from nominal to current; init to identity

// Initial values for dr and I; I is always the same in each step

  AlgebraicSymMatrix I(3); // inertia tensor

  GlobalVectors rotated = current; // rotated current vectors in each step

  unsigned int nPoints = nominal.size();

  for (unsigned int j = 0; j < nPoints; ++j)
  {
    const GlobalVector& r = nominal[j];
  // Inertial tensor: I_ij = delta_ij * r^2 - r_i * r_j (sum over points)

    I.fast(1, 1) += r.y() * r.y() + r.z() * r.z();
    I.fast(2, 2) += r.x() * r.x() + r.z() * r.z();
    I.fast(3, 3) += r.y() * r.y() + r.x() * r.x();
    I.fast(2, 1) -= r.x() * r.y(); // row index must be >= col index
    I.fast(3, 1) -= r.x() * r.z();
    I.fast(3, 2) -= r.y() * r.z();
  }
 int count=0;
  while (true)
  {
    AlgebraicVector rhs(3); // sum of dr * r

    for (unsigned int j = 0; j < nPoints; ++j)
    {
      const GlobalVector& r = nominal[j];
      const GlobalVector& c = rotated[j];

    // Cross product of dr * r = c * r (sum over points)

      rhs(1) += c.y() * r.z() - c.z() * r.y();
      rhs(2) += c.z() * r.x() - c.x() * r.z();
      rhs(3) += c.x() * r.y() - c.y() * r.x();
    }

    EulerAngles dOmega = CLHEP::solve(I, rhs);

    rot *= toMatrix(dOmega); // add to rotation

    if (dOmega.normsq() < tolerance) break; // converges, so exit loop
    count++;
    if(count>100000){
       std::cout<<"diffRot infinite loop: dOmega is "<<dOmega.normsq()<<"\n";
       break;
    }

  // Not yet converge; move current vectors to new positions and find dr

    for (unsigned int j = 0; j < nPoints; ++j)
    {
      rotated[j] = GlobalVector( rot.multiplyInverse( current[j].basicVector() ) );
    }
  }

  return rot;
}

align::RunRanges align::makeNonOverlappingRunRanges	(	const edm::VParameterSet &	runRanges,
		const RunNumber &	defaultRun
	)

Definition at line 218 of file Utilities.cc.

References cond::TimeTypeSpecs::beginValue, cond::TimeTypeSpecs::endValue, plotBeamSpotDB::first, mps_fire::i, cond::runnumber, groupFilesInBlocks::temp, cond::timeTypeSpecs, and edm::tokenize().

Referenced by MillePedeAlignmentAlgorithm::areIOVsSpecified(), and makeUniqueRunRanges().

{
  const auto beginValue = cond::timeTypeSpecs[cond::runnumber].beginValue;
  const auto endValue = cond::timeTypeSpecs[cond::runnumber].endValue;
  RunRanges uniqueRunRanges;
  if (!runRanges.empty()) {
    std::map<RunNumber,RunNumber> uniqueFirstRunNumbers;
    for (const auto& ipset: runRanges) {
      const auto RunRangeStrings =
        ipset.getParameter<std::vector<std::string> >("RunRanges");
      for (const auto& irange: RunRangeStrings) {
        if (irange.find(':')==std::string::npos) {
          long int temp{strtol(irange.c_str(), nullptr, 0)};
          auto first = (temp != -1) ? temp : beginValue;
          uniqueFirstRunNumbers[first] = first;
        } else {
          edm::LogWarning("BadConfig")
            << "@SUB=align::makeNonOverlappingRunRanges"
            << "Config file contains old format for 'RunRangeSelection'. Only "
            << "the start run number is used internally. The number of the last"
            << " run is ignored and can besafely removed from the config file.";
          auto tokens = edm::tokenize(irange, ":");
          long int temp{strtol(tokens[0].c_str(), nullptr, 0)};
          auto first = (temp != -1) ? temp : beginValue;
          uniqueFirstRunNumbers[first] = first;
        }
      }
    }

    for (const auto& iFirst: uniqueFirstRunNumbers) {
      uniqueRunRanges.push_back(std::make_pair(iFirst.first, endValue));
    }
    for (unsigned int i = 0;i<uniqueRunRanges.size()-1;++i) {
      uniqueRunRanges[i].second = uniqueRunRanges[i+1].first - 1;
    }
  } else {
    uniqueRunRanges.push_back(std::make_pair(defaultRun, endValue));
  }

  return uniqueRunRanges;
}

align::RunRanges align::makeUniqueRunRanges	(	const edm::VParameterSet &	runRanges,
		const RunNumber &	defaultRun
	)

Definition at line 263 of file Utilities.cc.

References makeNonOverlappingRunRanges(), cond::runnumber, and cond::timeTypeSpecs.

Referenced by AlignmentProducerBase::AlignmentProducerBase(), and AlignmentProducerBase::storeAlignmentsToDB().

                                                        {
  auto uniqueRunRanges =
    align::makeNonOverlappingRunRanges(runRanges, defaultRun);
  if (uniqueRunRanges.empty()) { // create dummy IOV
    const RunRange runRange(defaultRun,
                cond::timeTypeSpecs[cond::runnumber].endValue);
    uniqueRunRanges.push_back(runRange);
  }
  return uniqueRunRanges;
}

align::PositionType align::motherPosition

(

const std::vector< const PositionType * > &

dauPos

)

Find mother's position from the average of its daughters' positions.

Definition at line 53 of file Utilities.cc.

References mps_fire::i, point, RecoTauValidation_cfi::posX, RecoTauValidation_cfi::posY, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by SurveyResidual::calculate().

{
  unsigned int nDau = dauPos.size();

  Scalar posX(0.), posY(0.), posZ(0.); // position of mother

  for (unsigned int i = 0; i < nDau; ++i)
  {
    const PositionType* point = dauPos[i];

    posX += point->x();
    posY += point->y();
    posZ += point->z();
  }

  Scalar inv = 1. / static_cast<Scalar>(nDau);

  return PositionType(posX *= inv, posY *= inv, posZ *= inv);
}

void align::moveAlignable	(	Alignable *	ali,
		AlgebraicVector	diff
	)

Moves the alignable by the AlgebraicVector.

Finds the TR between 2 sets of alignables For example, if TIB/TID were to move as one unit

Definition at line 81 of file AlignTools.cc.

References PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, Alignable::move(), Alignable::rotateInGlobalFrame(), and toMatrix().

Referenced by MuonGeometryArrange::compareGeometries(), TrackerGeometryCompare::compareGeometries(), and TrackerGeometryCompare::setCommonTrackerSystem().

                                                             {
    
    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);
    
}

bool align::readModuleList	(	unsigned int	aliId,
		unsigned int	motherId,
		const std::vector< unsigned int > &	weightByIdVector
	)

Definition at line 142 of file AlignTools.cc.

References mps_fire::i.

Referenced by MuonGeometryArrange::compareGeometries(), and createPoints().

                                                                                                                      {
    
    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;
}

void align::rectify

(

RotationType &

rot

)

Correct a rotation matrix for rounding errors.

Definition at line 198 of file Utilities.cc.

References toAngles(), and toMatrix().

Referenced by BeamSpotAlignmentParameters::apply(), RigidBodyAlignmentParameters::apply(), BowedSurfaceAlignmentParameters::apply(), TwoBowedSurfacesAlignmentParameters::apply(), AlignmentParameterStore::applyAlignableAbsolutePositions(), MuonAlignmentInputXML::set_one_position(), and SurveyAlignment::shiftSensors().

{
// Use ROOT for better numerical precision but slower.

//   ROOT::Math::Rotation3D temp( rot.xx(), rot.xy(), rot.xz(),
//                                rot.yx(), rot.yy(), rot.yz(),
//                                rot.zx(), rot.zy(), rot.zz() );
// 
//   temp.Rectify();
// 
//   Scalar elems[9];
// 
//   temp.GetComponents(elems);
//   rot = RotationType(elems);

  rot = toMatrix( toAngles(rot) ); // fast rectification but less precise
}

align::EulerAngles align::toAngles

(

const RotationType &

rot

)

Convert rotation matrix to angles about x-, y-, z-axes (frame rotation).

Definition at line 9 of file Utilities.cc.

References funct::abs(), particleFlowDisplacedVertex_cfi::angles, makeMuonMisalignmentScenario::rot, TkRotation< T >::xx(), TkRotation< T >::xy(), TkRotation< T >::xz(), TkRotation< T >::yx(), TkRotation< T >::yy(), TkRotation< T >::yz(), TkRotation< T >::zx(), TkRotation< T >::zy(), and TkRotation< T >::zz().

Referenced by AlignmentParameterStore::acquireRelativeParameters(), MuonGeometryArrange::compareGeometries(), diffAlignables(), RigidBodyAlignmentParameters::displacementFromAlignable(), MuonAlignmentInputXML::do_setposition(), MuonGeometryArrange::fillTree(), TrackerGeometryCompare::fillTree(), rectify(), BeamSpotAlignmentParameters::rotation(), SurveyResidual::sensorResidual(), AlignableSurface::toGlobal(), AlignableSurface::toLocal(), SurveyOutput::write(), and MuonAlignmentOutputXML::writeComponents().

{
  const Scalar one = 1; // to ensure same precison is used in comparison

  EulerAngles angles(3);

  if (std::abs( rot.zx() ) > one)
  {
    edm::LogWarning("Alignment") << "Rounding errors in\n" << rot;
  }

  if (std::abs( rot.zx() ) < one)
  {
    angles(1) = -std::atan2( rot.zy(), rot.zz() );
    angles(2) =  std::asin( rot.zx() );
    angles(3) = -std::atan2( rot.yx(), rot.xx() );
  }
  else if (rot.zx() >= one)
  {
    angles(1) = std::atan2(rot.xy() + rot.yz(), rot.yy() - rot.xz() );
    angles(2) = std::asin(one);
    angles(3) = 0;
  }
  else if (rot.zx() <= -one)
  {
    angles(1) = std::atan2(rot.xy() - rot.yz(), rot.yy() + rot.xz() );
    angles(2) = std::asin(-one);
    angles(3) = 0;
  }

  return angles;
}

align::RotationType align::toMatrix

(

const EulerAngles &

angles

)

Convert rotation angles about x-, y-, z-axes to matrix.

Definition at line 42 of file Utilities.cc.

References alignmentValidation::c1, funct::cos(), indexGen::s2, and funct::sin().

Referenced by BeamSpotAlignmentParameters::apply(), RigidBodyAlignmentParameters::apply(), BowedSurfaceAlignmentParameters::apply(), TwoBowedSurfacesAlignmentParameters::apply(), PedeSteerer::correctToReferenceSystem(), diffRot(), MuonAlignmentInputXML::do_setposition(), MuonGeometryArrange::fillTree(), moveAlignable(), rectify(), AlignmentParameterStore::setAlignmentPositionError(), TrackerGeometryCompare::setCommonTrackerSystem(), SurveyAlignment::shiftSensors(), AlignmentProducerBase::simpleMisalignment(), AlignableSurface::toGlobal(), and AlignableSurface::toLocal().

{
  Scalar s1 = std::sin(angles[0]), c1 = std::cos(angles[0]);
  Scalar s2 = std::sin(angles[1]), c2 = std::cos(angles[1]);
  Scalar s3 = std::sin(angles[2]), c3 = std::cos(angles[2]);

  return RotationType( c2 * c3, c1 * s3 + s1 * s2 * c3, s1 * s3 - c1 * s2 * c3,
              -c2 * s3, c1 * c3 - s1 * s2 * s3, s1 * c3 + c1 * s2 * s3,
                    s2,               -s1 * c2,                c1 * c2);
}