fixing compiler warning (MuonCalibExtraNtuple-02-00-02)

MuonSpectrometer/MuonCalib/MuonCalibExtraTree/MuonCalibExtraNtuple/MuonCalibExtraNtuple/NTReaderBase_E.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+
+#ifndef NTReaderBase_E_h
+#define NTReaderBase_E_h
+
+#include <TROOT.h>
+#include <TChain.h>
+#include <TFile.h>
+#include <vector>
+
+#include "CalibNtupleReader/NTReaderBase.h"
+
+/**
+   @class NTReaderBase_E
+   Extended version of NTReaderBase, making it capable to hold variables of the extended Branches too.
+   
+   @author Zdenko.Van.Kesteren@cern.ch
+*/
+
+namespace MuonCalib{
+  class NTReaderBase_E : virtual public NTReaderBase{
+    public :
+      
+    // Declaration of leaf types
+    Int_t           ctp_nTriggerInfo;
+    UInt_t          ctp_numberBC;
+    UInt_t          ctp_L1A_BC;
+    UInt_t          ctp_timeNs;
+    UInt_t          ctp_randomTrig;
+    UInt_t          ctp_firedItemsBeforePrescale;
+    UInt_t          ctp_prescaledClock;
+    Int_t           ctp_bcid[7680];
+    Int_t           ctp_bcIndexTriggerItems[7680];
+    Int_t           ctp_bcIndexPIT[7680];
+    Int_t           ctp_pit[7680];
+    Int_t           ctp_tbp[7680];
+    Int_t           ctp_tap[7680];
+    Int_t           ctp_tav[7680];
+    Int_t           ctp_type[7680];
+    Float_t         ctp_delay[7680];
+            
+    Int_t           muctpi_nHits;
+    Int_t           muctpi_roiWord[100];
+    Int_t           muctpi_bcID[100];  
+    Int_t           muctpi_sysID[100];
+    Int_t           muctpi_subsysID[100];
+    Int_t           muctpi_sectorID[100];
+    Int_t           muctpi_thresholdNumber[100];
+    Int_t           muctpi_thresholdValue[100];
+    Int_t           muctpi_roINumber[100];
+    Int_t           muctpi_overlap[100];
+    Int_t           muctpi_firstCandidate[100];
+    Int_t           muctpi_sectorOverflow[100];
+    Int_t           muctpi_padOverflow[100];
+    Float_t         muctpi_phi[100];
+    Float_t         muctpi_eta[100];
+
+    //Backward compatibility
+    Int_t           rpcSl_nLogics;
+    Int_t           rpcSl_sectorId[100];
+    Int_t           rpcSl_fel1Id[100];
+    Int_t           rpcSl_bcid[100];
+    Int_t           rpcSl_errorCode[100];
+    Int_t           rpcSl_crc[100];
+    Int_t           rpcSl_hasMoreThan2TriggerCand[100];
+    Int_t           rpcSl_nLogicsTimes;
+    Int_t           rpcSl_slIndex[100];
+    Float_t         rpcSl_triggerRates[100];
+    Int_t           rpcSl_counters[100];
+    Int_t           rpcSl_nSLHits;
+    Int_t           rpcSl_slIndex2[100];  
+    Int_t           rpcSl_rowinBcid[100];
+    Int_t           rpcSl_padid[100];
+    Int_t           rpcSl_ptid[100];
+    Int_t           rpcSl_roi[100];
+    Int_t           rpcSl_outerPlane[100];
+    Int_t           rpcSl_overlapPhi[100];
+    Int_t           rpcSl_overlapEta[100];
+    Int_t           rpcSl_triggerBcid[100];
+    Int_t           rpcSl_isInput[100];
+    //End bwd comp
+    Int_t           rpc_SL_nSectors;
+    Int_t           rpc_SL_sectorId[100];   
+    Int_t           rpc_SL_lvl1id[100];   
+    Int_t           rpc_SL_bcid[100];   
+    Int_t           rpc_SL_errorCode[100];   
+    Int_t           rpc_SL_crc[100];   
+    Int_t           rpc_SL_hasMoreThan2TriggerCand[100];   
+    Int_t           rpc_SLnTriggerHits;
+    Int_t           rpc_SLhit_sector[100];   
+    Int_t           rpc_SLhit_rowinBcid[100];   
+    Int_t           rpc_SLhit_padId[100];   
+    Int_t           rpc_SLhit_ptId[100];   
+    Int_t           rpc_SLhit_roi[100];   
+    Int_t           rpc_SLhit_outerPlane[100];   
+    Int_t           rpc_SLhit_overlapPhi[100];   
+    Int_t           rpc_SLhit_overlapEta[100];   
+    Int_t           rpc_SLhit_triggerBcid[100];   
+    Int_t           rpc_SLhit_isInput[100];   
+        
+    Int_t           rawRpcCoin_nRpcCoin;
+    Int_t           rawRpcCoin_occupancy[1000];   
+    Int_t           rawRpcCoin_id[1000];   
+    Float_t         rawRpcCoin_t[1000];   
+    Float_t         rawRpcCoin_width[1000];   
+    Float_t         rawRpcCoin_length[1000];   
+    Float_t         rawRpcCoin_gPosX[1000];   
+    Float_t         rawRpcCoin_gPosY[1000];   
+    Float_t         rawRpcCoin_gPosZ[1000];   
+    Int_t           rawRpcCoin_ijk[1000];   
+    Int_t           rawRpcCoin_threshold[1000];   
+    Int_t           rawRpcCoin_overlap[1000];   
+    Int_t           rawRpcCoin_parentCmId[1000];   
+    Int_t           rawRpcCoin_parentPadId[1000];   
+    Int_t           rawRpcCoin_parentSectorId[1000];   
+    Int_t           rawRpcCoin_lowPtCm[1000];   
+    
+    Int_t           calo_nHits;
+    Int_t           calo_id[100];
+    Float_t         calo_posX[100];
+    Float_t         calo_posY[100];
+    Float_t         calo_posZ[100];
+    Float_t         calo_charge[100];
+    Float_t         calo_time[100];
+   
+    Int_t           mbts_nHits;
+    Int_t           mbts_id[100];
+    Float_t         mbts_posX[100];
+    Float_t         mbts_posY[100];
+    Float_t         mbts_posZ[100];
+    Float_t         mbts_charge[100];
+    Float_t         mbts_time[100];
+   
+    Int_t           phi_nPhiHits;
+    Int_t           phi_phiPatIndex[6000];
+    UInt_t          phi_id[6000];
+    Float_t         phi_posX[6000];
+    Float_t         phi_posY[6000];
+    Float_t         phi_posZ[6000];
+    Float_t         phi_error[6000];
+   
+    Int_t           trk_nTracks;
+    Float_t         trk_x0[3000];
+    Float_t         trk_y0[3000];
+    Float_t         trk_z0[3000];
+    Float_t         trk_theta[3000];
+    Float_t         trk_phi[3000];
+    Float_t         trk_qOverP[3000];
+//    Float_t         trk_errInvP[3000];
+    Int_t           trk_author[3000] ;
+    Float_t         trk_cov00[3000];
+    Float_t         trk_cov01[3000];
+    Float_t         trk_cov02[3000];
+    Float_t         trk_cov03[3000];
+    Float_t         trk_cov04[3000];
+    Float_t         trk_cov11[3000];
+    Float_t         trk_cov12[3000];
+    Float_t         trk_cov13[3000];
+    Float_t         trk_cov14[3000];
+    Float_t         trk_cov22[3000];
+    Float_t         trk_cov23[3000];
+    Float_t         trk_cov24[3000];
+    Float_t         trk_cov33[3000];
+    Float_t         trk_cov34[3000];
+    Float_t         trk_cov44[3000];
+    Float_t         trk_chi2[3000];
+    Int_t           trk_ndof[3000];
+
+    Int_t           trkHit_nHits;
+    UInt_t          trkHit_id[3000];
+    Int_t           trkHit_trackIndex[3000];
+    Float_t         trkHit_posX[3000];
+    Float_t         trkHit_posY[3000];
+    Float_t         trkHit_posZ[3000];
+    Float_t         trkHit_driftRadius[3000];
+    Float_t         trkHit_error[3000];
+    Float_t         trkHit_resi[3000];
+    Float_t         trkHit_pull[3000];
+    Int_t           trkHit_type[3000];
+
+    Int_t           trkHole_nHoles;
+    UInt_t          trkHole_id[3000];
+    Int_t           trkHole_trackIndex[3000];
+    Float_t         trkHole_posX[3000];
+    Float_t         trkHole_posY[3000];
+    Float_t         trkHole_posZ[3000];
+
+    Int_t           trkSeg_nTrkSegs;
+    UShort_t        trkSeg_trkIndex[3000];
+    UShort_t        trkSeg_segIndex[3000];
+    
+    bool            hasTrkSegs;
+
+
+    NTReaderBase_E(TTree *tree=0);               //!< default constructor, opening directory SegmentNtuple.root:/PatternNtupleMaker/Segments
+    virtual ~NTReaderBase_E();                   //!< destructor
+    virtual Int_t    Cut(Long64_t entry);        //!< empty routine
+    virtual Int_t    GetEntry(Long64_t entry);   //!< Read contents of entry
+    virtual Long64_t LoadTree(Long64_t entry);   //!< Set the environment to read one entry
+    virtual void     Init(TTree *tree);          //!<The Init() function is called when the selector needs to initialize a new tree or chain.
+    virtual void     Loop();                     //!< empty routine
+    virtual void     Show(Long64_t entry = -1);  //!< Print contents of entry.
+
+  };
+} //namespace MuonCalib
+#endif
+

