#include <AlignableModifier.h>

Public Member Functions
void	addAlignmentPositionError (Alignable *alignable, float dx, float dy, float dz)
	Add the AlignmentPositionError (in global frame) to Alignable. More...

void	addAlignmentPositionErrorFromLocalRotation (Alignable *alignable, align::RotationType &)
	Add alignment position error resulting from rotation in local frame. More...

void	addAlignmentPositionErrorFromLocalRotation (Alignable *alignable, float phiX, float phiY, float phiZ)
	Add alignment position error resulting from rotation in local frame. More...

void	addAlignmentPositionErrorFromRotation (Alignable *alignable, align::RotationType &)
	Add alignment position error resulting from rotation in global frame. More...

void	addAlignmentPositionErrorFromRotation (Alignable *alignable, float phiX, float phiY, float phiZ)
	Add alignment position error resulting from rotation in global frame. More...

void	addAlignmentPositionErrorLocal (Alignable *alignable, float dx, float dy, float dz)
	Add the AlignmentPositionError (in local frame) to Alignable. More...

	AlignableModifier ()
	Constructor. More...

const std::vector< float >	flatRandomVector (float sigmaX, float sigmaY, float sigmaZ) const
	Return a vector of random numbers (flat distribution) More...

const std::vector< float >	gaussianRandomVector (float sigmaX, float sigmaY, float sigmaZ) const
	Return a vector of random numbers (gaussian distribution) More...

bool	isPropagated (const std::string &parameterName) const
	Check if given parameter should be propagated. More...

bool	modify (Alignable *alignable, const edm::ParameterSet &pSet)
	Modify given set of alignables according to parameters. More...

void	moveAlignable (Alignable *alignable, bool random, bool gaussian, float sigmaX, float sigmaY, float sigmaZ)
	Move alignable in global space according to parameters. More...

void	moveAlignableLocal (Alignable *alignable, bool random, bool gaussian, float sigmaX, float sigmaY, float sigmaZ)
	Move alignable in local space according to parameters. More...

void	randomise (std::vector< double > &rnd, bool gaussian) const

void	rotateAlignable (Alignable *alignable, bool random, bool gaussian, float sigmaPhiX, float sigmaPhiY, float sigmaPhiZ)
	Rotate alignable in global space according to parameters. More...

void	rotateAlignableLocal (Alignable *alignable, bool random, bool gaussian, float sigmaPhiX, float sigmaPhiY, float sigmaPhiZ)
	Rotate alignable in local space according to parameters. More...

void	setDistribution (const std::string &distr)
	Decodes string and sets distribution accordingly ('fixed', 'flat' or 'gaussian'). More...

void	setSeed (long seed)
	Resets the generator seed according to the argument. More...

	~AlignableModifier ()
	Destructor. More...

Private Types
typedef std::pair< std::string, std::vector< double > >	DeformationMemberType

Private Member Functions
void	addDeformation (Alignable *alignable, const DeformationMemberType &deformation, bool random, bool gaussian, double scale)

void	init_ ()
	Initialisation of all parameters. More...

Private Attributes
DeformationMemberType	deformation_

std::string	distribution_

double	dX_

double	dXlocal_

double	dY_

double	dYlocal_

double	dZ_

double	dZlocal_

bool	gaussian_

int	m_modified

double	phiX_

double	phiXlocal_

double	phiY_

double	phiYlocal_

double	phiZ_

double	phiZlocal_

bool	random_

double	scale_

double	scaleError_

long	seed_

bool	setError_

bool	setRotations_

bool	setTranslations_

double	shear_

CLHEP::DRand48Engine *	theDRand48Engine
	Unique random number generator. More...

double	twist_

Detailed Description

Definition at line 23 of file AlignableModifier.h.

Member Typedef Documentation

◆ DeformationMemberType

typedef std::pair<std::string, std::vector<double> > AlignableModifier::DeformationMemberType

private

Definition at line 85 of file AlignableModifier.h.

Constructor & Destructor Documentation

◆ AlignableModifier()

AlignableModifier::AlignableModifier ( void )

Constructor.

Definition at line 21 of file AlignableModifier.cc.

     : distribution_(""),
       random_(false),
       gaussian_(false),
       setError_(false),
       setRotations_(false),
       setTranslations_(false),
       seed_(0),
       scaleError_(0.),
       scale_(0.),
       phiX_(0.),
       phiY_(0.),
       phiZ_(0.),
       phiXlocal_(0.),
       phiYlocal_(0.),
       phiZlocal_(0.),
       dX_(0.),
       dY_(0.),
       dZ_(0.),
       dXlocal_(0.),
       dYlocal_(0.),
       dZlocal_(0.),
       twist_(0.),
       shear_(0.) {
   theDRand48Engine = new CLHEP::DRand48Engine();
 }

References theDRand48Engine.

◆ ~AlignableModifier()

AlignableModifier::~AlignableModifier ( )

Destructor.

Definition at line 49 of file AlignableModifier.cc.

49 { delete theDRand48Engine; }

References theDRand48Engine.

Member Function Documentation

◆ addAlignmentPositionError()

void AlignableModifier::addAlignmentPositionError	(	Alignable *	alignable,
		float	dx,
		float	dy,
		float	dz
	)

Add the AlignmentPositionError (in global frame) to Alignable.

Definition at line 532 of file AlignableModifier.cc.

                                                                                                     {
   LogDebug("PrintArgs") << "Adding an AlignmentPositionError of size " << dx << " " << dy << " " << dz;
  
   AlignmentPositionError ape(dx, dy, dz);
   alignable->addAlignmentPositionError(ape, true);
 }

