AlignmentParameterStore Class Reference

#include <AlignmentParameterStore.h>

Public Types
typedef std::map< std::pair< Alignable *, Alignable * >, AlgebraicMatrix >	Correlations
typedef std::vector< unsigned int >	DetIds
typedef std::pair< Alignable *, unsigned int >	ParameterId
	a single alignable parameter of an Alignable More...
typedef std::vector< AlignmentParameters * >	Parameters

Public Member Functions
void	acquireRelativeParameters (void)
Alignable *	alignableFromAlignableDet (const AlignableDetOrUnitPtr &alignableDet) const
	Obsolete: Use AlignableNavigator::alignableDetFromGeomDet and alignableFromAlignableDet. More...
const align::Alignables &	alignables (void) const
	get all alignables More...
	AlignmentParameterStore (const align::Alignables &alis, const edm::ParameterSet &config)
	constructor More...
void	applyAlignableAbsolutePositions (const align::Alignables &alis, const AlignablePositions &newpos, int &ierr)
	apply absolute positions to alignables More...
void	applyAlignableRelativePositions (const align::Alignables &alivec, const AlignableShifts &shifts, int &ierr)
	apply relative shifts to alignables More...
void	applyParameters (void)
	Obsolete: Use AlignableNavigator::alignableDetFromDetId and alignableFromAlignableDet. More...
void	applyParameters (Alignable *alignable)
	apply parameters of a given alignable More...
void	attachAlignmentParameters (const align::Alignables &alivec, const Parameters &parvec, int &ierr)
	Attach alignment parameters to given alignables. More...
void	attachAlignmentParameters (const Parameters &parvec, int &ierr)
	Attach alignment parameters to alignables. More...
void	attachCorrelations (const align::Alignables &alivec, const Correlations &cormap, bool overwrite, int &ierr)
	Attach correlations to given alignables. More...
void	attachCorrelations (const Correlations &cormap, bool overwrite, int &ierr)
	Attach correlations to alignables. More...
void	attachUserVariables (const align::Alignables &alivec, const std::vector< AlignmentUserVariables *> &uvarvec, int &ierr)
	Attach User Variables to given alignables. More...
void	cacheTransformations (void)
	cache the current position, rotation and other parameters More...
void	cacheTransformations (const align::RunNumber &)
	cache for the given run the current position, rotation and other parameters More...
AlignmentCorrelationsStore *	correlationsStore (void) const
	get full correlation map More...
bool	hierarchyConstraints (const Alignable *aliMaster, const align::Alignables &aliComps, std::vector< std::vector< ParameterId > > &paramIdsVecOut, std::vector< std::vector< double > > &factorsVecOut, bool all, double epsilon) const
const unsigned int	numCorrelations (void) const
	get number of correlations between alignables More...
int	numObjects (void) const
	returns number of alignables More...
void	resetParameters (void)
	reset parameters, correlations, user variables More...
void	resetParameters (Alignable *ali)
	reset parameters of a given alignable More...
void	restoreCachedTransformations (void)
	restore the previously cached position, rotation and other parameters More...
void	restoreCachedTransformations (const align::RunNumber &)
	restore for the given run the previously cached position, rotation and other parameters More...
CompositeAlignmentParameters	selectParameters (const std::vector< AlignableDet *> &alignabledets) const
CompositeAlignmentParameters	selectParameters (const std::vector< AlignableDetOrUnitPtr > &alignabledets) const
	select parameters More...
CompositeAlignmentParameters	selectParameters (const align::Alignables &) const
	select parameters More...
void	setAlignmentPositionError (const align::Alignables &alivec, double valshift, double valrot)
	Set Alignment position error. More...
std::pair< int, int >	typeAndLayer (const Alignable *ali, const TrackerTopology *tTopo) const
	Obtain type and layer from Alignable. More...
void	updateParameters (const CompositeAlignmentParameters &aap, bool updateCorrelations=true)
	update parameters More...
align::Alignables	validAlignables (void) const
	get all alignables with valid parameters More...
virtual	~AlignmentParameterStore ()
	destructor More...

Protected Attributes
AlignmentCorrelationsStore *	theCorrelationsStore

Private Types
enum	TypeOfConstraints { NONE, HIERARCHY_CONSTRAINTS, APPROX_AVERAGING_CONSTRAINTS }

Private Attributes
align::Alignables	theAlignables
	alignables More...
TypeOfConstraints	theTypeOfConstraints
	type of constraints More...

Detailed Description

Basic class for management of alignment parameters and correlations

Date

2011/05/23 20:50:31

Revision

1.19

(last update by

Author

mussgill

)

Definition at line 23 of file AlignmentParameterStore.h.

Member Typedef Documentation

Correlations

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

Definition at line 26 of file AlignmentParameterStore.h.

DetIds

typedef std::vector<unsigned int> AlignmentParameterStore::DetIds

Definition at line 27 of file AlignmentParameterStore.h.

ParameterId

typedef std::pair<Alignable*, unsigned int> AlignmentParameterStore::ParameterId

a single alignable parameter of an Alignable

Definition at line 128 of file AlignmentParameterStore.h.

Parameters

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

Definition at line 25 of file AlignmentParameterStore.h.

Member Enumeration Documentation

TypeOfConstraints

enum AlignmentParameterStore::TypeOfConstraints

private

Enumerator
NONE
HIERARCHY_CONSTRAINTS
APPROX_AVERAGING_CONSTRAINTS

Definition at line 156 of file AlignmentParameterStore.h.

{ NONE, HIERARCHY_CONSTRAINTS, APPROX_AVERAGING_CONSTRAINTS };

Constructor & Destructor Documentation

AlignmentParameterStore()

AlignmentParameterStore::AlignmentParameterStore	(	const align::Alignables &	alis,
		const edm::ParameterSet &	config
	)

constructor

Definition at line 29 of file AlignmentParameterStore.cc.

