MillePedeAlignmentAlgorithm Class Reference

#include <MillePedeAlignmentAlgorithm.h>

Inheritance diagram for MillePedeAlignmentAlgorithm:

Public Member Functions
virtual bool	addCalibrations (const std::vector< IntegratedCalibrationBase * > &iCals) override
	Pass integrated calibrations to Millepede (they are not owned by Millepede!) More...
virtual void	beginLuminosityBlock (const edm::EventSetup &) override
	called at begin of luminosity block (resets Mille binary in mille mode) More...
virtual 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...
virtual void	endRun (const EndRunInfo &runInfo, const edm::EventSetup &setup) override
	called at end of run - order of arguments like in EDProducer etc. More...
virtual 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...
virtual bool	processesEvents () override
	Returns whether MP should process events in the current configuration. More...
virtual void	run (const edm::EventSetup &setup, const EventInfo &eventInfo) override
	Run the algorithm on trajectories and tracks. More...
virtual bool	setParametersForRunRange (const RunRange &runrange) override
virtual bool	storeAlignments () override
	Returns whether MP produced results to be stored. More...
virtual bool	supportsCalibrations () override
	Returns whether MP supports calibrations. More...
virtual void	terminate (const edm::EventSetup &iSetup) override
	Called at end of job. More...
virtual void	terminate () override
	Called at end of job. More...
virtual	~MillePedeAlignmentAlgorithm ()
	Destructor. More...
Public Member Functions inherited from AlignmentAlgorithmBase
virtual bool	addCalibrations (const Calibrations &)
	AlignmentAlgorithmBase (const edm::ParameterSet &)
	Constructor. More...
virtual void	beginRun (const edm::EventSetup &setup)
	called at begin of run 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 std::vector< Alignable * > &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...
void	addRefTrackData2D (const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &refTrajPtr, unsigned int iTrajHit, TMatrixDSym &aHitCovarianceM, TMatrixF &aHitResidualsM, TMatrixF &aLocalDerivativesM)
	adds data from reference trajectory from a specific Hit More...
