PedeLabelerBase.h

Go to the documentation of this file.

#ifndef Alignment_MillePedeAlignmentAlgorithm_PedeLabelerBase_h
#define Alignment_MillePedeAlignmentAlgorithm_PedeLabelerBase_h

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

#include "Alignment/CommonAlignment/interface/AlignableObjectId.h"
#include "Alignment/CommonAlignment/interface/Utilities.h"
#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentAlgorithmBase.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"

#include "CondFormats/Common/interface/Time.h"

#include <vector>

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

/***************************************
****************************************/
class PedeLabelerBase {
public:
  using RunNumber = align::RunNumber;
  using RunRange = align::RunRange;
  using RunRanges = align::RunRanges;

  class TopLevelAlignables {
  public:
    TopLevelAlignables(AlignableTracker *aliTracker, AlignableMuon *aliMuon, AlignableExtras *extras)
        : aliTracker_(aliTracker), aliMuon_(aliMuon), aliExtras_(extras) {}
    AlignableTracker *aliTracker_;
    AlignableMuon *aliMuon_;
    AlignableExtras *aliExtras_;
  };

  PedeLabelerBase(const TopLevelAlignables &alignables, const edm::ParameterSet &config);
  virtual ~PedeLabelerBase() {}
  virtual void addCalibrations(const std::vector<IntegratedCalibrationBase *> &iCals);

  virtual unsigned int alignableLabel(const Alignable *alignable) const = 0;
  virtual unsigned int alignableLabelFromParamAndInstance(const Alignable *alignable,
                                                          unsigned int param,
                                                          unsigned int instance) const = 0;
  virtual unsigned int lasBeamLabel(unsigned int lasBeamId) const = 0;
  virtual unsigned int parameterLabel(unsigned int aliLabel, unsigned int parNum) const = 0;
  virtual unsigned int parameterLabel(Alignable *alignable,
                                      unsigned int parNum,
                                      const AlignmentAlgorithmBase::EventInfo &eventInfo,
                                      const TrajectoryStateOnSurface &tsos) const = 0;
  virtual bool hasSplitParameters(Alignable *alignable) const = 0;
  virtual unsigned int numberOfParameterInstances(Alignable *alignable, int param = -1) const = 0;
  virtual unsigned int maxNumberOfParameterInstances() const = 0;
  unsigned int parameterInstanceOffset() const { return theParamInstanceOffset; }

  virtual unsigned int paramNumFromLabel(unsigned int paramLabel) const = 0;
  virtual unsigned int alignableLabelFromLabel(unsigned int label) const = 0;
  virtual Alignable *alignableFromLabel(unsigned int label) const = 0;
  virtual unsigned int lasBeamIdFromLabel(unsigned int label) const = 0;
  virtual std::pair<IntegratedCalibrationBase *, unsigned int> calibrationParamFromLabel(unsigned int label) const;

  virtual const RunRange &runRangeFromLabel(unsigned int label) const { return theOpenRunRange; }
  virtual unsigned int firstFreeLabel() const;

  virtual unsigned int calibrationLabel(const IntegratedCalibrationBase *calib, unsigned int paramNum) const;
  const AlignableTracker *alignableTracker() const { return topLevelAlignables_.aliTracker_; }
  const AlignableMuon *alignableMuon() const { return topLevelAlignables_.aliMuon_; }
  const AlignableExtras *alignableExtras() const { return topLevelAlignables_.aliExtras_; }

  static const unsigned int theMaxNumParam;
  static const unsigned int theParamInstanceOffset;
  static const unsigned int theMinLabel;

protected:
  virtual unsigned int firstNonAlignableLabel() const;

  const AlignableObjectId &objectIdProvider() const { return alignableObjectId_; }

  const RunRange theOpenRunRange;

private:
  const TopLevelAlignables topLevelAlignables_;
  const AlignableObjectId alignableObjectId_;

  std::vector<std::pair<IntegratedCalibrationBase *, unsigned int> > theCalibrationLabels;
};

struct AlignableComparator {
  using is_transparent = void;  // needs to be defined, actual type is not relevant
  bool operator()(Alignable *a, Alignable *b) const { return a < b; }
  bool operator()(Alignable *a, const Alignable *b) const { return a < b; }
  bool operator()(const Alignable *a, Alignable *b) const { return a < b; }
};

#endif