References APPROX_AVERAGING_CONSTRAINTS, HIERARCHY_CONSTRAINTS, NONE, AlCaHLTBitMon_QueryRunRegistry::string, theAlignables, theCorrelationsStore, and theTypeOfConstraints.

    : theAlignables(alis) {
  if (config.getUntrackedParameter<bool>("UseExtendedCorrelations")) {
    theCorrelationsStore =
        new AlignmentExtendedCorrelationsStore(config.getParameter<edm::ParameterSet>("ExtendedCorrelationsConfig"));
  } else {
    theCorrelationsStore = new AlignmentCorrelationsStore();
  }

  edm::LogInfo("Alignment") << "@SUB=AlignmentParameterStore"
                            << "Created with " << theAlignables.size() << " alignables.";

  // set hierarchy vs averaging constraints
  theTypeOfConstraints = NONE;
  const std::string cfgStrTypeOfConstraints(config.getParameter<std::string>("TypeOfConstraints"));
  if (cfgStrTypeOfConstraints == "hierarchy") {
    theTypeOfConstraints = HIERARCHY_CONSTRAINTS;
  } else if (cfgStrTypeOfConstraints == "approximate_averaging") {
    theTypeOfConstraints = APPROX_AVERAGING_CONSTRAINTS;
    edm::LogWarning("Alignment")
        << "@SUB=AlignmentParameterStore"
        << "\n\n\n******* WARNING ******************************************\n"
        << "Using approximate implementation of averaging constraints."
        << "This is not recommended."
        << "Consider to use 'hierarchy' constraints:"
        << "  AlignmentProducer.ParameterStore.TypeOfConstraints = cms.string('hierarchy')\n\n\n";
  } else {
    edm::LogError("BadArgument") << "@SUB=AlignmentParameterStore"
                                 << "Unknown type of hierarchy constraints '" << cfgStrTypeOfConstraints << "'";
  }
}

~AlignmentParameterStore()

AlignmentParameterStore::~AlignmentParameterStore ( )

virtual

destructor

Definition at line 62 of file AlignmentParameterStore.cc.

References theCorrelationsStore.

{ delete theCorrelationsStore; }

Member Function Documentation

acquireRelativeParameters()

void AlignmentParameterStore::acquireRelativeParameters

(

void

)

acquire shifts/rotations from alignables of the store and copy into alignment parameters (local frame)

Definition at line 329 of file AlignmentParameterStore.cc.

References Alignable::alignmentParameters(), RigidBodyAlignmentParameters::clone(), Alignable::displacement(), Exception, mps_fire::i, Alignable::rotation(), Alignable::setAlignmentParameters(), AlignmentParameters::size(), Alignable::surface(), theAlignables, align::toAngles(), AlignableSurface::toLocal(), TkRotation< T >::x(), and Basic3DVector< T >::y().

                                                            {
  unsigned int nAlignables = theAlignables.size();

  for (unsigned int i = 0; i < nAlignables; ++i) {
    Alignable* ali = theAlignables[i];

    RigidBodyAlignmentParameters* ap = dynamic_cast<RigidBodyAlignmentParameters*>(ali->alignmentParameters());

    if (!ap)
      throw cms::Exception("BadAlignable") << "acquireRelativeParameters: "
                                           << "provided alignable does not have rigid body alignment parameters";

    AlgebraicVector par(ap->size(), 0);
    AlgebraicSymMatrix cov(ap->size(), 0);

    // Get displacement and transform global->local
    align::LocalVector dloc = ali->surface().toLocal(ali->displacement());
    par[0] = dloc.x();
    par[1] = dloc.y();
    par[2] = dloc.z();

    // Transform to local euler angles
    align::EulerAngles euloc = align::toAngles(ali->surface().toLocal(ali->rotation()));
    par[3] = euloc(1);
    par[4] = euloc(2);
    par[5] = euloc(3);

    // Clone parameters
    RigidBodyAlignmentParameters* apnew = ap->clone(par, cov);

    ali->setAlignmentParameters(apnew);
  }
}

alignableFromAlignableDet()

Alignable * AlignmentParameterStore::alignableFromAlignableDet

(

const AlignableDetOrUnitPtr &

alignableDet

)

const

Obsolete: Use AlignableNavigator::alignableDetFromGeomDet and alignableFromAlignableDet.

get Alignable corresponding to given AlignableDet (non-const ref. argument since might be returned)

Definition at line 242 of file AlignmentParameterStore.cc.

References Alignable::alignmentParameters(), and Alignable::mother().

Referenced by selectParameters().

                                                                                                              {
  AlignableDetOrUnitPtr alignableDet = _alignableDet;
  Alignable* mother = alignableDet;
  while (mother) {
    if (mother->alignmentParameters())
      return mother;
    mother = mother->mother();
  }

  return nullptr;
}

alignables()

const align::Alignables& AlignmentParameterStore::alignables ( void  ) const

inline

get all alignables

Definition at line 47 of file AlignmentParameterStore.h.

References theAlignables.

Referenced by AlignmentMonitorSurvey::book(), AlignmentMonitorGeneric::book(), AlignmentMonitorTemplate::book(), PedeSteerer::buildSubSteer(), SurveyAlignmentAlgorithm::initialize(), HIPAlignmentAlgorithm::initialize(), CSCOverlapsAlignmentAlgorithm::initialize(), MillePedeAlignmentAlgorithm::initialize(), MuonAlignmentFromReference::initialize(), selectParameters(), and updateParameters().

{ return theAlignables; }

applyAlignableAbsolutePositions()

void AlignmentParameterStore::applyAlignableAbsolutePositions	(	const align::Alignables &	alis,
		const AlignablePositions &	newpos,
		int &	ierr
	)

apply absolute positions to alignables

Definition at line 373 of file AlignmentParameterStore.cc.

References Alignable::addSurfaceDeformation(), Alignable::alignableObjectId(), SurfaceDeformationFactory::create(), isotrackApplyRegressor::dtype, newFWLiteAna::found, Alignable::globalPosition(), Alignable::globalRotation(), mps_fire::i, Alignable::id(), SurfaceDeformationFactory::kNoDeformations, LogDebug, Alignable::move(), TkRotation< T >::multiplyInverse(), SurfaceDeformation::parameters(), align::rectify(), TkRotation< T >::rot, Alignable::rotateInGlobalFrame(), Alignable::surfaceDeformationIdPairs(), SurfaceDeformationFactory::surfaceDeformationTypeName(), and SurfaceDeformation::type().

