MillePedeAlignmentAlgorithm Class Reference

#include <MillePedeAlignmentAlgorithm.h>

Inheritance diagram for MillePedeAlignmentAlgorithm:

Public Member Functions
bool	addCalibrations (const std::vector< IntegratedCalibrationBase * > &iCals) override
	Pass integrated calibrations to Millepede (they are not owned by Millepede!) More...
void	beginLuminosityBlock (const edm::EventSetup &) override
	called at begin of luminosity block (resets Mille binary in mille mode) More...
void	beginRun (const edm::Run &run, const edm::EventSetup &setup, bool changed) override
	called at begin of run More...
void	endLuminosityBlock (const edm::EventSetup &) override
	called at end of luminosity block More...
virtual void	endRun (const EventInfo &, const EndRunInfo &, const edm::EventSetup &)
	Run on run products, e.g. TkLAS. More...
void	endRun (const EndRunInfo &runInfo, const edm::EventSetup &setup) override
	called at end of run - order of arguments like in EDProducer etc. More...
void	initialize (const edm::EventSetup &setup, AlignableTracker *tracker, AlignableMuon *muon, AlignableExtras *extras, AlignmentParameterStore *store) override
	Called at beginning of job. More...
	MillePedeAlignmentAlgorithm (const edm::ParameterSet &cfg)
	Constructor. More...
bool	processesEvents () override
	Returns whether MP should process events in the current configuration. More...
void	run (const edm::EventSetup &setup, const EventInfo &eventInfo) override
	Run the algorithm on trajectories and tracks. More...
bool	setParametersForRunRange (const RunRange &runrange) override
bool	storeAlignments () override
	Returns whether MP produced results to be stored. More...
virtual bool	storeThresholds (const int &nRecords, const AlignPCLThresholds::threshold_map &thresholdMap)
bool	supportsCalibrations () override
	Returns whether MP supports calibrations. More...
void	terminate (const edm::EventSetup &iSetup) override
	Called at end of job. More...
void	terminate () override
	Called at end of job. More...
	~MillePedeAlignmentAlgorithm () override
	Destructor. More...
Public Member Functions inherited from AlignmentAlgorithmBase
virtual bool	addCalibrations (const Calibrations &)
	AlignmentAlgorithmBase (const edm::ParameterSet &)
	Constructor. More...
virtual void	startNewLoop ()
virtual	~AlignmentAlgorithmBase ()
	Destructor. More...

Private Types
enum	EModeBit { myMilleBit = 1 << 0, myPedeRunBit = 1 << 1, myPedeSteerBit = 1 << 2, myPedeReadBit = 1 << 3 }
enum	MeasurementDirection { kLocalX = 0, kLocalY }

Private Member Functions
int	addGlobalData (const edm::EventSetup &setup, const EventInfo &eventInfo, const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &refTrajPtr, unsigned int iHit, gbl::GblPoint &gblPoint)
unsigned int	addHitCount (const std::vector< AlignmentParameters * > &parVec, const std::vector< bool > &validHitVecY) const
bool	addHits (const align::Alignables &alis, const std::vector< AlignmentUserVariables * > &mpVars) const
bool	addHitStatistics (int fromLoop, const std::string &outFile, const std::vector< std::string > &inFiles) const
void	addLasBeam (const EventInfo &eventInfo, const TkFittedLasBeam &lasBeam, const std::vector< TrajectoryStateOnSurface > &tsoses)
void	addLaserData (const EventInfo &eventInfo, const TkFittedLasBeamCollection &tkLasBeams, const TsosVectorCollection &tkLasBeamTsoses)
int	addMeasurementData (const edm::EventSetup &setup, const EventInfo &eventInfo, const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &refTrajPtr, unsigned int iHit, AlignmentParameters *&params)
void	addPxbSurvey (const edm::ParameterSet &pxbSurveyCfg)
	add measurement data from PXB survey More...
std::pair< unsigned int, unsigned int >	addReferenceTrajectory (const edm::EventSetup &setup, const EventInfo &eventInfo, const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &refTrajPtr)
	fill mille for a trajectory, returning number of x/y hits ([0,0] if 'bad' trajectory) More...
template<typename CovarianceMatrix , typename ResidualMatrix , typename LocalDerivativeMatrix >
void	addRefTrackData2D (const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &refTrajPtr, unsigned int iTrajHit, Eigen::MatrixBase< CovarianceMatrix > &aHitCovarianceM, Eigen::MatrixBase< ResidualMatrix > &aHitResidualsM, Eigen::MatrixBase< LocalDerivativeMatrix > &aLocalDerivativesM)
	adds data from reference trajectory from a specific Hit More...
template<typename CovarianceMatrix , typename ResidualMatrix , typename LocalDerivativeMatrix >
void	addRefTrackVirtualMeas1D (const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &refTrajPtr, unsigned int iVirtualMeas, Eigen::MatrixBase< CovarianceMatrix > &aHitCovarianceM, Eigen::MatrixBase< ResidualMatrix > &aHitResidualsM, Eigen::MatrixBase< LocalDerivativeMatrix > &aLocalDerivativesM)
	adds data for a specific virtual measurement from reference trajectory More...
void	addVirtualMeas (const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &refTrajPtr, unsigned int iVirtualMeas)
	adds data for virtual measurements from reference trajectory More...
bool	areEmptyParams (const align::Alignables &alignables) const
bool	areIOVsSpecified () const
void	buildUserVariables (const align::Alignables &alignables) const
	add MillePedeVariables for each AlignmentParameters (exception if no parameters...) More...
int	callMille (const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &refTrajPtr, unsigned int iTrajHit, const std::vector< int > &globalLabels, const std::vector< float > &globalDerivativesX, const std::vector< float > &globalDerivativesY)
	calls callMille1D or callMille2D More...
int	callMille1D (const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &refTrajPtr, unsigned int iTrajHit, const std::vector< int > &globalLabels, const std::vector< float > &globalDerivativesX)
	calls Mille for 1D hits More...
int	callMille2D (const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &refTrajPtr, unsigned int iTrajHit, const std::vector< int > &globalLabels, const std::vector< float > &globalDerivativesx, const std::vector< float > &globalDerivativesy)
unsigned int	decodeMode (const std::string &mode) const
template<typename CovarianceMatrix , typename LocalDerivativeMatrix , typename ResidualMatrix , typename GlobalDerivativeMatrix >
void	diagonalize (Eigen::MatrixBase< CovarianceMatrix > &aHitCovarianceM, Eigen::MatrixBase< LocalDerivativeMatrix > &aLocalDerivativesM, Eigen::MatrixBase< ResidualMatrix > &aHitResidualsM, Eigen::MatrixBase< GlobalDerivativeMatrix > &aGlobalDerivativesM) const
unsigned int	doIO (int loop) const
std::vector< std::string >	getExistingFormattedFiles (const std::vector< std::string > &plainFiles, const std::string &theDir)
void	globalDerivativesCalibration (const TransientTrackingRecHit::ConstRecHitPointer &recHit, const TrajectoryStateOnSurface &tsos, const edm::EventSetup &setup, const EventInfo &eventInfo, std::vector< float > &globalDerivativesX, std::vector< float > &globalDerivativesY, std::vector< int > &globalLabels) const
	adding derivatives from integrated calibrations More...
bool	globalDerivativesHierarchy (const EventInfo &eventInfo, const TrajectoryStateOnSurface &tsos, Alignable *ali, const AlignableDetOrUnitPtr &alidet, std::vector< float > &globalDerivativesX, std::vector< float > &globalDerivativesY, std::vector< int > &globalLabels, AlignmentParameters *&lowestParams) const
	recursively adding derivatives and labels, false if problems More...
bool	globalDerivativesHierarchy (const EventInfo &eventInfo, const TrajectoryStateOnSurface &tsos, Alignable *ali, const AlignableDetOrUnitPtr &alidet, std::vector< double > &globalDerivativesX, std::vector< double > &globalDerivativesY, std::vector< int > &globalLabels, AlignmentParameters *&lowestParams) const
	recursively adding derivatives (double) and labels, false if problems More...
bool	is2D (const TransientTrackingRecHit::ConstRecHitPointer &recHit) const
	true if hit belongs to 2D detector (currently tracker specific) More...
bool	isMode (unsigned int testMode) const
template<typename GlobalDerivativeMatrix >
void	makeGlobDerivMatrix (const std::vector< float > &globalDerivativesx, const std::vector< float > &globalDerivativesy, Eigen::MatrixBase< GlobalDerivativeMatrix > &aGlobalDerivativesM)
bool	readFromPede (const edm::ParameterSet &mprespset, bool setUserVars, const RunRange &runrange)
	read pede input defined by 'psetName', flag to create/not create MillePedeVariables More...

Private Attributes
std::vector< align::RunNumber >	cachedRuns_
const bool	enableAlignableUpdates_
const bool	enforceSingleIOVInput_
const align::RunNumber	firstIOV_
const bool	ignoreFirstIOVCheck_
const bool	ignoreHitsWithoutGlobalDerivatives_
align::RunNumber	lastProcessedRun_
const bool	runAtPCL_
const bool	skipGlobalPositionRcdCheck_
std::unique_ptr< AlignableNavigator >	theAlignableNavigator
align::Alignables	theAlignables
AlignmentParameterStore *	theAlignmentParameterStore
	directory for all kind of files More...
std::unique_ptr< gbl::MilleBinary >	theBinary
std::vector< IntegratedCalibrationBase * >	theCalibrations
edm::ParameterSet	theConfig
std::string	theDir
bool	theDoSurveyPixelBarrel
std::vector< float >	theFloatBufferX
std::vector< float >	theFloatBufferY
bool	theGblDoubleBinary
std::vector< int >	theIntBuffer
int	theLastWrittenIov
double	theMaximalCor2D
std::unique_ptr< Mille >	theMille
unsigned int	theMinNumHits
unsigned int	theMode
std::unique_ptr< MillePedeMonitor >	theMonitor
std::shared_ptr< PedeLabelerBase >	thePedeLabels
std::unique_ptr< PedeSteerer >	thePedeSteer
std::shared_ptr< AlignPCLThresholds >	theThresholds
std::unique_ptr< TrajectoryFactoryBase >	theTrajectoryFactory
const align::RunRanges	uniqueRunRanges_

Additional Inherited Members
Public Types inherited from AlignmentAlgorithmBase
typedef std::pair< const Trajectory *, const reco::Track * >	ConstTrajTrackPair
typedef std::vector< ConstTrajTrackPair >	ConstTrajTrackPairCollection
using	RunNumber = align::RunNumber
using	RunRange = align::RunRange

Detailed Description

CMSSW interface to pede: produces pede's binary input and steering file(s)

Author

: Gero Flucke date : October 2006

Revision

1.36

Date

2012/08/10 09:01:11

(last update by

Author

flucke

)

Definition at line 53 of file MillePedeAlignmentAlgorithm.h.

Member Enumeration Documentation

enum MillePedeAlignmentAlgorithm::EModeBit

private

Enumerator
myMilleBit
myPedeRunBit
myPedeSteerBit
myPedeReadBit

Definition at line 262 of file MillePedeAlignmentAlgorithm.h.

                {myMilleBit = 1 << 0, myPedeRunBit = 1 << 1, myPedeSteerBit = 1 << 2,
                 myPedeReadBit = 1 << 3};

enum MillePedeAlignmentAlgorithm::MeasurementDirection

private

Enumerator
kLocalX
kLocalY

Definition at line 117 of file MillePedeAlignmentAlgorithm.h.

{kLocalX = 0, kLocalY};

Constructor & Destructor Documentation

MillePedeAlignmentAlgorithm::MillePedeAlignmentAlgorithm

(

const edm::ParameterSet &

cfg

)

Constructor.

Definition at line 93 of file MillePedeAlignmentAlgorithm.cc.

References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), isMode(), myMilleBit, AlCaHLTBitMon_QueryRunRegistry::string, theBinary, theConfig, theDir, theGblDoubleBinary, and theMille.

                                                                                   :
  AlignmentAlgorithmBase(cfg),
  theConfig(cfg),
  theMode(this->decodeMode(theConfig.getUntrackedParameter<std::string>("mode"))),
  theDir(theConfig.getUntrackedParameter<std::string>("fileDir")),
  theAlignmentParameterStore(nullptr),
  theAlignables(),
  theMinNumHits(cfg.getParameter<unsigned int>("minNumHits")),
  theMaximalCor2D(cfg.getParameter<double>("max2Dcorrelation")),
  firstIOV_(cfg.getUntrackedParameter<AlignmentAlgorithmBase::RunNumber>("firstIOV")),
  ignoreFirstIOVCheck_(cfg.getUntrackedParameter<bool>("ignoreFirstIOVCheck")),
  enableAlignableUpdates_(cfg.getUntrackedParameter<bool>("enableAlignableUpdates")),
  theLastWrittenIov(0),
  theGblDoubleBinary(cfg.getParameter<bool>("doubleBinary")),
  runAtPCL_(cfg.getParameter<bool>("runAtPCL")),
  ignoreHitsWithoutGlobalDerivatives_(cfg.getParameter<bool>("ignoreHitsWithoutGlobalDerivatives")),
  skipGlobalPositionRcdCheck_(cfg.getParameter<bool>("skipGlobalPositionRcdCheck")),
  uniqueRunRanges_
  (align::makeUniqueRunRanges(cfg.getUntrackedParameter<edm::VParameterSet>("RunRangeSelection"),
                              cond::timeTypeSpecs[cond::runnumber].beginValue)),
  enforceSingleIOVInput_(!(enableAlignableUpdates_ && areIOVsSpecified())),
  lastProcessedRun_(cond::timeTypeSpecs[cond::runnumber].beginValue)
{
  if (!theDir.empty() && theDir.find_last_of('/') != theDir.size()-1) theDir += '/';// may need '/'
  edm::LogInfo("Alignment") << "@SUB=MillePedeAlignmentAlgorithm" << "Start in mode '"
                            << theConfig.getUntrackedParameter<std::string>("mode")
                            << "' with output directory '" << theDir << "'.";
  if (this->isMode(myMilleBit)) {
    theMille = std::make_unique<Mille>((theDir + theConfig.getParameter<std::string>("binaryFile")).c_str());// add ', false);' for text output);
    // use same file for GBL
    theBinary = std::make_unique<MilleBinary>((theDir + theConfig.getParameter<std::string>("binaryFile")).c_str(), theGblDoubleBinary);
  }
}

