ParametersToParametersDerivatives Class Reference

#include <ParametersToParametersDerivatives.h>

Public Member Functions
bool	isOK () const
	Indicate whether able to provide the derivatives. More...
double	operator() (unsigned int indParMother, unsigned int indParComp) const
	ParametersToParametersDerivatives (const Alignable &component, const Alignable &mother)

Private Types
typedef ROOT::Math::SMatrix< double, 6, 9, ROOT::Math::MatRepStd< double, 6, 9 > >	AlgebraicMatrix69

Private Member Functions
AlgebraicMatrix69	dRigid_dBowed (const AlgebraicMatrix66 &dRigidM2dRigidC, double halfWidth, double halfLength)
bool	init (const Alignable &component, int typeComponent, const Alignable &mother, int typeMother)
bool	init2BowedRigid (const Alignable &component, const Alignable &mother)
bool	initBowedRigid (const Alignable &component, const Alignable &mother)
	init for component with BowedSurface and mother with RigidBody parameters More...
bool	initRigidRigid (const Alignable &component, const Alignable &mother)
	init for component and mother both with RigidBody parameters More...

Private Attributes
TMatrixD	derivatives_
	can we provide the desired? More...
bool	isOK_
	data members More...

Detailed Description

Class for getting the jacobian d_mother/d_component for various kinds of alignment parametrisations, i.e. the derivatives expressing the influence of the parameters of the 'component' on the parameters of its 'mother'. This is needed e.g. to formulate constraints to remove the additional degrees of freedom introduced if larger structures and their components are aligned simultaneously. The jacobian matrix is

/ dp1_l/dp1_i dp1_l/dp2_i ... dp1_l/dpn_i | | dp2_l/dp1_i dp2_l/dp2_i ... dp2_l/dpn_i | | . . . | | . . . | | . . . | \ dpm_l/dpm_i dpm_l/dpm_i ... dpm_l/dpn_i /

where p1_l, p2_l, ..., pn_l are the n parameters of the composite 'mother' object and p1_i, p2_i, ..., pm_i are the m parameters of its component.

Note that not all combinations of parameters are supported: Please check method isOK() before accessing the derivatives via operator(unsigned int indParMother, unsigned int indParComp).

Currently these parameters are supported:

• mother: rigid body parameters,

• component: rigid body, bowed surface or two bowed surfaces parameters.

  Date

  2010/12/09 19:53:42

  Revision

  1.1

  (last update by

  Author

  flucke

  )

Definition at line 43 of file ParametersToParametersDerivatives.h.

Member Typedef Documentation

AlgebraicMatrix69

typedef ROOT::Math::SMatrix<double, 6, 9, ROOT::Math::MatRepStd<double, 6, 9> > ParametersToParametersDerivatives::AlgebraicMatrix69

private

Definition at line 70 of file ParametersToParametersDerivatives.h.

Constructor & Destructor Documentation

ParametersToParametersDerivatives()

ParametersToParametersDerivatives::ParametersToParametersDerivatives	(	const Alignable &	component,
		const Alignable &	mother
	)

Definition at line 23 of file ParametersToParametersDerivatives.cc.

    : isOK_(component.alignmentParameters() && mother.alignmentParameters()) {
  if (isOK_) {
    isOK_ =
        this->init(component, component.alignmentParameters()->type(), mother, mother.alignmentParameters()->type());
  }
}

References Alignable::alignmentParameters(), init(), isOK_, and AlignmentParameters::type().

Member Function Documentation

dRigid_dBowed()

ParametersToParametersDerivatives::AlgebraicMatrix69 ParametersToParametersDerivatives::dRigid_dBowed ( const AlgebraicMatrix66 &  dRigidM2dRigidC, double  halfWidth, double  halfLength  )

private

from d(rigid_mother)/d(rigid_component) to d(rigid_mother)/d(bowed_component) for bad input (length or width zero), set object to invalid: isOK_ = false