MuonSpectrometer/MuonCalib/MuonCalibExtraTree/MuonCalibExtraNtuple/MuonCalibExtraNtuple/NTReader_E.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#ifndef NTReader_E_h
+#define NTReader_E_h
+
+#include "CalibNtupleReader/NTReader.h"
+#include "MuonCalibExtraNtuple/NTReaderBase_E.h"
+
+#include <vector>
+#include <list>
+#include <map>
+
+namespace MuonCalib{
+  class MuonCalibHit_E;
+  class MuonCalibCaloHit;
+  class MuonCalibTriggerInfo;
+  class MuonCalibMUCTPI;
+  class MuonCalibRpcSectorLogic;
+  class MuonCalibRawRpcCoin;
+  class MuonCalibHole_E;
+  class MuonCalibTrack_E;
+  class MuonCalibEvent_E;
+    /**
+     @class NTReader_E
+     class storing the variables of the Extended CalibrationNtuple into the 'extended Calib-EDM' classes as described in MuonCalibExtraTreeEvent.
+     @author Zdenko.Van.Kesteren@cern.ch
+  */
+  class NTReader_E : public NTReaderBase_E, public NTReader {
+  public:
+    NTReader_E( TTree *tree=0 ) : NTReaderBase(tree), NTReaderBase_E( tree ), NTReader( tree ),m_evente(0) {} ; //!< default constructor
+    virtual ~NTReader_E(); //!< virtual destructor, clearing the MuonCalib::MuonCalibEvent_E
+
+    const MuonCalibEvent_E&              getEvent( int i_event ) ;   //!< retrieve a fully constructed MuonCalib::MuonCalibEvent_E
+    MuonCalibTrack_E*              getPhiPattern( int i_pat ); //!< create a PhiPattern (of type MuonCalib::MuonCalibTrack_E) 
+    MuonCalibTrack_E*              getTrack( int i_trk );      //!< create a Track (of type MuonCalib::MuonCalibTrack_E) 
+    MuonCalibTriggerInfo*          getCtpTbpHit( int i_trg);   //!< create a TriggerBeforePrescale object (oftype MuonCalib::MuonCalibTriggerInfo) 
+    MuonCalibTriggerInfo*          getCtpHit( int i_trg);     //!< create a Trigger object (oftype MuonCalib::MuonCalibTriggerInfo) 
+    MuonCalibMUCTPI*               getMUCTPIHit( int i_muctpi);     //!< create a MUCTPI object (oftype MuonCalib::MuonCalibMUCTPI) 
+    MuonCalibRpcSectorLogic*       getRpcSLHit( int i_rpcsl);     //!< create an RpcSL object (oftype MuonCalib::MuonCalibRpcSectorLogic) 
+    MuonCalibRawRpcCoin*           getRpcCoinHit( int i_rpcco);     //!< create an RpcCoin object (oftype MuonCalib::MuonCalibRawRpcCoin) 
+
+    MuonCalibCaloHit*              getMBTSHit( int i_trk );     //!< create a MBTS hit  
+    MuonCalibCaloHit*              getL1CaloHit( int i_trk );   //!< create Calo hit  
+
+    MuonCalibHit_E*                      getPhiHit( int i_phi ) ;    //!< create the i_phi^th PhiHit (of type MuonCalib::MuonCalibHit_E) of the entry
+    MuonCalibHit_E*                      getTrackHit( int i_trkHit ) ; //!< create the i_trkHit^th Track hit (of type MuonCalib::MuonCalibHit_E) of the entry
+    MuonCalibHole_E*                     getTrackHole( int i_trkHole ) ; //!< create the i_trkHole^th MuonCalib::MuonCalibHole_E of the entry
+      std::map<int, std::list<int> > m_smap;
+      void buildSegmentOnTrackMap();
+   
+  private:
+    MuonCalibEvent_E* m_evente; //!< NTReader has a MuonCalibEvent* m_event, but is not used here
+
+    void clearEvent_E();        //!< deletes m_evente 
+  };
+
+}//namespace MuonCalib
+#endif

