PCLTrackerAlProducer.h

Go to the documentation of this file.

#ifndef Alignment_CommonAlignmentProducer_PCLTrackerAlProducer_h
#define Alignment_CommonAlignmentProducer_PCLTrackerAlProducer_h

/*** System includes ***/
#include <vector>
#include <memory>
#include <sstream>
#include <iostream>

/*** Core framework functionality ***/
#include "FWCore/Framework/interface/EDAnalyzer.h"
#include "FWCore/Framework/interface/ESHandle.h"
#include "FWCore/Framework/interface/ESWatcher.h"

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

/*** Alignment ***/
#include "Alignment/CommonAlignmentMonitor/interface/AlignmentMonitorBase.h"

#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentAlgorithmBase.h"
#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentParameterBuilder.h"
#include "Alignment/CommonAlignmentAlgorithm/interface/AlignmentParameterStore.h"

#include "Alignment/CommonAlignment/interface/Alignable.h"
#include "Alignment/CommonAlignment/interface/AlignableExtras.h"
#include "Alignment/TrackerAlignment/interface/AlignableTracker.h"
#include "Alignment/MuonAlignment/interface/AlignableMuon.h"

#include "CondFormats/Alignment/interface/Alignments.h"
#include "CondFormats/Alignment/interface/AlignmentErrorsExtended.h"
#include "CondFormats/Alignment/interface/AlignmentSurfaceDeformations.h"
#include "CondFormats/Alignment/interface/DetectorGlobalPosition.h"
#include "CondFormats/Alignment/interface/SurveyErrors.h"

/*** Records for ESWatcher ***/
#include "Geometry/Records/interface/IdealGeometryRecord.h"
#include "CondFormats/AlignmentRecord/interface/GlobalPositionRcd.h"

#include "CondFormats/AlignmentRecord/interface/TrackerAlignmentRcd.h"
#include "CondFormats/AlignmentRecord/interface/TrackerSurfaceDeformationRcd.h"
#include "CondFormats/AlignmentRecord/interface/TrackerAlignmentErrorExtendedRcd.h"

#include "CondFormats/AlignmentRecord/interface/DTAlignmentRcd.h"
#include "CondFormats/AlignmentRecord/interface/DTAlignmentErrorExtendedRcd.h"
#include "CondFormats/AlignmentRecord/interface/CSCAlignmentRcd.h"
#include "CondFormats/AlignmentRecord/interface/CSCAlignmentErrorExtendedRcd.h"

#include "CondFormats/AlignmentRecord/interface/TrackerSurveyRcd.h"
#include "CondFormats/AlignmentRecord/interface/TrackerSurveyErrorExtendedRcd.h"
#include "CondFormats/AlignmentRecord/interface/DTSurveyRcd.h"
#include "CondFormats/AlignmentRecord/interface/DTSurveyErrorExtendedRcd.h"
#include "CondFormats/AlignmentRecord/interface/CSCSurveyRcd.h"
#include "CondFormats/AlignmentRecord/interface/CSCSurveyErrorExtendedRcd.h"

#include "Alignment/LaserAlignment/interface/TsosVectorCollection.h"
#include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h"

/*** Forward declarations ***/
#include "FWCore/Framework/interface/Frameworkfwd.h"



class PCLTrackerAlProducer : public edm::EDAnalyzer {
  //========================== PUBLIC METHODS ==================================
  public: //====================================================================

    PCLTrackerAlProducer(const edm::ParameterSet&);
    virtual ~PCLTrackerAlProducer();

    /*** Code which implements the interface
         Called from outside ***/

    virtual void beginJob() override;
    virtual void endJob()   override;

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

    virtual void beginLuminosityBlock(const edm::LuminosityBlock&,
                                      const edm::EventSetup&) override;
    virtual void endLuminosityBlock  (const edm::LuminosityBlock&,
                                      const edm::EventSetup&) override;
  
    virtual void analyze(const edm::Event&, const edm::EventSetup&) override;


    //======================== PRIVATE METHODS =================================
    private: //=================================================================

    /*** Code which is independent of Event & Setup
         Called from constructor ***/

    void createAlignmentAlgorithm(const edm::ParameterSet&);

    void createMonitors          (const edm::ParameterSet&);

    void createCalibrations      (const edm::ParameterSet&);



    /*** Code which is dependent of Event & Setup
         Called and checked for each Event ***/

    bool setupChanged(const edm::EventSetup&);

    void initAlignmentAlgorithm(const edm::EventSetup&);

    void initBeamSpot(const edm::Event&);