Definition at line 154 of file ParametersToParametersDerivatives.cc.

                                                                                   {
  typedef BowedSurfaceAlignmentDerivatives BowedDerivs;
  const double gammaScale = BowedDerivs::gammaScale(2. * halfWidth, 2. * halfLength);
 
  // 'dRigidM2dRigidC' is dmother/dcomponent for both being rigid body
  // final matrix will be dmother/dcomponent for mother as rigid body, component
  // with bows 1st index (row) is parameter of the mother (0..5), 2nd index
  // (column) that of component (0..8):
  AlgebraicMatrix69 derivs;
  if (0. == gammaScale || 0. == halfWidth || 0. == halfLength) {
    isOK_ = false;  // bad input - we would have to devide by that in the following!
    edm::LogError("Alignment") << "@SUB=ParametersToParametersDerivatives::dRigid_dBowed"
                               << "Some zero length as input.";
    return derivs;
  }
 
  for (unsigned int iRow = 0; iRow < AlgebraicMatrix69::kRows; ++iRow) {
    // loop on 6 rigid body parameters of mother
    // First copy the common rigid body part, e.g.:
    // (0,0): du_moth/du_comp, (0,1): dv_moth/du_comp, (1,2): dw_moth/dv_comp
    for (unsigned int iCol = 0; iCol < 3; ++iCol) {  // 3 movements of component
      derivs(iRow, iCol) = dRigidM2dRigidC(iRow, iCol);
    }
 
    // Now we have to take care of order, signs and scales for rotation-like
    // parameters, see CMS AN-2011/531: slopeX = w10 = -halfWidth * beta
    // => dpar_m/dslopeX_comp = dpar_m/d(-hw * beta_comp) =
    // -(dpar_m/dbeta_comp)/hw
    derivs(iRow, 3) = -dRigidM2dRigidC(iRow, 4) / halfWidth;
    // slopeY = w10 = +halfLength * alpha
    // => dpar_m/dslopeY_comp = dpar_m/d(+hl * alpha_comp) =
    // (dpar_m/dalpha_comp)/hl
    derivs(iRow, 4) = dRigidM2dRigidC(iRow, 3) / halfLength;
    // rotZ = gammaScale * gamma
    // => dpar_m/drotZ_comp = dpar_m/d(gamma_comp * gscale) =
    // (dpar_m/dgamma)/gscale
    derivs(iRow, 5) = dRigidM2dRigidC(iRow, 5) / gammaScale;
 
    // Finally, sensor internals like their curvatures have no influence on
    // mother:
    for (unsigned int iCol = 6; iCol < AlgebraicMatrix69::kCols; ++iCol) {
      derivs(iRow, iCol) = 0.;  // 3 sagittae of component
    }
  }
 
  return derivs;
}

References isOK_.

Referenced by init2BowedRigid(), and initBowedRigid().

init()

bool ParametersToParametersDerivatives::init ( const Alignable &  component, int  typeComponent, const Alignable &  mother, int  typeMother  )

private

init by choosing the correct detailed init method depending on parameter types

Definition at line 33 of file ParametersToParametersDerivatives.cc.

                                                             {
  using namespace AlignmentParametersFactory;  // for kRigidBody etc.
  if ((typeMother == kRigidBody || typeMother == kRigidBody4D) &&
      (typeComponent == kRigidBody || typeComponent == kRigidBody4D)) {
    return this->initRigidRigid(component, mother);
  } else if ((typeMother == kRigidBody || typeMother == kRigidBody4D) && typeComponent == kBowedSurface) {
    return this->initBowedRigid(component, mother);
  } else if ((typeMother == kRigidBody || typeMother == kRigidBody4D) && typeComponent == kTwoBowedSurfaces) {
    return this->init2BowedRigid(component, mother);
  } else {
    // missing: mother with bows and component without, i.e. having 'common' bow
    // parameters
    edm::LogError("Alignment") << "@SUB=ParametersToParametersDerivatives::init"
                               << "Mother " << parametersTypeName(parametersType(typeMother)) << ", component "
                               << parametersTypeName(parametersType(typeComponent)) << ": not supported.";
    return false;
  }
}