Referenced by HIPAlignmentAlgorithm::startNewLoop().

                                                                         {
  unsigned int nappl = 0;
  ierr = 0;

  // Iterate over list of alignables
  for (align::Alignables::const_iterator iali = alivec.begin(); iali != alivec.end(); ++iali) {
    Alignable* ali = *iali;
    align::ID id = ali->id();
    align::StructureType typeId = ali->alignableObjectId();

    // Find corresponding entry in AlignablePositions
    bool found = false;
    for (AlignablePositions::const_iterator ipos = newpos.begin(); ipos != newpos.end(); ++ipos) {
      if (id == ipos->id() && typeId == ipos->objId()) {
        if (found) {
          edm::LogError("DuplicatePosition") << "New positions for alignable found more than once!";
        } else {
          // New position/rotation
          const align::PositionType& pnew = ipos->pos();
          const align::RotationType& rnew = ipos->rot();
          const std::vector<double>& dnew = ipos->deformationParameters();
          // Current position / rotation
          const align::PositionType& pold = ali->globalPosition();
          const align::RotationType& rold = ali->globalRotation();
          // Current surf. deformation
          std::vector<std::pair<int, SurfaceDeformation*> > dold_id_pairs;
          SurfaceDeformation* dold_obj = nullptr;
          SurfaceDeformationFactory::Type dtype = SurfaceDeformationFactory::kNoDeformations;
          std::vector<double> dold;
          if (1 == ali->surfaceDeformationIdPairs(dold_id_pairs)) {  // might not have any...
            dold_obj = dold_id_pairs[0].second;
            dold = dold_obj->parameters();
            dtype = (SurfaceDeformationFactory::Type)dold_obj->type();
          }

          // shift needed to move from current to new position
          align::GlobalVector posDiff = pnew - pold;
          align::RotationType rotDiff = rold.multiplyInverse(rnew);
          align::rectify(rotDiff);  // correct for rounding errors
          ali->move(posDiff);
          ali->rotateInGlobalFrame(rotDiff);
          LogDebug("NewPosition") << "moving by:" << posDiff;
          LogDebug("NewRotation") << "rotating by:\n" << rotDiff;

          // add the surface deformations
          // If an old surface deformation record exists, ensure that the added deformation has the same type and size.
          if (!dold.empty() && dtype != SurfaceDeformationFactory::kNoDeformations && dnew.size() == dold.size()) {
            std::vector<double> defDiff;
            defDiff.reserve(dold.size());
            for (unsigned int i = 0; i < dold.size(); i++)
              defDiff.push_back(dnew[i] - dold[i]);
            auto deform = SurfaceDeformationFactory::create(dtype, defDiff);
            edm::LogInfo("Alignment") << "@SUB=AlignmentParameterStore::applyAlignableAbsolutePositions"
                                      << "Adding surface deformation of type "
                                      << SurfaceDeformationFactory::surfaceDeformationTypeName(
                                             (SurfaceDeformationFactory::Type)deform->type())
                                      << ", size " << defDiff.size() << " and first element " << defDiff.at(0)
                                      << " to alignable with id / type: " << id << " / " << typeId;
            ali->addSurfaceDeformation(deform, true);
            delete deform;
          }
          // In case no old surface deformation record exists, only ensure that the new surface deformation record has size>0. Size check is done elsewhere.
          else if (!dnew.empty()) {
            auto deform = SurfaceDeformationFactory::create(dnew);
            edm::LogInfo("Alignment") << "@SUB=AlignmentParameterStore::applyAlignableAbsolutePositions"
                                      << "Setting surface deformation of type "
                                      << SurfaceDeformationFactory::surfaceDeformationTypeName(
                                             (SurfaceDeformationFactory::Type)deform->type())
                                      << ", size " << dnew.size() << " and first element " << dnew.at(0)
                                      << " to alignable with id / type: " << id << " / " << typeId;
            ali->addSurfaceDeformation(deform, true);  // Equivalent to setSurfaceDeformation in this case
            delete deform;
          }
          // If there is no new surface deformation record, do nothing.

          // add position error
          // AlignmentPositionError ape(shift.x(),shift.y(),shift.z());
          // (*iali)->addAlignmentPositionError(ape);
          // (*iali)->addAlignmentPositionErrorFromRotation(rot);

          found = true;
          ++nappl;
        }
      }
    }
  }

  if (nappl < newpos.size())
    edm::LogError("Mismatch") << "Applied only " << nappl << " new positions"
                              << " out of " << newpos.size();

  LogDebug("NewPositions") << "Applied new positions for " << nappl << " out of " << alivec.size() << " alignables.";
}

applyAlignableRelativePositions()

void AlignmentParameterStore::applyAlignableRelativePositions	(	const align::Alignables &	alivec,
		const AlignableShifts &	shifts,
		int &	ierr
	)

apply relative shifts to alignables

Definition at line 470 of file AlignmentParameterStore.cc.

