TwoBowedSurfacesDeformation Class Reference

#include <TwoBowedSurfacesDeformation.h>

Inheritance diagram for TwoBowedSurfacesDeformation:

Public Member Functions
bool	add (const SurfaceDeformation &other) override
TwoBowedSurfacesDeformation *	clone () const override
std::vector< double >	parameters () const override
	parameters - see constructor for meaning More...
Local2DVector	positionCorrection (const Local2DPoint &localPos, const LocalTrackAngles &localAngles, double length, double width) const override
	TwoBowedSurfacesDeformation (const std::vector< double > &parameters)
int	type () const override
	specific type, i.e. SurfaceDeformationFactory::kTwoBowedSurfaces More...
Public Member Functions inherited from SurfaceDeformation
virtual	~SurfaceDeformation ()

Static Public Member Functions
static constexpr unsigned int	k_ySplit ()
static constexpr unsigned int	maxParameterSize ()
	maximum size of vector that is accepted by constructor from vector More...
static constexpr unsigned int	minParameterSize ()
	minimum size of vector that is accepted by constructor from vector More...
static constexpr unsigned int	parameterSize ()

Static Public Attributes
static constexpr unsigned int	parSize = 13

Private Attributes
double	theParameters [parSize]

Additional Inherited Members
Public Types inherited from SurfaceDeformation
typedef Topology::Local2DPoint	Local2DPoint
typedef Vector2DBase< double, LocalTag >	Local2DVector
typedef Topology::LocalTrackAngles	LocalTrackAngles
typedef Topology::MathVector2D	MathVector2D
typedef Topology::Vector2D	Vector2D

Detailed Description

TwoBowedSurfacesAlignmentParameters

Class to apply corrections to local positions resulting from two surfaces chained in local y. Possible bows are parametrised using Legendre polynomials up to second order, excluding 0th and 1st order that are already treated by local w shift and rotations around local u and v axes. In addition store relative shifts and rotations of the two surfaces.

Definition at line 19 of file TwoBowedSurfacesDeformation.h.

Constructor & Destructor Documentation

TwoBowedSurfacesDeformation::TwoBowedSurfacesDeformation

(

const std::vector< double > &

pars

)

Constructor from vector of parameters, its size() must be between minParameterSize() and maxParameterSize(). The parameters are (in that order)

• mean sagittaX of both surfaces
• mean sagittaXY
• mean sagittaY
• 'delta' u of both surfaces (shift surface at lower/higher y by +u/-u)
• 'delta' v of both surfaces
• 'delta' w of both surfaces
• 'delta' alpha of both surfaces (rotate around local x)
• 'delta' beta
• 'delta' gamma
• 'delta' sagittaX of both surfaces (add/subtract for surfaces at lower/higher y)
• 'delta' sagittaXY
• 'delta' sagittaY
• ySplit: y-value where surfaces are split

Author

: Gero Flucke date : October 2010

Definition at line 13 of file TwoBowedSurfacesDeformation.cc.

References mps_fire::i, SiStripPI::min, parameterSize(), and theParameters.

Referenced by clone().

                                                                                      {
  if (pars.size() != parameterSize()) {
    edm::LogError("BadSetup") << "@SUB=TwoBowedSurfacesDeformation"
                              << "Input vector of wrong size " << pars.size() << " instead of " << parameterSize()
                              << ", add zeros to fill up!";
  }
  for (unsigned int i = 0; i != std::min((unsigned int)(pars.size()), parameterSize()); ++i)
    theParameters[i] = pars[i];
  for (unsigned int i = pars.size(); i != parameterSize(); ++i)
    theParameters[i] = 0;
}

Member Function Documentation

bool TwoBowedSurfacesDeformation::add ( const SurfaceDeformation &  other )

overridevirtual

update information with parameters of 'other', false in case the type or some parameters do not match and thus the information cannot be used (then no changes are done), true if merge was successful

Implements SurfaceDeformation.

Definition at line 98 of file TwoBowedSurfacesDeformation.cc.

