Mwibanda/BUILD/MBDStudy_Dict.C

0001 // Do NOT change. Changes will be lost next time file is generated
0002
0003 #define R__DICTIONARY_FILENAME MBDStudy_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 // Header files passed as explicit arguments
0038 #include "../MBDStudy.h"
0039
0040 // Header files passed via #pragma extra_include
0041
0042 // The generated code does not explicitly qualify STL entities
0043 namespace std {} using namespace std;
0044
0045 namespace ROOT {
0046    static TClass *MBDStudy_Dictionary();
0047    static void MBDStudy_TClassManip(TClass*);
0048    static void *new_MBDStudy(void *p = nullptr);
0049    static void *newArray_MBDStudy(Long_t size, void *p);
0050    static void delete_MBDStudy(void *p);
0051    static void deleteArray_MBDStudy(void *p);
0052    static void destruct_MBDStudy(void *p);
0053
0054    // Function generating the singleton type initializer
0055    static TGenericClassInfo *GenerateInitInstanceLocal(const ::MBDStudy*)
0056    {
0057       ::MBDStudy *ptr = nullptr;
0058       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::MBDStudy));
0059       static ::ROOT::TGenericClassInfo
0060          instance("MBDStudy", "", 28,
0061                   typeid(::MBDStudy), ::ROOT::Internal::DefineBehavior(ptr, ptr),
0062                   &MBDStudy_Dictionary, isa_proxy, 4,
0063                   sizeof(::MBDStudy) );
0064       instance.SetNew(&new_MBDStudy);
0065       instance.SetNewArray(&newArray_MBDStudy);
0066       instance.SetDelete(&delete_MBDStudy);
0067       instance.SetDeleteArray(&deleteArray_MBDStudy);
0068       instance.SetDestructor(&destruct_MBDStudy);
0069       return &instance;
0070    }
0071    TGenericClassInfo *GenerateInitInstance(const ::MBDStudy*)
0072    {
0073       return GenerateInitInstanceLocal((::MBDStudy*)nullptr);
0074    }
0075    // Static variable to force the class initialization
0076    static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const ::MBDStudy*)nullptr); R__UseDummy(_R__UNIQUE_DICT_(Init));
0077
0078    // Dictionary for non-ClassDef classes
0079    static TClass *MBDStudy_Dictionary() {
0080       TClass* theClass =::ROOT::GenerateInitInstanceLocal((const ::MBDStudy*)nullptr)->GetClass();
0081       MBDStudy_TClassManip(theClass);
0082    return theClass;
0083    }
0084
0085    static void MBDStudy_TClassManip(TClass* ){
0086    }
0087
0088 } // end of namespace ROOT
0089
0090 namespace ROOT {
0091    // Wrappers around operator new
0092    static void *new_MBDStudy(void *p) {
0093       return  p ? new(p) ::MBDStudy : new ::MBDStudy;
0094    }
0095    static void *newArray_MBDStudy(Long_t nElements, void *p) {
0096       return p ? new(p) ::MBDStudy[nElements] : new ::MBDStudy[nElements];
0097    }
0098    // Wrapper around operator delete
0099    static void delete_MBDStudy(void *p) {
0100       delete ((::MBDStudy*)p);
0101    }
0102    static void deleteArray_MBDStudy(void *p) {
0103       delete [] ((::MBDStudy*)p);
0104    }
0105    static void destruct_MBDStudy(void *p) {
0106       typedef ::MBDStudy current_t;
0107       ((current_t*)p)->~current_t();
0108    }
0109 } // end of namespace ROOT for class ::MBDStudy
0110
0111 namespace ROOT {
0112    static TClass *maplEintcOintgR_Dictionary();
0113    static void maplEintcOintgR_TClassManip(TClass*);
0114    static void *new_maplEintcOintgR(void *p = nullptr);
0115    static void *newArray_maplEintcOintgR(Long_t size, void *p);
0116    static void delete_maplEintcOintgR(void *p);
0117    static void deleteArray_maplEintcOintgR(void *p);
0118    static void destruct_maplEintcOintgR(void *p);
0119
0120    // Function generating the singleton type initializer
0121    static TGenericClassInfo *GenerateInitInstanceLocal(const map<int,int>*)
0122    {
0123       map<int,int> *ptr = nullptr;
0124       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<int,int>));
0125       static ::ROOT::TGenericClassInfo
0126          instance("map<int,int>", -2, "map", 100,
0127                   typeid(map<int,int>), ::ROOT::Internal::DefineBehavior(ptr, ptr),
0128                   &maplEintcOintgR_Dictionary, isa_proxy, 0,
0129                   sizeof(map<int,int>) );
0130       instance.SetNew(&new_maplEintcOintgR);
0131       instance.SetNewArray(&newArray_maplEintcOintgR);
0132       instance.SetDelete(&delete_maplEintcOintgR);
0133       instance.SetDeleteArray(&deleteArray_maplEintcOintgR);
0134       instance.SetDestructor(&destruct_maplEintcOintgR);
0135       instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<int,int> >()));
0136
0137       ::ROOT::AddClassAlternate("map<int,int>","std::map<int, int, std::less<int>, std::allocator<std::pair<int const, int> > >");
0138       return &instance;
0139    }
0140    // Static variable to force the class initialization
0141    static ::ROOT::TGenericClassInfo *_R__UNIQUE_DICT_(Init) = GenerateInitInstanceLocal((const map<int,int>*)nullptr); R__UseDummy(_R__UNIQUE_DICT_(Init));
0142
0143    // Dictionary for non-ClassDef classes
0144    static TClass *maplEintcOintgR_Dictionary() {
0145       TClass* theClass =::ROOT::GenerateInitInstanceLocal((const map<int,int>*)nullptr)->GetClass();
0146       maplEintcOintgR_TClassManip(theClass);
0147    return theClass;
0148    }
0149
0150    static void maplEintcOintgR_TClassManip(TClass* ){
0151    }
0152
0153 } // end of namespace ROOT
0154
0155 namespace ROOT {
0156    // Wrappers around operator new
0157    static void *new_maplEintcOintgR(void *p) {
0158       return  p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map<int,int> : new map<int,int>;
0159    }
0160    static void *newArray_maplEintcOintgR(Long_t nElements, void *p) {
0161       return p ? ::new((::ROOT::Internal::TOperatorNewHelper*)p) map<int,int>[nElements] : new map<int,int>[nElements];
0162    }
0163    // Wrapper around operator delete
0164    static void delete_maplEintcOintgR(void *p) {
0165       delete ((map<int,int>*)p);
0166    }
0167    static void deleteArray_maplEintcOintgR(void *p) {
0168       delete [] ((map<int,int>*)p);
0169    }
0170    static void destruct_maplEintcOintgR(void *p) {
0171       typedef map<int,int> current_t;
0172       ((current_t*)p)->~current_t();
0173    }
0174 } // end of namespace ROOT for class map<int,int>
0175
0176 namespace {
0177   void TriggerDictionaryInitialization_MBDStudy_Dict_Impl() {
0178     static const char* headers[] = {
0179 "0",
0180 nullptr
0181     };
0182     static const char* includePaths[] = {
0183 nullptr
0184     };
0185     static const char* fwdDeclCode = R"DICTFWDDCLS(
0186 #line 1 "MBDStudy_Dict dictionary forward declarations' payload"
0187 #pragma clang diagnostic ignored "-Wkeyword-compat"
0188 #pragma clang diagnostic ignored "-Wignored-attributes"
0189 #pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
0190 extern int __Cling_AutoLoading_Map;
0191 class MBDStudy;
0192 )DICTFWDDCLS";
0193     static const char* payloadCode = R"DICTPAYLOAD(
0194 #line 1 "MBDStudy_Dict dictionary payload"
0195
0196
0197 #define _BACKWARD_BACKWARD_WARNING_H
0198 // Inline headers
0199 #ifndef __MBDSTUDY_H__
0200 #define __MBDSTUDY_H__
0201
0202 #include <fun4all/SubsysReco.h>
0203 #include <string>
0204 #include <map>
0205 #include <TFile.h>
0206
0207 //Forward declerations
0208 class PHCompositeNode;
0209 class PHG4HitContainer;
0210 class PHG4TruthInfoContainer;
0211 class EventHeader;
0212 class MbdOut;
0213 class TFile;
0214 class TTree;
0215 class TDatabasePDG;
0216 class TRandom3;
0217 class TH1;
0218 class TH2;
0219 class TF1;
0220 class TCanvas;
0221
0222
0223 //Brief: basic ntuple and histogram creation for sim evaluation
0224 class MBDStudy: public SubsysReco
0225 {
0226 public:
0227
0228   //Default constructor
0229   MBDStudy(const std::string &name="MBDStudy");
0230
0231   //Initialization, called for initialization
0232   int Init(PHCompositeNode *);
0233
0234   //Initialization at start of every run
0235   int InitRun(PHCompositeNode *);
0236
0237   //Process Event, called for each event
0238   int process_event(PHCompositeNode *);
0239
0240   //End, write and close files
0241   int End(PHCompositeNode *);
0242
0243   //Change output filename
0244   void set_savefile(const char *f) { _savefname = f; }
0245
0246   void set_tres(const Float_t tr) { _tres = tr; }
0247
0248 private:
0249
0250   //
0251   void CheckDST(PHCompositeNode *topNode);
0252
0253   //output filename
0254   std::string _savefname;
0255   TFile* _savefile;
0256
0257   int nprocessed{0};     // num events processed
0258
0259   //Output
0260   TTree* _tree;
0261   Int_t    f_evt;
0262   Float_t  f_bimp;    // impact parameter
0263   Int_t    f_ncoll;   // number n-n collisions
0264   Int_t    f_npart;   // number participants
0265   Float_t  f_vx;      // true x vertex of collision point
0266   Float_t  f_vy;      // true y vertex
0267   Float_t  f_vz;      // true z vertex
0268   Float_t  f_vt;       // true start time
0269   Short_t  f_mbdn[2]; // num hits for each arm (north and south)
0270   Float_t  f_mbdq[2]; // total charge (currently npe) in each arm
0271   Float_t  f_mbdt[2]; // time in arm
0272   Float_t  f_mbdte[2]; // earliest hit time in arm
0273   Float_t  f_mbdz;    // z-vertex
0274   Float_t  f_mbdt0;   // start time
0275
0276   TH1* h_mbdq[128];   // q in each tube
0277   TH1* h_mbdqtot[2];  // total q in mbd arms
0278   TH2* h2_mbdqtot;    // north q vs south q
0279   TH1* h_ztrue;       // true z-vertex
0280   TH1* h_tdiff;       // time diff between estimated and real time
0281   TH2* h2_tdiff_ch;   // time diff by channel
0282
0283   TCanvas *c_mbdt;    // Canvas to
0284   TH1 *hevt_mbdt[2];  // time in each mbd, per event
0285   TF1 *gaussian;
0286
0287   std::map<int,int> _pids;  // PIDs of tracks in the MBD
0288
0289   //
0290   TDatabasePDG* _pdg;
0291   TRandom3*     _rndm;
0292   Float_t       _tres;    // time resolution of one channel
0293
0294   //Get all the nodes
0295   void GetNodes(PHCompositeNode *);
0296
0297   //Node pointers
0298   PHG4TruthInfoContainer* _truth_container;
0299   PHG4HitContainer* _mbdhits;
0300   EventHeader* _evtheader;
0301
0302 };
0303
0304 #endif //* __MBDSTUDY_H__ *//
0305
0306 #undef  _BACKWARD_BACKWARD_WARNING_H
0307 )DICTPAYLOAD";
0308     static const char* classesHeaders[] = {
0309 "MBDStudy", payloadCode, "@",
0310 nullptr
0311 };
0312     static bool isInitialized = false;
0313     if (!isInitialized) {
0314       TROOT::RegisterModule("MBDStudy_Dict",
0315         headers, includePaths, payloadCode, fwdDeclCode,
0316         TriggerDictionaryInitialization_MBDStudy_Dict_Impl, {}, classesHeaders, /*hasCxxModule*/false);
0317       isInitialized = true;
0318     }
0319   }
0320   static struct DictInit {
0321     DictInit() {
0322       TriggerDictionaryInitialization_MBDStudy_Dict_Impl();
0323     }
0324   } __TheDictionaryInitializer;
0325 }
0326 void TriggerDictionaryInitialization_MBDStudy_Dict() {
0327   TriggerDictionaryInitialization_MBDStudy_Dict_Impl();
0328 }