References Alignable::addSurfaceDeformation(), Alignable::alignableObjectId(), SurfaceDeformationFactory::create(), isotrackApplyRegressor::dtype, newFWLiteAna::found, mps_fire::i, Alignable::id(), SurfaceDeformationFactory::kNoDeformations, LogDebug, Alignable::move(), SurfaceDeformation::parameters(), Alignable::rotateInGlobalFrame(), Alignable::surfaceDeformationIdPairs(), SurfaceDeformationFactory::surfaceDeformationTypeName(), and SurfaceDeformation::type().

                                                                         {
  ierr = 0;
  unsigned int nappl = 0;
  unsigned int nAlignables = alivec.size();

  for (unsigned int i = 0; i < nAlignables; ++i) {
    Alignable* ali = alivec[i];

    align::ID id = ali->id();
    align::StructureType typeId = ali->alignableObjectId();

    // Find corresponding entry in AlignableShifts
    bool found = false;
    for (AlignableShifts::const_iterator ipos = shifts.begin(); ipos != shifts.end(); ++ipos) {
      if (id == ipos->id() && typeId == ipos->objId()) {
        if (found) {
          edm::LogError("DuplicatePosition") << "New positions for alignable found more than once!";
        } else {
          // Current surf. deformation
          std::vector<std::pair<int, SurfaceDeformation*> > dold_id_pairs;
          SurfaceDeformation* dold_obj = nullptr;
          SurfaceDeformationFactory::Type dtype = SurfaceDeformationFactory::kNoDeformations;
          std::vector<double> dold;
          if (1 == ali->surfaceDeformationIdPairs(dold_id_pairs)) {  // might not have any...
            dold_obj = dold_id_pairs[0].second;
            dold = dold_obj->parameters();
            dtype = (SurfaceDeformationFactory::Type)dold_obj->type();
          }

          ali->move(ipos->pos());
          ali->rotateInGlobalFrame(ipos->rot());

          const std::vector<double>& defDiff = ipos->deformationParameters();
          // If an old surface deformation record exists, ensure that the added deformation has the same type and size.
          if (!dold.empty() && dtype != SurfaceDeformationFactory::kNoDeformations && defDiff.size() == dold.size()) {
            auto deform = SurfaceDeformationFactory::create(dtype, defDiff);
            edm::LogInfo("Alignment") << "@SUB=AlignmentParameterStore::applyAlignableRelativePositions"
                                      << "Adding surface deformation of type "
                                      << SurfaceDeformationFactory::surfaceDeformationTypeName(
                                             (SurfaceDeformationFactory::Type)deform->type())
                                      << ", size " << defDiff.size() << " and first element " << defDiff.at(0)
                                      << " to alignable with id / type: " << id << " / " << typeId;
            ali->addSurfaceDeformation(deform, true);
            delete deform;
          }
          // In case no old surface deformation record exists, only ensure that the new surface deformation record has size>0. Size check is done elsewhere.
          else if (!defDiff.empty()) {
            auto deform = SurfaceDeformationFactory::create(defDiff);
            edm::LogInfo("Alignment") << "@SUB=AlignmentParameterStore::applyAlignableRelativePositions"
                                      << "Setting surface deformation of type "
                                      << SurfaceDeformationFactory::surfaceDeformationTypeName(
                                             (SurfaceDeformationFactory::Type)deform->type())
                                      << ", size " << defDiff.size() << " and first element " << defDiff.at(0)
                                      << " to alignable with id / type: " << id << " / " << typeId;
            ali->addSurfaceDeformation(deform, true);  // Equivalent to setSurfaceDeformation in this case
            delete deform;
          }
          // If there is no new surface deformation record, do nothing.

          // Add position error
          //AlignmentPositionError ape(pnew.x(),pnew.y(),pnew.z());
          //ali->addAlignmentPositionError(ape);
          //ali->addAlignmentPositionErrorFromRotation(rnew);

          found = true;
          ++nappl;
        }
      }
    }
  }

  if (nappl < shifts.size())
    edm::LogError("Mismatch") << "Applied only " << nappl << " new positions"
                              << " out of " << shifts.size();

  LogDebug("NewPositions") << "Applied new positions for " << nappl << " alignables.";
}

applyParameters() [1/2]

void AlignmentParameterStore::applyParameters

(

void

)

Obsolete: Use AlignableNavigator::alignableDetFromDetId and alignableFromAlignableDet.

apply all valid parameters to their alignables

Definition at line 255 of file AlignmentParameterStore.cc.

References theAlignables.

Referenced by CSCAlignmentCorrections::applyAlignment(), MuonAlignmentFromReference::fitAndAlign(), MillePedeAlignmentAlgorithm::initialize(), CSCChamberFitter::radiusCorrection(), MillePedeAlignmentAlgorithm::setParametersForRunRange(), and HIPAlignmentAlgorithm::terminate().

                                                  {
  align::Alignables::const_iterator iali;
  for (iali = theAlignables.begin(); iali != theAlignables.end(); ++iali)
    applyParameters(*iali);
}

applyParameters() [2/2]

void AlignmentParameterStore::applyParameters

(

Alignable *

alignable

)

apply parameters of a given alignable

Definition at line 262 of file AlignmentParameterStore.cc.

References Alignable::alignmentParameters(), AlignmentParameters::apply(), and Exception.

                                                                  {
  AlignmentParameters* pars = (alignable ? alignable->alignmentParameters() : nullptr);
  if (!pars) {
    throw cms::Exception("BadAlignable") << "applyParameters: provided alignable does not have alignment parameters";
  }
  pars->apply();
}

attachAlignmentParameters() [1/2]

void AlignmentParameterStore::attachAlignmentParameters	(	const align::Alignables &	alivec,
		const Parameters &	parvec,
		int &	ierr
	)

Attach alignment parameters to given alignables.

Definition at line 556 of file AlignmentParameterStore.cc.

References AlignmentParameters::alignable(), newFWLiteAna::found, and LogDebug.

Referenced by attachAlignmentParameters().

                                                                   {
  int ipass = 0;
  int ifail = 0;
  ierr = 0;

  // Iterate over alignables
  for (align::Alignables::const_iterator iali = alivec.begin(); iali != alivec.end(); ++iali) {
    // Iterate over Parameters
    bool found = false;
    for (Parameters::const_iterator ipar = parvec.begin(); ipar != parvec.end(); ++ipar) {
      // Get new alignment parameters
      AlignmentParameters* ap = *ipar;

      // Check if parameters belong to alignable
      if (ap->alignable() == (*iali)) {
        if (!found) {
          (*iali)->setAlignmentParameters(ap);
          ++ipass;
          found = true;
        } else
          edm::LogError("Alignment") << "@SUB=AlignmentParameterStore::attachAlignmentParameters"
                                     << "More than one parameters for Alignable.";
      }
    }
    if (!found)
      ++ifail;
  }
  if (ifail > 0)
    ierr = -1;

  LogDebug("attachAlignmentParameters") << " Parameters, Alignables: " << parvec.size() << "," << alivec.size()
                                        << "\n pass,fail: " << ipass << "," << ifail;
}

attachAlignmentParameters() [2/2]

void AlignmentParameterStore::attachAlignmentParameters	(	const Parameters &	parvec,
		int &	ierr
	)

Attach alignment parameters to alignables.

Definition at line 551 of file AlignmentParameterStore.cc.

References attachAlignmentParameters(), and theAlignables.

                                                                                           {
  attachAlignmentParameters(theAlignables, parvec, ierr);
}

attachCorrelations() [1/2]

