src/build/ElectronID_Dict.cc

0001 // Do NOT change. Changes will be lost next time file is generated
0002
0003 #define R__DICTIONARY_FILENAME ElectronID_Dict
0004 #define R__NO_DEPRECATION
0005
0006 /*******************************************************************/
0007 #include <stddef.h>
0008 #include <stdio.h>
0009 #include <stdlib.h>
0010 #include <string.h>
0011 #include <assert.h>
0012 #define G__DICTIONARY
0013 #include "RConfig.h"
0014 #include "TClass.h"
0015 #include "TDictAttributeMap.h"
0016 #include "TInterpreter.h"
0017 #include "TROOT.h"
0018 #include "TBuffer.h"
0019 #include "TMemberInspector.h"
0020 #include "TInterpreter.h"
0021 #include "TVirtualMutex.h"
0022 #include "TError.h"
0023
0024 #ifndef G__ROOT
0025 #define G__ROOT
0026 #endif
0027
0028 #include "RtypesImp.h"
0029 #include "TIsAProxy.h"
0030 #include "TFileMergeInfo.h"
0031 #include <algorithm>
0032 #include "TCollectionProxyInfo.h"
0033 /*******************************************************************/
0034
0035 #include "TDataMember.h"
0036
0037 // The generated code does not explicitly qualifies STL entities
0038 namespace std {} using namespace std;
0039
0040 // Header files passed as explicit arguments
0041 #include "/sphenix/u/weihuma/analysis/ElectronID/src/ElectronID.h"
0042
0043 // Header files passed via #pragma extra_include
0044
0045 namespace ROOT {
0046    static TClass *ElectronID_Dictionary();
0047    static void ElectronID_TClassManip(TClass*);
0048    static void *new_ElectronID(void *p = 0);
0049    static void *newArray_ElectronID(Long_t size, void *p);
0050    static void delete_ElectronID(void *p);
0051    static void deleteArray_ElectronID(void *p);
0052    static void destruct_ElectronID(void *p);
0053
0054    // Function generating the singleton type initializer
0055    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ElectronID*)
0056    {
0057       ::ElectronID *ptr = 0;
0058       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ElectronID));
0059       static ::ROOT::TGenericClassInfo
0060          instance("ElectronID", "", 40,
0061                   typeid(::ElectronID), ::ROOT::Internal::DefineBehavior(ptr, ptr),
0062                   &ElectronID_Dictionary, isa_proxy, 3,
0063                   sizeof(::ElectronID) );
0064       instance.SetNew(&new_ElectronID);
0065       instance.SetNewArray(&newArray_ElectronID);
0066       instance.SetDelete(&delete_ElectronID);
0067       instance.SetDeleteArray(&deleteArray_ElectronID);
0068       instance.SetDestructor(&destruct_ElectronID);
0069       return &instance;
0070    }
0071    TGenericClassInfo *GenerateInitInstance(const ::ElectronID*)
0072    {
0073       return GenerateInitInstanceLocal((::ElectronID*)0);
0074    }
0075    // Static variable to force the class initialization
0076    static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::ElectronID*)0x0); R__UseDummy(_R__UNIQUE_DICT_(Init));
0077
0078    // Dictionary for non-ClassDef classes
0079    static TClass *ElectronID_Dictionary() {
0080       TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::ElectronID*)0x0)->GetClass();
0081       ElectronID_TClassManip(theClass);
0082    return theClass;
0083    }
0084
0085    static void ElectronID_TClassManip(TClass* ){
0086    }
0087
0088 } // end of namespace ROOT
0089
0090 namespace ROOT {
0091    // Wrappers around operator new
0092    static void *new_ElectronID(void *p) {
0093       return  p ? new(p) ::ElectronID : new ::ElectronID;
0094    }
0095    static void *newArray_ElectronID(Long_t nElements, void *p) {
0096       return p ? new(p) ::ElectronID[nElements] : new ::ElectronID[nElements];
0097    }
0098    // Wrapper around operator delete
0099    static void delete_ElectronID(void *p) {
0100       delete ((::ElectronID*)p);
0101    }
0102    static void deleteArray_ElectronID(void *p) {
0103       delete [] ((::ElectronID*)p);
0104    }
0105    static void destruct_ElectronID(void *p) {
0106       typedef ::ElectronID current_t;
0107       ((current_t*)p)->~current_t();
0108    }
0109 } // end of namespace ROOT for class ::ElectronID
0110
0111 namespace {
0112   void TriggerDictionaryInitialization_ElectronID_Dict_Impl() {
0113     static const char* headers[] = {
0114 "0",
0115 0
0116     };
0117     static const char* includePaths[] = {
0118 0
0119     };
0120     static const char* fwdDeclCode = R"DICTFWDDCLS(
0121 #line 1 "ElectronID_Dict dictionary forward declarations' payload"
0122 #pragma clang diagnostic ignored "-Wkeyword-compat"
0123 #pragma clang diagnostic ignored "-Wignored-attributes"
0124 #pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
0125 extern int __Cling_AutoLoading_Map;
0126 class ElectronID;
0127 )DICTFWDDCLS";
0128     static const char* payloadCode = R"DICTPAYLOAD(
0129 #line 1 "ElectronID_Dict dictionary payload"
0130
0131
0132 #define _BACKWARD_BACKWARD_WARNING_H
0133 // Inline headers
0134 /*!
0135  *  \file       PHTruthClustering.h
0136  *  \brief      Clustering using truth info
0137  *  \author     Tony Frawley <afrawley@fsu.edu>
0138  */
0139
0140 #ifndef TRACKRECO_PHTRUTHCLUSTERING_H
0141 #define TRACKRECO_PHTRUTHCLUSTERING_H
0142
0143 #include <fun4all/SubsysReco.h>
0144
0145 // rootcint barfs with this header so we need to hide it
0146 #include <gsl/gsl_rng.h>
0147
0148
0149 #include <string>             // for string
0150 #include <vector>
0151 #include <map>
0152 #include <set>
0153 #include <memory>
0154
0155 #include <TFile.h>
0156 #include <TNtuple.h>
0157 #include "TMVA/Tools.h"
0158 #include "TMVA/Reader.h"
0159 #include <TMVA/MethodCuts.h>
0160
0161 // forward declarations
0162 class PHCompositeNode;
0163 class SvtxTrackMap;
0164 class SvtxTrack;
0165 class TrackPidAssoc;
0166 class PHG4TruthInfoContainer;
0167 class PHG4Particle;
0168
0169 class SvtxTrack;
0170
0171 class ElectronID  : public SubsysReco
0172 {
0173 public:
0174   ElectronID(const std::string &name = "ElectronID", const std::string &filename = "_ElectronID.root");
0175   virtual ~ElectronID();
0176
0177   int Init(PHCompositeNode *topNode);
0178   int InitRun(PHCompositeNode *topNode);
0179   int process_event(PHCompositeNode *topNode);
0180   int End(PHCompositeNode *topNode);
0181
0182   /// Set the cemce3x3/p cut limits for electrons; default: 0.7<cemce3x3/p<100.0, means without cuts
0183   void setEMOPcutlimits(float EMOPlowerlimit, float EMOPhigherlimit) { EMOP_lowerlimit = EMOPlowerlimit; EMOP_higherlimit = EMOPhigherlimit; }
0184
0185   /// Set the hcaline3x3/cemce3x3 cut limit for electrons; default: hcaline3x3/cemce3x3<100.0, means without cut
0186   void setHinOEMcutlimit(float HinOEMhigherlimit) { HinOEM_higherlimit = HinOEMhigherlimit; }
0187
0188   /// Set the pt cut limit for Upsilon decay electrons; default: 0.0<pt<100.0 GeV, means without cut
0189   void setPtcutlimit(float Ptlowerlimit, float Pthigherlimit) { Pt_lowerlimit = Ptlowerlimit; Pt_higherlimit = Pthigherlimit; }
0190
0191   /// Set the (hcaline3x3+hcaloute3x3)/p cut lower limit for hadrons; default: 0.0<(hcaline3x3+hcaloute3x3)/p, means without cut
0192   void setHOPcutlimit(float HOPlowerlimit) { HOP_lowerlimit = HOPlowerlimit; }
0193
0194   /// Set the track cut limits; default: nmvtx>=2, nintt>=0, ntpc>=20; quality<5.
0195   void setTrackcutlimits(int Nmvtxlowerlimit, int Ninttlowerlimit, int Ntpclowerlimit, float Nqualityhigherlimit) {
0196      Nmvtx_lowerlimit = Nmvtxlowerlimit;
0197      Nintt_lowerlimit = Ninttlowerlimit;
0198      Ntpc_lowerlimit = Ntpclowerlimit;
0199      Nquality_higherlimit = Nqualityhigherlimit;
0200   }
0201
0202   /// set "prob" variable cut
0203   void setPROBcut(float tmp) {PROB_cut = tmp;}
0204
0205   void set_output_ntuple(bool outputntuple) {output_ntuple = outputntuple;}
0206
0207   /// set MVA cut
0208   void setBDTcut(int isuseBDT_p, int isuseBDT_n, float bdtcut_p, float bdtcut_n) {ISUSE_BDT_p= isuseBDT_p; ISUSE_BDT_n= isuseBDT_n; BDT_cut_p = bdtcut_p; BDT_cut_n = bdtcut_n;}
0209
0210
0211 protected:
0212   bool output_ntuple;
0213
0214   TFile* OutputNtupleFile;
0215   std::string OutputFileName;
0216   TNtuple* ntpBDTresponse; //write ntuple for BDTresponse
0217   TNtuple* ntpbeforecut; //write ntuple before any cuts
0218   TNtuple* ntpcutEMOP; //write ntuple with only EMOP cut
0219   TNtuple* ntpcutEMOP_HinOEM; //write ntuple with EMOP & HinOEM cuts
0220   TNtuple* ntpcutEMOP_HinOEM_Pt; //write ntuple with EMOP & HinOEM & Pt cuts
0221   TNtuple* ntpcutEMOP_HinOEM_Pt_read; //write ntuple with EMOP & HinOEM & Pt cuts in the situation of reading back the association map.
0222   TNtuple* ntpcutBDT_read; //write ntuple with BDT & Pt cuts in the situation of reading back the association map.
0223
0224   TNtuple* ntpcutHOP; //write ntuple with only HOP cut
0225
0226   int EventNumber;
0227
0228 private:
0229 /// fetch node pointers
0230 int GetNodes(PHCompositeNode *topNode);
0231
0232 PHG4Particle* findMCmatch(SvtxTrack* track, PHG4TruthInfoContainer* truth_container);
0233
0234  TrackPidAssoc *_track_pid_assoc;
0235  SvtxTrackMap *_track_map;
0236
0237 /// A float lower limit for cutting on cemce3x3/p
0238   float EMOP_lowerlimit;
0239 /// A float higher limit for cutting on cemce3x3/p
0240   float EMOP_higherlimit;
0241
0242 /// "prob" variable cut
0243   float PROB_cut;
0244
0245 /// A float higher limit for cutting on hcaline3x3/cemce3x3
0246   float HinOEM_higherlimit;
0247
0248 /// A float lower limit for cutting on pt
0249   float Pt_lowerlimit;
0250 /// A float higher limit for cutting on pt
0251   float Pt_higherlimit;
0252
0253 /// A float lower limit for cutting on (hcaline3x3+hcaloute3x3)/p
0254   float HOP_lowerlimit;
0255
0256 /// A float lower limit for cutting on nmvtx
0257   int Nmvtx_lowerlimit;
0258
0259 /// A float lower limit for cutting on nintt
0260   int Nintt_lowerlimit;
0261
0262 /// A float lower limit for cutting on ntpc
0263   int Ntpc_lowerlimit;
0264
0265 /// A float higher limit for cutting on quality
0266   float Nquality_higherlimit;
0267
0268 /// MVA cut
0269   float BDT_cut_p, BDT_cut_n;
0270   int ISUSE_BDT_p, ISUSE_BDT_n;//0 for no; 1 for yes
0271
0272   unsigned int _nlayers_maps = 3;
0273   unsigned int _nlayers_intt = 4;
0274   unsigned int _nlayers_tpc = 48;
0275
0276
0277 };
0278
0279 #endif
0280
0281 #undef  _BACKWARD_BACKWARD_WARNING_H
0282 )DICTPAYLOAD";
0283     static const char* classesHeaders[] = {
0284 "ElectronID", payloadCode, "@",
0285 nullptr
0286 };
0287     static bool isInitialized = false;
0288     if (!isInitialized) {
0289       TROOT::RegisterModule("ElectronID_Dict",
0290         headers, includePaths, payloadCode, fwdDeclCode,
0291         TriggerDictionaryInitialization_ElectronID_Dict_Impl, {}, classesHeaders, /*hasCxxModule*/false);
0292       isInitialized = true;
0293     }
0294   }
0295   static struct DictInit {
0296     DictInit() {
0297       TriggerDictionaryInitialization_ElectronID_Dict_Impl();
0298     }
0299   } __TheDictionaryInitializer;
0300 }
0301 void TriggerDictionaryInitialization_ElectronID_Dict() {
0302   TriggerDictionaryInitialization_ElectronID_Dict_Impl();
0303 }