MuonSpectrometer/MuonCalib/MuonCalibExtraTree/MuonCalibExtraNtuple/cmt/requirements

+package MuonCalibExtraNtuple
+author Zdenko van Kesteren <zkestere@nikhef.nl>
+author Jochem Snuverink <jsnuverink@nikhef.nl>
+ 
+use AtlasPolicy             AtlasPolicy-*
+use AtlasROOT               AtlasROOT-*                External
+
+use CalibNtupleReader       CalibNtupleReader-*        MuonSpectrometer/MuonCalib/MuonCalibStandAlone
+
+#use CalibNtupleUtils        CalibNtupleUtils-*         MuonSpectrometer/MuonCalib/MuonCalibStandAlone
+
+#use TrkEventPrimitives      TrkEventPrimitives-*       Tracking/TrkEvent
+
+
+private
+
+use MuonCalibExtraTreeEvent MuonCalibExtraTreeEvent-*  MuonSpectrometer/MuonCalib/MuonCalibExtraTree
+#use MdtCalibFitters         MdtCalibFitters-*          MuonSpectrometer/MuonCalib/MdtCalib
+#use MuonCalibStl            MuonCalibStl-*             MuonSpectrometer/MuonCalib/MuonCalibUtils
+use AtlasCLHEP              AtlasCLHEP-*               External
+use MuonCalibEventBase      MuonCalibEventBase-*       MuonSpectrometer/MuonCalib
+use MuonCalibIdentifier     MuonCalibIdentifier-*      MuonSpectrometer/MuonCalib
+
+
+#use MuonHoughPatternEvent   MuonHoughPatternEvent-*    MuonSpectrometer/MuonReconstruction/MuonRecEvent
+
+
+public
+
+library  MuonCalibExtraNtuple ../src/*.cxx
+
+apply_pattern installed_library
+
+macro_append AnalyseExtraTreeNtuple_dependencies        " MuonCalibExtraNtuple "
+macro_append AnalyseTwoExtraTreeNtuples_dependencies    " MuonCalibExtraNtuple " 
+
+private
+apply_tag ROOTMathLibs
+apply_tag ROOTGraphicsLibs
+#macro_append ROOT_linkopts " -lReflex -lCintex"
+#macro cppdebugflags '$(cppdebugflags_s)'
+#macro_remove componentshr_linkopts "-Wl,-s"
+

MuonSpectrometer/MuonCalib/MuonCalibExtraTree/MuonCalibExtraNtuple/doc/mainpage.h

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+/**
+@mainpage MuonCalibExtraNtuple Package
+@author Zdenko.Van.Kesteren@cern.ch
+
+@section MuonCalibExtraNtupleIntro Introduction
+
+MuonCalibExtraNtuple is the package where one builds its analysis based on the extended CalibrationNtuple. 
+
+@section MuonCalibExtraNtupleOverview Class Overview
+
+MuonCalibExtraNtuple contains several classes:
+
+- NTReaderBase_E :  Extended version of NTReaderBase, making it capable to hold variables of the extended Branches too.
+
+- MuonCalib::NTReader_E : Class storing the variables of the extended CalibrationNtuple into extended Calib-EDM classes (as described in MuonCalib::MuonCalibEvent_E)
+   
+And some analysis programmes:
+
+- MuonCalib::ExtraAnalysis : Empty Analysis routine, to be used as skeleton analysis. It has an example of how to loop over the 'extended' classes available from MuonCalibEvent_E.
+
+- MuonCalib::TrackAnalysis : Analysis program for Tracks on Calibration Ntuple. This class performs checks and makes histograms for tracks, tue tracks, holes. Efficiencies, fake rates, outliers, hit distributions, angle distributions can be calculated and plotted 
+
+- MuonCalib::MultipleAnalysis : Analysis program for MuonSegment (MDT or CSC). This analysis routine performs checks for segments and patterns, and using hit truth information. Additional, the programme includes extended pattern recognition.
+
+
+@ref used_MuonCalibExtraNtuple
+                                                                                
+@ref requirements_MuonCalibExtraNtuple
+                                                                                
+*/
+                                                                                
+/**
+@page used_MuonCalibExtraNtuple Used Packages
+@htmlinclude used_packages.html
+*/
+                                                                                
+/**
+@page requirements_MuonCalibExtraNtuple Requirements
+@include requirements
+*/
+       