References init2BowedRigid(), initBowedRigid(), initRigidRigid(), AlignmentParametersFactory::kBowedSurface, AlignmentParametersFactory::kRigidBody, AlignmentParametersFactory::kRigidBody4D, AlignmentParametersFactory::kTwoBowedSurfaces, AlignmentParametersFactory::parametersType(), and AlignmentParametersFactory::parametersTypeName().

Referenced by ParametersToParametersDerivatives().

init2BowedRigid()

bool ParametersToParametersDerivatives::init2BowedRigid ( const Alignable &  component, const Alignable &  mother  )

private

init for component with TwoBowedSurfaces and mother with RigidBody parameters

Definition at line 100 of file ParametersToParametersDerivatives.cc.

                                                                                                           {
  // component is two bowed surfaces, mother rigid body
  const TwoBowedSurfacesAlignmentParameters *aliPar =
      dynamic_cast<TwoBowedSurfacesAlignmentParameters *>(component.alignmentParameters());
 
  if (!aliPar) {
    edm::LogError("Alignment") << "@SUB=ParametersToParametersDerivatives::init2BowedRigid"
                               << "dynamic_cast to TwoBowedSurfacesAlignmentParameters failed.";
    return false;
  }
 
  // We treat the two surfaces as independent objects, i.e.
  // 1) get the global position of each surface, depending on the ySplit value,
  const double ySplit = aliPar->ySplit();
  const double halfWidth = 0.5 * component.surface().width();
  const double halfLength = 0.5 * component.surface().length();
  const double halfLength1 = 0.5 * (halfLength + ySplit);
  const double halfLength2 = 0.5 * (halfLength - ySplit);
  const double yM1 = 0.5 * (ySplit - halfLength);  // y_mean of surface 1
  const double yM2 = yM1 + halfLength;             // y_mean of surface 2
  // The sensor positions and orientations could be adjusted using
  // TwoBowedSurfacesDeformation attached to the component,
  // but that should be 2nd order effect.
  const align::GlobalPoint posSurf1(component.surface().toGlobal(align::LocalPoint(0., yM1, 0.)));
  const align::GlobalPoint posSurf2(component.surface().toGlobal(align::LocalPoint(0., yM2, 0.)));
 
  // 2) get derivatives for both,
  // getDerivative(..) returns dcomponent/dmother for both being rigid body
  FrameToFrameDerivative f2fMaker;
  AlgebraicMatrix66 f2fSurf1(
      f2fMaker.getDerivative(component.globalRotation(), mother.globalRotation(), posSurf1, mother.globalPosition()));
  AlgebraicMatrix66 f2fSurf2(
      f2fMaker.getDerivative(component.globalRotation(), mother.globalRotation(), posSurf2, mother.globalPosition()));
  // We have to invert matrices to get d(rigid_mother)/d(rigid_component):
  if (!f2fSurf1.Invert() || !f2fSurf2.Invert())
    return false;  // bail out if bad inversion
  // Now get d(rigid_mother)/d(bowed_component):
  const AlgebraicMatrix69 derivs1(this->dRigid_dBowed(f2fSurf1, halfWidth, halfLength1));
  const AlgebraicMatrix69 derivs2(this->dRigid_dBowed(f2fSurf2, halfWidth, halfLength2));
 
  // 3) fill the common matrix by merging the two.
  typedef ROOT::Math::SMatrix<double, 6, 18, ROOT::Math::MatRepStd<double, 6, 18>> AlgebraicMatrix6_18;
  AlgebraicMatrix6_18 derivs;
  derivs.Place_at(derivs1, 0, 0);  // left half
  derivs.Place_at(derivs2, 0, 9);  // right half
 
  // copy to TMatrix
  derivatives_.ResizeTo(6, 18);
  derivatives_.SetMatrixArray(derivs.begin());
 
  return true;
}

References Alignable::alignmentParameters(), derivatives_, dRigid_dBowed(), Alignable::globalPosition(), Alignable::globalRotation(), AlignableSurface::length(), Alignable::surface(), AlignableSurface::toGlobal(), AlignableSurface::width(), and TwoBowedSurfacesAlignmentParameters::ySplit().

