MillePedeAlignmentAlgorithm.h

Go to the documentation of this file.

#ifndef Alignment_MillePedeAlignmentAlgorithm_MillePedeAlignmentAlgorithm_h
#define Alignment_MillePedeAlignmentAlgorithm_MillePedeAlignmentAlgorithm_h


#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentAlgorithmPluginFactory.h"
#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentAlgorithmBase.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"

#include "Alignment/ReferenceTrajectories/interface/ReferenceTrajectoryBase.h"

#include <vector>
#include <string>
#include <memory>

#include <TMatrixDSym.h>
#include <TMatrixD.h>
#include <TMatrixF.h>

class Alignable;
class AlignableTracker;
class AlignableMuon;
class AlignableExtras;

class AlignmentParameters;
class AlignableNavigator;
class AlignableDetOrUnitPtr;
class AlignmentUserVariables;

class AlignmentParameterStore;

class IntegratedCalibrationBase;

class MillePedeMonitor;
class PedeSteerer;
class PedeLabelerBase;
class Mille;
class TrajectoryFactoryBase;

// already from base class - and forward declaration does not work since typedef!
/* class TkFittedLasBeamCollection; */
/* class TsosVectorCollection; */

class MillePedeAlignmentAlgorithm : public AlignmentAlgorithmBase
{
 public:
  MillePedeAlignmentAlgorithm(const edm::ParameterSet &cfg);

  virtual ~MillePedeAlignmentAlgorithm();

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

  virtual bool supportsCalibrations() override;
  virtual bool addCalibrations(const std::vector<IntegratedCalibrationBase*> &iCals) override;

  virtual void terminate(const edm::EventSetup& iSetup) override;
  virtual void terminate() override;

  virtual bool processesEvents() override;

  virtual bool storeAlignments() override;

  virtual void run(const edm::EventSetup &setup, const EventInfo &eventInfo) override;

  // TODO: This method does NOT match endRun() in base class! Nobody is
  //       calling this?
  virtual void endRun(const EventInfo&, const EndRunInfo&,
                      const edm::EventSetup&); //override;

  // This one will be called since it matches the interface of the base class
  virtual void endRun(const EndRunInfo &runInfo, const edm::EventSetup &setup) override;

  virtual void beginLuminosityBlock(const edm::EventSetup&) override;

  virtual void endLuminosityBlock(const edm::EventSetup&) override;


/*   virtual void beginLuminosityBlock(const edm::EventSetup &setup) {} */
/*   virtual void endLuminosityBlock(const edm::EventSetup &setup) {} */

  virtual bool setParametersForRunRange(const RunRange &runrange) override;

 private:
  enum MeasurementDirection {kLocalX = 0, kLocalY};

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

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

  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;

  void addRefTrackData2D(const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &refTrajPtr,
             unsigned int iTrajHit, TMatrixDSym &aHitCovarianceM,
             TMatrixF &aHitResidualsM, TMatrixF &aLocalDerivativesM);
  
  void addVirtualMeas(const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &refTrajPtr,
              unsigned int iVirtualMeas);
               
  void addRefTrackVirtualMeas1D(const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &refTrajPtr,
                unsigned int iVirtualMeas,TMatrixDSym &aHitCovarianceM,
                TMatrixF &aHitResidualsM, TMatrixF &aLocalDerivativesM);
  
  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;

  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;

  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;

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

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

  int callMille2D ( const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &refTrajPtr,
            unsigned int iTrajHit, const std::vector<int> &globalLabels,
            const std::vector<float> &globalDerivativesx,
            const std::vector<float> &globalDerivativesy);
  void  diagonalize(TMatrixDSym &aHitCovarianceM, TMatrixF &aLocalDerivativesM,
            TMatrixF &aHitResidualsM,TMatrixF &theGlobalDerivativesM) const;
  // deals with the non matrix format of theFloatBufferX ...
  void makeGlobDerivMatrix(const std::vector<float> &globalDerivativesx,
               const std::vector<float> &globalDerivativesy,
               TMatrixF &aGlobalDerivativesM);

//   void callMille(const ReferenceTrajectoryBase::ReferenceTrajectoryPtr &refTrajPtr, 
//       unsigned int iTrajHit, MeasurementDirection xOrY,
//       const std::vector<float> &globalDerivatives, const std::vector<int> &globalLabels);
  bool is2D(const TransientTrackingRecHit::ConstRecHitPointer &recHit) const;

  bool readFromPede(const edm::ParameterSet &mprespset, bool setUserVars,
            const RunRange &runrange);
  bool areEmptyParams(const std::vector<Alignable*> &alignables) const;
  unsigned int doIO(int loop) const;
  void buildUserVariables(const std::vector<Alignable*> &alignables) const;

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

  void addLaserData(const EventInfo &eventInfo, 
            const TkFittedLasBeamCollection &tkLasBeams,
            const TsosVectorCollection &tkLasBeamTsoses);
  void addLasBeam(const EventInfo &eventInfo, 
          const TkFittedLasBeam &lasBeam,
          const std::vector<TrajectoryStateOnSurface> &tsoses);

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

  //--------------------------------------------------------
  // Data members
  //--------------------------------------------------------
  enum EModeBit {myMilleBit = 1 << 0, myPedeRunBit = 1 << 1, myPedeSteerBit = 1 << 2,
         myPedeReadBit = 1 << 3};
  unsigned int decodeMode(const std::string &mode) const;
  bool isMode(unsigned int testMode) const {return (theMode & testMode);}
  bool addHitStatistics(int fromLoop, const std::string &outFile,
            const std::vector<std::string> &inFiles) const;
  bool addHits(const std::vector<Alignable*> &alis,
           const std::vector<AlignmentUserVariables*> &mpVars) const;

  edm::ParameterSet         theConfig;
  unsigned int              theMode;
  std::string               theDir; 
  AlignmentParameterStore  *theAlignmentParameterStore;
  std::vector<Alignable*>   theAlignables;
  std::unique_ptr<AlignableNavigator>    theAlignableNavigator;
  std::unique_ptr<MillePedeMonitor>      theMonitor;
  std::unique_ptr<Mille>                 theMille;
  std::shared_ptr<PedeLabelerBase>       thePedeLabels;
  std::unique_ptr<PedeSteerer>           thePedeSteer;
  std::unique_ptr<TrajectoryFactoryBase> theTrajectoryFactory;
  std::vector<IntegratedCalibrationBase*> theCalibrations;
  unsigned int              theMinNumHits;
  double                    theMaximalCor2D; 
  int                       theLastWrittenIov; // keeping track for output trees...
  std::vector<float>        theFloatBufferX;
  std::vector<float>        theFloatBufferY;
  std::vector<int>          theIntBuffer;
  bool                      theDoSurveyPixelBarrel;
  // CHK for GBL
  std::unique_ptr<gbl::MilleBinary> theBinary;
  bool                      theGblDoubleBinary;

  const bool                runAtPCL_;
  const bool                ignoreHitsWithoutGlobalDerivatives_;
};

DEFINE_EDM_PLUGIN(AlignmentAlgorithmPluginFactory,
           MillePedeAlignmentAlgorithm, "MillePedeAlignmentAlgorithm");
#endif