void AlignmentParameterStore::attachCorrelations	(	const align::Alignables &	alivec,
		const Correlations &	cormap,
		bool	overwrite,
		int &	ierr
	)

Attach correlations to given alignables.

Definition at line 598 of file AlignmentParameterStore.cc.

References AlignmentCorrelationsStore::correlationsAvailable(), spr::find(), LogDebug, AlignmentCorrelationsStore::setCorrelations(), and theCorrelationsStore.

Referenced by attachCorrelations().

                                                            {
  ierr = 0;
  int icount = 0;

  // Iterate over correlations
  for (Correlations::const_iterator icor = cormap.begin(); icor != cormap.end(); ++icor) {
    AlgebraicMatrix mat = (*icor).second;
    Alignable* ali1 = (*icor).first.first;
    Alignable* ali2 = (*icor).first.second;

    // Check if alignables exist
    if (find(alivec.begin(), alivec.end(), ali1) != alivec.end() &&
        find(alivec.begin(), alivec.end(), ali2) != alivec.end()) {
      // Check if correlations already existing between these alignables
      if (!theCorrelationsStore->correlationsAvailable(ali1, ali2) || (overwrite)) {
        theCorrelationsStore->setCorrelations(ali1, ali2, mat);
        ++icount;
      } else
        edm::LogInfo("AlreadyExists") << "Correlation existing and not overwritten";
    } else
      edm::LogInfo("IgnoreCorrelation") << "Ignoring correlation with no alignables!";
  }

  LogDebug("attachCorrelations") << " Alignables,Correlations: " << alivec.size() << "," << cormap.size()
                                 << "\n applied: " << icount;
}

attachCorrelations() [2/2]

void AlignmentParameterStore::attachCorrelations	(	const Correlations &	cormap,
		bool	overwrite,
		int &	ierr
	)

Attach correlations to alignables.

Definition at line 593 of file AlignmentParameterStore.cc.

References attachCorrelations(), and theAlignables.

                                                                                                      {
  attachCorrelations(theAlignables, cormap, overwrite, ierr);
}

attachUserVariables()

void AlignmentParameterStore::attachUserVariables	(	const align::Alignables &	alivec,
		const std::vector< AlignmentUserVariables *> &	uvarvec,
		int &	ierr
	)

Attach User Variables to given alignables.

Definition at line 629 of file AlignmentParameterStore.cc.

References LogDebug, and AlignmentParameters::setUserVariables().

Referenced by HIPAlignmentAlgorithm::collector().

                                                             {
  ierr = 0;

  LogDebug("DumpArguments") << "size of alivec:   " << alivec.size() << "\nsize of uvarvec: " << uvarvec.size();

  std::vector<AlignmentUserVariables*>::const_iterator iuvar = uvarvec.begin();

  for (align::Alignables::const_iterator iali = alivec.begin(); iali != alivec.end(); ++iali, ++iuvar) {
    AlignmentParameters* ap = (*iali)->alignmentParameters();
    AlignmentUserVariables* uvarnew = (*iuvar);
    ap->setUserVariables(uvarnew);
  }
}

cacheTransformations() [1/2]

void AlignmentParameterStore::cacheTransformations

(

void

)

cache the current position, rotation and other parameters

Definition at line 303 of file AlignmentParameterStore.cc.

References theAlignables.

Referenced by MillePedeAlignmentAlgorithm::beginRun(), and MillePedeAlignmentAlgorithm::terminate().

                                                       {
  align::Alignables::const_iterator iali;
  for (iali = theAlignables.begin(); iali != theAlignables.end(); ++iali)
    (*iali)->cacheTransformation();
}

cacheTransformations() [2/2]

void AlignmentParameterStore::cacheTransformations

(

const align::RunNumber &

run

)

cache for the given run the current position, rotation and other parameters

Definition at line 310 of file AlignmentParameterStore.cc.

References writedatasetfile::run, and theAlignables.

                                                                            {
  for (const auto& iali : theAlignables)
    iali->cacheTransformation(run);
}

correlationsStore()

AlignmentCorrelationsStore* AlignmentParameterStore::correlationsStore ( void  ) const

inline

get full correlation map

Definition at line 56 of file AlignmentParameterStore.h.

References theCorrelationsStore.

{ return theCorrelationsStore; }

hierarchyConstraints()

bool AlignmentParameterStore::hierarchyConstraints	(	const Alignable *	aliMaster,
		const align::Alignables &	aliComps,
		std::vector< std::vector< ParameterId > > &	paramIdsVecOut,
		std::vector< std::vector< double > > &	factorsVecOut,
		bool	all,
		double	epsilon
	)		const

Assuming aliMaster has (sub-)components aliComps with alignment parameters (cf. Alignable::firstParamComponents), paramIdsVecOut and factorsVecOut will be filled (in parallel) with constraints on the selected alignment parameters of aliMaster to get rid of the additionally introduced degrees of freedom: The 'vector product' of the parameters identified by ParameterId in std::vector<ParameterId> and the factors in std::vector<double> has to vanish (i.e. == 0.), |factor| < epsilon will be treated as 0. If all == false, skip constraint on aliMaster's degree of freedom 'i' if 'i'th alignment parameter of aliMaster is not selected, i.e. constrain only for otherwise doubled d.o.f. If all == true, produce one constraint for each of the aliMaster's parameters irrespective of whether they are selecte dor not. paramIdsVecOut and factorsVecOut contain exactly one std::vector per selected alignment parameter of aliMaster, but in principle these can be empty... Note that not all combinations of AlignmentParameters classes ar supported. If not there will be an exception (and false returned...)

Definition at line 680 of file AlignmentParameterStore.cc.

References Alignable::alignmentParameters(), python.cmstools::all(), APPROX_AVERAGING_CONSTRAINTS, geometryDiff::epsilon, Exception, HIERARCHY_CONSTRAINTS, ParametersToParametersDerivatives::isOK(), AlignmentParameters::selector(), and theTypeOfConstraints.

