MuonGeometryArrange.h

Go to the documentation of this file.

#ifndef Alignment_OfflineValidation_MuonGeometryArrange_h
#define Alignment_OfflineValidation_MuonGeometryArrange_h

#include "FWCore/Framework/interface/EDAnalyzer.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "Alignment/MuonAlignment/interface/AlignableMuon.h"
#include "CondFormats/Alignment/interface/SurveyErrors.h"
#include "Alignment/CommonAlignment/interface/StructureType.h"

#include "Alignment/CommonAlignment/interface/AlignTools.h"

#include <algorithm>
#include "TTree.h"

class AlignTransform;
class MuonAlignment;
class TGraph;
class TH2F;

class MuonGeometryArrange:
public edm::EDAnalyzer
{
public:
    typedef AlignTransform SurveyValue;
    typedef Alignments SurveyValues;
        
  MuonGeometryArrange(
        const edm::ParameterSet&
        );
    
    void beginJob() override;

    void analyze(
        const edm::Event&,
        const edm::EventSetup&
        ) override;
//        virtual void endJob(void);
    
private:


    //parameters
    edm::ParameterSet m_params;
    std::vector<align::StructureType> theLevels;
    //std::vector<int> theSubDets;
    
    //compares two geometries, driver routine
    void compare(Alignable* refAli, Alignable* curAli,
        Alignable* curAliCopy2);
    void endHist();
    // Map one onto other and compare details
    void compareGeometries(Alignable* refAli, Alignable* curAli,
                Alignable* curAliCopy2);
    //filling the ROOT file
    void fillTree(Alignable *refAli, const AlgebraicVector& diff);
    //void createDBGeometry(const edm::EventSetup& iSetup);
    void createROOTGeometry(const edm::EventSetup& iSetup);
        void makeGraph(int sizeI, float smi, float sma, float minV,
                       float maxV, TH2F* dxh, TGraph* grx, const char* name,
                       const char* title, const char* titleg, const char* axis,
                       const float* xp, const float* yp, int numEntries);
    
    bool passIdCut( uint32_t );
    bool checkChosen( Alignable* ali ); // Is ali one of wanted CSC?
    bool passChosen( Alignable* ali );  // Is ali either one of wanted
                        // CSC or does it contain them?
    bool isMother( Alignable* ali );    // Is ali the container (ring)?
    
    AlignableMuon* referenceMuon;
    AlignableMuon* dummyMuon;
    AlignableMuon* currentMuon;
    Alignable* inputGeometry1;
    Alignable* inputGeometry2;

    unsigned int theSurveyIndex;
    const Alignments* theSurveyValues;
    const SurveyErrors* theSurveyErrors;
    
    // configurables
        const std::vector<std::string> _levelStrings;
    std::string _inputFilename1;
    std::string _inputFilename2;
    std::string _inputTreename;
    bool _writeToDB; 
    std::string _weightBy;
    std::string _setCommonMuonSystem;
    bool _detIdFlag;
    std::string _detIdFlagFile;
    bool _weightById;
    std::string _weightByIdFile;
    std::vector< unsigned int > _weightByIdVector;
    int _endcap;
    int _station;
    int _ring;
    
    std::vector< uint32_t > _detIdFlagVector;
    align::StructureType _commonMuonLevel;
    align::GlobalVector _MuonCommonT;
    align::EulerAngles _MuonCommonR;
    align::PositionType _MuonCommonCM;
    
    //root configuration
    std::string _filename;

struct MGACollection {
  int id;
  int level;
  int mid;
  int mlevel;
  int sublevel;
  float x,y,z;
  float r, phi, eta;
  float alpha, beta, gamma;
  float dx, dy, dz;
  float dr, dphi;       // no deta?
  float dalpha, dbeta, dgamma;
  float ldx, ldy, ldz;
  float ldr, ldphi;       // no deta?
  int useDetId, detDim;
  float rotx, roty, rotz;
  float drotx, droty, drotz;
  float surW, surL;     // surWidth and length
  double surRot[9];
  int phipos;
};

    std::vector<MGACollection> _mgacollection;  
    // Two sets of alignment inputs
    std::string _inputXMLCurrent;
    std::string _inputXMLReference;
    MuonAlignment* inputAlign1;
    MuonAlignment* inputAlign2;
    MuonAlignment* inputAlign2a;
    
    TFile* _theFile;
    TTree* _alignTree;
    TFile* _inputRootFile1;
    TFile* _inputRootFile2;
    TTree* _inputTree1;
    TTree* _inputTree2;
    
    int _id, _level, _mid, _mlevel, _sublevel, _useDetId, _detDim;
    float _xVal, _yVal, _zVal, _rVal, _phiVal, _alphaVal, _betaVal, _gammaVal, _etaVal;
    float _dxVal, _dyVal, _dzVal, _drVal, _dphiVal, _dalphaVal;
    float _dbetaVal, _dgammaVal, _ldxVal, _ldyVal, _ldzVal;
    float _ldrVal, _ldphiVal;
    float _rotxVal, _rotyVal, _rotzVal;
    float _drotxVal, _drotyVal, _drotzVal;
    float _surWidth, _surLength;
    double _surRot[9];
    
        bool firstEvent_;
    
};




#endif