MillePedeAlignmentAlgorithm::~MillePedeAlignmentAlgorithm ( )

override

Destructor.

Definition at line 129 of file MillePedeAlignmentAlgorithm.cc.

{
}

Member Function Documentation

bool MillePedeAlignmentAlgorithm::addCalibrations ( const std::vector< IntegratedCalibrationBase * > &  iCals )

override

Pass integrated calibrations to Millepede (they are not owned by Millepede!)

Definition at line 320 of file MillePedeAlignmentAlgorithm.cc.

References theCalibrations, and thePedeLabels.

{
  theCalibrations.insert(theCalibrations.end(), iCals.begin(), iCals.end());
  thePedeLabels->addCalibrations(iCals);
  return true;
}

int MillePedeAlignmentAlgorithm::addGlobalData ( const edm::EventSetup &  setup, const EventInfo &  eventInfo, const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &  refTrajPtr, unsigned int  iHit, gbl::GblPoint &  gblPoint  )

private

Add global data (labels, derivatives) to GBL trajectory Returns -1 if any problem (for params cf. globalDerivativesHierarchy)

Definition at line 809 of file MillePedeAlignmentAlgorithm.cc.

References globalDerivativesHierarchy(), mps_fire::i, theAlignableNavigator, theCalibrations, theIntBuffer, and thePedeLabels.

Referenced by addReferenceTrajectory().

{
  AlignmentParameters* params = nullptr;
  std::vector<double> theDoubleBufferX, theDoubleBufferY;
  theDoubleBufferX.clear();
  theDoubleBufferY.clear();
  theIntBuffer.clear();
  int iret = 0;

  const TrajectoryStateOnSurface &tsos = refTrajPtr->trajectoryStates()[iHit];
  const ConstRecHitPointer &recHitPtr = refTrajPtr->recHits()[iHit];
  // ignore invalid hits
  if (!recHitPtr->isValid()) return 0;

  // get AlignableDet/Unit for this hit
  AlignableDetOrUnitPtr alidet(theAlignableNavigator->alignableFromDetId(recHitPtr->geographicalId()));

  if (!this->globalDerivativesHierarchy(eventInfo,
                                        tsos, alidet, alidet, theDoubleBufferX, // 2x alidet, sic!
                                        theDoubleBufferY, theIntBuffer, params)) {
    return -1; // problem
  }
  //calibration parameters
  int globalLabel;
  std::vector<IntegratedCalibrationBase::ValuesIndexPair> derivs;
  for (auto iCalib = theCalibrations.begin(); iCalib != theCalibrations.end(); ++iCalib) {
    // get all derivatives of this calibration // const unsigned int num =
    (*iCalib)->derivatives(derivs, *recHitPtr, tsos, setup, eventInfo);
    for (auto iValuesInd = derivs.begin(); iValuesInd != derivs.end(); ++iValuesInd) {
      // transfer label and x/y derivatives
      globalLabel = thePedeLabels->calibrationLabel(*iCalib, iValuesInd->second);
      if (globalLabel > 0 && globalLabel <= 2147483647) {
        theIntBuffer.push_back(globalLabel);
        theDoubleBufferX.push_back(iValuesInd->first.first);
        theDoubleBufferY.push_back(iValuesInd->first.second);
      } else {
        edm::LogError("Alignment")
          << "@SUB=MillePedeAlignmentAlgorithm::addGlobalData"
          << "Invalid label " << globalLabel << " <= 0 or > 2147483647";
      }
    }
  }
  unsigned int numGlobals = theIntBuffer.size();
  if (numGlobals > 0)
  {
    Eigen::Matrix<double, 2, Eigen::Dynamic> globalDer{2, numGlobals};
    for (unsigned int i = 0; i < numGlobals; ++i) {
      globalDer(0,i) = theDoubleBufferX[i];
      globalDer(1,i) = theDoubleBufferY[i];
    }
    gblPoint.addGlobals( theIntBuffer, globalDer );
    iret = 1;
  }
  return iret;
}

unsigned int MillePedeAlignmentAlgorithm::addHitCount ( const std::vector< AlignmentParameters * > &  parVec, const std::vector< bool > &  validHitVecY  ) const

private

Increase hit counting of MillePedeVariables behind each parVec[i] (and also for parameters higher in hierarchy), assuming 'parVec' and 'validHitVecY' to be parallel. Returns number of valid y-hits.

Definition at line 619 of file MillePedeAlignmentAlgorithm.cc.

References Alignable::alignmentParameters(), MillePedeVariables::increaseHitsX(), MillePedeVariables::increaseHitsY(), Alignable::mother(), and AlignmentParameters::userVariables().

Referenced by addReferenceTrajectory().

{
  // Loop on all hit information in the input arrays and count valid y-hits:
  unsigned int nHitY = 0;
  for (unsigned int iHit = 0; iHit < validHitVecY.size(); ++iHit) {
    Alignable *ali = (parVec[iHit] ? parVec[iHit]->alignable() : nullptr);
    // Loop upwards on hierarchy of alignables to add hits to all levels
    // that are currently aligned. If only a non-selected alignable was hit,
    // (i.e. flagXY == 0 in addReferenceTrajectory(..)), there is no loop at all...
    while (ali) {
      AlignmentParameters *pars = ali->alignmentParameters();
      if (pars) { // otherwise hierarchy level not selected
        // cast ensured by previous checks:
        MillePedeVariables *mpVar = static_cast<MillePedeVariables*>(pars->userVariables());
        // every hit has an x-measurement, cf. addReferenceTrajectory(..):
        mpVar->increaseHitsX();
        if (validHitVecY[iHit]) {
          mpVar->increaseHitsY();
          if (pars == parVec[iHit]) ++nHitY; // do not count hits twice
        }
      }
      ali = ali->mother();
    }
  }

  return nHitY;
}

bool MillePedeAlignmentAlgorithm::addHits ( const align::Alignables &  alis, const std::vector< AlignmentUserVariables * > &  mpVars  ) const

private

Definition at line 1256 of file MillePedeAlignmentAlgorithm.cc.

References MillePedeVariables::hitsX(), MillePedeVariables::hitsY(), MillePedeVariables::increaseHitsX(), MillePedeVariables::increaseHitsY(), MillePedeVariables::size(), and AlignmentParameters::userVariables().

Referenced by addHitStatistics(), and isMode().

{
  bool allOk = (mpVars.size() == alis.size());
  std::vector<AlignmentUserVariables*>::const_iterator iUser = mpVars.begin();
  for (auto iAli = alis.cbegin(); iAli != alis.cend() && iUser != mpVars.end(); ++iAli, ++iUser) {
    MillePedeVariables *mpVarNew = dynamic_cast<MillePedeVariables*>(*iUser);
    AlignmentParameters *ps = (*iAli)->alignmentParameters();
    MillePedeVariables *mpVarOld = (ps ? dynamic_cast<MillePedeVariables*>(ps->userVariables()) : nullptr);
    if (!mpVarNew || !mpVarOld || mpVarOld->size() != mpVarNew->size()) {
      allOk = false;
      continue; // FIXME error etc.?
    }

    mpVarOld->increaseHitsX(mpVarNew->hitsX());
    mpVarOld->increaseHitsY(mpVarNew->hitsY());
  }

  return allOk;
}

bool MillePedeAlignmentAlgorithm::addHitStatistics ( int  fromLoop, const std::string &  outFile, const std::vector< std::string > &  inFiles  ) const

private

Definition at line 1229 of file MillePedeAlignmentAlgorithm.cc.

References addHits(), mps_fire::i, MillePedeVariablesIORoot::readMillePedeVariables(), AlCaHLTBitMon_QueryRunRegistry::string, theAlignables, and theDir.

Referenced by doIO(), and isMode().