Referenced by init().

initBowedRigid()

bool ParametersToParametersDerivatives::initBowedRigid ( const Alignable &  component, const Alignable &  mother  )

private

init for component with BowedSurface and mother with RigidBody parameters

Definition at line 78 of file ParametersToParametersDerivatives.cc.

                                                                                                          {
  // component is bowed surface, mother rigid body
  FrameToFrameDerivative f2f;
  // frame2frame returns dcomponent/dmother for both being rigid body, so we
  // have to invert
  AlgebraicMatrix66 rigM2rigC(asSMatrix<6, 6>(f2f.frameToFrameDerivative(&component, &mother)));
  if (rigM2rigC.Invert()) {  // now matrix is d(rigid_mother)/d(rigid_component)
    const double halfWidth = 0.5 * component.surface().width();
    const double halfLength = 0.5 * component.surface().length();
    const AlgebraicMatrix69 m(this->dRigid_dBowed(rigM2rigC, halfWidth, halfLength));
 
    // copy to TMatrix
    derivatives_.ResizeTo(6, 9);
    derivatives_.SetMatrixArray(m.begin());
 
    return true;
  } else {
    return false;
  }
}

References derivatives_, dRigid_dBowed(), FrameToFrameDerivative::frameToFrameDerivative(), AlignableSurface::length(), visualization-live-secondInstance_cfg::m, Alignable::surface(), and AlignableSurface::width().

Referenced by init().

initRigidRigid()

bool ParametersToParametersDerivatives::initRigidRigid ( const Alignable &  component, const Alignable &  mother  )

private

init for component and mother both with RigidBody parameters

Definition at line 56 of file ParametersToParametersDerivatives.cc.

                                                                                                          {
  // See G. Flucke's presentation from  20 Feb 2007
  // https://indico.cern.ch/contributionDisplay.py?contribId=15&sessionId=1&confId=10930
  // and C. Kleinwort's one from 14 Feb 2013
  // https://indico.cern.ch/contributionDisplay.py?contribId=14&sessionId=1&confId=224472
 
  FrameToFrameDerivative f2f;
  // frame2frame returns dcomponent/dmother for both being rigid body, so we
  // have to invert
  AlgebraicMatrix66 m(asSMatrix<6, 6>(f2f.frameToFrameDerivative(&component, &mother)));
 
  if (m.Invert()) {  // now matrix is d(rigid_mother)/d(rigid_component)
    // copy to TMatrix
    derivatives_.ResizeTo(6, 6);
    derivatives_.SetMatrixArray(m.begin());
    return true;
  } else {
    return false;
  }
}

References derivatives_, FrameToFrameDerivative::frameToFrameDerivative(), and visualization-live-secondInstance_cfg::m.

Referenced by init().

isOK()

bool ParametersToParametersDerivatives::isOK ( ) const

inline

Indicate whether able to provide the derivatives.

Definition at line 48 of file ParametersToParametersDerivatives.h.

{ return isOK_; }

References isOK_.

Referenced by AlignmentParameterStore::hierarchyConstraints().

operator()()

double ParametersToParametersDerivatives::operator()	(	unsigned int	indParMother,
		unsigned int	indParComp
	)		const

Return the derivative DeltaParam(mother)/DeltaParam(component). Indices start with 0 - but check isOK() first! See class description about matrix.

Definition at line 204 of file ParametersToParametersDerivatives.cc.

                                                                                                             {
  // Do range checks?
  return derivatives_(indParMother, indParComp);
}

References derivatives_.

Member Data Documentation

derivatives_

TMatrixD ParametersToParametersDerivatives::derivatives_

private

can we provide the desired?

Definition at line 78 of file ParametersToParametersDerivatives.h.

Referenced by init2BowedRigid(), initBowedRigid(), initRigidRigid(), and operator()().

isOK_

bool ParametersToParametersDerivatives::isOK_

private

data members

Definition at line 77 of file ParametersToParametersDerivatives.h.

Referenced by dRigid_dBowed(), isOK(), and ParametersToParametersDerivatives().