L1AnalysisRecoMuonDataFormat.h

Go to the documentation of this file.

#ifndef __L1Analysis_L1AnalysisRecoMuonDataFormat_H__
#define __L1Analysis_L1AnalysisRecoMuonDataFormat_H__

//-------------------------------------------------------------------------------
// Created 20/04/2010 - E. Conte, A.C. Le Bihan
// 
//
// Original code : L1Trigger/L1TNtuples/L1RecoMuonDataFormatProducer - Luigi Guiducci
//-------------------------------------------------------------------------------

#include <vector>

namespace L1Analysis
{
  struct L1AnalysisRecoMuonDataFormat
  {
    L1AnalysisRecoMuonDataFormat(){Reset();};
    ~L1AnalysisRecoMuonDataFormat(){Reset();};
    
    void Reset()
    {
    nMuons = 0;

    // what muon kind? 0=global 1=SA 2=trackeronly
    type.clear();
    howmanytypes.clear();
    // global muons quantities
    ch.clear();  
    pt.clear();
    p.clear(); 
    eta.clear();  
    phi.clear();
    validhits.clear();
    numberOfMatchedStations.clear();
    numberOfValidMuonHits.clear();
    normchi2.clear();
    imp_point_x.clear(); 
    imp_point_y.clear(); 
    imp_point_z.clear(); 
    imp_point_p.clear(); 
    imp_point_pt.clear(); 
    phi_hb.clear();
    z_hb.clear();
    r_he_p.clear();
    r_he_n.clear();
    phi_he_p.clear();
    phi_he_n.clear();

    // tracker muons quantities
    tr_ch.clear();  
    tr_pt.clear();
    tr_p.clear(); 
    tr_eta.clear();  
    tr_phi.clear();
    tr_validhits.clear();
    tr_validpixhits.clear();
    tr_normchi2.clear();
    tr_d0.clear();
    tr_imp_point_x.clear(); 
    tr_imp_point_y.clear(); 
    tr_imp_point_z.clear(); 
    tr_imp_point_p.clear(); 
    tr_imp_point_pt.clear();
 
    tr_z_mb2.clear();
    tr_phi_mb2.clear();
    tr_r_me2_p.clear();
    tr_phi_me2_p.clear();
    tr_r_me2_n.clear();
    tr_phi_me2_n.clear();

    tr_z_mb1.clear();
    tr_phi_mb1.clear();
    tr_r_me1_p.clear();
    tr_phi_me1_p.clear();
    tr_r_me1_n.clear();
    tr_phi_me1_n.clear();

    // standalone muons (either part of global or SA only)
    sa_phi_mb2.clear();
    sa_z_mb2.clear();
    sa_pseta.clear();
    sa_normchi2.clear();
    sa_validhits.clear();
    sa_ch.clear(); 
    sa_pt.clear(); 
    sa_p.clear(); 
    sa_eta.clear(); 
    sa_phi.clear(); 
    sa_outer_pt.clear(); 
    sa_inner_pt.clear(); 
    sa_outer_eta.clear(); 
    sa_inner_eta.clear(); 
    sa_outer_phi.clear(); 
    sa_inner_phi.clear(); 
    sa_outer_x.clear(); 
    sa_outer_y.clear(); 
    sa_outer_z.clear(); 
    sa_inner_x.clear(); 
    sa_inner_y.clear(); 
    sa_inner_z.clear(); 
    sa_imp_point_x.clear(); 
    sa_imp_point_y.clear(); 
    sa_imp_point_z.clear(); 
    sa_imp_point_p.clear(); 
    sa_imp_point_pt.clear(); 
    sa_phi_hb.clear();
    sa_z_hb.clear();
    sa_r_he_p.clear();
    sa_r_he_n.clear();
    sa_phi_he_p.clear();
    sa_phi_he_n.clear();
    sa_phi_me2_p.clear();
    sa_phi_me2_n.clear();
    sa_r_me2_p.clear();
    sa_r_me2_n.clear();

    sa_z_mb1.clear();
    sa_phi_mb1.clear();
    sa_r_me1_p.clear();
    sa_phi_me1_p.clear();
    sa_r_me1_n.clear();
    sa_phi_me1_n.clear();
 
    calo_energy.clear();
    calo_energy3x3.clear();
    ecal_time.clear();
    ecal_terr.clear();
    hcal_time.clear();
    hcal_terr.clear();
    time_dir.clear(); // -1 = outsideIn 0=undefined 1=insideOut
    time_inout.clear();
    time_inout_err.clear();
    time_outin.clear();
    time_outin_err.clear();

    sa_nChambers.clear();
    sa_nMatches.clear();

    // RECHIT information from CSC: only for standalone/global muons!
    rchCSCtype.clear();
    rchPhi.clear();
    rchEta.clear();

    // Trigger matching information:
    hlt_isomu.clear();
    hlt_mu.clear();
    hlt_isoDeltaR.clear();
    hlt_deltaR.clear();


    }      
    
    // how many muons of any kind
    int nMuons;
 