{
  bool allOk = true;
  int ierr = 0;
  MillePedeVariablesIORoot millePedeIO;
  for (std::vector<std::string>::const_iterator iFile = inFiles.begin();
       iFile != inFiles.end(); ++iFile) {
    const std::string inFile(theDir + *iFile);
    const std::vector<AlignmentUserVariables*> mpVars =
      millePedeIO.readMillePedeVariables(theAlignables, inFile.c_str(), fromIov, ierr);
    if (ierr || !this->addHits(theAlignables, mpVars)) {
      edm::LogError("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::addHitStatistics"
                                 << "Error " << ierr << " reading from " << inFile
                                 << ", tree " << fromIov << ", or problems in addHits";
      allOk = false;
    }
    for (std::vector<AlignmentUserVariables*>::const_iterator i = mpVars.begin();
         i != mpVars.end(); ++i) {
      delete *i; // clean created objects
    }
  }

  return allOk;
}

void MillePedeAlignmentAlgorithm::addLasBeam ( const EventInfo &  eventInfo, const TkFittedLasBeam &  lasBeam, const std::vector< TrajectoryStateOnSurface > &  tsoses  )

private

Definition at line 1599 of file MillePedeAlignmentAlgorithm.cc.

References funct::derivative(), TkFittedLasBeam::derivatives(), relativeConstraints::error, TkFittedLasBeam::firstFixedParameter(), TkLasBeam::getBeamId(), TkLasBeam::getData(), SiStripLaserRecHit2D::getDetId(), globalDerivativesHierarchy(), SiStripLaserRecHit2D::localPosition(), TkFittedLasBeam::parameters(), theAlignableNavigator, theFloatBufferX, theFloatBufferY, theIntBuffer, theMille, and thePedeLabels.

Referenced by addLaserData().

{
  AlignmentParameters *dummyPtr = nullptr; // for globalDerivativesHierarchy()
  std::vector<float> lasLocalDerivsX; // buffer for local derivatives
  const unsigned int beamLabel = thePedeLabels->lasBeamLabel(lasBeam.getBeamId());// for global par

  for (unsigned int iHit = 0; iHit < tsoses.size(); ++iHit) {
    if (!tsoses[iHit].isValid()) continue;
    // clear buffer
    theFloatBufferX.clear();
    theFloatBufferY.clear();
    theIntBuffer.clear();
    lasLocalDerivsX.clear();
    // get alignables and global parameters
    const SiStripLaserRecHit2D &hit = lasBeam.getData()[iHit];
    AlignableDetOrUnitPtr lasAli(theAlignableNavigator->alignableFromDetId(hit.getDetId()));
    this->globalDerivativesHierarchy(eventInfo,
                                     tsoses[iHit], lasAli, lasAli,
                                     theFloatBufferX, theFloatBufferY, theIntBuffer, dummyPtr);
    // fill derivatives vector from derivatives matrix
    for (unsigned int nFitParams = 0;
         nFitParams < static_cast<unsigned int>(lasBeam.parameters().size());
         ++nFitParams) {
      const float derivative = lasBeam.derivatives()[iHit][nFitParams];
      if (nFitParams < lasBeam.firstFixedParameter()) { // first local beam parameters
        lasLocalDerivsX.push_back(derivative);
      } else {                                          // now global ones
        const unsigned int numPar = nFitParams - lasBeam.firstFixedParameter();
        theIntBuffer.push_back(thePedeLabels->parameterLabel(beamLabel, numPar));
        theFloatBufferX.push_back(derivative);
      }
    } // end loop over parameters

    const float residual = hit.localPosition().x() - tsoses[iHit].localPosition().x();
    // error from file or assume 0.003
    const float error = 0.003; // hit.localPositionError().xx(); sqrt???

    theMille->mille(lasLocalDerivsX.size(), &(lasLocalDerivsX[0]), theFloatBufferX.size(),
                    &(theFloatBufferX[0]), &(theIntBuffer[0]), residual, error);
  } // end of loop over hits

  theMille->end();
}

void MillePedeAlignmentAlgorithm::addLaserData ( const EventInfo &  eventInfo, const TkFittedLasBeamCollection &  tkLasBeams, const TsosVectorCollection &  tkLasBeamTsoses  )

private

Definition at line 1580 of file MillePedeAlignmentAlgorithm.cc.

References addLasBeam().

Referenced by endRun().

{
  TsosVectorCollection::const_iterator iTsoses = lasBeamTsoses.begin();
  for(TkFittedLasBeamCollection::const_iterator iBeam = lasBeams.begin(), iEnd = lasBeams.end();
      iBeam != iEnd; ++iBeam, ++iTsoses){ // beam/tsoses parallel!

    edm::LogInfo("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::addLaserData"
                              << "Beam " << iBeam->getBeamId() << " with "
                              << iBeam->parameters().size() << " parameters and "
                              << iBeam->getData().size() << " hits.\n There are "
                              << iTsoses->size() << " TSOSes.";

    this->addLasBeam(eventInfo, *iBeam, *iTsoses);
  }
}

int MillePedeAlignmentAlgorithm::addMeasurementData ( const edm::EventSetup &  setup, const EventInfo &  eventInfo, const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &  refTrajPtr, unsigned int  iHit, AlignmentParameters *&  params  )

private

If hit is usable: callMille for x and (probably) y direction. If globalDerivatives fine: returns 2 if 2D-hit, 1 if 1D-hit, 0 if no Alignable for hit. Returns -1 if any problem (for params cf. globalDerivativesHierarchy)

Definition at line 770 of file MillePedeAlignmentAlgorithm.cc.

References callMille(), globalDerivativesCalibration(), globalDerivativesHierarchy(), ignoreHitsWithoutGlobalDerivatives_, theAlignableNavigator, theFloatBufferX, theFloatBufferY, and theIntBuffer.

Referenced by addReferenceTrajectory().

{
  params = nullptr;
  theFloatBufferX.clear();
  theFloatBufferY.clear();
  theIntBuffer.clear();

  const TrajectoryStateOnSurface &tsos = refTrajPtr->trajectoryStates()[iHit];
  const ConstRecHitPointer &recHitPtr = refTrajPtr->recHits()[iHit];
  // ignore invalid hits
  if (!recHitPtr->isValid()) return 0;

  // First add the derivatives from IntegratedCalibration's,
  // should even be OK if problems for "usual" derivatives from Alignables
  this->globalDerivativesCalibration(recHitPtr, tsos, setup, eventInfo, // input
                                     theFloatBufferX, theFloatBufferY, theIntBuffer); // output

  // get AlignableDet/Unit for this hit
  AlignableDetOrUnitPtr alidet(theAlignableNavigator->alignableFromDetId(recHitPtr->geographicalId()));

  if (!this->globalDerivativesHierarchy(eventInfo,
                                        tsos, alidet, alidet, theFloatBufferX, // 2x alidet, sic!
                                        theFloatBufferY, theIntBuffer, params)) {
    return -1; // problem
  } else if (theFloatBufferX.empty() && ignoreHitsWithoutGlobalDerivatives_) {
     return 0; // empty for X: no alignable for hit, nor calibrations
  } else {
    // store measurement even if no alignable or calibrations
    // -> measurement used for pede-internal track-fit
    return this->callMille(refTrajPtr, iHit, theIntBuffer, theFloatBufferX, theFloatBufferY);
  }
}

void MillePedeAlignmentAlgorithm::addPxbSurvey ( const edm::ParameterSet &  pxbSurveyCfg )

private

add measurement data from PXB survey

Definition at line 1645 of file MillePedeAlignmentAlgorithm.cc.

References a, vertices_cff::chi2, SurveyPxbDicer::doDice(), corrVsCorr::filename, edm::FileInPath::fullPath(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), mps_fire::i, SurveyPxbImageLocalFit::nMsrmts, lumiCalc2::outfile, matplotRender::reader, mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, Alignable::surface(), theAlignableNavigator, theMille, theMonitor, thePedeLabels, AlignableSurface::toGlobal(), and AlignableSurface::toLocal().

Referenced by initialize().

{
        // do some printing, if requested
        const bool doOutputOnStdout(pxbSurveyCfg.getParameter<bool>("doOutputOnStdout"));
        if (doOutputOnStdout) {
          edm::LogInfo("Alignment")
            << "@SUB=MillePedeAlignmentAlgorithm::addPxbSurvey"
            << "# Output from addPxbSurvey follows below because "
            << "doOutputOnStdout is set to True";
        }

        // instantiate a dicer object
        SurveyPxbDicer dicer(pxbSurveyCfg.getParameter<std::vector<edm::ParameterSet> >("toySurveyParameters"), pxbSurveyCfg.getParameter<unsigned int>("toySurveySeed"));
        std::ofstream outfile(pxbSurveyCfg.getUntrackedParameter<std::string>("toySurveyFile").c_str());

        // read data from file
        std::vector<SurveyPxbImageLocalFit> measurements;
        std::string filename(pxbSurveyCfg.getParameter<edm::FileInPath>("infile").fullPath());
        SurveyPxbImageReader<SurveyPxbImageLocalFit> reader(filename, measurements, 800);

        // loop over photographs (=measurements) and perform the fit
        for(std::vector<SurveyPxbImageLocalFit>::size_type i=0; i!=measurements.size(); i++)
        {
                if (doOutputOnStdout) {
                  edm::LogInfo("Alignment")
                    << "@SUB=MillePedeAlignmentAlgorithm::addPxbSurvey"
                    << "Module " << i << ": ";
                }

                // get the Alignables and their surfaces
                AlignableDetOrUnitPtr mod1(theAlignableNavigator->alignableFromDetId(measurements[i].getIdFirst()));
                AlignableDetOrUnitPtr mod2(theAlignableNavigator->alignableFromDetId(measurements[i].getIdSecond()));
                const AlignableSurface& surf1 = mod1->surface();
                const AlignableSurface& surf2 = mod2->surface();

                // the position of the fiducial points in local frame of a PXB module
                const LocalPoint fidpoint0(-0.91,+3.30);
                const LocalPoint fidpoint1(+0.91,+3.30);
                const LocalPoint fidpoint2(+0.91,-3.30);
                const LocalPoint fidpoint3(-0.91,-3.30);

                // We choose the local frame of the first module as reference,
                // so take the fidpoints of the second module and calculate their
                // positions in the reference frame
                const GlobalPoint surf2point0(surf2.toGlobal(fidpoint0));
                const GlobalPoint surf2point1(surf2.toGlobal(fidpoint1));
                const LocalPoint fidpoint0inSurf1frame(surf1.toLocal(surf2point0));
                const LocalPoint fidpoint1inSurf1frame(surf1.toLocal(surf2point1));

                // Create the vector for the fit
                SurveyPxbImageLocalFit::fidpoint_t fidpointvec;
                fidpointvec.push_back(fidpoint0inSurf1frame);
                fidpointvec.push_back(fidpoint1inSurf1frame);
                fidpointvec.push_back(fidpoint2);
                fidpointvec.push_back(fidpoint3);

                // if toy survey is requested, dice the values now
                if (pxbSurveyCfg.getParameter<bool>("doToySurvey"))
                {
                        dicer.doDice(fidpointvec,measurements[i].getIdPair(), outfile);
                }

                // do the fit
                measurements[i].doFit(fidpointvec, thePedeLabels->alignableLabel(mod1), thePedeLabels->alignableLabel(mod2));
            SurveyPxbImageLocalFit::localpars_t a; // local pars from fit
                a = measurements[i].getLocalParameters();
                const SurveyPxbImageLocalFit::value_t chi2 = measurements[i].getChi2();

                // do some reporting, if requested
                if (doOutputOnStdout)
                {
                  edm::LogInfo("Alignment")
                    << "@SUB=MillePedeAlignmentAlgorithm::addPxbSurvey"
                    << "a: " << a[0] << ", " << a[1]  << ", " << a[2] << ", " << a[3]
                    << " S= " << sqrt(a[2]*a[2]+a[3]*a[3])
                    << " phi= " << atan(a[3]/a[2])
                    << " chi2= " << chi2 << std::endl;
                }
                if (theMonitor)
                {
                        theMonitor->fillPxbSurveyHistsChi2(chi2);
                        theMonitor->fillPxbSurveyHistsLocalPars(a[0],a[1],sqrt(a[2]*a[2]+a[3]*a[3]),atan(a[3]/a[2]));
                }

                // pass the results from the local fit to mille
                for(SurveyPxbImageLocalFit::count_t j=0; j!=SurveyPxbImageLocalFit::nMsrmts; j++)
                {
                        theMille->mille((int)measurements[i].getLocalDerivsSize(),
                                measurements[i].getLocalDerivsPtr(j),
                                (int)measurements[i].getGlobalDerivsSize(),
                                measurements[i].getGlobalDerivsPtr(j),
                                measurements[i].getGlobalDerivsLabelPtr(j),
                                measurements[i].getResiduum(j),
                                measurements[i].getSigma(j));
                }
                theMille->end();
        }
        outfile.close();
}

std::pair< unsigned int, unsigned int > MillePedeAlignmentAlgorithm::addReferenceTrajectory ( const edm::EventSetup &  setup, const EventInfo &  eventInfo, const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &  refTrajPtr  )

private

fill mille for a trajectory, returning number of x/y hits ([0,0] if 'bad' trajectory)

Definition at line 533 of file MillePedeAlignmentAlgorithm.cc.

References addGlobalData(), addHitCount(), addMeasurementData(), addVirtualMeas(), theBinary, theMille, and theMinNumHits.

Referenced by run().

{
  std::pair<unsigned int, unsigned int> hitResultXy(0,0);
  if (refTrajPtr->isValid()) {


    // GblTrajectory?
    if (!refTrajPtr->gblInput().empty()) {
      // by construction: number of GblPoints == number of recHits or == zero !!!
      unsigned int iHit = 0;
      unsigned int numPointsWithMeas = 0;
      std::vector<GblPoint>::iterator itPoint;
      auto theGblInput = refTrajPtr->gblInput();
      for (unsigned int iTraj = 0; iTraj < refTrajPtr->gblInput().size(); ++iTraj) {
        for (itPoint = refTrajPtr->gblInput()[iTraj].first.begin(); itPoint < refTrajPtr->gblInput()[iTraj].first.end(); ++itPoint) {
          if (this->addGlobalData(setup, eventInfo, refTrajPtr, iHit++, *itPoint) < 0) return hitResultXy;
          if (itPoint->hasMeasurement() >= 1) ++numPointsWithMeas;
        }
      }
      hitResultXy.first = numPointsWithMeas;
      // check #hits criterion
      if (hitResultXy.first == 0 || hitResultXy.first < theMinNumHits) return hitResultXy;
      // construct GBL trajectory
      if (refTrajPtr->gblInput().size() == 1) {
        // from single track
        GblTrajectory aGblTrajectory( refTrajPtr->gblInput()[0].first, refTrajPtr->nominalField() != 0 );
        // GBL fit trajectory
        /*double Chi2;
        int Ndf;
        double lostWeight;
        aGblTrajectory.fit(Chi2, Ndf, lostWeight);
        std::cout << " GblFit: " << Chi2 << ", " << Ndf << ", " << lostWeight << std::endl; */
        // write to MP binary file
        if (aGblTrajectory.isValid() && aGblTrajectory.getNumPoints() >= theMinNumHits) aGblTrajectory.milleOut(*theBinary);
      }
      if (refTrajPtr->gblInput().size() == 2) {
        // from TwoBodyDecay
        GblTrajectory aGblTrajectory( refTrajPtr->gblInput(), refTrajPtr->gblExtDerivatives(), refTrajPtr->gblExtMeasurements(), refTrajPtr->gblExtPrecisions() );
        // write to MP binary file
        if (aGblTrajectory.isValid() && aGblTrajectory.getNumPoints() >= theMinNumHits) aGblTrajectory.milleOut(*theBinary);
      }
    } else {
      // to add hits if all fine:
      std::vector<AlignmentParameters*> parVec(refTrajPtr->recHits().size());
      // collect hit statistics, assuming that there are no y-only hits
      std::vector<bool> validHitVecY(refTrajPtr->recHits().size(), false);
      // Use recHits from ReferenceTrajectory (since they have the right order!):
      for (unsigned int iHit = 0; iHit < refTrajPtr->recHits().size(); ++iHit) {
        const int flagXY = this->addMeasurementData(setup, eventInfo, refTrajPtr, iHit, parVec[iHit]);

        if (flagXY < 0) { // problem
          hitResultXy.first = 0;
          break;
        } else { // hit is fine, increase x/y statistics
          if (flagXY >= 1) ++hitResultXy.first;
          validHitVecY[iHit] = (flagXY >= 2);
        }
      } // end loop on hits

      // add virtual measurements
      for (unsigned int iVirtualMeas = 0; iVirtualMeas < refTrajPtr->numberOfVirtualMeas(); ++iVirtualMeas) {
        this->addVirtualMeas(refTrajPtr, iVirtualMeas);
      }

      // kill or end 'track' for mille, depends on #hits criterion
      if (hitResultXy.first == 0 || hitResultXy.first < theMinNumHits) {
        theMille->kill();
        hitResultXy.first = hitResultXy.second = 0; //reset
      } else {
        theMille->end();
        // add x/y hit count to MillePedeVariables of parVec,
        // returning number of y-hits of the reference trajectory
        hitResultXy.second = this->addHitCount(parVec, validHitVecY);
        //
      }
    }

  } // end if valid trajectory

  return hitResultXy;
}

template<typename CovarianceMatrix , typename ResidualMatrix , typename LocalDerivativeMatrix >

void MillePedeAlignmentAlgorithm::addRefTrackData2D ( const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &  refTrajPtr, unsigned int  iTrajHit, Eigen::MatrixBase< CovarianceMatrix > &  aHitCovarianceM, Eigen::MatrixBase< ResidualMatrix > &  aHitResidualsM, Eigen::MatrixBase< LocalDerivativeMatrix > &  aLocalDerivativesM  )

private

adds data from reference trajectory from a specific Hit

Definition at line 1355 of file MillePedeAlignmentAlgorithm.cc.

References callMille(), and mps_fire::i.

Referenced by addRefTrackVirtualMeas1D(), and callMille2D().

{
  // This Method is valid for 2D measurements only

  const unsigned int xIndex = iTrajHit*2;
  const unsigned int yIndex = iTrajHit*2+1;

  aHitCovarianceM(0,0)=refTrajPtr->measurementErrors()[xIndex][xIndex];
  aHitCovarianceM(0,1)=refTrajPtr->measurementErrors()[xIndex][yIndex];
  aHitCovarianceM(1,0)=refTrajPtr->measurementErrors()[yIndex][xIndex];
  aHitCovarianceM(1,1)=refTrajPtr->measurementErrors()[yIndex][yIndex];

  aHitResidualsM(0,0)= refTrajPtr->measurements()[xIndex] - refTrajPtr->trajectoryPositions()[xIndex];
  aHitResidualsM(1,0)= refTrajPtr->measurements()[yIndex] - refTrajPtr->trajectoryPositions()[yIndex];

  const auto& locDerivMatrix = refTrajPtr->derivatives();
  for (int i = 0; i < locDerivMatrix.num_col(); ++i) {
    aLocalDerivativesM(0,i) = locDerivMatrix[xIndex][i];
    aLocalDerivativesM(1,i) = locDerivMatrix[yIndex][i];
  }
}

template<typename CovarianceMatrix , typename ResidualMatrix , typename LocalDerivativeMatrix >

void MillePedeAlignmentAlgorithm::addRefTrackVirtualMeas1D ( const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &  refTrajPtr, unsigned int  iVirtualMeas, Eigen::MatrixBase< CovarianceMatrix > &  aHitCovarianceM, Eigen::MatrixBase< ResidualMatrix > &  aHitResidualsM, Eigen::MatrixBase< LocalDerivativeMatrix > &  aLocalDerivativesM  )

private

adds data for a specific virtual measurement from reference trajectory

Definition at line 1331 of file MillePedeAlignmentAlgorithm.cc.

References addRefTrackData2D(), and mps_fire::i.

Referenced by addVirtualMeas(), and diagonalize().

{
  // This Method is valid for 1D measurements only

  const unsigned int xIndex = iVirtualMeas + refTrajPtr->numberOfHitMeas();

  aHitCovarianceM(0,0)=refTrajPtr->measurementErrors()[xIndex][xIndex];
  aHitResidualsM(0,0)= refTrajPtr->measurements()[xIndex];

  const auto& locDerivMatrix = refTrajPtr->derivatives();
  for (int i = 0; i < locDerivMatrix.num_col(); ++i) {
    aLocalDerivativesM(0,i) = locDerivMatrix[xIndex][i];
  }
}

void MillePedeAlignmentAlgorithm::addVirtualMeas ( const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &  refTrajPtr, unsigned int  iVirtualMeas  )

private

adds data for virtual measurements from reference trajectory

Definition at line 1546 of file MillePedeAlignmentAlgorithm.cc.

References addRefTrackVirtualMeas1D(), and theMille.

Referenced by addReferenceTrajectory(), and callMille2D().

{
  Eigen::Matrix<double, 1, 1> aHitCovarianceM;
  Eigen::Matrix<float, 1, 1> aHitResidualsM;
  Eigen::Matrix<float, 1, Eigen::Dynamic>
    aLocalDerivativesM{1, refTrajPtr->derivatives().num_col()};
  // below method fills above 3 'matrices'
  this->addRefTrackVirtualMeas1D(refTrajPtr, iVirtualMeas, aHitCovarianceM, aHitResidualsM, aLocalDerivativesM);

  // no global parameters (use dummy 0)
  auto aGlobalDerivativesM = Eigen::Matrix<float, 1, 1>::Zero();

  float newResidX = aHitResidualsM(0,0);
  float newHitErrX = TMath::Sqrt(aHitCovarianceM(0,0));
  std::vector<float> newLocalDerivsX(aLocalDerivativesM.size());
  Eigen::Map<Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> >
    (newLocalDerivsX.data(),
     aLocalDerivativesM.rows(),
     aLocalDerivativesM.cols()) = aLocalDerivativesM;

  std::vector<float> newGlobDerivsX(aGlobalDerivativesM.size());
  Eigen::Map<Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> >
    (newGlobDerivsX.data(),
     aGlobalDerivativesM.rows(),
     aGlobalDerivativesM.cols()) = aGlobalDerivativesM;

  const int nLocal  = aLocalDerivativesM.cols();
  const int nGlobal = 0;

  theMille->mille(nLocal, newLocalDerivsX.data(), nGlobal, newGlobDerivsX.data(),
                  &nGlobal, newResidX, newHitErrX);
}

bool MillePedeAlignmentAlgorithm::areEmptyParams ( const align::Alignables &  alignables ) const

private

Definition at line 1098 of file MillePedeAlignmentAlgorithm.cc.

References AlignmentParameters::covariance(), mps_fire::i, and AlignmentParameters::parameters().

Referenced by readFromPede().

{

  for (const auto& iAli: alignables) {
    const AlignmentParameters *params = iAli->alignmentParameters();
    if (params) {
      const auto& parVec(params->parameters());
      const auto& parCov(params->covariance());
      for (int i = 0; i < parVec.num_row(); ++i) {
        if (parVec[i] != 0.) return false;
        for (int j = i; j < parCov.num_col(); ++j) {
          if (parCov[i][j] != 0.) return false;
        }
      }
    }
  }

  return true;
}

bool MillePedeAlignmentAlgorithm::areIOVsSpecified ( ) const

private

Definition at line 1746 of file MillePedeAlignmentAlgorithm.cc.

References edm::ParameterSet::getUntrackedParameter(), align::makeNonOverlappingRunRanges(), cond::runnumber, theConfig, and cond::timeTypeSpecs.

                                                         {
  const auto runRangeSelection =
    theConfig.getUntrackedParameter<edm::VParameterSet>("RunRangeSelection");

  if (runRangeSelection.empty()) return false;

  const auto runRanges =
    align::makeNonOverlappingRunRanges(runRangeSelection,
                                       cond::timeTypeSpecs[cond::runnumber].beginValue);

  return !(runRanges.empty());
}

void MillePedeAlignmentAlgorithm::beginLuminosityBlock ( const edm::EventSetup &  )

overridevirtual

called at begin of luminosity block (resets Mille binary in mille mode)

Reimplemented from AlignmentAlgorithmBase.

Definition at line 755 of file MillePedeAlignmentAlgorithm.cc.

References isMode(), myMilleBit, runAtPCL_, and theMille.

{
  if (!runAtPCL_) return;
  if(this->isMode(myMilleBit)) theMille->resetOutputFile();
}

void MillePedeAlignmentAlgorithm::beginRun ( const edm::Run &  run, const edm::EventSetup &  setup, bool  changed  )

overridevirtual

called at begin of run

Reimplemented from AlignmentAlgorithmBase.

Definition at line 649 of file MillePedeAlignmentAlgorithm.cc.

References cond::TimeTypeSpecs::beginValue, cachedRuns_, AlignmentParameterStore::cacheTransformations(), enableAlignableUpdates_, edm::IOVSyncValue::eventID(), Exception, spr::find(), edm::ValidityInterval::first(), firstIOV_, dataset::firstRun, edm::EventSetup::get(), ignoreFirstIOVCheck_, edm::eventsetup::EventSetupRecordImplementation< T >::key(), lastProcessedRun_, edm::eventsetup::EventSetupRecordKey::name(), edm::EventID::run(), edm::RunBase::run(), cond::runnumber, convertSQLiteXML::runNumber, skipGlobalPositionRcdCheck_, theAlignmentParameterStore, cond::persistency::throwException(), cond::timeTypeSpecs, uniqueRunRanges_, and edm::eventsetup::EventSetupRecord::validityInterval().

                                                         {
  if (run.run() < firstIOV_ && !ignoreFirstIOVCheck_) {
    throw cms::Exception("Alignment")
      << "@SUB=MillePedeAlignmentAlgorithm::beginRun\n"
      << "Using data (run = " << run.run()
      << ") prior to the first defined IOV (" << firstIOV_ << ").";
  }

  lastProcessedRun_ = run.run();

  if (changed && enableAlignableUpdates_) {
    const auto runNumber = run.run();
    auto firstRun = cond::timeTypeSpecs[cond::runnumber].beginValue;
    for (auto runRange = uniqueRunRanges_.crbegin();
         runRange != uniqueRunRanges_.crend(); ++runRange) {
      if (runNumber >= runRange->first) {
        firstRun = runRange->first;
        break;
      }
    }
    if (std::find(cachedRuns_.begin(), cachedRuns_.end(), firstRun)
        != cachedRuns_.end()) {
      const auto& geometryRcd  = setup.get<IdealGeometryRecord>();
      const auto& globalPosRcd = setup.get<GlobalPositionRcd>();
      const auto& alignmentRcd = setup.get<TrackerAlignmentRcd>();
      const auto& surfaceRcd   = setup.get<TrackerSurfaceDeformationRcd>();
      const auto& errorRcd     = setup.get<TrackerAlignmentErrorExtendedRcd>();

      std::ostringstream message;
      bool throwException{false};
      message
        << "Trying to cache tracker alignment payloads for a run (" << runNumber
        << ") in an IOV (" << firstRun << ") that was already cached.\n"
        << "The following records in your input database tag have an IOV "
        << "boundary that does not match your IOV definition:\n";
      if (geometryRcd.validityInterval().first().eventID().run() > firstRun) {
        message
          << " - IdealGeometryRecord '" << geometryRcd.key().name()
          << "' (since "
          << geometryRcd.validityInterval().first().eventID().run() << ")\n";
        throwException = true;
      }
      if (globalPosRcd.validityInterval().first().eventID().run() > firstRun) {
        message
          << " - GlobalPositionRecord '" << globalPosRcd.key().name()
          << "' (since "
          << globalPosRcd.validityInterval().first().eventID().run() << ")";
        if (skipGlobalPositionRcdCheck_) {
          message << " --> ignored\n";
        } else {
          message << "\n";
          throwException = true;
        }
      }
      if (alignmentRcd.validityInterval().first().eventID().run() > firstRun) {
        message
          << " - TrackerAlignmentRcd '" << alignmentRcd.key().name()
          << "' (since "
          << alignmentRcd.validityInterval().first().eventID().run() << ")\n";
        throwException = true;
      }
      if (surfaceRcd.validityInterval().first().eventID().run() > firstRun) {
        message
          << " - TrackerSurfaceDeformationRcd '" << surfaceRcd.key().name()
          << "' (since "
          << surfaceRcd.validityInterval().first().eventID().run() << ")\n";
        throwException = true;
      }
      if (errorRcd.validityInterval().first().eventID().run() > firstRun) {
        message
          << " - TrackerAlignmentErrorExtendedRcd '" << errorRcd.key().name()
          << "' (since "
          << errorRcd.validityInterval().first().eventID().run() << ")\n";
        throwException = true;
      }

      if (throwException) {
        throw cms::Exception("Alignment")
          << "@SUB=MillePedeAlignmentAlgorithm::beginRun\n" << message.str();
      }
    } else {
      cachedRuns_.push_back(firstRun);
      theAlignmentParameterStore->cacheTransformations(firstRun);
    }
  }
}

void MillePedeAlignmentAlgorithm::buildUserVariables ( const align::Alignables &  alignables ) const

private

add MillePedeVariables for each AlignmentParameters (exception if no parameters...)

Definition at line 1179 of file MillePedeAlignmentAlgorithm.cc.

References Exception, MillePedeVariables::setAllDefault(), AlignmentParameters::setUserVariables(), MillePedeVariables::size(), AlignmentParameters::size(), thePedeLabels, and AlignmentParameters::userVariables().

Referenced by initialize(), and setParametersForRunRange().

{
  for (const auto& iAli: alis) {
    AlignmentParameters *params = iAli->alignmentParameters();
    if (!params) {
      throw cms::Exception("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::buildUserVariables"
                                        << "No parameters for alignable";
    }
    MillePedeVariables *userVars = dynamic_cast<MillePedeVariables*>(params->userVariables());
    if (userVars) { // Just re-use existing, keeping label and numHits:
      for (unsigned int iPar = 0; iPar < userVars->size(); ++iPar) {
        //      if (params->hierarchyLevel() > 0) {
        //std::cout << params->hierarchyLevel() << "\nBefore: " << userVars->parameter()[iPar];
        //      }
        userVars->setAllDefault(iPar);
        //std::cout << "\nAfter: " << userVars->parameter()[iPar] << std::endl;
      }
    } else { // Nothing yet or erase wrong type:
      userVars = new MillePedeVariables(params->size(), thePedeLabels->alignableLabel(iAli),
                                        thePedeLabels->alignableTracker()->objectIdProvider().typeToName(iAli->alignableObjectId()));
      params->setUserVariables(userVars);
    }
  }
}

int MillePedeAlignmentAlgorithm::callMille ( const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &  refTrajPtr, unsigned int  iTrajHit, const std::vector< int > &  globalLabels, const std::vector< float > &  globalDerivativesX, const std::vector< float > &  globalDerivativesY  )

private

calls callMille1D or callMille2D

Definition at line 1383 of file MillePedeAlignmentAlgorithm.cc.

References callMille1D(), and callMille2D().

Referenced by addMeasurementData(), and addRefTrackData2D().

{
  const ConstRecHitPointer aRecHit(refTrajPtr->recHits()[iTrajHit]);

  if((aRecHit)->dimension() == 1) {
    return this->callMille1D(refTrajPtr, iTrajHit, globalLabels, globalDerivativesX);
  } else {
    return this->callMille2D(refTrajPtr, iTrajHit, globalLabels,
                             globalDerivativesX, globalDerivativesY);
  }
}

int MillePedeAlignmentAlgorithm::callMille1D ( const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &  refTrajPtr, unsigned int  iTrajHit, const std::vector< int > &  globalLabels, const std::vector< float > &  globalDerivativesX  )

private

calls Mille for 1D hits

Definition at line 1401 of file MillePedeAlignmentAlgorithm.cc.

References callMille2D(), mps_fire::i, theMille, and theMonitor.

Referenced by callMille().

{
  const ConstRecHitPointer aRecHit(refTrajPtr->recHits()[iTrajHit]);
  const unsigned int xIndex = iTrajHit*2; // the even ones are local x

  // local derivatives
  const AlgebraicMatrix &locDerivMatrix = refTrajPtr->derivatives();
  const int nLocal  = locDerivMatrix.num_col();
  std::vector<float> localDerivatives(nLocal);
  for (unsigned int i = 0; i < localDerivatives.size(); ++i) {
    localDerivatives[i] = locDerivMatrix[xIndex][i];
  }

  // residuum and error
  float residX = refTrajPtr->measurements()[xIndex] - refTrajPtr->trajectoryPositions()[xIndex];
  float hitErrX = TMath::Sqrt(refTrajPtr->measurementErrors()[xIndex][xIndex]);

  // number of global derivatives
  const int nGlobal = globalDerivativesX.size();

  // &(localDerivatives[0]) etc. are valid - as long as vector is not empty
  // cf. http://www.parashift.com/c++-faq-lite/containers.html#faq-34.3
  theMille->mille(nLocal, &(localDerivatives[0]), nGlobal, &(globalDerivativesX[0]),
                  &(globalLabels[0]), residX, hitErrX);

  if (theMonitor) {
    theMonitor->fillDerivatives(aRecHit, &(localDerivatives[0]), nLocal,
                                &(globalDerivativesX[0]), nGlobal, &(globalLabels[0]));
    theMonitor->fillResiduals(aRecHit, refTrajPtr->trajectoryStates()[iTrajHit],
                              iTrajHit, residX, hitErrX, false);
  }

  return 1;
}

int MillePedeAlignmentAlgorithm::callMille2D ( const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &  refTrajPtr, unsigned int  iTrajHit, const std::vector< int > &  globalLabels, const std::vector< float > &  globalDerivativesx, const std::vector< float > &  globalDerivativesy  )

private

calls Mille for x and possibly y component of hit, y is skipped for non-real 2D (e.g. SiStripRecHit2D), for TID/TEC first diagonalises if correlation is larger than configurable

Definition at line 1440 of file MillePedeAlignmentAlgorithm.cc.

References Abs(), addRefTrackData2D(), addVirtualMeas(), corr, diagonalize(), pat::helper::ParametrizationHelper::dimension(), is2D(), makeGlobDerivMatrix(), mathSSE::sqrt(), std::swap(), SiStripDetId::TEC, theMaximalCor2D, theMille, theMonitor, SiStripDetId::TID, and DetId::Tracker.

Referenced by callMille(), and callMille1D().

{
  const ConstRecHitPointer aRecHit(refTrajPtr->recHits()[iTrajHit]);

  if((aRecHit)->dimension() != 2) {
    edm::LogError("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::callMille2D"
                               << "You try to call method for 2D hits for a "
                               << (aRecHit)->dimension()
                               <<  "D Hit. Hit gets ignored!";
    return -1;
  }

  Eigen::Matrix<double, 2, 2> aHitCovarianceM;
  Eigen::Matrix<float, 2, 1> aHitResidualsM;
  Eigen::Matrix<float, 2, Eigen::Dynamic>
    aLocalDerivativesM{2, refTrajPtr->derivatives().num_col()};
  // below method fills above 3 matrices
  this->addRefTrackData2D(refTrajPtr, iTrajHit, aHitCovarianceM,aHitResidualsM,aLocalDerivativesM);
  Eigen::Matrix<float, 2, Eigen::Dynamic>
    aGlobalDerivativesM{2, globalDerivativesx.size()};
  this->makeGlobDerivMatrix(globalDerivativesx, globalDerivativesy, aGlobalDerivativesM);

  // calculates correlation between Hit measurements
  // FIXME: Should take correlation (and resulting transformation) from original hit,
  //        not 2x2 matrix from ReferenceTrajectory: That can come from error propagation etc.!
  const double corr = aHitCovarianceM(0,1) / sqrt(aHitCovarianceM(0,0) * aHitCovarianceM(1,1));
  if (theMonitor) theMonitor->fillCorrelations2D(corr, aRecHit);
  bool diag = false; // diagonalise only tracker TID, TEC
  switch(aRecHit->geographicalId().subdetId()) {
  case SiStripDetId::TID:
  case SiStripDetId::TEC:
    if (aRecHit->geographicalId().det() == DetId::Tracker && TMath::Abs(corr) > theMaximalCor2D) {
      this->diagonalize(aHitCovarianceM, aLocalDerivativesM, aHitResidualsM, aGlobalDerivativesM);
      diag = true;
    }
    break;
  default:;
  }

  float newResidX = aHitResidualsM(0,0);
  float newResidY = aHitResidualsM(1,0);
  float newHitErrX = TMath::Sqrt(aHitCovarianceM(0,0));
  float newHitErrY = TMath::Sqrt(aHitCovarianceM(1,1));

  // change from column major (Eigen default) to row major to have row entries
  // in continuous memory
  std::vector<float> newLocalDerivs(aLocalDerivativesM.size());
  Eigen::Map<Eigen::Matrix<float, 2, Eigen::Dynamic, Eigen::RowMajor> >
    (newLocalDerivs.data(),
     aLocalDerivativesM.rows(),
     aLocalDerivativesM.cols()) = aLocalDerivativesM;
  float* newLocalDerivsX = &(newLocalDerivs[0]);
  float* newLocalDerivsY = &(newLocalDerivs[aLocalDerivativesM.cols()]);

  // change from column major (Eigen default) to row major to have row entries
  // in continuous memory
  std::vector<float> newGlobDerivs(aGlobalDerivativesM.size());
  Eigen::Map<Eigen::Matrix<float, 2, Eigen::Dynamic, Eigen::RowMajor> >
    (newGlobDerivs.data(),
     aGlobalDerivativesM.rows(),
     aGlobalDerivativesM.cols()) = aGlobalDerivativesM;
  float* newGlobDerivsX = &(newGlobDerivs[0]);
  float* newGlobDerivsY = &(newGlobDerivs[aGlobalDerivativesM.cols()]);

  const int nLocal  = aLocalDerivativesM.cols();
  const int nGlobal = aGlobalDerivativesM.cols();

  if (diag && (newHitErrX > newHitErrY)) { // also for 2D hits?
    // measurement with smaller error is x-measurement (for !is2D do not fill y-measurement):
    std::swap(newResidX, newResidY);
    std::swap(newHitErrX, newHitErrY);
    std::swap(newLocalDerivsX, newLocalDerivsY);
    std::swap(newGlobDerivsX, newGlobDerivsY);
  }

  // &(globalLabels[0]) is valid - as long as vector is not empty
  // cf. http://www.parashift.com/c++-faq-lite/containers.html#faq-34.3
  theMille->mille(nLocal, newLocalDerivsX, nGlobal, newGlobDerivsX,
                  &(globalLabels[0]), newResidX, newHitErrX);

  if (theMonitor) {
    theMonitor->fillDerivatives(aRecHit, newLocalDerivsX, nLocal, newGlobDerivsX,
                                nGlobal, &(globalLabels[0]));
    theMonitor->fillResiduals(aRecHit, refTrajPtr->trajectoryStates()[iTrajHit],
                              iTrajHit, newResidX, newHitErrX, false);
  }
  const bool isReal2DHit = this->is2D(aRecHit); // strip is 1D (except matched hits)
  if (isReal2DHit) {
    theMille->mille(nLocal, newLocalDerivsY, nGlobal, newGlobDerivsY,
                    &(globalLabels[0]), newResidY, newHitErrY);
    if (theMonitor) {
      theMonitor->fillDerivatives(aRecHit, newLocalDerivsY, nLocal, newGlobDerivsY,
                                  nGlobal, &(globalLabels[0]));
      theMonitor->fillResiduals(aRecHit, refTrajPtr->trajectoryStates()[iTrajHit],
                                iTrajHit, newResidY, newHitErrY, true);// true: y
    }
  }

  return (isReal2DHit ? 2 : 1);
}

unsigned int MillePedeAlignmentAlgorithm::decodeMode ( const std::string &  mode ) const

private

Definition at line 1205 of file MillePedeAlignmentAlgorithm.cc.

References Exception, myMilleBit, myPedeReadBit, myPedeRunBit, and myPedeSteerBit.

{
  if (mode == "full") {
    return myMilleBit + myPedeSteerBit + myPedeRunBit + myPedeReadBit;
  } else if (mode == "mille") {
    return myMilleBit; // + myPedeSteerBit; // sic! Including production of steerig file. NO!
  } else if (mode == "pede") {
    return myPedeSteerBit + myPedeRunBit + myPedeReadBit;
  } else if (mode == "pedeSteer") {
    return myPedeSteerBit;
  } else if (mode == "pedeRun") {
    return myPedeSteerBit + myPedeRunBit + myPedeReadBit; // sic! Including steering and reading of result.
  } else if (mode == "pedeRead") {
    return myPedeReadBit;
  }

  throw cms::Exception("BadConfig")
    << "Unknown mode '" << mode
    << "', use 'full', 'mille', 'pede', 'pedeRun', 'pedeSteer' or 'pedeRead'.";

  return 0;
}

template<typename CovarianceMatrix , typename LocalDerivativeMatrix , typename ResidualMatrix , typename GlobalDerivativeMatrix >

void MillePedeAlignmentAlgorithm::diagonalize ( Eigen::MatrixBase< CovarianceMatrix > &  aHitCovarianceM, Eigen::MatrixBase< LocalDerivativeMatrix > &  aLocalDerivativesM, Eigen::MatrixBase< ResidualMatrix > &  aHitResidualsM, Eigen::MatrixBase< GlobalDerivativeMatrix > &  aGlobalDerivativesM  ) const

private

Definition at line 1298 of file MillePedeAlignmentAlgorithm.cc.

References addRefTrackVirtualMeas1D().

Referenced by callMille2D(), and makeGlobDerivMatrix().

{
  static_assert(std::is_same<typename LocalDerivativeMatrix::Scalar,
                             typename ResidualMatrix::Scalar>::value,
                "'aLocalDerivativesM' and 'aHitResidualsM' must have the "
                "same underlying scalar type");
  static_assert(std::is_same<typename LocalDerivativeMatrix::Scalar,
                             typename GlobalDerivativeMatrix::Scalar>::value,
                "'aLocalDerivativesM' and 'aGlobalDerivativesM' must have the "
                "same underlying scalar type");

  Eigen::SelfAdjointEigenSolver<typename CovarianceMatrix::PlainObject> myDiag{aHitCovarianceM};
  // eigenvectors of real symmetric matrices are orthogonal, i.e. invert == transpose
  auto aTranfoToDiagonalSystemInv =
    myDiag.eigenvectors().transpose().template cast<typename LocalDerivativeMatrix::Scalar>();

  aHitCovarianceM    = myDiag.eigenvalues().asDiagonal();
  aLocalDerivativesM = aTranfoToDiagonalSystemInv * aLocalDerivativesM;
  aHitResidualsM     = aTranfoToDiagonalSystemInv * aHitResidualsM;
  if (aGlobalDerivativesM.size() > 0) {
    // diagonalize only if measurement depends on alignables or calibrations
    aGlobalDerivativesM = aTranfoToDiagonalSystemInv * aGlobalDerivativesM;
  }
}

unsigned int MillePedeAlignmentAlgorithm::doIO ( int  loop ) const

private

Definition at line 1119 of file MillePedeAlignmentAlgorithm.cc.

References addHitStatistics(), edm::ParameterSet::getParameter(), heppy_loop::loop, GetRecoTauVFromDQM_MC_cff::outFile, mps_fire::result, AlCaHLTBitMon_QueryRunRegistry::string, theAlignables, theConfig, theDir, AlignmentIORoot::writeAlignableAbsolutePositions(), AlignmentIORoot::writeAlignableOriginalPositions(), MillePedeVariablesIORoot::writeMillePedeVariables(), and AlignmentIORoot::writeOrigRigidBodyAlignmentParameters().

Referenced by setParametersForRunRange(), and terminate().

{
  unsigned int result = 0;

  const std::string outFilePlain(theConfig.getParameter<std::string>("treeFile"));
  if (outFilePlain.empty()) {
    edm::LogInfo("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::doIO"
                              << "treeFile parameter empty => skip writing for 'loop' " << loop;
    return result;
  }

  const std::string outFile(theDir + outFilePlain);

  AlignmentIORoot aliIO;
  int ioerr = 0;
  if (loop == 0) {
    aliIO.writeAlignableOriginalPositions(theAlignables, outFile.c_str(), loop, false, ioerr);
    if (ioerr) {
      edm::LogError("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::doIO"
                                 << "Problem " << ioerr << " in writeAlignableOriginalPositions";
      ++result;
    }
  } else if (loop == 1) {
    // only for first iov add hit counts, else 2x, 3x,... number of hits in IOV 2, 3,...
    const std::vector<std::string> inFiles
      (theConfig.getParameter<std::vector<std::string> >("mergeTreeFiles"));
    const std::vector<std::string> binFiles
      (theConfig.getParameter<std::vector<std::string> >("mergeBinaryFiles"));
    if (inFiles.size() != binFiles.size()) {
      edm::LogWarning("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::doIO"
                                   << "'vstring mergeTreeFiles' and 'vstring mergeBinaryFiles' "
                                   << "differ in size";
    }
    this->addHitStatistics(0, outFile, inFiles); // add hit info from tree 0 in 'infiles'
  }
  MillePedeVariablesIORoot millePedeIO;
  millePedeIO.writeMillePedeVariables(theAlignables, outFile.c_str(), loop, false, ioerr);
  if (ioerr) {
    edm::LogError("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::doIO"
                               << "Problem " << ioerr << " writing MillePedeVariables";
    ++result;
  }

  aliIO.writeOrigRigidBodyAlignmentParameters(theAlignables, outFile.c_str(), loop, false, ioerr);
  if (ioerr) {
    edm::LogError("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::doIO" << "Problem " << ioerr
                               << " in writeOrigRigidBodyAlignmentParameters, " << loop;
    ++result;
  }
  aliIO.writeAlignableAbsolutePositions(theAlignables, outFile.c_str(), loop, false, ioerr);
  if (ioerr) {
    edm::LogError("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::doIO" << "Problem " << ioerr
                               << " in writeAlignableAbsolutePositions, " << loop;
    ++result;
  }

  return result;
}

void MillePedeAlignmentAlgorithm::endLuminosityBlock ( const edm::EventSetup &  )

overridevirtual

called at end of luminosity block

Reimplemented from AlignmentAlgorithmBase.

Definition at line 762 of file MillePedeAlignmentAlgorithm.cc.

References isMode(), myMilleBit, runAtPCL_, and theMille.

{
  if (!runAtPCL_) return;
  if(this->isMode(myMilleBit)) theMille->flushOutputFile();
}

void MillePedeAlignmentAlgorithm::endRun ( const EventInfo &  eventInfo, const EndRunInfo &  runInfo, const edm::EventSetup &  setup  )

virtual

Run on run products, e.g. TkLAS.

Definition at line 739 of file MillePedeAlignmentAlgorithm.cc.

References addLaserData(), isMode(), myMilleBit, theMille, AlignmentAlgorithmBase::EndRunInfo::tkLasBeams(), and AlignmentAlgorithmBase::EndRunInfo::tkLasBeamTsoses().

{
  if(runInfo.tkLasBeams() && runInfo.tkLasBeamTsoses()){
    // LAS beam treatment
    this->addLaserData(eventInfo, *(runInfo.tkLasBeams()), *(runInfo.tkLasBeamTsoses()));
  }
  if(this->isMode(myMilleBit)) theMille->flushOutputFile();
}

void MillePedeAlignmentAlgorithm::endRun ( const EndRunInfo &  runInfo, const edm::EventSetup &  setup  )

overridevirtual

called at end of run - order of arguments like in EDProducer etc.

Reimplemented from AlignmentAlgorithmBase.

Definition at line 750 of file MillePedeAlignmentAlgorithm.cc.

References isMode(), myMilleBit, and theMille.

                                                                                              {
  if(this->isMode(myMilleBit)) theMille->flushOutputFile();
}

std::vector< std::string > MillePedeAlignmentAlgorithm::getExistingFormattedFiles ( const std::vector< std::string > &  plainFiles, const std::string &  theDir  )

private

Generates list of files to read, given the list and dir from the configuration. This will automatically expand formatting directives, if they appear.

Definition at line 454 of file MillePedeAlignmentAlgorithm.cc.

References edmScanValgrind::buffer, haddnano::files, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by terminate().

                                                                                                                                           {
  std::vector<std::string> files;
  for (const auto& plainFile: plainFiles) {
    const std::string& theInputFileName = plainFile;
    int theNumber = 0;
    while (true) {
      // Create a formatted version of the filename, with growing numbers
      // If the parameter doesn't contain a formatting directive, it just stays unchanged
      char theNumberedInputFileName[200];
      sprintf(theNumberedInputFileName, theInputFileName.c_str(), theNumber);
      std::string theCompleteInputFileName = theDir + theNumberedInputFileName;
      const auto endOfStrippedFileName = theCompleteInputFileName.rfind(" --");
      const auto strippedInputFileName = theCompleteInputFileName.substr(0, endOfStrippedFileName);
      // Check if the file exists
      struct stat buffer;
      if (stat (strippedInputFileName.c_str(), &buffer) == 0) {
        // If the file exists, add it to the list
        files.push_back(theCompleteInputFileName);
        if (theNumberedInputFileName == theInputFileName) {
          // If the filename didn't contain a formatting directive, no reason to look any further, break out of the loop
          break;
        } else {
          // Otherwise look for the next number
          theNumber++;
        }
      } else {
        // The file doesn't exist, break out of the loop
        break;
      }
    }
    // warning if unformatted (-> theNumber stays at 0) does not exist
    if (theNumber == 0 && (files.empty() || files.back() != plainFile)) {
      edm::LogWarning("Alignment")
        << "The input file '" << plainFile << "' does not exist.";
    }
  }
  return files;
}

void MillePedeAlignmentAlgorithm::globalDerivativesCalibration ( const TransientTrackingRecHit::ConstRecHitPointer &  recHit, const TrajectoryStateOnSurface &  tsos, const edm::EventSetup &  setup, const EventInfo &  eventInfo, std::vector< float > &  globalDerivativesX, std::vector< float > &  globalDerivativesY, std::vector< int > &  globalLabels  ) const

private

adding derivatives from integrated calibrations

Definition at line 987 of file MillePedeAlignmentAlgorithm.cc.

References theCalibrations, and thePedeLabels.

Referenced by addMeasurementData(), and globalDerivativesHierarchy().

{
  std::vector<IntegratedCalibrationBase::ValuesIndexPair> derivs;
  for (auto iCalib = theCalibrations.begin(); iCalib != theCalibrations.end(); ++iCalib) {
    // get all derivatives of this calibration // const unsigned int num =
    (*iCalib)->derivatives(derivs, *recHit, tsos, setup, eventInfo);
    for (auto iValuesInd = derivs.begin(); iValuesInd != derivs.end(); ++iValuesInd) {
      // transfer label and x/y derivatives
      globalLabels.push_back(thePedeLabels->calibrationLabel(*iCalib, iValuesInd->second));
      globalDerivativesX.push_back(iValuesInd->first.first);
      globalDerivativesY.push_back(iValuesInd->first.second);
    }
  }
}

bool MillePedeAlignmentAlgorithm::globalDerivativesHierarchy ( const EventInfo &  eventInfo, const TrajectoryStateOnSurface &  tsos, Alignable *  ali, const AlignableDetOrUnitPtr &  alidet, std::vector< float > &  globalDerivativesX, std::vector< float > &  globalDerivativesY, std::vector< int > &  globalLabels, AlignmentParameters *&  lowestParams  ) const

private

recursively adding derivatives and labels, false if problems

Definition at line 869 of file MillePedeAlignmentAlgorithm.cc.

References Alignable::alignmentParameters(), AlignmentParameters::derivatives(), kLocalX, kLocalY, Alignable::mother(), AlignmentParameters::selector(), theMonitor, thePedeLabels, and thePedeSteer.

Referenced by addGlobalData(), addLasBeam(), addMeasurementData(), and globalDerivativesHierarchy().

{
  // derivatives and labels are recursively attached
  if (!ali) return true; // no mother might be OK

  if (false && theMonitor && alidet != ali) theMonitor->fillFrameToFrame(alidet, ali);

  AlignmentParameters *params = ali->alignmentParameters();

  if (params) {
    if (!lowestParams) lowestParams = params; // set parameters of lowest level

    bool hasSplitParameters = thePedeLabels->hasSplitParameters(ali);
    const unsigned int alignableLabel = thePedeLabels->alignableLabel(ali);

    if (0 == alignableLabel) { // FIXME: what about regardAllHits in Markus' code?
      edm::LogWarning("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::globalDerivativesHierarchy"
                                   << "Label not found, skip Alignable.";
      return false;
    }

    const std::vector<bool> &selPars = params->selector();
    const AlgebraicMatrix derivs(params->derivatives(tsos, alidet));

    // cols: 2, i.e. x&y, rows: parameters, usually RigidBodyAlignmentParameters::N_PARAM
    for (unsigned int iSel = 0; iSel < selPars.size(); ++iSel) {
      if (selPars[iSel]) {
        globalDerivativesX.push_back(derivs[iSel][kLocalX]
                                     /thePedeSteer->cmsToPedeFactor(iSel));
        if (hasSplitParameters==true) {
          globalLabels.push_back(thePedeLabels->parameterLabel(ali, iSel, eventInfo, tsos));
        } else {
          globalLabels.push_back(thePedeLabels->parameterLabel(alignableLabel, iSel));
        }
        globalDerivativesY.push_back(derivs[iSel][kLocalY]
                                     /thePedeSteer->cmsToPedeFactor(iSel));
      }
    }
    // Exclude mothers if Alignable selected to be no part of a hierarchy:
    if (thePedeSteer->isNoHiera(ali)) return true;
  }
  // Call recursively for mother, will stop if mother == 0:
  return this->globalDerivativesHierarchy(eventInfo,
                                          tsos, ali->mother(), alidet,
                                          globalDerivativesX, globalDerivativesY,
                                          globalLabels, lowestParams);
}

bool MillePedeAlignmentAlgorithm::globalDerivativesHierarchy ( const EventInfo &  eventInfo, const TrajectoryStateOnSurface &  tsos, Alignable *  ali, const AlignableDetOrUnitPtr &  alidet, std::vector< double > &  globalDerivativesX, std::vector< double > &  globalDerivativesY, std::vector< int > &  globalLabels, AlignmentParameters *&  lowestParams  ) const

private

recursively adding derivatives (double) and labels, false if problems

Definition at line 925 of file MillePedeAlignmentAlgorithm.cc.

References Alignable::alignmentParameters(), AlignmentParameters::derivatives(), globalDerivativesCalibration(), globalDerivativesHierarchy(), kLocalX, kLocalY, Alignable::mother(), AlignmentParameters::selector(), theMonitor, thePedeLabels, and thePedeSteer.

{
  // derivatives and labels are recursively attached
  if (!ali) return true; // no mother might be OK

  if (false && theMonitor && alidet != ali) theMonitor->fillFrameToFrame(alidet, ali);

  AlignmentParameters *params = ali->alignmentParameters();

  if (params) {
    if (!lowestParams) lowestParams = params; // set parameters of lowest level

    bool hasSplitParameters = thePedeLabels->hasSplitParameters(ali);
    const unsigned int alignableLabel = thePedeLabels->alignableLabel(ali);

    if (0 == alignableLabel) { // FIXME: what about regardAllHits in Markus' code?
      edm::LogWarning("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::globalDerivativesHierarchy"
                                   << "Label not found, skip Alignable.";
      return false;
    }

    const std::vector<bool> &selPars = params->selector();
    const AlgebraicMatrix derivs(params->derivatives(tsos, alidet));
    int globalLabel;

    // cols: 2, i.e. x&y, rows: parameters, usually RigidBodyAlignmentParameters::N_PARAM
    for (unsigned int iSel = 0; iSel < selPars.size(); ++iSel) {
      if (selPars[iSel]) {
        if (hasSplitParameters==true) {
          globalLabel = thePedeLabels->parameterLabel(ali, iSel, eventInfo, tsos);
        } else {
          globalLabel = thePedeLabels->parameterLabel(alignableLabel, iSel);
        }
        if (globalLabel > 0 && globalLabel <= 2147483647) {
          globalLabels.push_back(globalLabel);
          globalDerivativesX.push_back(derivs[iSel][kLocalX] / thePedeSteer->cmsToPedeFactor(iSel));
          globalDerivativesY.push_back(derivs[iSel][kLocalY] / thePedeSteer->cmsToPedeFactor(iSel));
        } else {
          edm::LogError("Alignment")
            << "@SUB=MillePedeAlignmentAlgorithm::globalDerivativesHierarchy"
            << "Invalid label " << globalLabel << " <= 0 or > 2147483647";
        }
      }
    }
    // Exclude mothers if Alignable selected to be no part of a hierarchy:
    if (thePedeSteer->isNoHiera(ali)) return true;
  }
  // Call recursively for mother, will stop if mother == 0:
  return this->globalDerivativesHierarchy(eventInfo,
                                          tsos, ali->mother(), alidet,
                                          globalDerivativesX, globalDerivativesY,
                                          globalLabels, lowestParams);
}

void MillePedeAlignmentAlgorithm::initialize ( const edm::EventSetup &  setup, AlignableTracker *  tracker, AlignableMuon *  muon, AlignableExtras *  extras, AlignmentParameterStore *  store  )

overridevirtual

Called at beginning of job.

Implements AlignmentAlgorithmBase.

Definition at line 135 of file MillePedeAlignmentAlgorithm.cc.

References addPxbSurvey(), edm::ParameterSet::addUntrackedParameter(), cond::TimeTypeSpecs::beginValue, buildUserVariables(), relativeConstraints::empty, cond::TimeTypeSpecs::endValue, enforceSingleIOVInput_, Exception, edm::ParameterSet::exists(), reco::get(), edm::EventSetup::get(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), isMode(), crabWrapper::key, cond::time::MAX_VAL(), cond::time::MIN_VAL(), metsig::muon, myMilleBit, myPedeSteerBit, edm::ESHandle< T >::product(), readFromPede(), runAtPCL_, cond::runnumber, storeThresholds(), AlCaHLTBitMon_QueryRunRegistry::string, theAlignableNavigator, theAlignables, theAlignmentParameterStore, theConfig, theDir, theDoSurveyPixelBarrel, theMonitor, thePedeLabels, thePedeSteer, theThresholds, theTrajectoryFactory, cond::persistency::throwException(), cond::timeTypeSpecs, and trackingTruthProducer_cfi::tracker.

{
  if (muon) {
    edm::LogWarning("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::initialize"
                                 << "Running with AlignabeMuon not yet tested.";
  }

  if (!runAtPCL_ && enforceSingleIOVInput_) {
    const auto MIN_VAL = cond::timeTypeSpecs[cond::runnumber].beginValue;
    const auto MAX_VAL = cond::timeTypeSpecs[cond::runnumber].endValue;
    const auto& iov_alignments =
      setup.get<TrackerAlignmentRcd>().validityInterval();
    const auto& iov_surfaces =
      setup.get<TrackerSurfaceDeformationRcd>().validityInterval();
    const auto& iov_errors =
      setup.get<TrackerAlignmentErrorExtendedRcd>().validityInterval();

    std::ostringstream message;
    bool throwException{false};
    if (iov_alignments.first().eventID().run() != MIN_VAL ||
        iov_alignments.last().eventID().run() != MAX_VAL) {
      message
        << "\nTrying to apply " << setup.get<TrackerAlignmentRcd>().key().name()
        << " with multiple IOVs in tag without specifying 'RunRangeSelection'.\n"
        << "Validity range is "
        << iov_alignments.first().eventID().run() << " - "
        << iov_alignments.last().eventID().run() << "\n";
      throwException = true;
    }
    if (iov_surfaces.first().eventID().run() != MIN_VAL ||
        iov_surfaces.last().eventID().run() != MAX_VAL) {
      message
        << "\nTrying to apply "
        << setup.get<TrackerSurfaceDeformationRcd>().key().name()
        << " with multiple IOVs in tag without specifying 'RunRangeSelection'.\n"
        << "Validity range is "
        << iov_surfaces.first().eventID().run() << " - "
        << iov_surfaces.last().eventID().run() << "\n";
      throwException = true;
    }
    if (iov_errors.first().eventID().run() != MIN_VAL ||
        iov_errors.last().eventID().run() != MAX_VAL) {
      message
        << "\nTrying to apply "
        << setup.get<TrackerAlignmentErrorExtendedRcd>().key().name()
        << " with multiple IOVs in tag without specifying 'RunRangeSelection'.\n"
        << "Validity range is "
        << iov_errors.first().eventID().run() << " - "
        << iov_errors.last().eventID().run() << "\n";
      throwException = true;
    }
    if (throwException) {
      throw cms::Exception("DatabaseError")
        << "@SUB=MillePedeAlignmentAlgorithm::initialize" << message.str();
    }
  }


  //Retrieve tracker topology from geometry
  edm::ESHandle<TrackerTopology> tTopoHandle;
  setup.get<TrackerTopologyRcd>().get(tTopoHandle);
  const TrackerTopology* const tTopo = tTopoHandle.product();

  //Retrieve the thresolds cuts from DB for the PCL
  if (runAtPCL_) {
    edm::ESHandle<AlignPCLThresholds> thresholdHandle;
    setup.get<AlignPCLThresholdsRcd>().get(thresholdHandle);
    auto th = thresholdHandle.product();    
    theThresholds = std::make_shared<AlignPCLThresholds>();
    storeThresholds(th->getNrecords(),th->getThreshold_Map());
  } 

  theAlignableNavigator = std::make_unique<AlignableNavigator>(extras, tracker, muon);
  theAlignmentParameterStore = store;
  theAlignables = theAlignmentParameterStore->alignables();

  edm::ParameterSet pedeLabelerCfg(theConfig.getParameter<edm::ParameterSet>("pedeLabeler"));
  edm::VParameterSet RunRangeSelectionVPSet(theConfig.getUntrackedParameter<edm::VParameterSet>("RunRangeSelection"));
  pedeLabelerCfg.addUntrackedParameter<edm::VParameterSet>("RunRangeSelection",
                                                           RunRangeSelectionVPSet);

  std::string labelerPlugin = "PedeLabeler";
  if (!RunRangeSelectionVPSet.empty()) {
    labelerPlugin = "RunRangeDependentPedeLabeler";
    if (pedeLabelerCfg.exists("plugin")) {
      std::string labelerPluginCfg = pedeLabelerCfg.getParameter<std::string>("plugin");
      if ((labelerPluginCfg!="PedeLabeler" && labelerPluginCfg!="RunRangeDependentPedeLabeler") ||
          !pedeLabelerCfg.getUntrackedParameter<edm::VParameterSet>("parameterInstances").empty()) {
        throw cms::Exception("BadConfig")
          << "MillePedeAlignmentAlgorithm::initialize"
          << "both RunRangeSelection and generic labeler specified in config file. "
          << "Please get rid of either one of them.\n";
      }
    }
  } else {
    if (pedeLabelerCfg.exists("plugin")) {
      labelerPlugin = pedeLabelerCfg.getParameter<std::string>("plugin");
    }
  }

  if (!pedeLabelerCfg.exists("plugin")) {
    pedeLabelerCfg.addUntrackedParameter<std::string>("plugin", labelerPlugin);
  }

  edm::LogInfo("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::initialize"
                            << "Using plugin '" << labelerPlugin << "' to generate labels.";

  thePedeLabels = std::shared_ptr<PedeLabelerBase>(PedeLabelerPluginFactory::get()
                                                   ->create(labelerPlugin,
                                                            PedeLabelerBase::TopLevelAlignables(tracker, muon, extras),
                                                            pedeLabelerCfg));

  // 1) Create PedeSteerer: correct alignable positions for coordinate system selection
  edm::ParameterSet pedeSteerCfg(theConfig.getParameter<edm::ParameterSet>("pedeSteerer"));
  thePedeSteer = std::make_unique<PedeSteerer>(tracker, muon, extras,
                                               theAlignmentParameterStore, thePedeLabels.get(),
                                               pedeSteerCfg, theDir, !this->isMode(myPedeSteerBit));

  // 2) If requested, directly read in and apply result of previous pede run,
  //    assuming that correction from 1) was also applied to create the result:
  const std::vector<edm::ParameterSet> mprespset
    (theConfig.getParameter<std::vector<edm::ParameterSet> >("pedeReaderInputs"));
  if (!mprespset.empty()) {
    edm::LogInfo("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::initialize"
                              << "Apply " << mprespset.end() - mprespset.begin()
                              << " previous MillePede constants from 'pedeReaderInputs'.";
  }

  // FIXME: add selection of run range via 'pedeReaderInputs'
  // Note: Results for parameters of IntegratedCalibration's cannot be treated...
  RunRange runrange(cond::timeTypeSpecs[cond::runnumber].beginValue,
                    cond::timeTypeSpecs[cond::runnumber].endValue);
  for (std::vector<edm::ParameterSet>::const_iterator iSet = mprespset.begin(), iE = mprespset.end();
       iSet != iE; ++iSet) {
    // This read will ignore calibrations as long as they are not yet passed to Millepede
    // during/before initialize(..) - currently addCalibrations(..) is called later in AlignmentProducer
    if (!this->readFromPede((*iSet), false, runrange)) { // false: do not erase SelectionUserVariables
      throw cms::Exception("BadConfig")
        << "MillePedeAlignmentAlgorithm::initialize: Problems reading input constants of "
        << "pedeReaderInputs entry " << iSet - mprespset.begin() << '.';
    }
    theAlignmentParameterStore->applyParameters();
    // Needed to shut up later warning from checkAliParams:
    theAlignmentParameterStore->resetParameters();
  }

  // 3) Now create steerings with 'final' start position:
  thePedeSteer->buildSubSteer(tracker, muon, extras);

  // After (!) 1-3 of PedeSteerer which uses the SelectionUserVariables attached to the parameters:
  this->buildUserVariables(theAlignables); // for hit statistics and/or pede result

  if (this->isMode(myMilleBit)) {
    if (!theConfig.getParameter<std::vector<std::string> >("mergeBinaryFiles").empty() ||
        !theConfig.getParameter<std::vector<std::string> >("mergeTreeFiles").empty()) {
      throw cms::Exception("BadConfig")
        << "'vstring mergeTreeFiles' and 'vstring mergeBinaryFiles' must be empty for "
        << "modes running mille.";
    }
    const std::string moniFile(theConfig.getUntrackedParameter<std::string>("monitorFile"));
    if (!moniFile.empty()) theMonitor = std::make_unique<MillePedeMonitor>(tTopo, (theDir + moniFile).c_str());

    // Get trajectory factory. In case nothing found, FrameWork will throw...
    const edm::ParameterSet fctCfg(theConfig.getParameter<edm::ParameterSet>("TrajectoryFactory"));
    const std::string fctName(fctCfg.getParameter<std::string>("TrajectoryFactoryName"));
    theTrajectoryFactory = std::unique_ptr<TrajectoryFactoryBase>(TrajectoryFactoryPlugin::get()
                                                                  ->create(fctName, fctCfg));
  }

  if (this->isMode(myPedeSteerBit)) {
    // Get config for survey and set flag accordingly
    const edm::ParameterSet pxbSurveyCfg(theConfig.getParameter<edm::ParameterSet>("surveyPixelBarrel"));
    theDoSurveyPixelBarrel = pxbSurveyCfg.getParameter<bool>("doSurvey");
    if (theDoSurveyPixelBarrel) this->addPxbSurvey(pxbSurveyCfg);
  }
}

bool MillePedeAlignmentAlgorithm::is2D ( const TransientTrackingRecHit::ConstRecHitPointer &  recHit ) const

private

true if hit belongs to 2D detector (currently tracker specific)

Definition at line 1042 of file MillePedeAlignmentAlgorithm.cc.

Referenced by callMille2D().

{
  // FIXME: Check whether this is a reliable and recommended way to find out...

  if (recHit->dimension() < 2) {
    return false; // some muon and TIB/TOB stuff really has RecHit1D
  } else if (recHit->detUnit()) { // detunit in strip is 1D, in pixel 2D
    return recHit->detUnit()->type().isTrackerPixel();
  } else { // stereo strips  (FIXME: endcap trouble due to non-parallel strips (wedge sensors)?)
    if (dynamic_cast<const ProjectedSiStripRecHit2D*>(recHit->hit())) { // check persistent hit
      // projected: 1D measurement on 'glued' module
      return false;
    } else {
      return true;
    }
  }
}

bool MillePedeAlignmentAlgorithm::isMode ( unsigned int  testMode ) const

inlineprivate

Definition at line 265 of file MillePedeAlignmentAlgorithm.h.

References addHits(), addHitStatistics(), GetRecoTauVFromDQM_MC_cff::outFile, AlCaHLTBitMon_QueryRunRegistry::string, and theMode.

Referenced by beginLuminosityBlock(), endLuminosityBlock(), endRun(), initialize(), MillePedeAlignmentAlgorithm(), processesEvents(), run(), setParametersForRunRange(), storeAlignments(), and terminate().

{return (theMode & testMode);}

template<typename GlobalDerivativeMatrix >

void MillePedeAlignmentAlgorithm::makeGlobDerivMatrix ( const std::vector< float > &  globalDerivativesx, const std::vector< float > &  globalDerivativesy, Eigen::MatrixBase< GlobalDerivativeMatrix > &  aGlobalDerivativesM  )

private

Definition at line 1279 of file MillePedeAlignmentAlgorithm.cc.

References diagonalize(), and mps_fire::i.

Referenced by callMille2D().

{
  static_assert(GlobalDerivativeMatrix::RowsAtCompileTime == 2,
                "global derivative matrix must have two rows");

  for (size_t i = 0; i < globalDerivativesx.size(); ++i) {
    aGlobalDerivativesM(0,i) = globalDerivativesx[i];
    aGlobalDerivativesM(1,i) = globalDerivativesy[i];
  }
}

bool MillePedeAlignmentAlgorithm::processesEvents ( )

overridevirtual

Returns whether MP should process events in the current configuration.

Reimplemented from AlignmentAlgorithmBase.

Definition at line 335 of file MillePedeAlignmentAlgorithm.cc.

References isMode(), and myMilleBit.

{
  if (isMode(myMilleBit)) {
    return true;
  } else {
    return false;
  }
}

bool MillePedeAlignmentAlgorithm::readFromPede ( const edm::ParameterSet &  mprespset, bool  setUserVars, const RunRange &  runrange  )

private

read pede input defined by 'psetName', flag to create/not create MillePedeVariables

Definition at line 1061 of file MillePedeAlignmentAlgorithm.cc.

References areEmptyParams(), MillePedeFileConverter_cfg::out, PedeReader::read(), matplotRender::reader, theAlignables, thePedeLabels, and thePedeSteer.

Referenced by initialize(), and setParametersForRunRange().

{
  bool allEmpty = this->areEmptyParams(theAlignables);

  PedeReader reader(mprespset, *thePedeSteer, *thePedeLabels, runrange);
  align::Alignables alis;
  bool okRead = reader.read(alis, setUserVars); // also may set params of IntegratedCalibration's
  bool numMatch = true;

  std::stringstream out;
  out << "Read " << alis.size() << " alignables";
  if (alis.size() != theAlignables.size()) {
    out << " while " << theAlignables.size() << " in store";
    numMatch = false; // FIXME: Should we check one by one? Or transfer 'alis' to the store?
  }
  if (!okRead) out << ", but problems in reading";
  if (!allEmpty) out << ", possibly overwriting previous settings";
  out << ".";

  if (okRead && allEmpty) {
    if (numMatch) { // as many alignables with result as trying to align
      edm::LogInfo("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::readFromPede" << out.str();
    } else if (!alis.empty()) { // dead module do not get hits and no pede result
      edm::LogWarning("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::readFromPede" << out.str();
    } else { // serious problem: no result read - and not all modules can be dead...
      edm::LogError("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::readFromPede" << out.str();
      return false;
    }
    return true;
  }
  // the rest is not OK:
  edm::LogError("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::readFromPede" << out.str();
  return false;
}

void MillePedeAlignmentAlgorithm::run ( const edm::EventSetup &  setup, const EventInfo &  eventInfo  )

overridevirtual

Run the algorithm on trajectories and tracks.

Implements AlignmentAlgorithmBase.

Definition at line 495 of file MillePedeAlignmentAlgorithm.cc.

References addReferenceTrajectory(), AlignmentAlgorithmBase::EventInfo::beamSpot(), isMode(), myMilleBit, PFRecoTauDiscriminationByIsolation_cfi::offset, edm::second(), theMonitor, theTrajectoryFactory, l1t::tracks, HiRegitMuonDetachedTripletStep_cff::trajectories, and AlignmentAlgorithmBase::EventInfo::trajTrackPairs().

Referenced by DTWorkflow.DTWorkflow::all(), Types.EventID::cppID(), Types.LuminosityBlockID::cppID(), o2olib.O2OTool::execute(), and terminate().

{
  if (!this->isMode(myMilleBit)) return; // no theMille created...
  const auto& tracks = eventInfo.trajTrackPairs();

  if (theMonitor) { // monitor input tracks
    for (const auto& iTrajTrack: tracks) {
      theMonitor->fillTrack(iTrajTrack.second);
    }
  }

  const RefTrajColl trajectories(theTrajectoryFactory->trajectories(setup, tracks, eventInfo.beamSpot()));

  // Now loop over ReferenceTrajectoryCollection
  unsigned int refTrajCount = 0; // counter for track monitoring
  const auto tracksPerTraj = theTrajectoryFactory->tracksPerTrajectory();
  for (auto iRefTraj = trajectories.cbegin(), iRefTrajE = trajectories.cend();
       iRefTraj != iRefTrajE; ++iRefTraj, ++refTrajCount) {

    RefTrajColl::value_type refTrajPtr = *iRefTraj;
    if (theMonitor) theMonitor->fillRefTrajectory(refTrajPtr);

    const auto nHitXy = this->addReferenceTrajectory(setup, eventInfo, refTrajPtr);

    if (theMonitor && (nHitXy.first || nHitXy.second)) {
      // if trajectory used (i.e. some hits), fill monitoring
      const auto offset = tracksPerTraj*refTrajCount;
      for (unsigned int iTrack = 0; iTrack < tracksPerTraj; ++iTrack) {
        theMonitor->fillUsedTrack(tracks[offset+iTrack].second,
                                  nHitXy.first, nHitXy.second);
      }
    }

  } // end of reference trajectory and track loop
}

bool MillePedeAlignmentAlgorithm::setParametersForRunRange ( const RunRange &  runrange )

overridevirtual

Called in order to pass parameters to alignables for a specific run range in case the algorithm supports run range dependent alignment.

Reimplemented from AlignmentAlgorithmBase.

Definition at line 365 of file MillePedeAlignmentAlgorithm.cc.

References AlignmentParameterStore::applyParameters(), buildUserVariables(), doIO(), enableAlignableUpdates_, edm::ParameterSet::getParameter(), isMode(), myPedeReadBit, readFromPede(), AlignmentParameterStore::resetParameters(), AlignmentParameterStore::restoreCachedTransformations(), theAlignables, theAlignmentParameterStore, theConfig, and theLastWrittenIov.

{
  if (this->isMode(myPedeReadBit)) {
    // restore initial positions, rotations and deformations
    if (enableAlignableUpdates_) {
      theAlignmentParameterStore->restoreCachedTransformations(runrange.first);
    } else {
      theAlignmentParameterStore->restoreCachedTransformations();
    }

    // Needed to shut up later warning from checkAliParams:
    theAlignmentParameterStore->resetParameters();
    // To avoid that they keep values from previous IOV if no new one in pede result
    this->buildUserVariables(theAlignables);

    if (!this->readFromPede(theConfig.getParameter<edm::ParameterSet>("pedeReader"), true, runrange)) {
      edm::LogError("Alignment") << "@SUB=MillePedeAlignmentAlgorithm::setParametersForRunRange"
                                 << "Problems reading pede result, but applying!";
    }
    theAlignmentParameterStore->applyParameters();

    this->doIO(++theLastWrittenIov); // pre-increment!
  }

  return true;
}

bool MillePedeAlignmentAlgorithm::storeAlignments ( )

overridevirtual

Returns whether MP produced results to be stored.

Reimplemented from AlignmentAlgorithmBase.

Definition at line 345 of file MillePedeAlignmentAlgorithm.cc.

References edm::ParameterSet::getParameter(), isMode(), myPedeReadBit, MillePedeFileReader::read(), runAtPCL_, MillePedeFileReader::storeAlignments(), theConfig, thePedeLabels, and theThresholds.

{
  if (isMode(myPedeReadBit)) {
    if (runAtPCL_) {

      MillePedeFileReader mpReader(theConfig.getParameter<edm::ParameterSet>("MillePedeFileReader"),
                   thePedeLabels,
                   theThresholds
                   );
      mpReader.read();
      return mpReader.storeAlignments();
    } else {
      return true;
    }
  } else {
    return false;
  }
}

bool MillePedeAlignmentAlgorithm::storeThresholds ( const int &  nRecords, const AlignPCLThresholds::threshold_map &  thresholdMap  )

virtual

Definition at line 328 of file MillePedeAlignmentAlgorithm.cc.

References theThresholds.

Referenced by initialize().

{
  theThresholds->setAlignPCLThresholds(nRecords,thresholdMap);
  return true;
}

bool MillePedeAlignmentAlgorithm::supportsCalibrations ( )

overridevirtual

Returns whether MP supports calibrations.

Reimplemented from AlignmentAlgorithmBase.

Definition at line 315 of file MillePedeAlignmentAlgorithm.cc.

                                                       {
  return true;
}

void MillePedeAlignmentAlgorithm::terminate ( const edm::EventSetup &  iSetup )

overridevirtual

Called at end of job.

Implements AlignmentAlgorithmBase.

Definition at line 395 of file MillePedeAlignmentAlgorithm.cc.

References terminate().

{
  terminate();
}

void MillePedeAlignmentAlgorithm::terminate ( void  )

overridevirtual

Called at end of job.

Reimplemented from AlignmentAlgorithmBase.

Definition at line 399 of file MillePedeAlignmentAlgorithm.cc.

References cachedRuns_, AlignmentParameterStore::cacheTransformations(), doIO(), enableAlignableUpdates_, Exception, FrontierConditions_GlobalTag_cff::file, haddnano::files, spr::find(), getExistingFormattedFiles(), edm::ParameterSet::getParameter(), isMode(), lastProcessedRun_, myMilleBit, myPedeReadBit, myPedeRunBit, AlignmentParameterStore::restoreCachedTransformations(), run(), AlCaHLTBitMon_QueryRunRegistry::string, theAlignmentParameterStore, theBinary, theConfig, theDir, theLastWrittenIov, theMille, thePedeSteer, and uniqueRunRanges_.

Referenced by terminate().

{
  theMille.reset(); // delete to close binary before running pede below (flush would be enough...)
  theBinary.reset();

  std::vector<std::string> files;
  if (this->isMode(myMilleBit) || !theConfig.getParameter<std::string>("binaryFile").empty()) {
    files.push_back(theDir + theConfig.getParameter<std::string>("binaryFile"));
  } else {
    const std::vector<std::string> plainFiles(theConfig.getParameter<std::vector<std::string> >("mergeBinaryFiles"));
    files = getExistingFormattedFiles(plainFiles, theDir);
    // Do some logging:
    std::string filesForLogOutput;
    for (const auto& file: files) filesForLogOutput += " " + file + ",";
    if (filesForLogOutput.length() != 0) filesForLogOutput.pop_back();
    edm::LogInfo("Alignment")
      << "Based on the config parameter mergeBinaryFiles, using the following "
      << "files as input (assigned weights are indicated by ' -- <weight>'):"
      << filesForLogOutput;
  }

  // cache all positions, rotations and deformations
  theAlignmentParameterStore->cacheTransformations();
  if (this->isMode(myPedeReadBit) && enableAlignableUpdates_) {
    if (lastProcessedRun_ < uniqueRunRanges_.back().first) {
      throw cms::Exception("BadConfig")
    << "@SUB=MillePedeAlignmentAlgorithm::terminate\n"
    << "Last IOV of 'RunRangeSelection' has not been processed. "
    << "Please reconfigure your source to process the runs at least up to "
    << uniqueRunRanges_.back().first << ".";
    }
    auto lastCachedRun = uniqueRunRanges_.front().first;
    for (const auto& runRange: uniqueRunRanges_) {
      const auto run = runRange.first;
      if (std::find(cachedRuns_.begin(), cachedRuns_.end(), run) == cachedRuns_.end()) {
    theAlignmentParameterStore->restoreCachedTransformations(lastCachedRun);
    theAlignmentParameterStore->cacheTransformations(run);
      } else {
    lastCachedRun = run;
      }
    }
    theAlignmentParameterStore->restoreCachedTransformations();
  }

  const std::string masterSteer(thePedeSteer->buildMasterSteer(files));// do only if myPedeSteerBit?
  if (this->isMode(myPedeRunBit)) {
    thePedeSteer->runPede(masterSteer);
  }

  // parameters from pede are not yet applied,
  // so we can still write start positions (but with hit statistics in case of mille):
  this->doIO(0);
  theLastWrittenIov = 0;
}

Member Data Documentation

std::vector<align::RunNumber> MillePedeAlignmentAlgorithm::cachedRuns_

private

Definition at line 305 of file MillePedeAlignmentAlgorithm.h.

Referenced by beginRun(), and terminate().

const bool MillePedeAlignmentAlgorithm::enableAlignableUpdates_

private

Definition at line 289 of file MillePedeAlignmentAlgorithm.h.

Referenced by beginRun(), setParametersForRunRange(), and terminate().

const bool MillePedeAlignmentAlgorithm::enforceSingleIOVInput_

private

Definition at line 304 of file MillePedeAlignmentAlgorithm.h.

Referenced by initialize().

const align::RunNumber MillePedeAlignmentAlgorithm::firstIOV_

private

maximal correlation allowed for 2D hit in TID/TEC. If larger, the 2D measurement gets diagonalized!!!

Definition at line 287 of file MillePedeAlignmentAlgorithm.h.

Referenced by beginRun().

const bool MillePedeAlignmentAlgorithm::ignoreFirstIOVCheck_

private

Definition at line 288 of file MillePedeAlignmentAlgorithm.h.

Referenced by beginRun().

const bool MillePedeAlignmentAlgorithm::ignoreHitsWithoutGlobalDerivatives_

private

Definition at line 300 of file MillePedeAlignmentAlgorithm.h.

Referenced by addMeasurementData().

align::RunNumber MillePedeAlignmentAlgorithm::lastProcessedRun_

private

Definition at line 306 of file MillePedeAlignmentAlgorithm.h.

Referenced by beginRun(), and terminate().

const bool MillePedeAlignmentAlgorithm::runAtPCL_

private

Definition at line 299 of file MillePedeAlignmentAlgorithm.h.

Referenced by beginLuminosityBlock(), endLuminosityBlock(), initialize(), and storeAlignments().

const bool MillePedeAlignmentAlgorithm::skipGlobalPositionRcdCheck_

private

Definition at line 301 of file MillePedeAlignmentAlgorithm.h.

Referenced by beginRun().

std::unique_ptr<AlignableNavigator> MillePedeAlignmentAlgorithm::theAlignableNavigator

private

Definition at line 276 of file MillePedeAlignmentAlgorithm.h.

Referenced by addGlobalData(), addLasBeam(), addMeasurementData(), addPxbSurvey(), and initialize().

align::Alignables MillePedeAlignmentAlgorithm::theAlignables

private

Definition at line 275 of file MillePedeAlignmentAlgorithm.h.

Referenced by addHitStatistics(), doIO(), initialize(), readFromPede(), and setParametersForRunRange().

AlignmentParameterStore* MillePedeAlignmentAlgorithm::theAlignmentParameterStore

private

directory for all kind of files

Definition at line 274 of file MillePedeAlignmentAlgorithm.h.

Referenced by beginRun(), initialize(), setParametersForRunRange(), and terminate().

std::unique_ptr<gbl::MilleBinary> MillePedeAlignmentAlgorithm::theBinary

private

Definition at line 296 of file MillePedeAlignmentAlgorithm.h.

Referenced by addReferenceTrajectory(), MillePedeAlignmentAlgorithm(), and terminate().

std::vector<IntegratedCalibrationBase*> MillePedeAlignmentAlgorithm::theCalibrations

private

Definition at line 282 of file MillePedeAlignmentAlgorithm.h.

Referenced by addCalibrations(), addGlobalData(), and globalDerivativesCalibration().

edm::ParameterSet MillePedeAlignmentAlgorithm::theConfig

private

Definition at line 271 of file MillePedeAlignmentAlgorithm.h.

Referenced by areIOVsSpecified(), doIO(), initialize(), MillePedeAlignmentAlgorithm(), setParametersForRunRange(), storeAlignments(), and terminate().

std::string MillePedeAlignmentAlgorithm::theDir

private

Definition at line 273 of file MillePedeAlignmentAlgorithm.h.

Referenced by addHitStatistics(), doIO(), initialize(), MillePedeAlignmentAlgorithm(), and terminate().

bool MillePedeAlignmentAlgorithm::theDoSurveyPixelBarrel

private

Definition at line 294 of file MillePedeAlignmentAlgorithm.h.

Referenced by initialize().

std::vector<float> MillePedeAlignmentAlgorithm::theFloatBufferX

private

Definition at line 291 of file MillePedeAlignmentAlgorithm.h.

Referenced by addLasBeam(), and addMeasurementData().

std::vector<float> MillePedeAlignmentAlgorithm::theFloatBufferY

private

Definition at line 292 of file MillePedeAlignmentAlgorithm.h.

Referenced by addLasBeam(), and addMeasurementData().

bool MillePedeAlignmentAlgorithm::theGblDoubleBinary

private

Definition at line 297 of file MillePedeAlignmentAlgorithm.h.

Referenced by MillePedeAlignmentAlgorithm().

std::vector<int> MillePedeAlignmentAlgorithm::theIntBuffer

private

Definition at line 293 of file MillePedeAlignmentAlgorithm.h.

Referenced by addGlobalData(), addLasBeam(), and addMeasurementData().

int MillePedeAlignmentAlgorithm::theLastWrittenIov

private

Definition at line 290 of file MillePedeAlignmentAlgorithm.h.

Referenced by setParametersForRunRange(), and terminate().

double MillePedeAlignmentAlgorithm::theMaximalCor2D

private

Definition at line 285 of file MillePedeAlignmentAlgorithm.h.

Referenced by callMille2D().

std::unique_ptr<Mille> MillePedeAlignmentAlgorithm::theMille

private

Definition at line 278 of file MillePedeAlignmentAlgorithm.h.

Referenced by addLasBeam(), addPxbSurvey(), addReferenceTrajectory(), addVirtualMeas(), beginLuminosityBlock(), callMille1D(), callMille2D(), endLuminosityBlock(), endRun(), MillePedeAlignmentAlgorithm(), and terminate().

unsigned int MillePedeAlignmentAlgorithm::theMinNumHits

private

Definition at line 284 of file MillePedeAlignmentAlgorithm.h.

Referenced by addReferenceTrajectory().

unsigned int MillePedeAlignmentAlgorithm::theMode

private

Definition at line 272 of file MillePedeAlignmentAlgorithm.h.

Referenced by isMode().

std::unique_ptr<MillePedeMonitor> MillePedeAlignmentAlgorithm::theMonitor

private

Definition at line 277 of file MillePedeAlignmentAlgorithm.h.

Referenced by addPxbSurvey(), callMille1D(), callMille2D(), globalDerivativesHierarchy(), initialize(), and run().

std::shared_ptr<PedeLabelerBase> MillePedeAlignmentAlgorithm::thePedeLabels

private

Definition at line 279 of file MillePedeAlignmentAlgorithm.h.

Referenced by addCalibrations(), addGlobalData(), addLasBeam(), addPxbSurvey(), buildUserVariables(), globalDerivativesCalibration(), globalDerivativesHierarchy(), initialize(), readFromPede(), and storeAlignments().

std::unique_ptr<PedeSteerer> MillePedeAlignmentAlgorithm::thePedeSteer

private

Definition at line 280 of file MillePedeAlignmentAlgorithm.h.

Referenced by globalDerivativesHierarchy(), initialize(), readFromPede(), and terminate().

std::shared_ptr<AlignPCLThresholds> MillePedeAlignmentAlgorithm::theThresholds

private

Definition at line 283 of file MillePedeAlignmentAlgorithm.h.

Referenced by initialize(), storeAlignments(), and storeThresholds().

std::unique_ptr<TrajectoryFactoryBase> MillePedeAlignmentAlgorithm::theTrajectoryFactory

private

Definition at line 281 of file MillePedeAlignmentAlgorithm.h.

Referenced by initialize(), and run().

const align::RunRanges MillePedeAlignmentAlgorithm::uniqueRunRanges_

private

Definition at line 303 of file MillePedeAlignmentAlgorithm.h.

Referenced by beginRun(), and terminate().