IntegratedCalibrationBase.h

Go to the documentation of this file.

#ifndef Alignment_CommonAlignmentAlgorithm_IntegratedCalibrationBase_h
#define Alignment_CommonAlignmentAlgorithm_IntegratedCalibrationBase_h
 
#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentAlgorithmBase.h"
 
#include <vector>
#include <utility>
#include <string>
 
class AlignableTracker;
class AlignableMuon;
class AlignableExtras;
 
class TrajectoryStateOnSurface;
class TrackingRecHit;
 
namespace edm {
  class EventSetup;
  class ParameterSet;
}  // namespace edm
 
class IntegratedCalibrationBase {
public:
  typedef AlignmentAlgorithmBase::EventInfo EventInfo;
  typedef std::pair<double, double> Values;                 
  typedef std::pair<Values, unsigned int> ValuesIndexPair;  
 
  explicit IntegratedCalibrationBase(const edm::ParameterSet &cfg);
 
  virtual ~IntegratedCalibrationBase(){};
 
  virtual unsigned int numParameters() const = 0;
 
  virtual std::vector<Values> derivatives(const TrackingRecHit &hit,
                                          const TrajectoryStateOnSurface &tsos,
                                          const edm::EventSetup &setup,
                                          const EventInfo &eventInfo) const;
 
  virtual unsigned int derivatives(std::vector<ValuesIndexPair> &outDerivInds,
                                   const TrackingRecHit &hit,
                                   const TrajectoryStateOnSurface &tsos,
                                   const edm::EventSetup &setup,
                                   const EventInfo &eventInfo) const = 0;
 
  virtual bool setParameter(unsigned int index, double value) = 0;
 
  virtual bool setParameterError(unsigned int index, double value) = 0;
 
  virtual double getParameter(unsigned int index) const = 0;
 
  virtual double getParameterError(unsigned int index) const = 0;
 
  virtual void beginOfJob(AlignableTracker *tracker, AlignableMuon *muon, AlignableExtras *extras){};
 
  virtual void beginRun(const edm::Run &, const edm::EventSetup &){};
 
  virtual void startNewLoop(){};
 
  virtual void endOfLoop(){};
 
  virtual void endOfJob() = 0;
 
  /* /// called at begin of run */
  /* virtual void beginRun(const edm::EventSetup &setup) {}; */
 
  /* /// called at end of run - order of arguments like in EDProducer etc. */
  /* virtual void endRun(const EndRunInfo &runInfo, const edm::EventSetup &setup) {}; */
 
  /* /// called at begin of luminosity block (no lumi block info passed yet) */
  /* virtual void beginLuminosityBlock(const edm::EventSetup &setup) {}; */
 
  /* /// called at end of luminosity block (no lumi block info passed yet) */
  /* virtual void endLuminosityBlock(const edm::EventSetup &setup) {}; */
 
  const std::string &name() const { return name_; }  // non-virtual since refering to private member
 
private:
  const std::string name_;  
};
 
#endif