References alignCSCRings::e, mps_fire::i, k_ySplit(), SurfaceDeformation::parameters(), parameterSize(), theParameters, SurfaceDeformation::type(), and type().

Referenced by counter.Counter::register().

                                                                     {
  if (this->type() == other.type()) {
    const std::vector<double> otherParameters(other.parameters());
    if (otherParameters.size() == parameterSize()) {
      // Second check in case it is really adding, either way DO NOT check equality directly
      if (fabs(theParameters[k_ySplit()] - otherParameters[k_ySplit()]) < 1e-5 ||
          fabs(otherParameters[k_ySplit()]) < 1e-5) {
        for (unsigned int i = 0; i != parameterSize() - 1; ++i) {  // -1 for ySplit
          // mean bows, delta shifts, delta angles and delta bows can simply be added up
          theParameters[i] += otherParameters[i];
        }
        return true;
      } else {  // ySplit values are different!
        edm::LogError("Alignment") << "@SUB=TwoBowedSurfacesDeformation::add"
                                   << "Different ySplit: this " << theParameters[k_ySplit()] << ", to add "
                                   << otherParameters[k_ySplit()];
      }
    }  // same size
  }    // same type

  edm::LogError("Alignment") << "@SUB=TwoBowedSurfacesDeformation::add"
                             << "Types are different!";

  return false;
}

TwoBowedSurfacesDeformation * TwoBowedSurfacesDeformation::clone ( void  ) const

overridevirtual

Implements SurfaceDeformation.

Definition at line 26 of file TwoBowedSurfacesDeformation.cc.

References TwoBowedSurfacesDeformation().

                                                                      {
  return new TwoBowedSurfacesDeformation(*this);
}

static constexpr unsigned int TwoBowedSurfacesDeformation::k_ySplit ( )

inlinestatic

Definition at line 74 of file TwoBowedSurfacesDeformation.h.

References parameterSize().

Referenced by add(), and positionCorrection().

{ return parameterSize() - 1; }

static constexpr unsigned int TwoBowedSurfacesDeformation::maxParameterSize ( )

inlinestatic

maximum size of vector that is accepted by constructor from vector

Definition at line 71 of file TwoBowedSurfacesDeformation.h.

References parameterSize().

Referenced by SurfaceDeformationFactory::create().

{ return parameterSize(); }

static constexpr unsigned int TwoBowedSurfacesDeformation::minParameterSize ( )

inlinestatic

minimum size of vector that is accepted by constructor from vector

Definition at line 69 of file TwoBowedSurfacesDeformation.h.

References parameterSize().

Referenced by SurfaceDeformationFactory::create().

{ return parameterSize(); }

std::vector< double > TwoBowedSurfacesDeformation::parameters ( void  ) const

overridevirtual

parameters - see constructor for meaning

Implements SurfaceDeformation.

Definition at line 125 of file TwoBowedSurfacesDeformation.cc.

References parameterSize(), and theParameters.

                                                                {
  return std::vector<double>(theParameters, theParameters + parameterSize());
}

static constexpr unsigned int TwoBowedSurfacesDeformation::parameterSize ( )

inlinestatic

Definition at line 66 of file TwoBowedSurfacesDeformation.h.

References parSize.

Referenced by add(), k_ySplit(), maxParameterSize(), minParameterSize(), parameters(), and TwoBowedSurfacesDeformation().

{ return parSize; }

SurfaceDeformation::Local2DVector TwoBowedSurfacesDeformation::positionCorrection ( const Local2DPoint &  localPos, const LocalTrackAngles &  localAngles, double  length, double  width  ) const

overridevirtual

correction to add to local position depending on

• track parameters in local frame (from LocalTrajectoryParameters):
  • track position as Local2DPoint(x,y)
  • track angles as LocalTrackAngles(dxdz, dydz)
• length of surface (local y-coordinate)
• width of surface (local x-coordinate)

Implements SurfaceDeformation.

Definition at line 34 of file TwoBowedSurfacesDeformation.cc.

