/data/refman/pasoursint/CMSSW_5_3_1/src/Alignment/CommonAlignmentAlgorithm/interface/AlignmentAlgorithmBase.h

Go to the documentation of this file.

#ifndef Alignment_CommonAlignmentAlgorithm_AlignmentAlgorithmBase_h
#define Alignment_CommonAlignmentAlgorithm_AlignmentAlgorithmBase_h

//
// Base class for the alignment algorithm
//
// Any algorithm should derive from this class
//

#include <vector>
#include <utility>

class AlignableTracker;
class AlignableMuon;
class AlignableExtras;
class AlignmentParameterStore;
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 "CondCore/DBCommon/interface/Time.h"
#include "Alignment/LaserAlignment/interface/TsosVectorCollection.h"
#include "DataFormats/Alignment/interface/TkFittedLasBeamCollectionFwd.h"
#include "DataFormats/Alignment/interface/AliClusterValueMapFwd.h"

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

class AlignmentAlgorithmBase
{

public:

  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;

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

    const edm::EventID                 &eventId_;
    const ConstTrajTrackPairCollection &trajTrackPairs_;
    const reco::BeamSpot               &beamSpot_;
    const AliClusterValueMap           *clusterValueMap_;
  };
  
  struct EndRunInfo {
    EndRunInfo(const edm::RunID &runId, const TkFittedLasBeamCollection *tkLasBeams,
               const TsosVectorCollection *tkLasBeamTsoses)
      : runId_(runId), tkLasBeams_(tkLasBeams), tkLasBeamTsoses_(tkLasBeamTsoses) {}
    const edm::RunID &runId_;
    const TkFittedLasBeamCollection *tkLasBeams_; 
    const TsosVectorCollection *tkLasBeamTsoses_; 
  };
  
  AlignmentAlgorithmBase(const edm::ParameterSet& cfg);
  
  virtual ~AlignmentAlgorithmBase() {};

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

  virtual void terminate() = 0;

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

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

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

#endif