MuonSpectrometer/MuonCalib/MuonCalibExtraTree/MuonCalibExtraNtuple/src/NTReaderBase_E.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "MuonCalibExtraNtuple/NTReaderBase_E.h"
+#include <TH2.h>
+#include <TStyle.h>
+#include <TCanvas.h>
+
+namespace MuonCalib {
+
+  void NTReaderBase_E::Loop()
+  {
+    if (fChain == 0) return;
+
+    Long64_t nentries = fChain->GetEntriesFast();
+
+    Int_t nbytes = 0, nb = 0;
+    for (Long64_t jentry=0; jentry<nentries;jentry++) {
+      Long64_t ientry = LoadTree(jentry);
+      if (ientry < 0) break;
+      nb = fChain->GetEntry(jentry);   nbytes += nb;
+      // if (Cut(ientry) < 0) continue;
+    }
+  }
+
+  NTReaderBase_E::NTReaderBase_E(TTree *tree) : NTReaderBase( tree )
+  {
+    // if parameter tree is not specified (or zero), connect the file
+    // used to generate this class and read the Tree.
+    if (tree == 0) {
+
+#ifdef SINGLE_TREE
+      // The following code should be used if you want this class to access
+      // a single tree instead of a chain
+      TFile *f = (TFile*)gROOT->GetListOfFiles()->FindObject("Memory Directory");
+      if (!f) {
+	f = new TFile("Memory Directory");
+	f->cd("SegmentNtuple.root:/PatternNtupleMaker");
+      }
+      tree = (TTree*)gDirectory->Get("NTReaderBase");
+
+#else // SINGLE_TREE
+
+      // The following code should be used if you want this class to access a chain
+      // of trees.
+      TChain * chain = new TChain("NTReaderBase","");
+      chain->Add("SegmentNtuple.root/PatternNtupleMaker/Segments");
+      tree = chain;
+#endif // SINGLE_TREE
+
+    }
+    Init(tree);
+  }
+
+  NTReaderBase_E::~NTReaderBase_E()
+  {
+  }
+
+  Int_t NTReaderBase_E::GetEntry(Long64_t entry)
+  {
+    // Read contents of entry.
+    if (!fChain) return 0;
+    return fChain->GetEntry(entry);
+  }
+  Long64_t NTReaderBase_E::LoadTree(Long64_t entry)
+  {
+    // Set the environment to read one entry
+    if (!fChain) return -5;
+    Long64_t centry = fChain->LoadTree(entry);
+    if (centry < 0) return centry;
+    if (fChain->IsA() != TChain::Class()) return centry;
+    TChain *chain = (TChain*)fChain;
+    if (chain->GetTreeNumber() != fCurrent) {
+      fCurrent = chain->GetTreeNumber();
+    }
+    return centry;
+  }
+
+  void NTReaderBase_E::Init(TTree *tree)
+  {
+    // The Init() function is called when the selector needs to initialize
+    // a new tree or chain. Typically here the branch addresses of the tree
+    // will be set. It is normaly not necessary to make changes to the
+    // generated code, but the routine can be extended by the user if needed.
+    // Init() will be called many times when running with PROOF.
+
+    // Set branch addresses
+    if (tree == 0) return;
+    fChain = tree;
+    fCurrent = -1;
+    fChain->SetMakeClass(1);
+
+// trigger info
+    ctp_nTriggerInfo =0;
+    fChain->SetBranchAddress("ctp_nTriggerInfo",&ctp_nTriggerInfo);
+    fChain->SetBranchAddress("ctp_numberBC", &ctp_numberBC);
+    fChain->SetBranchAddress("ctp_L1A_BC", &ctp_L1A_BC);
+    fChain->SetBranchAddress("ctp_timeNs", &ctp_timeNs);
+    fChain->SetBranchAddress("ctp_randomTrig", &ctp_randomTrig);
+    fChain->SetBranchAddress("ctp_firedItemsBeforePrescale", &ctp_firedItemsBeforePrescale);
+    fChain->SetBranchAddress("ctp_prescaledClock", &ctp_prescaledClock);
+    fChain->SetBranchAddress("ctp_bcid", &ctp_bcid);
+    fChain->SetBranchAddress("ctp_bcIndexPIT", &ctp_bcIndexPIT);
+    fChain->SetBranchAddress("ctp_pit", &ctp_pit);
+    fChain->SetBranchAddress("ctp_bcIndexTriggerItems", &ctp_bcIndexTriggerItems);
+    fChain->SetBranchAddress("ctp_tbp", &ctp_tbp);
+    fChain->SetBranchAddress("ctp_tap", &ctp_tap);
+    fChain->SetBranchAddress("ctp_tav", &ctp_tav);
+    fChain->SetBranchAddress("ctp_type",&ctp_type);
+    fChain->SetBranchAddress("ctp_delay",&ctp_delay);
+
+//mu ctpi info
+    muctpi_nHits=0;
+    fChain->SetBranchAddress("muctpi_nHits", &muctpi_nHits);
+    fChain->SetBranchAddress("muctpi_roiWord", &muctpi_roiWord);
+    fChain->SetBranchAddress("muctpi_bcID", &muctpi_bcID);
+    fChain->SetBranchAddress("muctpi_sysID", &muctpi_sysID);
+    fChain->SetBranchAddress("muctpi_subsysID", &muctpi_subsysID);
+    fChain->SetBranchAddress("muctpi_sectorID", &muctpi_sectorID);
+    fChain->SetBranchAddress("muctpi_thresholdNumber", &muctpi_thresholdNumber);
+    fChain->SetBranchAddress("muctpi_thresholdValue", &muctpi_thresholdValue);
+    fChain->SetBranchAddress("muctpi_roINumber", &muctpi_roINumber);
+    fChain->SetBranchAddress("muctpi_overlap", &muctpi_overlap);
+    fChain->SetBranchAddress("muctpi_firstCandidate", &muctpi_firstCandidate);
+    fChain->SetBranchAddress("muctpi_sectorOverflow", &muctpi_sectorOverflow);
+    fChain->SetBranchAddress("muctpi_padOverflow", &muctpi_padOverflow);
+    fChain->SetBranchAddress("muctpi_phi", &muctpi_phi);
+    fChain->SetBranchAddress("muctpi_eta", &muctpi_eta);
+
+//mu rpcsl info
+    if(fChain->GetBranch("rpc_SL_nSectors") != NULL){
+      rpc_SL_nSectors = 0;
+      fChain->SetBranchAddress("rpc_SL_nSectors", &rpc_SL_nSectors);
+      fChain->SetBranchAddress("rpc_SL_sectorId", &rpc_SL_sectorId);
+      fChain->SetBranchAddress("rpc_SL_lvl1id", &rpc_SL_lvl1id);
+      fChain->SetBranchAddress("rpc_SL_bcid", &rpc_SL_bcid);
+      fChain->SetBranchAddress("rpc_SL_errorCode", &rpc_SL_errorCode);
+      fChain->SetBranchAddress("rpc_SL_crc", &rpc_SL_crc);
+      fChain->SetBranchAddress("rpc_SL_hasMoreThan2TriggerCand", &rpc_SL_hasMoreThan2TriggerCand);
+      fChain->SetBranchAddress("rpc_SLnTriggerHits", &rpc_SLnTriggerHits);
+      fChain->SetBranchAddress("rpc_SLhit_sector", &rpc_SLhit_sector);
+      fChain->SetBranchAddress("rpc_SLhit_rowinBcid", &rpc_SLhit_rowinBcid);
+      fChain->SetBranchAddress("rpc_SLhit_padId", &rpc_SLhit_padId);
+      fChain->SetBranchAddress("rpc_SLhit_ptId", &rpc_SLhit_ptId);
+      fChain->SetBranchAddress("rpc_SLhit_roi", &rpc_SLhit_roi);
+      fChain->SetBranchAddress("rpc_SLhit_outerPlane", &rpc_SLhit_outerPlane);
+      fChain->SetBranchAddress("rpc_SLhit_overlapPhi", &rpc_SLhit_overlapPhi);
+      fChain->SetBranchAddress("rpc_SLhit_overlapEta", &rpc_SLhit_overlapEta);
+      fChain->SetBranchAddress("rpc_SLhit_triggerBcid", &rpc_SLhit_triggerBcid);
+      fChain->SetBranchAddress("rpc_SLhit_isInput", &rpc_SLhit_isInput);
+    }else{
+      //Reading old nomenclature
+      rpcSl_nLogics=0;
+      fChain->SetBranchAddress("rpcSl_nLogics", &rpcSl_nLogics);    
+      fChain->SetBranchAddress("rpcSl_sectorId", &rpcSl_sectorId);
+      fChain->SetBranchAddress("rpcSl_fel1Id", &rpcSl_fel1Id);
+      fChain->SetBranchAddress("rpcSl_bcid", &rpcSl_bcid);
+      fChain->SetBranchAddress("rpcSl_errorCode", &rpcSl_errorCode);
+      fChain->SetBranchAddress("rpcSl_crc", &rpcSl_crc);
+      fChain->SetBranchAddress("rpcSl_hasMoreThan2TriggerCand", &rpcSl_hasMoreThan2TriggerCand);
+      fChain->SetBranchAddress("rpcSl_nLogicsTimes", &rpcSl_nLogicsTimes);
+      fChain->SetBranchAddress("rpcSl_slIndex", &rpcSl_slIndex);
+      fChain->SetBranchAddress("rpcSl_triggerRates", &rpcSl_triggerRates);
+      fChain->SetBranchAddress("rpcSl_counters", &rpcSl_counters);
+      fChain->SetBranchAddress("rpcSl_nSLHits", &rpcSl_nSLHits);
+      fChain->SetBranchAddress("rpcSl_slIndex2", &rpcSl_slIndex2);
+      fChain->SetBranchAddress("rpcSl_rowinBcid", &rpcSl_rowinBcid);
+      fChain->SetBranchAddress("rpcSl_padid", &rpcSl_padid);
+      fChain->SetBranchAddress("rpcSl_ptid", &rpcSl_ptid);
+      fChain->SetBranchAddress("rpcSl_roi", &rpcSl_roi);
+      fChain->SetBranchAddress("rpcSl_outerPlane", &rpcSl_outerPlane);
+      fChain->SetBranchAddress("rpcSl_overlapPhi", &rpcSl_overlapPhi);
+      fChain->SetBranchAddress("rpcSl_overlapEta", &rpcSl_overlapEta);
+      fChain->SetBranchAddress("rpcSl_triggerBcid", &rpcSl_triggerBcid);
+      fChain->SetBranchAddress("rpcSl_isInput", &rpcSl_isInput);
+    }
+    
+    //rpc coin info
+    rawRpcCoin_nRpcCoin =0;
+    fChain->SetBranchAddress("rawRpcCoin_nRpcCoin", &rawRpcCoin_nRpcCoin);
+    fChain->SetBranchAddress("rawRpcCoin_occupancy", rawRpcCoin_occupancy);
+    fChain->SetBranchAddress("rawRpcCoin_id", rawRpcCoin_id); 
+    fChain->SetBranchAddress("rawRpcCoin_t", rawRpcCoin_t); 
+    fChain->SetBranchAddress("rawRpcCoin_width", rawRpcCoin_width); 
+    fChain->SetBranchAddress("rawRpcCoin_length", rawRpcCoin_length);
+    fChain->SetBranchAddress("rawRpcCoin_gPosX", rawRpcCoin_gPosX);
+    fChain->SetBranchAddress("rawRpcCoin_gPosY", rawRpcCoin_gPosY);
+    fChain->SetBranchAddress("rawRpcCoin_gPosZ", rawRpcCoin_gPosZ);
+    fChain->SetBranchAddress("rawRpcCoin_ijk", rawRpcCoin_ijk);
+    fChain->SetBranchAddress("rawRpcCoin_threshold", rawRpcCoin_threshold);
+    fChain->SetBranchAddress("rawRpcCoin_overlap", rawRpcCoin_overlap); 
+    fChain->SetBranchAddress("rawRpcCoin_parentCmId", rawRpcCoin_parentCmId); 
+    fChain->SetBranchAddress("rawRpcCoin_parentPadId", rawRpcCoin_parentPadId); 
+    fChain->SetBranchAddress("rawRpcCoin_parentSectorId", rawRpcCoin_parentSectorId); 
+    fChain->SetBranchAddress("rawRpcCoin_lowPtCm", rawRpcCoin_lowPtCm);
+    
+// calo hit info
+    calo_nHits=0;
+    fChain->SetBranchAddress("calo_nHits",&calo_nHits);
+    fChain->SetBranchAddress("calo_id",calo_id);
+    fChain->SetBranchAddress("calo_posX",calo_posX);
+    fChain->SetBranchAddress("calo_posY",calo_posY);
+    fChain->SetBranchAddress("calo_posZ",calo_posZ);
+    fChain->SetBranchAddress("calo_charge",calo_charge);
+    fChain->SetBranchAddress("calo_time",calo_time);
+// mbts  hit info
+    mbts_nHits=0;
+    fChain->SetBranchAddress("mbts_nHits",&mbts_nHits);
+    fChain->SetBranchAddress("mbts_id",mbts_id);
+    fChain->SetBranchAddress("mbts_posX",mbts_posX);
+    fChain->SetBranchAddress("mbts_posY",mbts_posY);
+    fChain->SetBranchAddress("mbts_posZ",mbts_posZ);
+    fChain->SetBranchAddress("mbts_charge",mbts_charge);
+    fChain->SetBranchAddress("mbts_time",mbts_time);
+
+// phi hit info 
+    phi_nPhiHits =0;
+    fChain->SetBranchAddress("phi_nPhiHits",&phi_nPhiHits);
+    fChain->SetBranchAddress("phi_phiPatIndex", phi_phiPatIndex);
+    fChain->SetBranchAddress("phi_id",phi_id);
+    fChain->SetBranchAddress("phi_posX",phi_posX);
+    fChain->SetBranchAddress("phi_posY",phi_posY);
+    fChain->SetBranchAddress("phi_posZ",phi_posZ);
+    fChain->SetBranchAddress("phi_error",phi_error);
+
+    fChain->SetBranchAddress("trk_nTracks", &trk_nTracks);
+    fChain->SetBranchAddress("trk_x0", trk_x0);
+    fChain->SetBranchAddress("trk_y0", trk_y0);
+    fChain->SetBranchAddress("trk_z0", trk_z0);
+    fChain->SetBranchAddress("trk_theta", trk_theta);
+    fChain->SetBranchAddress("trk_phi", trk_phi);
+    fChain->SetBranchAddress("trk_qOverP", trk_qOverP);
+    fChain->SetBranchAddress("trk_author", trk_author);
+    fChain->SetBranchAddress("trk_cov00", trk_cov00);
+    fChain->SetBranchAddress("trk_cov01", trk_cov01);
+    fChain->SetBranchAddress("trk_cov02", trk_cov02);
+    fChain->SetBranchAddress("trk_cov03", trk_cov03);
+    fChain->SetBranchAddress("trk_cov04", trk_cov04);
+    fChain->SetBranchAddress("trk_cov11", trk_cov11);
+    fChain->SetBranchAddress("trk_cov12", trk_cov12);
+    fChain->SetBranchAddress("trk_cov13", trk_cov13);
+    fChain->SetBranchAddress("trk_cov14", trk_cov14);
+    fChain->SetBranchAddress("trk_cov22", trk_cov22);
+    fChain->SetBranchAddress("trk_cov23", trk_cov23);
+    fChain->SetBranchAddress("trk_cov24", trk_cov24);
+    fChain->SetBranchAddress("trk_cov33", trk_cov33);
+    fChain->SetBranchAddress("trk_cov34", trk_cov34);
+    fChain->SetBranchAddress("trk_cov44", trk_cov44);
+//    fChain->SetBranchAddress("trk_errInvP", trk_errInvP);
+    fChain->SetBranchAddress("trk_chi2", trk_chi2);
+    fChain->SetBranchAddress("trk_ndof", trk_ndof);
+
+    fChain->SetBranchAddress("trkHit_nHits", &trkHit_nHits);
+    fChain->SetBranchAddress("trkHit_id", trkHit_id);
+    fChain->SetBranchAddress("trkHit_trackIndex", trkHit_trackIndex);
+    fChain->SetBranchAddress("trkHit_posX", trkHit_posX);
+    fChain->SetBranchAddress("trkHit_posY", trkHit_posY);
+    fChain->SetBranchAddress("trkHit_posZ", trkHit_posZ);
+    fChain->SetBranchAddress("trkHit_driftRadius", trkHit_driftRadius);
+    fChain->SetBranchAddress("trkHit_error", trkHit_error);
+    fChain->SetBranchAddress("trkHit_resi", trkHit_resi);
+    fChain->SetBranchAddress("trkHit_pull", trkHit_pull);
+    fChain->SetBranchAddress("trkHit_type", trkHit_type);
+
+    fChain->SetBranchAddress("trkHole_nHoles", &trkHole_nHoles);
+    fChain->SetBranchAddress("trkHole_id", trkHole_id);
+    fChain->SetBranchAddress("trkHole_trackIndex", trkHole_trackIndex);
+    fChain->SetBranchAddress("trkHole_posX", trkHole_posX);
+    fChain->SetBranchAddress("trkHole_posY", trkHole_posY);
+    fChain->SetBranchAddress("trkHole_posZ", trkHole_posZ);
+    
+    if(fChain->GetBranch("trkSeg_nTrkSegs")!=0)
+    	{
+    	fChain->SetBranchAddress("trkSeg_nTrkSegs", &trkSeg_nTrkSegs);
+    	fChain->SetBranchAddress("trkSeg_trkIndex", trkSeg_trkIndex);
+    	fChain->SetBranchAddress("trkSeg_segIndex", trkSeg_segIndex);
+	hasTrkSegs=true;
+	}
+ else
+ 	{
+	trkSeg_nTrkSegs=0;
+	hasTrkSegs=false;
+	}
+    
+  }
+
+
+
+  void NTReaderBase_E::Show(Long64_t entry)
+  {
+    // Print contents of entry.
+    // If entry is not specified, print current entry
+    if (!fChain) return;
+    fChain->Show(entry);
+  }
+  Int_t NTReaderBase_E::Cut(Long64_t /*entry*/)
+  {
+    // This function may be called from Loop.
+    // returns  1 if entry is accepted.
+    // returns -1 otherwise.
+    return 1;
+  }
+
+
+} //namespace MuonCalib