    void createGeometries(const edm::EventSetup&, const TrackerTopology*);

    void applyAlignmentsToDB(const edm::EventSetup&);

    void createAlignables(const TrackerTopology* const);

    void buildParameterStore();

    void applyMisalignment();

    void simpleMisalignment(const Alignables&, const std::string&,
                            float, float, bool);

    void applyAlignmentsToGeometry();

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

    template<class G, class DeformationRcd>
    void applyDB(G*, const edm::EventSetup&) const;

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



    /*** Code for writing results to database
         Called from endJob() ***/

    void finish();

    void storeAlignmentsToDB();

    RunRanges makeNonOverlappingRunRanges(const edm::VParameterSet&);

    void writeForRunRange(cond::Time_t);

    void writeDB(Alignments*, const std::string&, AlignmentErrorsExtended*,
                 const std::string&, const AlignTransform*, cond::Time_t) const;

    void writeDB(AlignmentSurfaceDeformations*,
                 const std::string&, cond::Time_t) const;



  //========================== PRIVATE DATA ====================================
  //============================================================================

    /*** Alignment data ***/

    AlignmentAlgorithmBase* theAlignmentAlgo;
    Calibrations            theCalibrations;
    AlignmentMonitors       theMonitors;

    AlignmentParameterStore* theAlignmentParameterStore;
    AlignableTracker*        theTrackerAlignables;
    AlignableMuon*           theMuonAlignables;
    AlignableExtras*         theExtraAlignables;

    edm::Handle<reco::BeamSpot> theBeamSpot;
    const Alignments* globalPositions_;

    // TODO: Change pointers to std::shared_ptr
    boost::shared_ptr<TrackerGeometry> theTrackerGeometry;
    boost::shared_ptr<DTGeometry>      theMuonDTGeometry;
    boost::shared_ptr<CSCGeometry>     theMuonCSCGeometry;

    int nevent_;



    /*** Parameters from config-file ***/

    edm::ParameterSet theParameterSet;

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

    const edm::InputTag tjTkAssociationMapTag_;
    const edm::InputTag beamSpotTag_;
    const edm::InputTag tkLasBeamTag_;
    const edm::InputTag clusterValueMapTag_;

    edm::EDGetTokenT<TrajTrackAssociationCollection> tjTkAssociationMapToken;
    edm::EDGetTokenT<reco::BeamSpot> beamSpotToken;
    edm::EDGetTokenT<TkFittedLasBeamCollection> tkLasBeamToken;
    edm::EDGetTokenT<TsosVectorCollection> tsosVectorToken;
    edm::EDGetTokenT<AliClusterValueMap> clusterValueMapToken;
    cond::Time_t theFirstRun;

    // file-names
    //std::string millePedeLogFile_ = "millepede.log";
    //std::string millePedeResFile_ = "millepede.res";


    /*** ESWatcher ***/

    edm::ESWatcher<IdealGeometryRecord> watchIdealGeometryRcd;
    edm::ESWatcher<GlobalPositionRcd>   watchGlobalPositionRcd;

    edm::ESWatcher<TrackerAlignmentRcd>              watchTrackerAlRcd;
    edm::ESWatcher<TrackerAlignmentErrorExtendedRcd> watchTrackerAlErrorExtRcd;
    edm::ESWatcher<TrackerSurfaceDeformationRcd>     watchTrackerSurDeRcd;

    edm::ESWatcher<DTAlignmentRcd>               watchDTAlRcd;
    edm::ESWatcher<DTAlignmentErrorExtendedRcd>  watchDTAlErrExtRcd;
    edm::ESWatcher<CSCAlignmentRcd>              watchCSCAlRcd;
    edm::ESWatcher<CSCAlignmentErrorExtendedRcd> watchCSCAlErrExtRcd;

    edm::ESWatcher<TrackerSurveyRcd>              watchTkSurveyRcd;
    edm::ESWatcher<TrackerSurveyErrorExtendedRcd> watchTkSurveyErrExtRcd;
    edm::ESWatcher<DTSurveyRcd>                   watchDTSurveyRcd;
    edm::ESWatcher<DTSurveyErrorExtendedRcd>      watchDTSurveyErrExtRcd;
    edm::ESWatcher<CSCSurveyRcd>                  watchCSCSurveyRcd;
    edm::ESWatcher<CSCSurveyErrorExtendedRcd>     watchCSCSurveyErrExtRcd;



    /*** Survey stuff ***/

    size_t              theSurveyIndex;
    const Alignments*   theSurveyValues;
    const SurveyErrors* theSurveyErrors;

};

#endif