Referenced by PedeSteerer::hierarchyConstraint().

                                                                          {
  // Weak point if all = false:
  // Ignores constraints between non-subsequent levels in case the parameter is not considered in
  // the intermediate level, e.g. global z for dets and layers is aligned, but not for rods!
  if (!ali || !ali->alignmentParameters())
    return false;

  const std::vector<bool>& aliSel = ali->alignmentParameters()->selector();
  paramIdsVecOut.clear();
  factorsVecOut.clear();

  bool firstComp = true;
  for (align::Alignables::const_iterator iComp = aliComps.begin(), iCompE = aliComps.end(); iComp != iCompE; ++iComp) {
    const ParametersToParametersDerivatives p2pDerivs(**iComp, *ali);
    if (!p2pDerivs.isOK()) {
      // std::cerr << (*iComp)->alignmentParameters()->type() << " "
      //        << ali->alignmentParameters()->type() << std::endl;
      throw cms::Exception("BadConfig") << "AlignmentParameterStore::hierarchyConstraints"
                                        << " Bad match of types of AlignmentParameters classes.\n";
      return false;
    }
    const std::vector<bool>& aliCompSel = (*iComp)->alignmentParameters()->selector();
    for (unsigned int iParMast = 0, iParMastUsed = 0; iParMast < aliSel.size(); ++iParMast) {
      if (!all && !aliSel[iParMast])
        continue;       // no higher level parameter & constraint deselected
      if (firstComp) {  // fill output with empty arrays
        paramIdsVecOut.push_back(std::vector<ParameterId>());
        factorsVecOut.push_back(std::vector<double>());
      }
      for (unsigned int iParComp = 0; iParComp < aliCompSel.size(); ++iParComp) {
        if (aliCompSel[iParComp]) {
          double factor = 0.;
          if (theTypeOfConstraints == HIERARCHY_CONSTRAINTS) {
            // hierachy constraints
            factor = p2pDerivs(iParMast, iParComp);
          } else if (theTypeOfConstraints == APPROX_AVERAGING_CONSTRAINTS) {
            // CHK poor mans averaging constraints
            factor = p2pDerivs(iParMast, iParComp);
            if (iParMast < 3 && (iParComp % 9) >= 3)
              factor = 0.;
          }
          if (fabs(factor) > epsilon) {
            paramIdsVecOut[iParMastUsed].push_back(ParameterId(*iComp, iParComp));
            factorsVecOut[iParMastUsed].push_back(factor);
          }
        }
      }
      ++iParMastUsed;
    }
    firstComp = false;
  }  // end loop on components

  return true;
}

numCorrelations()

const unsigned int AlignmentParameterStore::numCorrelations ( void  ) const

inline

get number of correlations between alignables

Definition at line 59 of file AlignmentParameterStore.h.

References AlignmentCorrelationsStore::size(), and theCorrelationsStore.

{ return theCorrelationsStore->size(); }

numObjects()

int AlignmentParameterStore::numObjects ( void  ) const

inline

returns number of alignables

Definition at line 53 of file AlignmentParameterStore.h.

References theAlignables.

{ return theAlignables.size(); }

resetParameters() [1/2]

void AlignmentParameterStore::resetParameters

(

void

)

reset parameters, correlations, user variables

Definition at line 271 of file AlignmentParameterStore.cc.

References AlignmentCorrelationsStore::resetCorrelations(), theAlignables, and theCorrelationsStore.

Referenced by MillePedeAlignmentAlgorithm::initialize(), and MillePedeAlignmentAlgorithm::setParametersForRunRange().

                                                  {
  // Erase contents of correlation map
  theCorrelationsStore->resetCorrelations();

  // Iterate over alignables in the store and reset parameters
  align::Alignables::const_iterator iali;
  for (iali = theAlignables.begin(); iali != theAlignables.end(); ++iali)
    resetParameters(*iali);
}

resetParameters() [2/2]

void AlignmentParameterStore::resetParameters

(

Alignable *

ali

)

reset parameters of a given alignable

Definition at line 282 of file AlignmentParameterStore.cc.

References Alignable::alignmentParameters(), AlignmentParameters::cloneFromSelected(), AlignmentParameters::numSelected(), Alignable::setAlignmentParameters(), and AlignmentParameters::setValid().

                                                            {
  if (ali) {
    // Get alignment parameters for this alignable
    AlignmentParameters* ap = ali->alignmentParameters();
    if (ap) {
      int npar = ap->numSelected();

      AlgebraicVector par(npar, 0);
      AlgebraicSymMatrix cov(npar, 0);
      AlignmentParameters* apnew = ap->cloneFromSelected(par, cov);
      ali->setAlignmentParameters(apnew);
      apnew->setValid(false);
    } else
      edm::LogError("BadArgument") << "@SUB=AlignmentParameterStore::resetParameters"
                                   << "alignable has no alignment parameter";
  } else
    edm::LogError("BadArgument") << "@SUB=AlignmentParameterStore::resetParameters"
                                 << "argument is NULL";
}

restoreCachedTransformations() [1/2]

void AlignmentParameterStore::restoreCachedTransformations

(

void

)

restore the previously cached position, rotation and other parameters

Definition at line 316 of file AlignmentParameterStore.cc.

References theAlignables.

Referenced by MillePedeAlignmentAlgorithm::setParametersForRunRange(), and MillePedeAlignmentAlgorithm::terminate().

                                                               {
  align::Alignables::const_iterator iali;
  for (iali = theAlignables.begin(); iali != theAlignables.end(); ++iali)
    (*iali)->restoreCachedTransformation();
}

restoreCachedTransformations() [2/2]

void AlignmentParameterStore::restoreCachedTransformations

(

const align::RunNumber &

run

)

restore for the given run the previously cached position, rotation and other parameters

Definition at line 323 of file AlignmentParameterStore.cc.

References writedatasetfile::run, and theAlignables.

                                                                                    {
  for (const auto& iali : theAlignables)
    iali->restoreCachedTransformation(run);
}

selectParameters() [1/3]

CompositeAlignmentParameters AlignmentParameterStore::selectParameters

(

const std::vector< AlignableDet *> &

alignabledets

)

const

select parameters (for backward compatibility, use with vector<AlignableDetOrUnitPtr> as argument instead)

Definition at line 65 of file AlignmentParameterStore.cc.

References ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it.