References Topology::LocalTrackAngles::dxdz(), Topology::LocalTrackAngles::dydz(), k_ySplit(), jetcorrextractor::sign(), theParameters, x, PV2DBase< T, PVType, FrameType >::x(), y, and PV2DBase< T, PVType, FrameType >::y().

                                                                                                      {
  const double ySplit = theParameters[k_ySplit()];

  // treatment of different widthes at high/low y could be done by theRelWidthLowY or so
  //   if (widthLowY > 0. && widthHighY != widthLowY) {
  //     std::cout << "SurfaceDeformation::positionCorrection2Bowed: Cannot yet deal "
  //          << " with different widthes, take " << widthHighY << " not " << widthLowY
  //          << std::endl;
  //   }
  //   const double width = widthHighY;

  // Some signs depend on whether we are in surface part below or above ySplit:
  const double sign = (localPos.y() < ySplit ? +1. : -1.);
  const double yMiddle = ySplit * 0.5 - sign * length * .25;
  // 'calibrate' y length and transform y to be w.r.t. surface middle
  const double myY = localPos.y() - yMiddle;
  const double myLength = length * 0.5 + sign * ySplit;

  double uRel = 2. * localPos.x() / width;  // relative u (-1 .. +1)
  double vRel = 2. * myY / myLength;        // relative v (-1 .. +1)
  // 'range check':
  const double cutOff = 1.5;
  if (uRel < -cutOff) {
    uRel = -cutOff;
  } else if (uRel > cutOff) {
    uRel = cutOff;
  }
  if (vRel < -cutOff) {
    vRel = -cutOff;
  } else if (vRel > cutOff) {
    vRel = cutOff;
  }

  auto pars = theParameters;
  // 1st, get dw effect depending
  // - on the surface sagittas (Legendre polynomials),
  //   see BowedSurfaceAlignmentDerivatives::operator()(..)
  // - relative dw
  // - surface specific dalpha (note that this shifts surface specific dw)
  // - surface specific dbeta
  const double dw = (uRel * uRel - 1. / 3.) * (pars[0] + sign * pars[9])     // sagittaX
                    + uRel * vRel * (pars[1] + sign * pars[10])              // sagittaXY
                    + (vRel * vRel - 1. / 3.) * (pars[2] + sign * pars[11])  // sagittaY
                    + sign * pars[5]                                         // different dw
                    + myY * sign * pars[6]                                   // different dalpha
                    - localPos.x() * sign * pars[7];                         // different dbeta
  // 2nd, translate the dw effect to shifts in x and y
  // Positive dxdz/dydz and positive dw mean negative shift in x/y:
  Local2DVector::ScalarType x = -dw * localAngles.dxdz();
  Local2DVector::ScalarType y = -dw * localAngles.dydz();
  // 3rd, treat in-plane differences depending on surface from xy-shifts...
  x += (sign * pars[3]);  // different du
  y += (sign * pars[4]);  // different dv
  //     ...and gamma-rotation
  x -= myY * (sign * pars[8]);           // different dgamma for u
  y += localPos.x() * (sign * pars[8]);  // different dgamma for v

  return Local2DVector(x, y);
}

int TwoBowedSurfacesDeformation::type ( ) const

overridevirtual

specific type, i.e. SurfaceDeformationFactory::kTwoBowedSurfaces

Implements SurfaceDeformation.

Definition at line 31 of file TwoBowedSurfacesDeformation.cc.

References SurfaceDeformationFactory::kTwoBowedSurfaces.

Referenced by add().

{ return SurfaceDeformationFactory::kTwoBowedSurfaces; }

Member Data Documentation

constexpr unsigned int TwoBowedSurfacesDeformation::parSize = 13

static

Definition at line 65 of file TwoBowedSurfacesDeformation.h.

Referenced by parameterSize().

double TwoBowedSurfacesDeformation::theParameters[parSize]

private

Definition at line 77 of file TwoBowedSurfacesDeformation.h.

Referenced by add(), parameters(), positionCorrection(), and TwoBowedSurfacesDeformation().