References Alignable::addAlignmentPositionError(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, and LogDebug.

Referenced by modify(), MuonScenarioBuilder::moveChamberInSector(), and MuonScenarioBuilder::moveMuon().

◆ addAlignmentPositionErrorFromLocalRotation() [1/2]

void AlignableModifier::addAlignmentPositionErrorFromLocalRotation	(	Alignable *	alignable,
		align::RotationType &	rotation
	)

Add alignment position error resulting from rotation in local frame.

Definition at line 618 of file AlignableModifier.cc.

                                                                                                 {
   LogDebug("PrintArgs") << "Adding an AlignmentPositionError from Local Rotation" << std::endl << rotation;
  
   // true: propagate down to components
   alignable->addAlignmentPositionErrorFromLocalRotation(rotation, true);
 }

References Alignable::addAlignmentPositionErrorFromLocalRotation(), LogDebug, and idealTransformation::rotation.

◆ addAlignmentPositionErrorFromLocalRotation() [2/2]

void AlignableModifier::addAlignmentPositionErrorFromLocalRotation	(	Alignable *	alignable,
		float	phiX,
		float	phiY,
		float	phiZ
	)

Add alignment position error resulting from rotation in local frame.

Definition at line 598 of file AlignableModifier.cc.

                                                                                {
   align::RotationType rotx(Basic3DVector<float>(1.0, 0.0, 0.0), phiX);
   align::RotationType roty(Basic3DVector<float>(0.0, 1.0, 0.0), phiY);
   align::RotationType rotz(Basic3DVector<float>(0.0, 0.0, 1.0), phiZ);
   align::RotationType rot = rotz * roty * rotx;
  
   this->addAlignmentPositionErrorFromLocalRotation(alignable, rot);
 }

References makeMuonMisalignmentScenario::rot.

Referenced by modify().

◆ addAlignmentPositionErrorFromRotation() [1/2]

void AlignableModifier::addAlignmentPositionErrorFromRotation	(	Alignable *	alignable,
		align::RotationType &	rotation
	)

Add alignment position error resulting from rotation in global frame.

Definition at line 611 of file AlignableModifier.cc.

                                                                                                                {
   LogDebug("PrintArgs") << "Adding an AlignmentPositionError from Rotation" << std::endl << rotation;
  
   alignable->addAlignmentPositionErrorFromRotation(rotation, true);  // propagate down to components
 }

References Alignable::addAlignmentPositionErrorFromRotation(), LogDebug, and idealTransformation::rotation.

◆ addAlignmentPositionErrorFromRotation() [2/2]

void AlignableModifier::addAlignmentPositionErrorFromRotation	(	Alignable *	alignable,
		float	phiX,
		float	phiY,
		float	phiZ
	)

Add alignment position error resulting from rotation in global frame.

Definition at line 588 of file AlignableModifier.cc.

                                                                                                                       {
   align::RotationType rotx(Basic3DVector<float>(1.0, 0.0, 0.0), phiX);
   align::RotationType roty(Basic3DVector<float>(0.0, 1.0, 0.0), phiY);
   align::RotationType rotz(Basic3DVector<float>(0.0, 0.0, 1.0), phiZ);
   align::RotationType rot = rotz * roty * rotx;
  
   this->addAlignmentPositionErrorFromRotation(alignable, rot);
 }

References makeMuonMisalignmentScenario::rot.

Referenced by modify(), MuonScenarioBuilder::moveChamberInSector(), and MuonScenarioBuilder::moveMuon().

◆ addAlignmentPositionErrorLocal()

void AlignableModifier::addAlignmentPositionErrorLocal	(	Alignable *	alignable,
		float	dx,
		float	dy,
		float	dz
	)

Add the AlignmentPositionError (in local frame) to Alignable.

Definition at line 540 of file AlignableModifier.cc.

                                                                                                          {
   LogDebug("PrintArgs") << "Adding a local AlignmentPositionError of size " << dx << " " << dy << " " << dz;
  
   AlgebraicSymMatrix as(3, 0);  //3x3, zeroed
   as[0][0] = dx * dx;
   as[1][1] = dy * dy;
   as[2][2] = dz * dz;                                    //diagonals
   align::RotationType rt = alignable->globalRotation();  //get rotation
   AlgebraicMatrix am(3, 3);
   am[0][0] = rt.xx();
   am[0][1] = rt.xy();
   am[0][2] = rt.xz();
   am[1][0] = rt.yx();
   am[1][1] = rt.yy();
   am[1][2] = rt.yz();
   am[2][0] = rt.zx();
   am[2][1] = rt.zy();
   am[2][2] = rt.zz();
   as = as.similarityT(am);  //rotate error matrix
  
   GlobalError ge(asSMatrix<3>(as));
   GlobalErrorExtended gee(ge.cxx(),
                           ge.cyx(),
                           ge.czx(),
                           0.,
                           0.,
                           0.,
                           ge.cyy(),
                           ge.czy(),
                           0.,
                           0.,
                           0.,
                           ge.czz(),
                           0.,
                           0.,
                           0.,
                           0.,
                           0.,
                           0.,
                           0.,
                           0.,
                           0.);
   AlignmentPositionError ape(gee);
  
   alignable->addAlignmentPositionError(ape, true);  // propagate down to components
 }

References Alignable::addAlignmentPositionError(), GlobalErrorBase< T, ErrorWeightType >::cxx(), GlobalErrorBase< T, ErrorWeightType >::cyx(), GlobalErrorBase< T, ErrorWeightType >::cyy(), GlobalErrorBase< T, ErrorWeightType >::czx(), GlobalErrorBase< T, ErrorWeightType >::czy(), GlobalErrorBase< T, ErrorWeightType >::czz(), PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, Alignable::globalRotation(), LogDebug, and hcal_runs::rt.

Referenced by modify().

◆ addDeformation()

void AlignableModifier::addDeformation	(	Alignable *	alignable,
		const DeformationMemberType &	deformation,
		bool	random,
		bool	gaussian,
		double	scale
	)

private

Definition at line 355 of file AlignableModifier.cc.

                                                       {
   const SurfaceDeformationFactory::Type deformType =
       SurfaceDeformationFactory::surfaceDeformationType(deformation.first);
  
   // Scale and randomize
   // (need a little hack since ySplit must not be treated)!
   const bool rndNotLast = (deformType == SurfaceDeformationFactory::kTwoBowedSurfaces);
   std::vector<double> rndDeformation(deformation.second.begin(), deformation.second.end() - (rndNotLast ? 1 : 0));
   for (unsigned int i = 0; i < rndDeformation.size(); ++i) {
     rndDeformation[i] *= scale;
   }
   if (random) {
     this->randomise(rndDeformation, gaussian);
   }
   if (rndNotLast) {  // put back ySplit at the end
     rndDeformation.push_back(deformation.second.back());
   }
  
   // auto_ptr has exception safe delete (in contrast to bare pointer)
   const std::unique_ptr<SurfaceDeformation> surfDef(SurfaceDeformationFactory::create(deformType, rndDeformation));
  
   alignable->addSurfaceDeformation(surfDef.get(), true);  // true to propagate down
   ++m_modified;
 }

References Alignable::addSurfaceDeformation(), SurfaceDeformationFactory::create(), mps_fire::i, SurfaceDeformationFactory::kTwoBowedSurfaces, m_modified, randomise(), L1EGammaCrystalsEmulatorProducer_cfi::scale, and SurfaceDeformationFactory::surfaceDeformationType().

Referenced by modify().

◆ flatRandomVector()

const std::vector< float > AlignableModifier::flatRandomVector	(	float	sigmaX,
		float	sigmaY,
		float	sigmaZ
	)		const

Return a vector of random numbers (flat distribution)

Definition at line 486 of file AlignableModifier.cc.

                                                                                                          {
   // Get absolute value if negative arguments
   if (sigmaX < 0) {
     edm::LogWarning("BadConfig") << " taking absolute value for flat sigma_x";
     sigmaX = std::abs(sigmaX);
   }
   if (sigmaY < 0) {
     edm::LogWarning("BadConfig") << " taking absolute value for flat sigma_y";
     sigmaY = std::abs(sigmaY);
   }
   if (sigmaZ < 0) {
     edm::LogWarning("BadConfig") << " taking absolute value for flat sigma_z";
     sigmaZ = std::abs(sigmaZ);
   }
  
   CLHEP::RandFlat aFlatObjX(*theDRand48Engine, -sigmaX, sigmaX);
   CLHEP::RandFlat aFlatObjY(*theDRand48Engine, -sigmaY, sigmaY);
   CLHEP::RandFlat aFlatObjZ(*theDRand48Engine, -sigmaZ, sigmaZ);
  
   std::vector<float> randomVector;
   randomVector.push_back(aFlatObjX.fire());
   randomVector.push_back(aFlatObjY.fire());
   randomVector.push_back(aFlatObjZ.fire());
  
   return randomVector;
 }

References funct::abs(), BeamSpotPI::sigmaX, BeamSpotPI::sigmaY, BeamSpotPI::sigmaZ, and theDRand48Engine.

Referenced by moveAlignable(), moveAlignableLocal(), MuonScenarioBuilder::moveCSCSectors(), MuonScenarioBuilder::moveDTSectors(), MuonScenarioBuilder::moveGEMSectors(), MuonScenarioBuilder::moveMuon(), rotateAlignable(), and rotateAlignableLocal().

◆ gaussianRandomVector()

const std::vector< float > AlignableModifier::gaussianRandomVector	(	float	sigmaX,
		float	sigmaY,
		float	sigmaZ
	)		const

Return a vector of random numbers (gaussian distribution)

Definition at line 457 of file AlignableModifier.cc.

                                                                                                              {
   // Get absolute value if negative arguments
   if (sigmaX < 0) {
     edm::LogWarning("BadConfig") << " taking absolute value for gaussian sigma_x";
     sigmaX = std::abs(sigmaX);
   }
   if (sigmaY < 0) {
     edm::LogWarning("BadConfig") << " taking absolute value for gaussian sigma_y";
     sigmaY = std::abs(sigmaY);
   }
   if (sigmaZ < 0) {
     edm::LogWarning("BadConfig") << " taking absolute value for gaussian sigma_z";
     sigmaZ = std::abs(sigmaZ);
   }
  
   // Pass by reference, otherwise pointer is deleted!
   CLHEP::RandGauss aGaussObjX(*theDRand48Engine, 0., sigmaX);
   CLHEP::RandGauss aGaussObjY(*theDRand48Engine, 0., sigmaY);
   CLHEP::RandGauss aGaussObjZ(*theDRand48Engine, 0., sigmaZ);
  
   std::vector<float> randomVector;
   randomVector.push_back(aGaussObjX.fire());
   randomVector.push_back(aGaussObjY.fire());
   randomVector.push_back(aGaussObjZ.fire());
  
   return randomVector;
 }

References funct::abs(), BeamSpotPI::sigmaX, BeamSpotPI::sigmaY, BeamSpotPI::sigmaZ, and theDRand48Engine.

Referenced by moveAlignable(), moveAlignableLocal(), MuonScenarioBuilder::moveCSCSectors(), MuonScenarioBuilder::moveDTSectors(), MuonScenarioBuilder::moveGEMSectors(), MuonScenarioBuilder::moveMuon(), rotateAlignable(), and rotateAlignableLocal().

◆ init_()

void AlignableModifier::init_ ( void )

private

Initialisation of all parameters.

Definition at line 52 of file AlignableModifier.cc.

                                   {
   // Initialize all known parameters (according to ORCA's MisalignmentScenario.cc)
   distribution_ = "";           // Switch for distributions ("fixed","flat","gaussian")
   setError_ = false;            // Apply alignment errors
   setRotations_ = true;         // Apply rotations
   setTranslations_ = true;      // Apply translations
   scale_ = 1.;                  // Scale to apply to all movements
   scaleError_ = 1.;             // Scale to apply to alignment errors
   phiX_ = 0.;                   // Rotation angle around X [rad]
   phiY_ = 0.;                   // Rotation angle around Y [rad]
   phiZ_ = 0.;                   // Rotation angle around Z [rad]
   phiXlocal_ = 0.;              // Local rotation angle around X [rad]
   phiYlocal_ = 0.;              // Local rotation angle around Y [rad]
   phiZlocal_ = 0.;              // Local rotation angle around Z [rad]
   dX_ = 0.;                     // X displacement [cm]
   dY_ = 0.;                     // Y displacement [cm]
   dZ_ = 0.;                     // Z displacement [cm]
   dXlocal_ = 0.;                // Local X displacement [cm]
   dYlocal_ = 0.;                // Local Y displacement [cm]
   dZlocal_ = 0.;                // Local Z displacement [cm]
   deformation_.first.clear();   // SurfaceDeformation: type
   deformation_.second.clear();  //SurfaceDeformation: parameter vector
   twist_ = 0.;                  // Twist angle [rad]
   shear_ = 0.;                  // Shear angle [rad]
  
   // These are set through 'distribution'
   random_ = true;    // Use random distributions
   gaussian_ = true;  // Use gaussian distribution (otherwise flat)
 }

References deformation_, distribution_, dX_, dXlocal_, dY_, dYlocal_, dZ_, dZlocal_, gaussian_, phiX_, phiXlocal_, phiY_, phiYlocal_, phiZ_, phiZlocal_, random_, scale_, scaleError_, setError_, setRotations_, setTranslations_, shear_, and twist_.

Referenced by modify().

◆ isPropagated()

bool AlignableModifier::isPropagated ( const std::string & parameterName ) const

Check if given parameter should be propagated.

Definition at line 84 of file AlignableModifier.cc.

                                                                          {
   if (parameterName == "distribution" || parameterName == "setError" || parameterName == "scaleError" ||
       parameterName == "setRotations" || parameterName == "setTranslations" || parameterName == "scale")
     return true;
  
   return false;
 }

Referenced by MisalignmentScenarioBuilder::propagateParameters_().

◆ modify()

bool AlignableModifier::modify	(	Alignable *	alignable,
		const edm::ParameterSet &	pSet
	)

Modify given set of alignables according to parameters.

All known parameters and defaults are defined here! Returns true if modification actually applied.

Definition at line 94 of file AlignableModifier.cc.

                                                                                 {
   // Initialize parameters
   this->init_();
   int rotX_ = 0, rotY_ = 0, rotZ_ = 0;  // To check correct backward compatibility
  
   // Reset counter
   m_modified = 0;
  
   // Retrieve parameters
   std::ostringstream error;
   std::vector<std::string> parameterNames = pSet.getParameterNames();
   for (std::vector<std::string>::iterator iParam = parameterNames.begin(); iParam != parameterNames.end(); ++iParam) {
     if ((*iParam) == "distribution")
       distribution_ = pSet.getParameter<std::string>(*iParam);
     else if ((*iParam) == "setError")
       setError_ = pSet.getParameter<bool>(*iParam);
     else if ((*iParam) == "setRotations")
       setRotations_ = pSet.getParameter<bool>(*iParam);
     else if ((*iParam) == "setTranslations")
       setTranslations_ = pSet.getParameter<bool>(*iParam);
     else if ((*iParam) == "scale")
       scale_ = pSet.getParameter<double>(*iParam);
     else if ((*iParam) == "scaleError")
       scaleError_ = pSet.getParameter<double>(*iParam);
     else if ((*iParam) == "phiX")
       phiX_ = pSet.getParameter<double>(*iParam);
     else if ((*iParam) == "phiY")
       phiY_ = pSet.getParameter<double>(*iParam);
     else if ((*iParam) == "phiZ")
       phiZ_ = pSet.getParameter<double>(*iParam);
     else if ((*iParam) == "dX")
       dX_ = pSet.getParameter<double>(*iParam);
     else if ((*iParam) == "dY")
       dY_ = pSet.getParameter<double>(*iParam);
     else if ((*iParam) == "dZ")
       dZ_ = pSet.getParameter<double>(*iParam);
     else if ((*iParam) == "dXlocal")
       dXlocal_ = pSet.getParameter<double>(*iParam);
     else if ((*iParam) == "dYlocal")
       dYlocal_ = pSet.getParameter<double>(*iParam);
     else if ((*iParam) == "dZlocal")
       dZlocal_ = pSet.getParameter<double>(*iParam);
     else if ((*iParam) == "twist")
       twist_ = pSet.getParameter<double>(*iParam);
     else if ((*iParam) == "shear")
       shear_ = pSet.getParameter<double>(*iParam);
     else if ((*iParam) == "localX") {
       phiXlocal_ = pSet.getParameter<double>(*iParam);
       rotX_++;
     } else if ((*iParam) == "localY") {
       phiYlocal_ = pSet.getParameter<double>(*iParam);
       rotY_++;
     } else if ((*iParam) == "localZ") {
       phiZlocal_ = pSet.getParameter<double>(*iParam);
       rotZ_++;
     } else if ((*iParam) == "phiXlocal") {
       phiXlocal_ = pSet.getParameter<double>(*iParam);
       rotX_++;
     } else if ((*iParam) == "phiYlocal") {
       phiYlocal_ = pSet.getParameter<double>(*iParam);
       rotY_++;
     } else if ((*iParam) == "phiZlocal") {
       phiZlocal_ = pSet.getParameter<double>(*iParam);
       rotZ_++;
     } else if ((*iParam) == "deformation") {
       const edm::ParameterSet deform(pSet.getParameter<edm::ParameterSet>(*iParam));
       deformation_.first = deform.getParameter<std::string>("type");
       deformation_.second = deform.getParameter<std::vector<double> >("parameters");
     } else if (pSet.existsAs<edm::ParameterSet>(*iParam)) {
       // Other PSets than 'deformation' must refer to hierarchy structures, i.e. their name
       // is a level name followed by 's' or ending with a digit (see
       // MisalignmentScenarioBuilder::getParameterSet_). Pitfall is to forget the trailing 's'!
       // 'Muon' is an especially allowed case used in MuonScenarioBuilder::moveMuon(..),
       //  also check that we do not have any mistyping like 'deformations' or 'deformation2'
       const auto lastCharacter = (iParam->empty() ? '_' : (*iParam)[iParam->size() - 1]);
       if ((lastCharacter != 's' && !isdigit(lastCharacter) && (*iParam) != "Muon") ||
           iParam->find("deformation") != std::string::npos) {
         throw cms::Exception("BadConfig") << "@SUB=AlignableModifier::modify(..):\n"
                                           << "I see parameter '" << *iParam << "' of type PSet, "
                                           << "but expect either 'deformation' or a level name "
                                           << "with 's' or a digit at the end.\n";
       }  // other PSets should now be hierarchy levels and thus be OK to ignore here
     } else {
       if (!error.str().length())
         error << "Unknown parameter name(s): ";
       error << " " << *iParam;
     }
   }
  
   // Check if both 'localN' and 'phiNlocal' have been used
   if (rotX_ == 2)
     throw cms::Exception("BadConfig") << "Found both localX and phiXlocal";
   if (rotY_ == 2)
     throw cms::Exception("BadConfig") << "Found both localY and phiYlocal";
   if (rotZ_ == 2)
     throw cms::Exception("BadConfig") << "Found both localZ and phiZlocal";
  
   // Check error
   if (error.str().length())
     throw cms::Exception("BadConfig") << error.str();
  
   // Decode distribution
   this->setDistribution(distribution_);
  
   //if (scale_) { NO! Different random sequence if only parts scale to zero!
  
   // Apply displacements
   if (std::abs(dX_) + std::abs(dY_) + std::abs(dZ_) > 0 && setTranslations_)
     this->moveAlignable(alignable, random_, gaussian_, scale_ * dX_, scale_ * dY_, scale_ * dZ_);
  
   // Apply local displacements
   if (std::abs(dXlocal_) + std::abs(dYlocal_) + std::abs(dZlocal_) > 0 && setTranslations_)
     this->moveAlignableLocal(alignable, random_, gaussian_, scale_ * dXlocal_, scale_ * dYlocal_, scale_ * dZlocal_);
  
   // Apply rotations
   if (std::abs(phiX_) + std::abs(phiY_) + std::abs(phiZ_) > 0 && setRotations_)
     this->rotateAlignable(alignable, random_, gaussian_, scale_ * phiX_, scale_ * phiY_, scale_ * phiZ_);
  
   // Apply local rotations
   if (std::abs(phiXlocal_) + std::abs(phiYlocal_) + std::abs(phiZlocal_) > 0 && setRotations_)
     this->rotateAlignableLocal(
         alignable, random_, gaussian_, scale_ * phiXlocal_, scale_ * phiYlocal_, scale_ * phiZlocal_);
  
   // Apply twist
   if (std::abs(twist_) > 0)
     edm::LogError("NotImplemented") << "Twist is not implemented yet";
  
   // Apply shear
   if (std::abs(shear_) > 0)
     edm::LogError("NotImplemented") << "Shear is not implemented yet";
  
   if (!deformation_.first.empty()) {
     this->addDeformation(alignable, deformation_, random_, gaussian_, scale_);
   }
  
   // Apply error - first add scale_ to error
   scaleError_ *= scale_;
   if (setError_ && scaleError_) {
     // Alignment Position Error for flat distribution: 1 sigma
     if (!gaussian_)
       scaleError_ *= 0.68;
  
     // Error on displacement
     if (std::abs(dX_) + std::abs(dY_) + std::abs(dZ_) > 0 && setTranslations_)
       this->addAlignmentPositionError(alignable, scaleError_ * dX_, scaleError_ * dY_, scaleError_ * dZ_);
  
     // Error on local displacements
     if (std::abs(dXlocal_) + std::abs(dYlocal_) + std::abs(dZlocal_) > 0 && setTranslations_)
       this->addAlignmentPositionErrorLocal(
           alignable, scaleError_ * dXlocal_, scaleError_ * dYlocal_, scaleError_ * dZlocal_);
  
     // Error on rotations
     if (std::abs(phiX_) + std::abs(phiY_) + std::abs(phiZ_) > 0 && setRotations_)
       this->addAlignmentPositionErrorFromRotation(
           alignable, scaleError_ * phiX_, scaleError_ * phiY_, scaleError_ * phiZ_);
  
     // Error on local rotations
     if (std::abs(phiXlocal_) + std::abs(phiYlocal_) + std::abs(phiZlocal_) > 0 && setRotations_)
       this->addAlignmentPositionErrorFromLocalRotation(
           alignable, scaleError_ * phiXlocal_, scaleError_ * phiYlocal_, scaleError_ * phiZlocal_);
     // Do we need to add any APE for deformations?
     // Probably we would do so if there wouldn't be data, but only MC to play with... ;-)
   }
   // } // end if (scale_)
  
   return (m_modified > 0);
 }

References funct::abs(), addAlignmentPositionError(), addAlignmentPositionErrorFromLocalRotation(), addAlignmentPositionErrorFromRotation(), addAlignmentPositionErrorLocal(), addDeformation(), deformation_, distribution_, dX_, dXlocal_, dY_, dYlocal_, dZ_, dZlocal_, relativeConstraints::error, Exception, edm::ParameterSet::existsAs(), gaussian_, edm::ParameterSet::getParameter(), edm::ParameterSet::getParameterNames(), init_(), m_modified, moveAlignable(), moveAlignableLocal(), phiX_, phiXlocal_, phiY_, phiYlocal_, phiZ_, phiZlocal_, random_, rotateAlignable(), rotateAlignableLocal(), scale_, scaleError_, setDistribution(), setError_, setRotations_, setTranslations_, shear_, AlCaHLTBitMon_QueryRunRegistry::string, and twist_.

Referenced by MisalignmentScenarioBuilder::decodeMovements_().

◆ moveAlignable()

void AlignableModifier::moveAlignable	(	Alignable *	alignable,
		bool	random,
		bool	gaussian,
		float	sigmaX,
		float	sigmaY,
		float	sigmaZ
	)

Move alignable in global space according to parameters.

If 'random' is false, the given movements are strictly applied. Otherwise, a random number is generated according to a gaussian or a flat distribution depending on 'gaussian'.

Definition at line 295 of file AlignableModifier.cc.

                                                                                                 {
   std::ostringstream message;
  
   // Get movement vector according to arguments
   GlobalVector moveV(sigmaX, sigmaY, sigmaZ);  // Default: fixed
   if (random) {
     std::vector<float> randomNumbers;
     message << "random ";
     if (gaussian) {
       randomNumbers = this->gaussianRandomVector(sigmaX, sigmaY, sigmaZ);
       message << "gaussian ";
     } else {
       randomNumbers = this->flatRandomVector(sigmaX, sigmaY, sigmaZ);
       message << "flat ";
     }
     moveV = GlobalVector(randomNumbers[0], randomNumbers[1], randomNumbers[2]);
   }
  
   message << " move with sigma " << sigmaX << " " << sigmaY << " " << sigmaZ;
  
   LogDebug("PrintArgs") << message.str();  // Arguments
  
   LogDebug("PrintMovement") << "applied displacement: " << moveV;  // Actual movements
   alignable->move(moveV);
   m_modified++;
 }

References flatRandomVector(), gaussianRandomVector(), LogDebug, m_modified, Alignable::move(), BeamSpotPI::sigmaX, BeamSpotPI::sigmaY, and BeamSpotPI::sigmaZ.

Referenced by modify(), MuonScenarioBuilder::moveChamberInSector(), and MuonScenarioBuilder::moveMuon().

◆ moveAlignableLocal()

void AlignableModifier::moveAlignableLocal	(	Alignable *	alignable,
		bool	random,
		bool	gaussian,
		float	sigmaX,
		float	sigmaY,
		float	sigmaZ
	)

Move alignable in local space according to parameters.

If 'random' is false, the given movements are strictly applied. Otherwise, a random number is generated according to a gaussian or a flat distribution depending on 'gaussian'.

Definition at line 326 of file AlignableModifier.cc.

                                                                                                 {
   std::ostringstream message;
  
   // Get movement vector according to arguments
   align::LocalVector moveV(sigmaX, sigmaY, sigmaZ);  // Default: fixed
   if (random) {
     std::vector<float> randomNumbers;
     message << "random ";
     if (gaussian) {
       randomNumbers = this->gaussianRandomVector(sigmaX, sigmaY, sigmaZ);
       message << "gaussian ";
     } else {
       randomNumbers = this->flatRandomVector(sigmaX, sigmaY, sigmaZ);
       message << "flat ";
     }
     moveV = align::LocalVector(randomNumbers[0], randomNumbers[1], randomNumbers[2]);
   }
  
   message << " move with sigma " << sigmaX << " " << sigmaY << " " << sigmaZ;
  
   LogDebug("PrintArgs") << message.str();  // Arguments
  
   LogDebug("PrintMovement") << "applied local displacement: " << moveV;  // Actual movements
   alignable->move(alignable->surface().toGlobal(moveV));
   m_modified++;
 }

References flatRandomVector(), gaussianRandomVector(), LogDebug, m_modified, Alignable::move(), BeamSpotPI::sigmaX, BeamSpotPI::sigmaY, BeamSpotPI::sigmaZ, Alignable::surface(), and AlignableSurface::toGlobal().

Referenced by modify().

◆ randomise()

void AlignableModifier::randomise	(	std::vector< double > &	rnd,
		bool	gaussian
	)		const

Randomise all entries in 'rnd':

either from gaussian with width rnd[i]
or from flat distribution between -rnd[i] and rnd[i]

Definition at line 514 of file AlignableModifier.cc.

                                                                              {
   for (unsigned int i = 0; i < rnd.size(); ++i) {
     if (rnd[i] < 0.) {
       edm::LogWarning("BadConfig") << " taking absolute value to randomise " << i;
       rnd[i] = std::abs(rnd[i]);
     }
  
     if (gaussian) {
       CLHEP::RandGauss aGaussObj(*theDRand48Engine, 0., rnd[i]);
       rnd[i] = aGaussObj.fire();
     } else {
       CLHEP::RandFlat aFlatObj(*theDRand48Engine, -rnd[i], rnd[i]);
       rnd[i] = aFlatObj.fire();
     }
   }
 }

References funct::abs(), mps_fire::i, and theDRand48Engine.

Referenced by addDeformation().

◆ rotateAlignable()

void AlignableModifier::rotateAlignable	(	Alignable *	alignable,
		bool	random,
		bool	gaussian,
		float	sigmaPhiX,
		float	sigmaPhiY,
		float	sigmaPhiZ
	)

Rotate alignable in global space according to parameters.

If 'random' is false, the given rotations are strictly applied. Otherwise, a random number is generated according to a gaussian or a flat distribution depending on 'gaussian'.

Definition at line 387 of file AlignableModifier.cc.

                                                                                                          {
   std::ostringstream message;
  
   // Get rotation vector according to arguments
   GlobalVector rotV(sigmaPhiX, sigmaPhiY, sigmaPhiZ);  // Default: fixed
   if (random) {
     std::vector<float> randomNumbers;
     message << "random ";
     if (gaussian) {
       randomNumbers = this->gaussianRandomVector(sigmaPhiX, sigmaPhiY, sigmaPhiZ);
       message << "gaussian ";
     } else {
       randomNumbers = flatRandomVector(sigmaPhiX, sigmaPhiY, sigmaPhiZ);
       message << "flat ";
     }
     rotV = GlobalVector(randomNumbers[0], randomNumbers[1], randomNumbers[2]);
   }
  
   message << "global rotation by angles " << sigmaPhiX << " " << sigmaPhiY << " " << sigmaPhiZ;
  
   LogDebug("PrintArgs") << message.str();  // Arguments
  
   LogDebug("PrintMovement") << "applied rotation angles: " << rotV;  // Actual movements
   if (std::abs(sigmaPhiX))
     alignable->rotateAroundGlobalX(rotV.x());
   if (std::abs(sigmaPhiY))
     alignable->rotateAroundGlobalY(rotV.y());
   if (std::abs(sigmaPhiZ))
     alignable->rotateAroundGlobalZ(rotV.z());
   m_modified++;
 }

References funct::abs(), flatRandomVector(), gaussianRandomVector(), LogDebug, m_modified, Alignable::rotateAroundGlobalX(), Alignable::rotateAroundGlobalY(), Alignable::rotateAroundGlobalZ(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by modify(), MuonScenarioBuilder::moveChamberInSector(), and MuonScenarioBuilder::moveMuon().

◆ rotateAlignableLocal()

void AlignableModifier::rotateAlignableLocal	(	Alignable *	alignable,
		bool	random,
		bool	gaussian,
		float	sigmaPhiX,
		float	sigmaPhiY,
		float	sigmaPhiZ
	)

Rotate alignable in local space according to parameters.

If 'random' is false, the given rotations are strictly applied. Otherwise, a random number is generated according to a gaussian or a flat distribution depending on 'gaussian'.

Definition at line 423 of file AlignableModifier.cc.

                                                                                                          {
   std::ostringstream message;
  
   // Get rotation vector according to arguments
   align::LocalVector rotV(sigmaPhiX, sigmaPhiY, sigmaPhiZ);  // Default: fixed
   if (random) {
     std::vector<float> randomNumbers;
     message << "random ";
     if (gaussian) {
       randomNumbers = this->gaussianRandomVector(sigmaPhiX, sigmaPhiY, sigmaPhiZ);
       message << "gaussian ";
     } else {
       randomNumbers = flatRandomVector(sigmaPhiX, sigmaPhiY, sigmaPhiZ);
       message << "flat ";
     }
     rotV = align::LocalVector(randomNumbers[0], randomNumbers[1], randomNumbers[2]);
   }
  
   message << "local rotation by angles " << sigmaPhiX << " " << sigmaPhiY << " " << sigmaPhiZ;
  
   LogDebug("PrintArgs") << message.str();  // Arguments
  
   LogDebug("PrintMovement") << "applied local rotation angles: " << rotV;  // Actual movements
   if (std::abs(sigmaPhiX))
     alignable->rotateAroundLocalX(rotV.x());
   if (std::abs(sigmaPhiY))
     alignable->rotateAroundLocalY(rotV.y());
   if (std::abs(sigmaPhiZ))
     alignable->rotateAroundLocalZ(rotV.z());
   m_modified++;
 }

References funct::abs(), flatRandomVector(), gaussianRandomVector(), LogDebug, m_modified, Alignable::rotateAroundLocalX(), Alignable::rotateAroundLocalY(), Alignable::rotateAroundLocalZ(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by modify().

◆ setDistribution()

void AlignableModifier::setDistribution ( const std::string & distr )

Decodes string and sets distribution accordingly ('fixed', 'flat' or 'gaussian').

Definition at line 263 of file AlignableModifier.cc.

                                                               {
   if (distr == "fixed")
     random_ = false;
   else if (distr == "flat") {
     random_ = true;
     gaussian_ = false;
   } else if (distr == "gaussian") {
     random_ = true;
     gaussian_ = true;
   }
 }

References gaussian_, and random_.

Referenced by modify().

◆ setSeed()

void AlignableModifier::setSeed ( long seed )

Resets the generator seed according to the argument.

If 'seed' is zero, asks RandomNumberGenerator service.

Definition at line 277 of file AlignableModifier.cc.

                                                {
   long m_seed;
  
   if (seed > 0)
     m_seed = seed;
   else {
     edm::Service<edm::RandomNumberGenerator> rng;
     m_seed = rng->mySeed();
   }
  
   LogDebug("PrintArgs") << "Setting generator seed to " << m_seed;
  
   theDRand48Engine->setSeed(m_seed);
 }

References LogDebug, edm::RandomNumberGenerator::mySeed(), fileCollector::seed, and theDRand48Engine.

Referenced by MuonScenarioBuilder::applyScenario(), and TrackerScenarioBuilder::applyScenario().

Member Data Documentation

◆ deformation_

DeformationMemberType AlignableModifier::deformation_

private

Definition at line 107 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ distribution_

std::string AlignableModifier::distribution_

private

Definition at line 98 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ dX_

double AlignableModifier::dX_

private

Definition at line 105 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ dXlocal_

double AlignableModifier::dXlocal_

private

Definition at line 106 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ dY_

double AlignableModifier::dY_

private

Definition at line 105 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ dYlocal_

double AlignableModifier::dYlocal_

private

Definition at line 106 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ dZ_

double AlignableModifier::dZ_

private

Definition at line 105 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ dZlocal_

double AlignableModifier::dZlocal_

private

Definition at line 106 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ gaussian_

bool AlignableModifier::gaussian_

private

Definition at line 99 of file AlignableModifier.h.

Referenced by init_(), modify(), and setDistribution().

◆ m_modified

int AlignableModifier::m_modified

private

Definition at line 95 of file AlignableModifier.h.

Referenced by addDeformation(), modify(), moveAlignable(), moveAlignableLocal(), rotateAlignable(), and rotateAlignableLocal().

◆ phiX_

double AlignableModifier::phiX_

private

Definition at line 103 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ phiXlocal_

double AlignableModifier::phiXlocal_

private

Definition at line 104 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ phiY_

double AlignableModifier::phiY_

private

Definition at line 103 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ phiYlocal_

double AlignableModifier::phiYlocal_

private

Definition at line 104 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ phiZ_

double AlignableModifier::phiZ_

private

Definition at line 103 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ phiZlocal_

double AlignableModifier::phiZlocal_

private

Definition at line 104 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ random_

bool AlignableModifier::random_

private

Definition at line 99 of file AlignableModifier.h.

Referenced by init_(), modify(), and setDistribution().

◆ scale_

double AlignableModifier::scale_

private

Definition at line 102 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ scaleError_

double AlignableModifier::scaleError_

private

Definition at line 102 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ seed_

long AlignableModifier::seed_

private

Definition at line 101 of file AlignableModifier.h.

◆ setError_

bool AlignableModifier::setError_

private

Definition at line 99 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ setRotations_

bool AlignableModifier::setRotations_

private

Definition at line 100 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ setTranslations_

bool AlignableModifier::setTranslations_

private

Definition at line 100 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ shear_

double AlignableModifier::shear_

private

Definition at line 108 of file AlignableModifier.h.

Referenced by init_(), and modify().

◆ theDRand48Engine

CLHEP::DRand48Engine* AlignableModifier::theDRand48Engine

private

Unique random number generator.

Definition at line 90 of file AlignableModifier.h.

Referenced by AlignableModifier(), flatRandomVector(), gaussianRandomVector(), randomise(), setSeed(), and ~AlignableModifier().

◆ twist_

double AlignableModifier::twist_

private

Definition at line 108 of file AlignableModifier.h.

Referenced by init_(), and modify().

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DeformationMemberType

Constructor & Destructor Documentation

◆ AlignableModifier()

◆ ~AlignableModifier()

Member Function Documentation

◆ addAlignmentPositionError()

◆ addAlignmentPositionErrorFromLocalRotation() [1/2]

◆ addAlignmentPositionErrorFromLocalRotation() [2/2]

◆ addAlignmentPositionErrorFromRotation() [1/2]

◆ addAlignmentPositionErrorFromRotation() [2/2]

◆ addAlignmentPositionErrorLocal()

◆ addDeformation()

◆ flatRandomVector()

◆ gaussianRandomVector()

◆ init_()

◆ isPropagated()

◆ modify()

◆ moveAlignable()

◆ moveAlignableLocal()

◆ randomise()

◆ rotateAlignable()

◆ rotateAlignableLocal()

◆ setDistribution()

◆ setSeed()

Member Data Documentation

◆ deformation_

◆ distribution_

◆ dX_

◆ dXlocal_

◆ dY_

◆ dYlocal_

◆ dZ_

◆ dZlocal_

◆ gaussian_

◆ m_modified

◆ phiX_

◆ phiXlocal_

◆ phiY_

◆ phiYlocal_

◆ phiZ_

◆ phiZlocal_

◆ random_

◆ scale_

◆ scaleError_

◆ seed_

◆ setError_

◆ setRotations_

◆ setTranslations_

◆ shear_

◆ theDRand48Engine

◆ twist_