MuonSpectrometer/MuonCalib/MuonCalibExtraTree/MuonCalibExtraNtuple/src/NTReader_E.cxx

+/*
+  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
+*/
+
+#include "MuonCalibExtraNtuple/NTReader_E.h"
+
+#include "CLHEP/Geometry/Point3D.h"
+
+#include "MuonCalibExtraTreeEvent/MuonCalibHit_E.h"
+#include "MuonCalibExtraTreeEvent/MuonCalibTriggerInfo.h"
+#include "MuonCalibExtraTreeEvent/MuonCalibMUCTPI.h"
+#include "MuonCalibExtraTreeEvent/MuonCalibRpcSectorLogic.h"
+#include "MuonCalibEventBase/MuonCalibRawRpcCoin.h"
+#include "MuonCalibExtraTreeEvent/MuonCalibCaloHit.h"
+#include "MuonCalibExtraTreeEvent/MuonCalibHole_E.h"
+#include "MuonCalibExtraTreeEvent/MuonCalibTrack_E.h"
+#include "MuonCalibExtraTreeEvent/MuonCalibEvent_E.h"
+#include "MuonCalibExtraNtuple/NTReaderBase_E.h"
+
+#include "MuonCalibIdentifier/MuonFixedId.h"
+#include "MuonCalibEventBase/MuonCalibEvent.h"
+
+#include "MuonCalibEventBase/MuonCalibTruthCollection.h"
+
+#include <iostream>
+
+namespace MuonCalib{
+
+  NTReader_E::~NTReader_E(){
+    clearEvent_E();
+  }
+
+  void NTReader_E::clearEvent_E(){
+    delete m_evente;
+    m_evente=0;
+  }
+
+  const MuonCalibEvent_E& NTReader_E::getEvent( int i_event ){
+    
+    clearEvent_E();
+
+    if(!fChain->GetEntry( i_event ))
+    	{
+	m_evente = new MuonCalibEvent_E();
+	return *m_evente;
+	}
+
+    MuonCalibRawHitCollection* raw = buildRawColl();
+    const MuonCalibEventInfo info = buildEventInfo();
+    MuonCalibEvent::MCPVec patternVec = buildPatternVec();
+
+    m_evente = new MuonCalibEvent_E();
+
+    m_evente->setMuonCalibPatternVec(patternVec);
+    
+    m_evente->setMuonCalibRawHitCollection(raw);
+    
+    if(m_storeTruth==true){
+
+      MuonCalibTruthCollection* truth = buildTruthColl();
+      m_evente->setMuonCalibTruthCollection(truth);
+
+    }
+
+    m_evente->setMuonCalibEventInfo(info);
+
+    bool m_debug = false; 
+ 
+    if (m_debug) {
+      std::cout << "  evente.eventInfo().eventNumber() = " <<  m_evente->eventInfo().eventNumber()  << std::endl;
+      std::cout << "  evente.numberOfPatterns = " << pat_nPatterns << std::endl;
+      std::cout << "  evente.numberOfTracks = " << trk_nTracks << std::endl;
+    }
+    for( int i_trig = 0 ; i_trig < ctp_nTriggerInfo ; ++ i_trig ){
+      m_evente->addCtp( getCtpTbpHit(i_trig) );
+      if (m_debug) std::cout << " CTP trigger bit Added" << std::endl;
+    }
+    if(muctpi_nHits>99) {
+     std::cout << " WARNING muctpi_nHits TOO BIG " << muctpi_nHits << std::endl;
+     muctpi_nHits = 99;
+    }  
+    for( int i_muctpi = 0 ; i_muctpi < muctpi_nHits ; ++ i_muctpi ){
+      m_evente->addMUCTPI( getMUCTPIHit(i_muctpi) );
+      if (m_debug) std::cout << " MUCTPI object Added" << std::endl;
+    }
+
+    if(rpcSl_nLogics > 0){
+      for( int i_rpcsl = 0 ; i_rpcsl < rpcSl_nLogics ; ++ i_rpcsl ){
+	m_evente->addRpcSL( getRpcSLHit(i_rpcsl) );
+	if (m_debug) std::cout << " RpcSL object Added" << std::endl;
+      }
+    }
+
+    for( int i_rpcco = 0 ; i_rpcco < rawRpcCoin_nRpcCoin ; ++ i_rpcco ){
+      m_evente->addRpcCoin( getRpcCoinHit(i_rpcco) );
+      if (m_debug) std::cout << " RpcCoin object Added" << std::endl;
+    }
+
+    for( int i_calo = 0 ; i_calo < calo_nHits ; ++ i_calo ){
+      m_evente->addL1Calo( getL1CaloHit(i_calo) );
+      if (m_debug) std::cout << " L1Calo Added" << std::endl;
+    }
+
+    for( int i_mbts = 0 ; i_mbts < mbts_nHits ; ++ i_mbts ){
+      m_evente->addMBTS( getMBTSHit(i_mbts) );
+      if (m_debug) std::cout << " MBTS Added" << std::endl;
+    }
+
+    for( int i_pat = 0 ; i_pat < pat_nPatterns ; ++ i_pat ){
+      m_evente->addPattern( getPhiPattern(i_pat) );
+      if (m_debug) std::cout << "Pattern Added" << std::endl;
+    }
+    buildSegmentOnTrackMap();
+    for( int i_trk = 0 ; i_trk < trk_nTracks ; ++ i_trk ){
+      m_evente->addTrack( getTrack(i_trk) );
+
+      if (m_debug) std::cout << "Track Added" << std::endl;
+    }
+
+    if (m_debug) std::cout << "NTReader_E::end of getEvent" << std::endl;
+    
+    return *m_evente;
+  }
+  
+  MuonCalibHit_E* NTReader_E::getPhiHit( int i_phi ) {
+    MuonFixedId id( phi_id[i_phi] );
+    Amg::Vector3D position( phi_posX[i_phi], phi_posY[i_phi], phi_posZ[i_phi] );
+    double error = phi_error[i_phi];
+    MuonCalibHit_E* hit = new MuonCalibHit_E(id, position,0.,error);
+    return hit;
+  }
+
+  MuonCalibHit_E* NTReader_E::getTrackHit( int i_trkHit ) {
+    MuonFixedId id( trkHit_id[i_trkHit] );
+    Amg::Vector3D position( trkHit_posX[i_trkHit], trkHit_posY[i_trkHit], trkHit_posZ[i_trkHit] );
+    double error = trkHit_error[i_trkHit];
+    MuonCalibHit_E* hit = new MuonCalibHit_E(id, position, trkHit_driftRadius[i_trkHit], error, 
+					     trkHit_resi[i_trkHit], trkHit_pull[i_trkHit], trkHit_type[i_trkHit]);
+    return hit;
+  }
+
+  MuonCalibHole_E* NTReader_E::getTrackHole( int i_trkHole ) {
+    MuonFixedId id( trkHole_id[i_trkHole] );
+    Amg::Vector3D position( trkHole_posX[i_trkHole], trkHole_posY[i_trkHole], trkHole_posZ[i_trkHole] );
+    MuonCalibHole_E* hole = new MuonCalibHole_E(id, position);
+    return hole;
+  }
+
+  MuonCalibTriggerInfo* NTReader_E::getCtpTbpHit( int i_trigHit ) {
+    int theTbpBit    = ctp_tbp[i_trigHit];  
+    int theTapBit    = ctp_tap[i_trigHit];  
+    int theTavBit    = ctp_tav[i_trigHit];  
+    int theBcIndex   = ctp_bcIndexTriggerItems[i_trigHit];  
+    MuonCalibTriggerInfo* trig  = new MuonCalibTriggerInfo(theTbpBit, theTapBit, theTavBit, theBcIndex);
+    return trig;
+  } 
+
+  MuonCalibTriggerInfo* NTReader_E::getCtpHit( int i_trigHit ) {
+    int theTypeValue = ctp_type[i_trigHit];
+    double theDelayValue = ctp_delay[i_trigHit];
+    MuonCalibTriggerType theTrigType = (MuonCalibTriggerType)theTypeValue;
+    
+    MuonCalibTriggerInfo* trig  = new MuonCalibTriggerInfo(theTrigType, theDelayValue);
+    return trig;
+  } 
+
+  MuonCalibMUCTPI* NTReader_E::getMUCTPIHit( int i_trigMUCTPI ) {
+    MuonCalibMUCTPI* muctpi  = new MuonCalibMUCTPI(muctpi_roiWord[i_trigMUCTPI], muctpi_bcID[i_trigMUCTPI], muctpi_sysID[i_trigMUCTPI], muctpi_subsysID[i_trigMUCTPI], muctpi_sectorID[i_trigMUCTPI], muctpi_thresholdNumber[i_trigMUCTPI], muctpi_thresholdValue[i_trigMUCTPI], muctpi_roINumber[i_trigMUCTPI], muctpi_overlap[i_trigMUCTPI], muctpi_firstCandidate[i_trigMUCTPI], muctpi_sectorOverflow[i_trigMUCTPI], muctpi_padOverflow[i_trigMUCTPI], muctpi_phi[i_trigMUCTPI], muctpi_eta[i_trigMUCTPI]);
+    return muctpi;
+  } 
+  
+  MuonCalibRpcSectorLogic* NTReader_E::getRpcSLHit( int i_rpcSL ) {
+    MuonCalibRpcSectorLogic* rpcsl  = new MuonCalibRpcSectorLogic(rpcSl_sectorId[i_rpcSL],  rpcSl_fel1Id[i_rpcSL],  rpcSl_bcid[i_rpcSL],  rpcSl_errorCode[i_rpcSL],  rpcSl_crc[i_rpcSL],  rpcSl_hasMoreThan2TriggerCand[i_rpcSL],  rpcSl_slIndex[i_rpcSL], rpcSl_triggerRates[i_rpcSL], rpcSl_counters[i_rpcSL], rpcSl_slIndex2[i_rpcSL],  rpcSl_rowinBcid[i_rpcSL],  rpcSl_padid[i_rpcSL],  rpcSl_ptid[i_rpcSL],  rpcSl_roi[i_rpcSL],  rpcSl_outerPlane[i_rpcSL],  rpcSl_overlapPhi[i_rpcSL],  rpcSl_overlapEta[i_rpcSL],  rpcSl_triggerBcid[i_rpcSL],  rpcSl_isInput[i_rpcSL] ); 
+    return rpcsl;
+  }
+
+  MuonCalibRawRpcCoin* NTReader_E::getRpcCoinHit( int i_rpcCoin ) {
+    MuonFixedId id( rawRpcCoin_id[i_rpcCoin] );
+    Amg::Vector3D position( rawRpcCoin_gPosX[i_rpcCoin], rawRpcCoin_gPosY[i_rpcCoin], rawRpcCoin_gPosZ[i_rpcCoin] ); 
+    MuonCalibRawRpcHit theRpcHit( id, position, rawRpcCoin_occupancy[i_rpcCoin], rawRpcCoin_t[i_rpcCoin], rawRpcCoin_width[i_rpcCoin] );
+    MuonCalibRawRpcCoin* rpcco  = new MuonCalibRawRpcCoin( theRpcHit, rawRpcCoin_ijk[i_rpcCoin], rawRpcCoin_threshold[i_rpcCoin], rawRpcCoin_overlap[i_rpcCoin], rawRpcCoin_parentCmId[i_rpcCoin], rawRpcCoin_parentPadId[i_rpcCoin], rawRpcCoin_parentSectorId[i_rpcCoin], rawRpcCoin_lowPtCm[i_rpcCoin] ); 
+    return rpcco;
+  }
+
+  MuonCalibCaloHit* NTReader_E::getMBTSHit( int i_trkHit ) {
+    int id = mbts_id[i_trkHit];
+    Amg::Vector3D position( mbts_posX[i_trkHit], mbts_posY[i_trkHit], mbts_posZ[i_trkHit] );
+    MuonCalibCaloHit* mbts  = new MuonCalibCaloHit(id, position,mbts_time[i_trkHit],mbts_charge[i_trkHit]);
+    return mbts;
+  } 
+
+  MuonCalibCaloHit* NTReader_E::getL1CaloHit( int i_trkHit ) {
+    int id = calo_id[i_trkHit];
+    Amg::Vector3D position( calo_posX[i_trkHit], calo_posY[i_trkHit], calo_posZ[i_trkHit] );
+    MuonCalibCaloHit* calo = new MuonCalibCaloHit(id, position,calo_time[i_trkHit],calo_charge[i_trkHit]);
+    return calo;
+  } 
+
+
+
+  MuonCalibTrack_E* NTReader_E::getPhiPattern( int i_pat ){
+
+    bool m_debug = false;  
+    //    std::cout << "making a new MuonCalibTrack_E, looping over " << phi_nPhiHits
+    //	      << " phiHits, assigning them to its righteous pattern" << std::endl;
+
+    double r0 = NTReader::pat_r0[i_pat];
+    double phi = NTReader::pat_phi[i_pat];
+    double x0= r0*sin(phi);
+    double y0= -r0*cos(phi);
+    
+    
+    MuonCalibTrack_E* pattern = new MuonCalibTrack_E( x0, y0, NTReader::pat_z0[i_pat], NTReader::pat_phi[i_pat],
+						      NTReader::pat_theta[i_pat], 
+                                                      NTReader::pat_invP[i_pat],0,   
+                                                      -999.,-999.,-999.,-999.,-999.,  
+                                                      -999.,-999.,-999.,-999.,  
+                                                      -999.,-999.,-999.,  
+                                                      -999.,-999.,  
+                                                      -999., 0.,0);   
+    //    std::cout << "scanning hits ... " << std::endl ;
+    for( int i_phi = 0 ; i_phi < phi_nPhiHits ; ++i_phi ){
+	//      std::cout << i_phi << " " ;
+	if( phi_phiPatIndex[i_phi] == i_pat ) {
+	 if(m_debug) std::cout << " added the hit to pattern " << i_pat << "(index = " << phi_phiPatIndex[i_phi] << ")" << std::endl;
+	  pattern->addHit( getPhiHit(i_phi) ) ;
+	}
+    }
+      //     const MuonCalibTrack_E* cPattern = new MuonCalibTrack_E( *pattern );
+ 
+    return pattern;  
+  }
+
+  MuonCalibTrack_E* NTReader_E::getTrack( int i_trk ){
+
+    bool m_debug = false;  
+    if (m_debug) { std::cout << "making a new MuonCalibTrack_E, looping over " << trkHit_nHits
+			     << " Hits, assigning them to its righteous track" << std::endl;
+    }
+    MuonCalibTrack_E* track = new MuonCalibTrack_E(  trk_x0[i_trk], trk_y0[i_trk], trk_z0[i_trk], 
+						     trk_phi[i_trk], trk_theta[i_trk], trk_qOverP[i_trk],trk_author[i_trk], 
+						     trk_cov00[i_trk],trk_cov01[i_trk],trk_cov02[i_trk],trk_cov03[i_trk],trk_cov04[i_trk],
+						     trk_cov11[i_trk],trk_cov12[i_trk],trk_cov13[i_trk],trk_cov14[i_trk],
+						     trk_cov22[i_trk],trk_cov23[i_trk],trk_cov24[i_trk],
+						     trk_cov33[i_trk],trk_cov34[i_trk],
+						     trk_cov44[i_trk],
+						     trk_chi2[i_trk],trk_ndof[i_trk]);   
+    if (m_debug) std::cout << "track author ... " << trk_author[
+i_trk] << " itrk " << i_trk << std::endl ;
+    for( int i_trkHit = 0 ; i_trkHit < trkHit_nHits ; ++i_trkHit ){
+      if( trkHit_trackIndex[i_trkHit] == i_trk ) {
+	if(m_debug) std::cout << " added the hit to track " << i_trk << "(index = " << trkHit_trackIndex[i_trkHit] << ")" << std::endl;
+	track->addHit( getTrackHit(i_trkHit) ) ;
+      }
+    }
+    for( int i_trkHole = 0 ; i_trkHole < trkHole_nHoles ; ++i_trkHole ){
+      if (m_debug) std::cout << i_trkHole << " " ;
+      if( trkHole_trackIndex[i_trkHole] == i_trk ) {
+	if(m_debug) std::cout << " added the hole to track " << i_trk << "(index = " << trkHole_trackIndex[i_trkHole] << ")" << std::endl;
+	track->addHole( getTrackHole(i_trkHole) ) ;
+      }
+    }
+    //const MuonCalibTrack_E* cTrack = new MuonCalibTrack_E( *track );
+
+    std::map<int, std::list<int> >::const_iterator it=m_smap.find(i_trk);
+    if(it!=m_smap.end())
+    	{
+	for (std::list<int> :: const_iterator it2=it->second.begin(); it2!=it->second.end(); it2++)
+		{
+		track->addSegmentOnTrack(m_ordered_segments[*it2]);
+		}
+	}
+
+    return track;  
+  }
+
+void NTReader_E::buildSegmentOnTrackMap()
+	{
+	m_smap.clear();
+	if(!hasTrkSegs)
+		return;
+	for(int i=0; i<trkSeg_nTrkSegs; i++)
+		{
+		m_smap[trkSeg_trkIndex[i]].push_back(trkSeg_segIndex[i]);
+		}
+	}
+
+} //namespace MuonCalib
+
+