#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, float phiX, float phiY, float phiZ)
	Add alignment position error resulting from rotation in local frame. More...

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

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

void	addAlignmentPositionErrorFromRotation (Alignable *alignable, align::RotationType &)
	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.

References theDRand48Engine.

     : 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();
 }

◆ ~AlignableModifier()

AlignableModifier::~AlignableModifier ( )

Destructor.

Definition at line 49 of file AlignableModifier.cc.

References theDRand48Engine.

49 { delete theDRand48Engine; }

AlignableModifier::theDRand48Engine

CLHEP::DRand48Engine * theDRand48Engine

Unique random number generator.

Definition: AlignableModifier.h:90

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.

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

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

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

◆ addAlignmentPositionErrorFromLocalRotation() [1/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.

References makeMuonMisalignmentScenario::rot.

Referenced by modify().

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

◆ addAlignmentPositionErrorFromLocalRotation() [2/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.

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

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

◆ addAlignmentPositionErrorFromRotation() [1/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.

References makeMuonMisalignmentScenario::rot.

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

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

◆ addAlignmentPositionErrorFromRotation() [2/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.

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

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

◆ 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.

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().

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

◆ addDeformation()

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

private

Definition at line 355 of file AlignableModifier.cc.

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

Referenced by modify().

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

◆ 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.

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().

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

◆ 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.

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().

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

◆ init_()

void AlignableModifier::init_ ( void )

private

Initialisation of all parameters.

Definition at line 52 of file AlignableModifier.cc.

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().

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

◆ isPropagated()

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

Check if given parameter should be propagated.

Definition at line 84 of file AlignableModifier.cc.

Referenced by MisalignmentScenarioBuilder::propagateParameters_().

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

◆ 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.

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_().

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

◆ 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.

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

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

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

◆ 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.

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

Referenced by modify().

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

◆ 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.

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

Referenced by addDeformation().

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

◆ 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.

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().

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

◆ 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.

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().

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

◆ 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.

References gaussian_, and random_.

Referenced by modify().

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

◆ 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.

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

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

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

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_