AlignmentAlgorithmBase.h

Go to the documentation of this file.

#ifndef Alignment_CommonAlignmentAlgorithm_AlignmentAlgorithmBase_h
#define Alignment_CommonAlignmentAlgorithm_AlignmentAlgorithmBase_h

#include <vector>
#include <utility>

class AlignableTracker;
class AlignableMuon;
class AlignableExtras;
class AlignmentParameterStore;
class IntegratedCalibrationBase;
class Trajectory;
// These data formats cannot be forward declared since they are typedef's,
// so include the headers that define the typedef's
// (no need to include in dependencies in BuildFile):
// class TsosVectorCollection;
// class TkFittedLasBeamCollection;
// class AliClusterValueMap;
#include "Alignment/CommonAlignment/interface/Utilities.h"
#include "Alignment/LaserAlignment/interface/TsosVectorCollection.h"
#include "DataFormats/Alignment/interface/TkFittedLasBeamCollectionFwd.h"
#include "DataFormats/Alignment/interface/AliClusterValueMapFwd.h"
#include "FWCore/Framework/interface/Event.h"

namespace edm { class EventSetup; class ParameterSet; }
namespace reco { class Track; class BeamSpot; }

/*** Global typedefs part I (see EOF for part II) ***/
typedef std::pair<const Trajectory*, const reco::Track*> ConstTrajTrackPair;
typedef std::vector< ConstTrajTrackPair >                ConstTrajTrackPairs;

typedef std::vector<IntegratedCalibrationBase*> Calibrations;



class AlignmentAlgorithmBase
{

public:
  // TODO: DEPRECATED: For not breaking the interface, used in serveral files.
  //                   If possible use the global typedefs above.
  // With global typedefs one does not have to typedef again like
  // 'typedef AlignmentAlgorithmBase::ConstTrajTrackPair ConstTrajTrackPair;'
  // in other files.
  typedef std::pair<const Trajectory*, const reco::Track*> ConstTrajTrackPair; 
  typedef std::vector< ConstTrajTrackPair >  ConstTrajTrackPairCollection;
  using RunNumber = align::RunNumber;
  using RunRange = align::RunRange;

  class EventInfo {
  public:
    EventInfo(const edm::EventID &theEventId, 
          const ConstTrajTrackPairCollection &theTrajTrackPairs,
          const reco::BeamSpot &theBeamSpot,
          const AliClusterValueMap *theClusterValueMap) 
      : eventId_(theEventId), trajTrackPairs_(theTrajTrackPairs), beamSpot_(theBeamSpot), clusterValueMap_(theClusterValueMap) {}

    const edm::EventID eventId() const { return eventId_; }
    const ConstTrajTrackPairCollection& trajTrackPairs() const { return trajTrackPairs_; }
    const reco::BeamSpot& beamSpot() const { return beamSpot_; }
    const AliClusterValueMap* clusterValueMap() const { return clusterValueMap_; }
    

  private:
    const edm::EventID                 eventId_;
    const ConstTrajTrackPairCollection &trajTrackPairs_;
    const reco::BeamSpot               &beamSpot_;
    const AliClusterValueMap           *clusterValueMap_;
  };
  
  class EndRunInfo {
  public:
    EndRunInfo(const edm::RunID &theRunId, const TkFittedLasBeamCollection *theTkLasBeams,
           const TsosVectorCollection *theTkLasBeamTsoses)
      : runId_(theRunId), tkLasBeams_(theTkLasBeams), tkLasBeamTsoses_(theTkLasBeamTsoses) {}

    const edm::RunID runId() const { return runId_; }
    const TkFittedLasBeamCollection* tkLasBeams() const { return tkLasBeams_; } 
    const TsosVectorCollection* tkLasBeamTsoses() const { return tkLasBeamTsoses_; } 


  private:
    const edm::RunID runId_;
    const TkFittedLasBeamCollection *tkLasBeams_; 
    const TsosVectorCollection *tkLasBeamTsoses_; 
  };
  
  AlignmentAlgorithmBase(const edm::ParameterSet&) {};
  
  virtual ~AlignmentAlgorithmBase() {};

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

  virtual bool supportsCalibrations() { return false; }
  virtual bool addCalibrations(const Calibrations&) { return false; }

  virtual bool processesEvents() { return true; }

  virtual bool storeAlignments() { return true; }

  // TODO: DEPRECATED: Actually, there are no iterative algorithms, use
  //                   initialze() and terminate()
  virtual void startNewLoop() {}

  virtual void terminate(const edm::EventSetup& iSetup) = 0;
  virtual void terminate() {}

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

  virtual void beginRun(const edm::Run&, const edm::EventSetup&, bool changed) {};

  virtual void endRun(const EndRunInfo &runInfo, const edm::EventSetup &setup) {};

  virtual void beginLuminosityBlock(const edm::EventSetup &setup) {};

  virtual void endLuminosityBlock(const edm::EventSetup &setup) {};

  virtual bool setParametersForRunRange(const RunRange& rr) { return false; };
};

/*** Global typedefs part II ***/
typedef AlignmentAlgorithmBase::EventInfo  EventInfo;
typedef AlignmentAlgorithmBase::EndRunInfo EndRunInfo;

#endif