Referenced by HIPAlignmentAlgorithm::run().

                                                         {
  std::vector<AlignableDetOrUnitPtr> detOrUnits;
  detOrUnits.reserve(alignabledets.size());

  std::vector<AlignableDet*>::const_iterator it, iEnd;
  for (it = alignabledets.begin(), iEnd = alignabledets.end(); it != iEnd; ++it)
    detOrUnits.push_back(AlignableDetOrUnitPtr(*it));

  return this->selectParameters(detOrUnits);
}

selectParameters() [2/3]

CompositeAlignmentParameters AlignmentParameterStore::selectParameters

(

const std::vector< AlignableDetOrUnitPtr > &

alignabledets

)

const

select parameters

Definition at line 78 of file AlignmentParameterStore.cc.

References alignableFromAlignableDet(), alignables(), Alignable::alignmentParameters(), AlignmentCorrelationsStore::correlations(), data, spr::find(), AlignmentParameters::numSelected(), AlignmentParameters::selectedCovariance(), AlignmentParameters::selectedParameters(), and theCorrelationsStore.

                                                                 {
  align::Alignables alignables;
  std::map<AlignableDetOrUnitPtr, Alignable*> alidettoalimap;
  std::map<Alignable*, int> aliposmap;
  std::map<Alignable*, int> alilenmap;
  int nparam = 0;

  // iterate over AlignableDet's
  for (std::vector<AlignableDetOrUnitPtr>::const_iterator iad = alignabledets.begin(); iad != alignabledets.end();
       ++iad) {
    Alignable* ali = alignableFromAlignableDet(*iad);
    if (ali) {
      alidettoalimap[*iad] = ali;  // Add to map
      // Check if Alignable already there, insert into vector if not
      if (find(alignables.begin(), alignables.end(), ali) == alignables.end()) {
        alignables.push_back(ali);
        AlignmentParameters* ap = ali->alignmentParameters();
        nparam += ap->numSelected();
      }
    }
  }

  AlgebraicVector* selpar = new AlgebraicVector(nparam, 0);
  AlgebraicSymMatrix* selcov = new AlgebraicSymMatrix(nparam, 0);

  // Fill in parameters and corresponding covariance matricess
  int ipos = 1;  // NOTE: .sub indices start from 1
  align::Alignables::const_iterator it1;
  for (it1 = alignables.begin(); it1 != alignables.end(); ++it1) {
    AlignmentParameters* ap = (*it1)->alignmentParameters();
    selpar->sub(ipos, ap->selectedParameters());
    selcov->sub(ipos, ap->selectedCovariance());
    int npar = ap->numSelected();
    aliposmap[*it1] = ipos;
    alilenmap[*it1] = npar;
    ipos += npar;
  }

  // Fill in the correlations. Has to be an extra loop, because the
  // AlignmentExtendedCorrelationsStore (if used) needs the
  // alignables' covariance matrices already present.
  ipos = 1;
  for (it1 = alignables.begin(); it1 != alignables.end(); ++it1) {
    int jpos = 1;

    // Look for correlations between alignables
    align::Alignables::const_iterator it2;
    for (it2 = alignables.begin(); it2 != it1; ++it2) {
      theCorrelationsStore->correlations(*it1, *it2, *selcov, ipos - 1, jpos - 1);
      jpos += (*it2)->alignmentParameters()->numSelected();
    }

    ipos += (*it1)->alignmentParameters()->numSelected();
  }

  AlignmentParametersData::DataContainer data(new AlignmentParametersData(selpar, selcov));
  CompositeAlignmentParameters aap(data, alignables, alidettoalimap, aliposmap, alilenmap);

  return aap;
}

selectParameters() [3/3]

CompositeAlignmentParameters AlignmentParameterStore::selectParameters

(

const align::Alignables &

alignables

)

const

select parameters

Definition at line 141 of file AlignmentParameterStore.cc.

References alignables(), AlignmentCorrelationsStore::correlations(), data, spr::find(), AlignmentParameters::numSelected(), AlignmentParameters::selectedCovariance(), AlignmentParameters::selectedParameters(), and theCorrelationsStore.

                                                                                                              {
  align::Alignables selectedAlignables;
  std::map<AlignableDetOrUnitPtr, Alignable*> alidettoalimap;  // This map won't be filled!!!
  std::map<Alignable*, int> aliposmap;
  std::map<Alignable*, int> alilenmap;
  int nparam = 0;

  // iterate over Alignable's
  align::Alignables::const_iterator ita;
  for (ita = alignables.begin(); ita != alignables.end(); ++ita) {
    // Check if Alignable already there, insert into vector if not
    if (find(selectedAlignables.begin(), selectedAlignables.end(), *ita) == selectedAlignables.end()) {
      selectedAlignables.push_back(*ita);
      AlignmentParameters* ap = (*ita)->alignmentParameters();
      nparam += ap->numSelected();
    }
  }

  AlgebraicVector* selpar = new AlgebraicVector(nparam, 0);
  AlgebraicSymMatrix* selcov = new AlgebraicSymMatrix(nparam, 0);

  // Fill in parameters and corresponding covariance matrices
  int ipos = 1;  // NOTE: .sub indices start from 1
  align::Alignables::const_iterator it1;
  for (it1 = selectedAlignables.begin(); it1 != selectedAlignables.end(); ++it1) {
    AlignmentParameters* ap = (*it1)->alignmentParameters();
    selpar->sub(ipos, ap->selectedParameters());
    selcov->sub(ipos, ap->selectedCovariance());
    int npar = ap->numSelected();
    aliposmap[*it1] = ipos;
    alilenmap[*it1] = npar;
    ipos += npar;
  }

  // Fill in the correlations. Has to be an extra loop, because the
  // AlignmentExtendedCorrelationsStore (if used) needs the
  // alignables' covariance matrices already present.
  ipos = 1;
  for (it1 = selectedAlignables.begin(); it1 != selectedAlignables.end(); ++it1) {
    int jpos = 1;

    // Look for correlations between alignables
    align::Alignables::const_iterator it2;
    for (it2 = selectedAlignables.begin(); it2 != it1; ++it2) {
      theCorrelationsStore->correlations(*it1, *it2, *selcov, ipos - 1, jpos - 1);
      jpos += (*it2)->alignmentParameters()->numSelected();
    }

    ipos += (*it1)->alignmentParameters()->numSelected();
  }

  AlignmentParametersData::DataContainer data(new AlignmentParametersData(selpar, selcov));
  CompositeAlignmentParameters aap(data, selectedAlignables, alidettoalimap, aliposmap, alilenmap);

  return aap;
}