    // what muon kind? 0=global 1=SA 2=trackeronly 3=trsa
    std::vector<int> type;
    std::vector<int> howmanytypes;
    // global muons quantities
    std::vector<double> ch;  
    std::vector<double> pt;
    std::vector<double> p; 
    std::vector<double> eta;  
    std::vector<double> phi;
    std::vector<double> validhits;
    std::vector<double> numberOfMatchedStations;
    std::vector<double> numberOfValidMuonHits;
    std::vector<double> normchi2;
    std::vector<double> imp_point_x; 
    std::vector<double> imp_point_y; 
    std::vector<double> imp_point_z; 
    std::vector<double> imp_point_p; 
    std::vector<double> imp_point_pt; 
    std::vector<double> phi_hb;
    std::vector<double> z_hb;
    std::vector<double> r_he_p;
    std::vector<double> r_he_n;
    std::vector<double> phi_he_p;
    std::vector<double> phi_he_n;

    // tracker muons quantities
    std::vector<double> tr_ch;  
    std::vector<double> tr_pt;
    std::vector<double> tr_p; 
    std::vector<double> tr_eta;  
    std::vector<double> tr_phi;
    std::vector<double> tr_validhits;
    std::vector<double> tr_validpixhits;    
    std::vector<double> tr_normchi2;
    std::vector<double> tr_d0;
    std::vector<double> tr_imp_point_x; 
    std::vector<double> tr_imp_point_y; 
    std::vector<double> tr_imp_point_z; 
    std::vector<double> tr_imp_point_p; 
    std::vector<double> tr_imp_point_pt; 

    std::vector<double> tr_z_mb2;
    std::vector<double> tr_phi_mb2;
    std::vector<double> tr_r_me2_p;
    std::vector<double> tr_phi_me2_p;
    std::vector<double> tr_r_me2_n;
    std::vector<double> tr_phi_me2_n;

    std::vector<double> tr_z_mb1 ;
    std::vector<double> tr_phi_mb1; 
    std::vector<double> tr_r_me1_p ;
    std::vector<double> tr_phi_me1_p; 
    std::vector<double> tr_r_me1_n ;
    std::vector<double> tr_phi_me1_n; 

    // standalone muons (either part of global or SA only)
    std::vector<double> sa_phi_mb2;
    std::vector<double> sa_z_mb2;
    std::vector<double> sa_pseta;
    std::vector<double> sa_normchi2;
    std::vector<double> sa_validhits;
    std::vector<double> sa_ch; 
    std::vector<double> sa_pt; 
    std::vector<double> sa_p; 
    std::vector<double> sa_eta; 
    std::vector<double> sa_phi; 
    std::vector<double> sa_outer_pt; 
    std::vector<double> sa_inner_pt; 
    std::vector<double> sa_outer_eta; 
    std::vector<double> sa_inner_eta; 
    std::vector<double> sa_outer_phi; 
    std::vector<double> sa_inner_phi; 
    std::vector<double> sa_outer_x; 
    std::vector<double> sa_outer_y; 
    std::vector<double> sa_outer_z; 
    std::vector<double> sa_inner_x; 
    std::vector<double> sa_inner_y; 
    std::vector<double> sa_inner_z; 
    std::vector<double> sa_imp_point_x; 
    std::vector<double> sa_imp_point_y; 
    std::vector<double> sa_imp_point_z; 
    std::vector<double> sa_imp_point_p; 
    std::vector<double> sa_imp_point_pt; 
    std::vector<double> sa_phi_hb;
    std::vector<double> sa_z_hb;
    std::vector<double> sa_r_he_p;
    std::vector<double> sa_r_he_n;
    std::vector<double> sa_phi_he_p;
    std::vector<double> sa_phi_he_n;
    std::vector<double> sa_r_me2_p;
    std::vector<double> sa_r_me2_n;
    std::vector<double> sa_phi_me2_p;
    std::vector<double> sa_phi_me2_n;

    std::vector<double> sa_z_mb1;
    std::vector<double> sa_phi_mb1;
    std::vector<double> sa_r_me1_p;
    std::vector<double> sa_phi_me1_p;
    std::vector<double> sa_r_me1_n;
    std::vector<double> sa_phi_me1_n;

    std::vector<double> calo_energy;
    std::vector<double> calo_energy3x3;
    std::vector<double> ecal_time;
    std::vector<double> ecal_terr;
    std::vector<double> hcal_time;
    std::vector<double> hcal_terr;

    std::vector<double> time_dir; // -1 = outsideIn ; 0=undefined; 1=insideOut
    std::vector<double> time_inout;
    std::vector<double> time_inout_err;
    std::vector<double> time_outin;
    std::vector<double> time_outin_err;

    std::vector<int> sa_nChambers;
    std::vector<int> sa_nMatches;

    
    // RECHIT information from CSC: only for standalone/global muons!
    std::vector<int>    rchCSCtype;
    std::vector<double> rchPhi;
    std::vector<double> rchEta;    

    // Trigger matching information:
    std::vector<int> hlt_isomu;
    std::vector<int> hlt_mu;
    std::vector<double> hlt_isoDeltaR;
    std::vector<double> hlt_deltaR;

  }; 
}
#endif