AlignmentProducer.h

Go to the documentation of this file.

#ifndef Alignment_CommonAlignmentAlgorithm_TrackerAlignmentProducer_h
#define Alignment_CommonAlignmentAlgorithm_TrackerAlignmentProducer_h


#include <vector>

// Framework
#include "FWCore/Framework/interface/ESProducerLooper.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/ESWatcher.h"

#include "DataFormats/Provenance/interface/RunID.h"

// Geometry
#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"

// Alignment
#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentAlgorithmBase.h"
#include "Alignment/CommonAlignmentMonitor/interface/AlignmentMonitorBase.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h" 
#include <Geometry/Records/interface/MuonGeometryRecord.h> 
#include "Alignment/CommonAlignment/interface/AlignableExtras.h"
#include "Alignment/TrackerAlignment/interface/AlignableTracker.h"
#include "Alignment/MuonAlignment/interface/AlignableMuon.h"
#include <FWCore/Framework/interface/Frameworkfwd.h>
#include "CondCore/DBCommon/interface/Time.h"
#include "CondFormats/Alignment/interface/Alignments.h"
#include "CondFormats/Alignment/interface/AlignmentSurfaceDeformations.h"

// for watcher
#include "CondFormats/AlignmentRecord/interface/TrackerSurveyRcd.h"
#include "CondFormats/AlignmentRecord/interface/TrackerSurveyErrorRcd.h"
#include "CondFormats/AlignmentRecord/interface/DTSurveyRcd.h"
#include "CondFormats/AlignmentRecord/interface/DTSurveyErrorRcd.h"
#include "CondFormats/AlignmentRecord/interface/CSCSurveyRcd.h"
#include "CondFormats/AlignmentRecord/interface/CSCSurveyErrorRcd.h"


class Alignments;
class SurveyErrors;
namespace edm {
  class Run;
  class LuminosityBlock;
}

class AlignmentProducer : public edm::ESProducerLooper
{

 public:
  typedef std::vector<Alignable*> Alignables;
  typedef std::pair<const Trajectory*, const reco::Track*> ConstTrajTrackPair; 
  typedef std::vector<ConstTrajTrackPair>  ConstTrajTrackPairCollection;

  typedef AlignmentAlgorithmBase::RunNumber            RunNumber;
  typedef AlignmentAlgorithmBase::RunRange             RunRange;
  typedef std::vector<RunRange>                        RunRanges;

  AlignmentProducer( const edm::ParameterSet& iConfig );
  
  ~AlignmentProducer();

  virtual boost::shared_ptr<TrackerGeometry> produceTracker( const TrackerDigiGeometryRecord& iRecord );
  virtual boost::shared_ptr<DTGeometry>      produceDT( const MuonGeometryRecord& iRecord );
  virtual boost::shared_ptr<CSCGeometry>     produceCSC( const MuonGeometryRecord& iRecord );

  virtual void beginOfJob(const edm::EventSetup&);

  virtual void endOfJob();

  virtual void startingNewLoop( unsigned int iLoop );

  virtual Status endOfLoop( const edm::EventSetup&, unsigned int iLoop );

  virtual void beginRun(const edm::Run &run, const edm::EventSetup &setup);
  virtual void endRun(const edm::Run &run, const edm::EventSetup &setup);

  virtual void beginLuminosityBlock(const edm::LuminosityBlock &lumiBlock,
                    const edm::EventSetup &setup);
  virtual void endLuminosityBlock(const edm::LuminosityBlock &lumiBlock,
                  const edm::EventSetup &setup);
  virtual Status duringLoop(const edm::Event &event, const edm::EventSetup &setup);

 private:

  // private member functions

  void simpleMisalignment_(const Alignables &alivec, const std::string &selection,
                          float shift, float rot, bool local);

  void createGeometries_( const edm::EventSetup& );

  template<class G, class Rcd, class ErrRcd>
    void applyDB(G *geometry, const edm::EventSetup &iSetup,
         const AlignTransform &globalPosition) const;
  template<class G, class DeformationRcd>
    void applyDB(G *geometry, const edm::EventSetup &iSetup) const;

  // write alignments and alignment errors for all sub detectors and
  // the given run number
  void writeForRunRange(cond::Time_t time);

  void writeDB(Alignments *alignments, const std::string &alignRcd,
           AlignmentErrors *alignmentErrors, const std::string &errRcd,
           const AlignTransform *globalCoordinates,
           cond::Time_t time) const;
  void writeDB(AlignmentSurfaceDeformations *alignmentSurfaceDeformations,
           const std::string &surfaceDeformationRcd,
           cond::Time_t time) const;

  void addSurveyInfo_(Alignable*);
    
  void readInSurveyRcds( const edm::EventSetup& );

  RunRanges makeNonOverlappingRunRanges(const edm::VParameterSet& RunRangeSelectionVPSet);

  // private data members

  unsigned int        theSurveyIndex;
  const Alignments*   theSurveyValues;
  const SurveyErrors* theSurveyErrors;

  AlignmentAlgorithmBase* theAlignmentAlgo;
  std::vector<AlignmentMonitorBase*> theMonitors;
  AlignmentParameterStore* theAlignmentParameterStore;

  AlignableExtras* theAlignableExtras;
  AlignableTracker* theAlignableTracker;
  AlignableMuon* theAlignableMuon;

  boost::shared_ptr<TrackerGeometry> theTracker;
  boost::shared_ptr<DTGeometry> theMuonDT;
  boost::shared_ptr<CSCGeometry> theMuonCSC;
  const Alignments *globalPositions_;

  int nevent_;
  edm::ParameterSet theParameterSet;

  // steering parameters

  const unsigned int theMaxLoops;     // Number of loops to loop

  const int stNFixAlignables_;
  const double stRandomShift_,stRandomRotation_;
  const bool applyDbAlignment_,checkDbAlignmentValidity_;
  const bool doMisalignmentScenario_;
  const bool saveToDB_, saveApeToDB_,saveDeformationsToDB_;
  const bool doTracker_,doMuon_,useExtras_;
  const bool useSurvey_; // true to read survey info from DB

  // event input tags
  const edm::InputTag tjTkAssociationMapTag_; // map with tracks/trajectories
  const edm::InputTag beamSpotTag_;           // beam spot
  const edm::InputTag tkLasBeamTag_;          // LAS beams in edm::Run (ignore if empty)
  const edm::InputTag clusterValueMapTag_;              // ValueMap containing associtaion cluster - flag


  // ESWatcher
  edm::ESWatcher<TrackerSurveyRcd> watchTkSurveyRcd_;
  edm::ESWatcher<TrackerSurveyErrorRcd> watchTkSurveyErrRcd_;
  edm::ESWatcher<DTSurveyRcd> watchDTSurveyRcd_;
  edm::ESWatcher<DTSurveyErrorRcd> watchDTSurveyErrRcd_;
  edm::ESWatcher<CSCSurveyRcd> watchCSCSurveyRcd_;
  edm::ESWatcher<CSCSurveyErrorRcd> watchCSCSurveyErrRcd_;  
  
};

#endif