setAlignmentPositionError()

void AlignmentParameterStore::setAlignmentPositionError	(	const align::Alignables &	alivec,
		double	valshift,
		double	valrot
	)

Set Alignment position error.

Definition at line 646 of file AlignmentParameterStore.cc.

References Alignable::addAlignmentPositionError(), Alignable::addAlignmentPositionErrorFromRotation(), mps_fire::i, LogDebug, alignCSCRings::r, Alignable::setAlignmentPositionError(), and align::toMatrix().

Referenced by MuonAlignmentFromReference::fitAndAlign(), MuonAlignmentFromReference::initialize(), and HIPAlignmentAlgorithm::setAlignmentPositionError().

                                                                       {
  unsigned int nAlignables = alivec.size();

  for (unsigned int i = 0; i < nAlignables; ++i) {
    Alignable* ali = alivec[i];

    // First reset APE
    AlignmentPositionError nulApe(0, 0, 0);
    ali->setAlignmentPositionError(nulApe, true);

    // Set APE from displacement
    AlignmentPositionError ape(valshift, valshift, valshift);
    if (valshift > 0.)
      ali->addAlignmentPositionError(ape, true);
    else
      ali->setAlignmentPositionError(ape, true);
    // GF: Resetting and setting as above does not really make sense to me,
    //     and adding to zero or setting is the same! I'd just do
    //ali->setAlignmentPositionError(AlignmentPositionError ape(valshift,valshift,valshift),true);

    // Set APE from rotation
    align::EulerAngles r(3);
    r(1) = valrot;
    r(2) = valrot;
    r(3) = valrot;
    ali->addAlignmentPositionErrorFromRotation(align::toMatrix(r), true);
  }

  LogDebug("StoreAPE") << "Store APE from shift: " << valshift << "\nStore APE from rotation: " << valrot;
}

typeAndLayer()

std::pair< int, int > AlignmentParameterStore::typeAndLayer	(	const Alignable *	ali,
		const TrackerTopology *	tTopo
	)		const

Obtain type and layer from Alignable.

Definition at line 368 of file AlignmentParameterStore.cc.

References Alignable::id(), and TrackerAlignableId::typeAndLayerFromDetId().

Referenced by HIPAlignmentAlgorithm::fillAlignablesMonitor(), and HIPAlignmentAlgorithm::terminate().

                                                                                                                {
  return TrackerAlignableId().typeAndLayerFromDetId(ali->id(), tTopo);
}

updateParameters()

void AlignmentParameterStore::updateParameters	(	const CompositeAlignmentParameters &	aap,
		bool	updateCorrelations = true
	)

update parameters

Definition at line 199 of file AlignmentParameterStore.cc.

References alignables(), AlignmentParameters::cloneFromSelected(), CompositeAlignmentParameters::components(), CompositeAlignmentParameters::covariance(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, AlignmentParameters::numSelected(), CompositeAlignmentParameters::parameters(), AlignmentCorrelationsStore::setCorrelations(), and theCorrelationsStore.

                                                                                                               {
  align::Alignables alignables = aap.components();
  const AlgebraicVector& parameters = aap.parameters();
  const AlgebraicSymMatrix& covariance = aap.covariance();

  int ipos = 1;  // NOTE: .sub indices start from 1

  // Loop over alignables
  for (align::Alignables::const_iterator it = alignables.begin(); it != alignables.end(); ++it) {
    // Update parameters and local covariance
    AlignmentParameters* ap = (*it)->alignmentParameters();
    int nsel = ap->numSelected();
    AlgebraicVector subvec = parameters.sub(ipos, ipos + nsel - 1);
    AlgebraicSymMatrix subcov = covariance.sub(ipos, ipos + nsel - 1);
    AlignmentParameters* apnew = ap->cloneFromSelected(subvec, subcov);
    (*it)->setAlignmentParameters(apnew);

    // Now update correlations between detectors
    if (updateCorrelations) {
      int jpos = 1;
      for (align::Alignables::const_iterator it2 = alignables.begin(); it2 != it; ++it2) {
        theCorrelationsStore->setCorrelations(*it, *it2, covariance, ipos - 1, jpos - 1);
        jpos += (*it2)->alignmentParameters()->numSelected();
      }
    }

    ipos += nsel;
  }
}

validAlignables()

align::Alignables AlignmentParameterStore::validAlignables

(

void

)

const

get all alignables with valid parameters

Definition at line 230 of file AlignmentParameterStore.cc.

References LogDebug, mps_fire::result, and theAlignables.

                                                                   {
  align::Alignables result;
  for (align::Alignables::const_iterator iali = theAlignables.begin(); iali != theAlignables.end(); ++iali)
    if ((*iali)->alignmentParameters()->isValid())
      result.push_back(*iali);

  LogDebug("Alignment") << "@SUB=AlignmentParameterStore::validAlignables"
                        << "Valid alignables: " << result.size() << "out of " << theAlignables.size();
  return result;
}

Member Data Documentation

theAlignables

align::Alignables AlignmentParameterStore::theAlignables

private

alignables

Definition at line 161 of file AlignmentParameterStore.h.

Referenced by acquireRelativeParameters(), alignables(), AlignmentParameterStore(), applyParameters(), attachAlignmentParameters(), attachCorrelations(), cacheTransformations(), numObjects(), resetParameters(), restoreCachedTransformations(), and validAlignables().

theCorrelationsStore

AlignmentCorrelationsStore* AlignmentParameterStore::theCorrelationsStore

protected

Definition at line 153 of file AlignmentParameterStore.h.

Referenced by AlignmentParameterStore(), attachCorrelations(), correlationsStore(), numCorrelations(), resetParameters(), selectParameters(), updateParameters(), and ~AlignmentParameterStore().

theTypeOfConstraints

TypeOfConstraints AlignmentParameterStore::theTypeOfConstraints

private

type of constraints

Definition at line 164 of file AlignmentParameterStore.h.

Referenced by AlignmentParameterStore(), and hierarchyConstraints().