void	addRefTrackVirtualMeas1D (const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &refTrajPtr, unsigned int iVirtualMeas, TMatrixDSym &aHitCovarianceM, TMatrixF &aHitResidualsM, TMatrixF &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 std::vector< Alignable * > &alignables) const
void	buildUserVariables (const std::vector< Alignable * > &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
void	diagonalize (TMatrixDSym &aHitCovarianceM, TMatrixF &aLocalDerivativesM, TMatrixF &aHitResidualsM, TMatrixF &theGlobalDerivativesM) 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
void	makeGlobDerivMatrix (const std::vector< float > &globalDerivativesx, const std::vector< float > &globalDerivativesy, TMatrixF &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
const bool	ignoreHitsWithoutGlobalDerivatives_
const bool	runAtPCL_
std::unique_ptr < AlignableNavigator >	theAlignableNavigator
std::vector< Alignable * >	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::unique_ptr < TrajectoryFactoryBase >	theTrajectoryFactory

Additional Inherited Members
Public Types inherited from AlignmentAlgorithmBase
typedef std::pair< const Trajectory *, const reco::Track * >	ConstTrajTrackPair
typedef std::vector < ConstTrajTrackPair >	ConstTrajTrackPairCollection
typedef cond::RealTimeType < cond::runnumber >::type	RunNumber
typedef std::pair< RunNumber, RunNumber >	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 56 of file MillePedeAlignmentAlgorithm.h.

Member Enumeration Documentation

enum MillePedeAlignmentAlgorithm::EModeBit

private

Enumerator
myMilleBit
myPedeRunBit
myPedeSteerBit
myPedeReadBit

Definition at line 236 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 113 of file MillePedeAlignmentAlgorithm.h.

{kLocalX = 0, kLocalY};

Constructor & Destructor Documentation

MillePedeAlignmentAlgorithm::MillePedeAlignmentAlgorithm

(

const edm::ParameterSet &

cfg

)

Constructor.

Definition at line 89 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")),
  theLastWrittenIov(0),
  theGblDoubleBinary(cfg.getParameter<bool>("doubleBinary")),
  runAtPCL_(cfg.getParameter<bool>("runAtPCL")),
  ignoreHitsWithoutGlobalDerivatives_(cfg.getParameter<bool>("ignoreHitsWithoutGlobalDerivatives"))
{
  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 ( )

virtual

Destructor.

Definition at line 116 of file MillePedeAlignmentAlgorithm.cc.

{
}

Member Function Documentation

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

overridevirtual

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

Definition at line 292 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 656 of file MillePedeAlignmentAlgorithm.cc.

References gbl::GblPoint::addGlobals(), globalDerivativesHierarchy(), i, theAlignableNavigator, theCalibrations, theIntBuffer, and thePedeLabels.

Referenced by addReferenceTrajectory().

{
  AlignmentParameters* params = 0;
  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)
  {
    TMatrixD 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 556 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() : 0);
    // 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 std::vector< Alignable * > &  alis, const std::vector< AlignmentUserVariables * > &  mpVars  ) const

private

Definition at line 1103 of file MillePedeAlignmentAlgorithm.cc.

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

Referenced by addHitStatistics().

{
  bool allOk = (mpVars.size() == alis.size());
  std::vector<AlignmentUserVariables*>::const_iterator iUser = mpVars.begin();
  for (std::vector<Alignable*>::const_iterator iAli = alis.begin(); 
       iAli != alis.end() && iUser != mpVars.end(); ++iAli, ++iUser) {
    MillePedeVariables *mpVarNew = dynamic_cast<MillePedeVariables*>(*iUser);
    AlignmentParameters *ps = (*iAli)->alignmentParameters();
    MillePedeVariables *mpVarOld = (ps ? dynamic_cast<MillePedeVariables*>(ps->userVariables()) : 0);
    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 1076 of file MillePedeAlignmentAlgorithm.cc.

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

Referenced by doIO().

{
  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 1414 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 = 0; // 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 1395 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 617 of file MillePedeAlignmentAlgorithm.cc.

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

Referenced by addReferenceTrajectory().

{
  params = 0;
  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 1460 of file MillePedeAlignmentAlgorithm.cc.

References a, beam_dqm_sourceclient-live_cfg::chi2, SurveyPxbDicer::doDice(), lut2db_cfg::filename, edm::FileInPath::fullPath(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), i, j, SurveyPxbImageLocalFit::nMsrmts, timingPdfMaker::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 470 of file MillePedeAlignmentAlgorithm.cc.

References addGlobalData(), addHitCount(), addMeasurementData(), addVirtualMeas(), gbl::GblTrajectory::milleOut(), theBinary, theMille, and theMinNumHits.

Referenced by run().

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

    // GblTrajectory?
    if (refTrajPtr->gblInput().size() > 0) {
      // by construction: number of GblPoints == number of recHits or == zero !!!
      unsigned int iHit = 0;
      unsigned int numPointsWithMeas = 0;
      std::vector<GblPoint>::iterator itPoint;
      std::vector<std::pair<std::vector<GblPoint>, TMatrixD> > 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;
}

void MillePedeAlignmentAlgorithm::addRefTrackData2D ( const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &  refTrajPtr, unsigned int  iTrajHit, TMatrixDSym &  aHitCovarianceM, TMatrixF &  aHitResidualsM, TMatrixF &  aLocalDerivativesM  )

private

adds data from reference trajectory from a specific Hit

Definition at line 1194 of file MillePedeAlignmentAlgorithm.cc.

References i.

{
  // This Method is valid for 2D measurements only
  
  const unsigned int xIndex = iTrajHit*2;
  const unsigned int yIndex = iTrajHit*2+1;
  // Covariance into a TMatrixDSym

  //aHitCovarianceM = new TMatrixDSym(2);
  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];
  
  //theHitResidualsM= new TMatrixF(2,1);
  aHitResidualsM(0,0)= refTrajPtr->measurements()[xIndex] - refTrajPtr->trajectoryPositions()[xIndex];
  aHitResidualsM(1,0)= refTrajPtr->measurements()[yIndex] - refTrajPtr->trajectoryPositions()[yIndex];
  
  // Local Derivatives into a TMatrixDSym (to use matrix operations)
  const AlgebraicMatrix &locDerivMatrix = refTrajPtr->derivatives();
  //  theLocalDerivativeNumber = locDerivMatrix.num_col();
  
  //theLocalDerivativesM = new TMatrixF(2,locDerivMatrix.num_col());
  for (int i = 0; i < locDerivMatrix.num_col(); ++i) {
    aLocalDerivativesM(0,i) = locDerivMatrix[xIndex][i];
    aLocalDerivativesM(1,i) = locDerivMatrix[yIndex][i];
  }
}

void MillePedeAlignmentAlgorithm::addRefTrackVirtualMeas1D ( const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &  refTrajPtr, unsigned int  iVirtualMeas, TMatrixDSym &  aHitCovarianceM, TMatrixF &  aHitResidualsM, TMatrixF &  aLocalDerivativesM  )

private

adds data for a specific virtual measurement from reference trajectory

Definition at line 1167 of file MillePedeAlignmentAlgorithm.cc.

References i.

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

  const unsigned int xIndex = iVirtualMeas + refTrajPtr->numberOfHitMeas();
  // Covariance into a TMatrixDSym
  
  //aHitCovarianceM = new TMatrixDSym(1);
  aHitCovarianceM(0,0)=refTrajPtr->measurementErrors()[xIndex][xIndex];
  
  //theHitResidualsM= new TMatrixF(1,1);
  aHitResidualsM(0,0)= refTrajPtr->measurements()[xIndex];
  
  // Local Derivatives into a TMatrixDSym (to use matrix operations)
  const AlgebraicMatrix &locDerivMatrix = refTrajPtr->derivatives();
  //  theLocalDerivativeNumber = locDerivMatrix.num_col();
  
  //theLocalDerivativesM = new TMatrixF(1,locDerivMatrix.num_col());
  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 1371 of file MillePedeAlignmentAlgorithm.cc.

Referenced by addReferenceTrajectory().

{
  TMatrixDSym aHitCovarianceM(1);
  TMatrixF aHitResidualsM(1,1);
  TMatrixF 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)
  TMatrixF aGlobalDerivativesM(1,1);
  aGlobalDerivativesM(0,0) = 0;
      
  float newResidX = aHitResidualsM(0,0);  
  float newHitErrX = TMath::Sqrt(aHitCovarianceM(0,0));
  float *newLocalDerivsX = aLocalDerivativesM[0].GetPtr();
  float *newGlobDerivsX  = aGlobalDerivativesM[0].GetPtr();
  const int nLocal  = aLocalDerivativesM.GetNcols();
  const int nGlobal = 0;
  
  theMille->mille(nLocal, newLocalDerivsX, nGlobal, newGlobDerivsX,
          &nGlobal, newResidX, newHitErrX);  
}

bool MillePedeAlignmentAlgorithm::areEmptyParams ( const std::vector< Alignable * > &  alignables ) const

private

Definition at line 945 of file MillePedeAlignmentAlgorithm.cc.

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

Referenced by readFromPede().

{
  
  for (std::vector<Alignable*>::const_iterator iAli = alignables.begin();
       iAli != alignables.end(); ++iAli) {
    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;
}

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 602 of file MillePedeAlignmentAlgorithm.cc.

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

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

void MillePedeAlignmentAlgorithm::buildUserVariables ( const std::vector< Alignable * > &  alignables ) const

private

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

Definition at line 1027 of file MillePedeAlignmentAlgorithm.cc.

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

Referenced by initialize(), and setParametersForRunRange().

{
  for (std::vector<Alignable*>::const_iterator iAli = alis.begin(); iAli != alis.end(); ++iAli) {
    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));
      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 1227 of file MillePedeAlignmentAlgorithm.cc.

Referenced by addMeasurementData().

{    
  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 1245 of file MillePedeAlignmentAlgorithm.cc.

References i.

{
  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 1284 of file MillePedeAlignmentAlgorithm.cc.

References Abs(), corr, pat::helper::ParametrizationHelper::dimension(), fastTrackerRecHitType::is2D(), mathSSE::sqrt(), std::swap(), SiStripDetId::TEC, SiStripDetId::TID, and DetId::Tracker.

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

  TMatrixDSym aHitCovarianceM(2);
  TMatrixF aHitResidualsM(2,1);
  TMatrixF aLocalDerivativesM(2, refTrajPtr->derivatives().num_col());
  // below method fills above 3 matrices
  this->addRefTrackData2D(refTrajPtr, iTrajHit, aHitCovarianceM,aHitResidualsM,aLocalDerivativesM);
  TMatrixF 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));
  float *newLocalDerivsX = aLocalDerivativesM[0].GetPtr();
  float *newLocalDerivsY = aLocalDerivativesM[1].GetPtr();
  float *newGlobDerivsX  = aGlobalDerivativesM[0].GetPtr();
  float *newGlobDerivsY  = aGlobalDerivativesM[1].GetPtr();
  const int nLocal  = aLocalDerivativesM.GetNcols();
  const int nGlobal = aGlobalDerivativesM.GetNcols();

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

void MillePedeAlignmentAlgorithm::diagonalize ( TMatrixDSym &  aHitCovarianceM, TMatrixF &  aLocalDerivativesM, TMatrixF &  aHitResidualsM, TMatrixF &  theGlobalDerivativesM  ) const

private

Definition at line 1139 of file MillePedeAlignmentAlgorithm.cc.

{
  TMatrixDSymEigen myDiag(aHitCovarianceM);
  TMatrixD aTranfoToDiagonalSystem = myDiag.GetEigenVectors();
  TMatrixD aTranfoToDiagonalSystemInv = myDiag.GetEigenVectors( );
  TMatrixF aTranfoToDiagonalSystemInvF = myDiag.GetEigenVectors( );
  TMatrixD aMatrix = aTranfoToDiagonalSystemInv.Invert() * aHitCovarianceM * aTranfoToDiagonalSystem;
  // Tranformation of matrix M is done by A^T*M*A, not A^{-1}*M*A.
  // But here A^T == A^{-1}, so we would only save CPU by Transpose()...
  // FIXME this - I guess simply use T(), not Transpose()...
  // TMatrixD aMatrix = aTranfoToDiagonalSystemInv.Transpose() * aHitCovarianceM
  //    * aTranfoToDiagonalSystem;
  aHitCovarianceM = TMatrixDSym(2, aMatrix.GetMatrixArray());
  aTranfoToDiagonalSystemInvF.Invert();
  //edm::LogInfo("Alignment") << "NEW HIT loca in matrix"<<aLocalDerivativesM(0,0);
  aLocalDerivativesM = aTranfoToDiagonalSystemInvF * aLocalDerivativesM;
  
  //edm::LogInfo("Alignment") << "NEW HIT loca in matrix after diag:"<<aLocalDerivativesM(0,0);
  aHitResidualsM      = aTranfoToDiagonalSystemInvF * aHitResidualsM;
  if (aGlobalDerivativesM.GetNoElements() > 0) {
    // diagnoalize only if measurement depends on alignables or calibrations
    aGlobalDerivativesM = aTranfoToDiagonalSystemInvF * aGlobalDerivativesM;
  }
}

unsigned int MillePedeAlignmentAlgorithm::doIO ( int  loop ) const

private

Definition at line 967 of file MillePedeAlignmentAlgorithm.cc.

References addHitStatistics(), edm::ParameterSet::getParameter(), cmsHarvester::loop, produceTPGParameters_beamv6_transparency_spikekill_2016_script::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 609 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 586 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 597 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 391 of file MillePedeAlignmentAlgorithm.cc.

References MainPageGenerator::files, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by terminate().

                                                                                                                                           {
  std::vector<std::string> files;
  for (const auto& plainFile: plainFiles) {
    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.size() == 0 || 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 834 of file MillePedeAlignmentAlgorithm.cc.

References theCalibrations, and thePedeLabels.

Referenced by addMeasurementData().

{
  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 716 of file MillePedeAlignmentAlgorithm.cc.

References Alignable::alignmentParameters(), AlignmentParameters::derivatives(), Alignable::mother(), and AlignmentParameters::selector().

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

{
  // 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 772 of file MillePedeAlignmentAlgorithm.cc.

References Alignable::alignmentParameters(), AlignmentParameters::derivatives(), Alignable::mother(), and AlignmentParameters::selector().

{
  // 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 122 of file MillePedeAlignmentAlgorithm.cc.

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

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

  // temporary fix to avoid corrupted database output
  if (!runAtPCL_) {
    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();
    if (iov_alignments.first().eventID().run() != MIN_VAL ||
    iov_alignments.last().eventID().run() != MAX_VAL) {
    throw cms::Exception("DatabaseError")
      << "@SUB=MillePedeAlignmentAlgorithm::initialize"
      << "\nTrying to apply " << setup.get<TrackerAlignmentRcd>().key().name()
      << " with multiple IOVs in tag.\n"
      << "Validity range is "
      << iov_alignments.first().eventID().run() << " - "
      << iov_alignments.last().eventID().run();
    }
    if (iov_surfaces.first().eventID().run() != MIN_VAL ||
    iov_surfaces.last().eventID().run() != MAX_VAL) {
    throw cms::Exception("DatabaseError")
      << "@SUB=MillePedeAlignmentAlgorithm::initialize"
      << "\nTrying to apply "
      << setup.get<TrackerSurfaceDeformationRcd>().key().name()
      << " with multiple IOVs in tag.\n"
      << "Validity range is "
      << iov_surfaces.first().eventID().run() << " - "
      << iov_surfaces.last().eventID().run();
    }
    if (iov_errors.first().eventID().run() != MIN_VAL ||
    iov_errors.last().eventID().run() != MAX_VAL) {
    throw cms::Exception("DatabaseError")
      << "@SUB=MillePedeAlignmentAlgorithm::initialize"
      << "\nTrying to apply "
      << setup.get<TrackerAlignmentErrorExtendedRcd>().key().name()
      << " with multiple IOVs in tag.\n"
      << "Validity range is "
      << iov_errors.first().eventID().run() << " - "
      << iov_errors.last().eventID().run();
    }
  }


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

  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.size()>0) {
    labelerPlugin = "RunRangeDependentPedeLabeler";
    if (pedeLabelerCfg.exists("plugin")) {
      std::string labelerPluginCfg = pedeLabelerCfg.getParameter<std::string>("plugin");
      if ((labelerPluginCfg!="PedeLabeler" && labelerPluginCfg!="RunRangeDependentPedeLabeler") ||
      pedeLabelerCfg.getUntrackedParameter<edm::VParameterSet>("parameterInstances").size()>0) {
    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.size()) 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 889 of file MillePedeAlignmentAlgorithm.cc.

{
  // 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 239 of file MillePedeAlignmentAlgorithm.h.

References theMode.

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

{return (theMode & testMode);}

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

private

Definition at line 1126 of file MillePedeAlignmentAlgorithm.cc.

References i.

{

  for (unsigned int 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 300 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 908 of file MillePedeAlignmentAlgorithm.cc.

References areEmptyParams(), fileinputsource_cfi::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);
  std::vector<Alignable*> 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.size()) { // 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 432 of file MillePedeAlignmentAlgorithm.cc.

References addReferenceTrajectory(), AlignmentAlgorithmBase::EventInfo::beamSpot(), isMode(), myMilleBit, hltrates_dqm_sourceclient-live_cfg::offset, edm::second(), theMonitor, theTrajectoryFactory, testEve_cfg::tracks, HLT_FULL_cff::trajectories, and AlignmentAlgorithmBase::EventInfo::trajTrackPairs().

Referenced by Types.EventID::cppID(), and Types.LuminosityBlockID::cppID().

{
  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 327 of file MillePedeAlignmentAlgorithm.cc.

References AlignmentParameterStore::applyParameters(), buildUserVariables(), doIO(), 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
    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 310 of file MillePedeAlignmentAlgorithm.cc.

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

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

bool MillePedeAlignmentAlgorithm::supportsCalibrations ( )

overridevirtual

Returns whether MP supports calibrations.

Reimplemented from AlignmentAlgorithmBase.

Definition at line 287 of file MillePedeAlignmentAlgorithm.cc.

                                                       {
  return true;
}

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

overridevirtual

Called at end of job.

Implements AlignmentAlgorithmBase.

Definition at line 352 of file MillePedeAlignmentAlgorithm.cc.

References terminate().

{
  terminate();
}

void MillePedeAlignmentAlgorithm::terminate ( void  )

overridevirtual

Called at end of job.

Reimplemented from AlignmentAlgorithmBase.

Definition at line 356 of file MillePedeAlignmentAlgorithm.cc.

References AlignmentParameterStore::cacheTransformations(), doIO(), mergeVDriftHistosByStation::file, MainPageGenerator::files, getExistingFormattedFiles(), edm::ParameterSet::getParameter(), isMode(), myMilleBit, myPedeRunBit, AlCaHLTBitMon_QueryRunRegistry::string, theAlignmentParameterStore, theBinary, theConfig, theDir, theLastWrittenIov, theMille, and thePedeSteer.

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

  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

const bool MillePedeAlignmentAlgorithm::ignoreHitsWithoutGlobalDerivatives_

private

Definition at line 270 of file MillePedeAlignmentAlgorithm.h.

Referenced by addMeasurementData().

const bool MillePedeAlignmentAlgorithm::runAtPCL_

private

Definition at line 269 of file MillePedeAlignmentAlgorithm.h.

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

std::unique_ptr<AlignableNavigator> MillePedeAlignmentAlgorithm::theAlignableNavigator

private

Definition at line 250 of file MillePedeAlignmentAlgorithm.h.

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

std::vector<Alignable*> MillePedeAlignmentAlgorithm::theAlignables

private

Definition at line 249 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 248 of file MillePedeAlignmentAlgorithm.h.

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

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

private

Definition at line 266 of file MillePedeAlignmentAlgorithm.h.

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

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

private

Definition at line 256 of file MillePedeAlignmentAlgorithm.h.

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

edm::ParameterSet MillePedeAlignmentAlgorithm::theConfig

private

Definition at line 245 of file MillePedeAlignmentAlgorithm.h.

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

std::string MillePedeAlignmentAlgorithm::theDir

private

Definition at line 247 of file MillePedeAlignmentAlgorithm.h.

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

bool MillePedeAlignmentAlgorithm::theDoSurveyPixelBarrel

private

Definition at line 264 of file MillePedeAlignmentAlgorithm.h.

Referenced by initialize().

std::vector<float> MillePedeAlignmentAlgorithm::theFloatBufferX

private

Definition at line 261 of file MillePedeAlignmentAlgorithm.h.

Referenced by addLasBeam(), and addMeasurementData().

std::vector<float> MillePedeAlignmentAlgorithm::theFloatBufferY

private

Definition at line 262 of file MillePedeAlignmentAlgorithm.h.

Referenced by addLasBeam(), and addMeasurementData().

bool MillePedeAlignmentAlgorithm::theGblDoubleBinary

private

Definition at line 267 of file MillePedeAlignmentAlgorithm.h.

Referenced by MillePedeAlignmentAlgorithm().

std::vector<int> MillePedeAlignmentAlgorithm::theIntBuffer

private

Definition at line 263 of file MillePedeAlignmentAlgorithm.h.

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

int MillePedeAlignmentAlgorithm::theLastWrittenIov

private

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

Definition at line 260 of file MillePedeAlignmentAlgorithm.h.

Referenced by setParametersForRunRange(), and terminate().

double MillePedeAlignmentAlgorithm::theMaximalCor2D

private

Definition at line 258 of file MillePedeAlignmentAlgorithm.h.

std::unique_ptr<Mille> MillePedeAlignmentAlgorithm::theMille

private

Definition at line 252 of file MillePedeAlignmentAlgorithm.h.

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

unsigned int MillePedeAlignmentAlgorithm::theMinNumHits

private

Definition at line 257 of file MillePedeAlignmentAlgorithm.h.

Referenced by addReferenceTrajectory().

unsigned int MillePedeAlignmentAlgorithm::theMode

private

Definition at line 246 of file MillePedeAlignmentAlgorithm.h.

Referenced by isMode().

std::unique_ptr<MillePedeMonitor> MillePedeAlignmentAlgorithm::theMonitor

private

Definition at line 251 of file MillePedeAlignmentAlgorithm.h.

Referenced by addPxbSurvey(), initialize(), and run().

std::shared_ptr<PedeLabelerBase> MillePedeAlignmentAlgorithm::thePedeLabels

private

Definition at line 253 of file MillePedeAlignmentAlgorithm.h.

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

std::unique_ptr<PedeSteerer> MillePedeAlignmentAlgorithm::thePedeSteer

private

Definition at line 254 of file MillePedeAlignmentAlgorithm.h.

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

std::unique_ptr<TrajectoryFactoryBase> MillePedeAlignmentAlgorithm::theTrajectoryFactory

private

Definition at line 255 of file MillePedeAlignmentAlgorithm.h.

Referenced by initialize(), and run().