Index: trunk/MagicSoft/Mars/mtemp/mpisa/Changelog_pisa =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/Changelog_pisa (revision 4184) +++ trunk/MagicSoft/Mars/mtemp/mpisa/Changelog_pisa (revision 4185) @@ -18,4 +18,15 @@ -*-*- END OF LINE -*-*- + 2004/05/24: Antonio Stamerra + + * mpisa/classes/MTriggerLiveTime.[h.cc] + - added new class container for the Live-Deadtime from report files (.rep) + + * mpisa/classes/mtrigger + - added new directory for the MTrigger* classes. These + classes have been moved there. + - Various modifications have been made on these classes. + The MReportTrigger now fills these containers. + 2004/05/24: Antonio Stamerra Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/MReportTrigger.cc =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/MReportTrigger.cc (revision 4184) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/MReportTrigger.cc (revision 4185) @@ -34,6 +34,12 @@ #include "MReportTrigger.h" +#include "MParList.h" + #include "MLogManip.h" #include "MTriggerIPR.h" +#include "MTriggerCell.h" +#include "MTriggerBit.h" +#include "MTriggerPrescFact.h" +#include "MTriggerLiveTime.h" ClassImp(MReportTrigger); @@ -45,5 +51,5 @@ // Default construtor. Initialize identifier to "TRIGGER-REPORT" // -MReportTrigger::MReportTrigger() : MReport("TRIGGER-REPORT"), fPrescalerRates(19) +MReportTrigger::MReportTrigger() : MReport("TRIGGER-REPORT") { fName = "MReportTrigger"; @@ -76,4 +82,8 @@ if (!fPrescFactor) return kFALSE; + + fLiveTime = (MTriggerLiveTime*)plist.FindCreateObj("MTriggerLiveTime"); + if (!fLiveTime) + return kFALSE; return MReport::SetupReading(plist); @@ -83,7 +93,24 @@ // // Interprete the Cell rates part of the report -// -Int_t MReportTrigger::InterpreteCell(TString &str) -{ +// Read 32 floats separated with a blank +// +Bool_t MReportTrigger::InterpreteCell(TString &str) +{ + Int_t len, n, i=0; + Int_t gsNCells=32; + + const char *pos = str.Data(); + const char *end = str.Data() + gsNCells; + + while (pos < end) + { + n = sscanf(pos, " %f %n", &fCell->fCellRate[i++], &len); + if (n!=1) + { + *fLog << warn << "WARNING - Cell Scaler Value #" << i << " missing." << endl; + return kCONTINUE; + } + pos += len; + } return kTRUE; @@ -94,5 +121,5 @@ // Interprete the Bit rates part of the report // -Int_t MReportTrigger::InterpreteBit(TString &str) +Bool_t MReportTrigger::InterpreteBit(TString &str) { @@ -104,5 +131,5 @@ // Interprete the IPR part of the report // -Int_t MReportTrigger::InterpreteIPR(TString &str) +Bool_t MReportTrigger::InterpreteIPR(TString &str) { @@ -114,5 +141,5 @@ // Interprete the Prescaling factors part of the report // -Int_t MReportTrigger::InterpretePrescFact(TString &str) +Bool_t MReportTrigger::InterpretePrescFact(TString &str) { @@ -215,5 +242,7 @@ */ - str.Remove(0, pos-str.Data()); + + Int_t len=1; + str.Remove(0,len); str.Strip(TString::kBoth); Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/MReportTrigger.h =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/MReportTrigger.h (revision 4184) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/MReportTrigger.h (revision 4185) @@ -13,4 +13,6 @@ class MTriggerCell; class MTriggerBit; +class MTriggerPrescFact; +class MTriggerLiveTime; class MReportTrigger : public MReport @@ -27,7 +29,7 @@ MTriggerCell *fCell; // container of the L1 cell trigger rates MTriggerPrescFact *fPrescFactor; //container of the L2 prescaling factors + MTriggerLiveTime *fLiveTime; //container of the scaler live-deadtime Bool_t SetupReading(MParList &plist); - Bool_t CheckVersion(TString &str) const; Bool_t InterpreteIPR(TString &str); Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerBit.cc =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerBit.cc (revision 4185) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerBit.cc (revision 4185) @@ -0,0 +1,37 @@ +/* ======================================================================== *\ +! +! * +! * This file is part of MARS, the MAGIC Analysis and Reconstruction +! * Software. It is distributed to you in the hope that it can be a useful +! * and timesaving tool in analysing Data of imaging Cerenkov telescopes. +! * It is distributed WITHOUT ANY WARRANTY. +! * +! * Permission to use, copy, modify and distribute this software and its +! * documentation for any purpose is hereby granted without fee, +! * provided that the above copyright notice appear in all copies and +! * that both that copyright notice and this permission notice appear +! * in supporting documentation. It is provided "as is" without express +! * or implied warranty. +! * +! +! +! Author(s): Thomas Bretz, 11/2003 +! Antonio Stamerra, 05/2004 +! +! Copyright: MAGIC Software Development, 2000-2004 +! +! +\* ======================================================================== */ + +///////////////////////////////////////////////////////////////////////////// +// +// MTriggerBit +// This class stores the information about the L2 output Bit rates +// +// +///////////////////////////////////////////////////////////////////////////// +#include "MTriggerBit.h" + +ClassImp(MTriggerBit); + +using namespace std; Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerBit.h =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerBit.h (revision 4185) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerBit.h (revision 4185) @@ -0,0 +1,58 @@ +#ifndef MARS_MTriggerBit +#define MARS_MTriggerBit + +#ifndef MARS_MCamEvent +#include "MCamEvent.h" +#endif +#ifndef MARS_MParContainer +#include "MParContainer.h" +#endif + +#ifndef ROOT_TArrayL +#include +#endif + +class MTriggerBit : public MParContainer, public MCamEvent +{ + friend class MReportTrigger; + +private: + Byte_t fStatus; // Monitor of the L2T status + + static const Int_t gsNBits=16; // number of output bits + + TArrayL fBit; // Array with the prescaling factors + +public: + MTriggerBit() : fBit(gsNBits) + { + fName = "MTriggerBit"; + fTitle = "Container for the L2 output bits rates "; + } + + Bool_t GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type=0) const + { + if (idx > gsNBits) + return kFALSE; + + val = fBit[idx]; + + return val>0; + } + + Double_t operator[](const Int_t idx) + { + if (idx > gsNBits) + return kFALSE; + + return fBit[idx]; + } + + void DrawPixelContent(Int_t num) const + { + } + + ClassDef(MTriggerBit, 1) // Container for the L2 output bits rates +}; + +#endif Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerCell.cc =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerCell.cc (revision 4185) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerCell.cc (revision 4185) @@ -0,0 +1,37 @@ +/* ======================================================================== *\ +! +! * +! * This file is part of MARS, the MAGIC Analysis and Reconstruction +! * Software. It is distributed to you in the hope that it can be a useful +! * and timesaving tool in analysing Data of imaging Cerenkov telescopes. +! * It is distributed WITHOUT ANY WARRANTY. +! * +! * Permission to use, copy, modify and distribute this software and its +! * documentation for any purpose is hereby granted without fee, +! * provided that the above copyright notice appear in all copies and +! * that both that copyright notice and this permission notice appear +! * in supporting documentation. It is provided "as is" without express +! * or implied warranty. +! * +! +! +! Author(s): Thomas Bretz, 11/2003 +! Antonio Stamerra, 05/2004 +! +! Copyright: MAGIC Software Development, 2000-2004 +! +! +\* ======================================================================== */ + +///////////////////////////////////////////////////////////////////////////// +// +// MTriggerCell +// This class stores the information about the Trigger Cell Rates +// +// +///////////////////////////////////////////////////////////////////////////// +#include "MTriggerCell.h" + +ClassImp(MTriggerCell); + +using namespace std; Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerCell.h =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerCell.h (revision 4185) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerCell.h (revision 4185) @@ -0,0 +1,59 @@ +#ifndef MARS_MTriggerCell +#define MARS_MTriggerCell + +#ifndef MARS_MCamEvent +#include "MCamEvent.h" +#endif +#ifndef MARS_MParContainer +#include "MParContainer.h" +#endif + +#ifndef ROOT_TArrayF +#include +#endif + +class MTriggerCell : public MParContainer, public MCamEvent +{ + friend class MReportTrigger; +private: + Byte_t fStatus; // Monitor of the L2T status + + static const Int_t gsNCells=32; //Number of fields with cell rates + // 19 cells and 12 dummy + + TArrayF fCellRate; // Array of the measured L1 cell rates + +public: + MTriggerCell() : fCellRate(gsNCells) + { + fName = "MTriggerCell"; + fTitle = "Container for the measured cell rates"; + } + + Float_t GetMean() const { return fCellRate.GetSum()/fCellRate.GetSize(); } + + Bool_t GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type=0) const + { + if (idx > gsNCells) + return kFALSE; + + val = fCellRate[idx]; + return val>0; + } + + Double_t operator[](const Int_t idx) + { + if (idx > gsNCells) + return kFALSE; + + return fCellRate[idx]; + } + + void DrawPixelContent(Int_t num) const + { + } + + ClassDef(MTriggerCell, 1) // Container for the trigger cell rates +}; + +#endif Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerIPR.cc =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerIPR.cc (revision 4185) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerIPR.cc (revision 4185) @@ -0,0 +1,37 @@ +/* ======================================================================== *\ +! +! * +! * This file is part of MARS, the MAGIC Analysis and Reconstruction +! * Software. It is distributed to you in the hope that it can be a useful +! * and timesaving tool in analysing Data of imaging Cerenkov telescopes. +! * It is distributed WITHOUT ANY WARRANTY. +! * +! * Permission to use, copy, modify and distribute this software and its +! * documentation for any purpose is hereby granted without fee, +! * provided that the above copyright notice appear in all copies and +! * that both that copyright notice and this permission notice appear +! * in supporting documentation. It is provided "as is" without express +! * or implied warranty. +! * +! +! +! Author(s): Thomas Bretz, 11/2003 +! Antonio Stamerra, 05/2004 +! +! Copyright: MAGIC Software Development, 2000-2004 +! +! +\* ======================================================================== */ + +///////////////////////////////////////////////////////////////////////////// +// +// MTriggerIPR +// This class stores the information about the Individual Pixel Rates +// +// +///////////////////////////////////////////////////////////////////////////// +#include "MTriggerIPR.h" + +ClassImp(MTriggerIPR); + +using namespace std; Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerIPR.h =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerIPR.h (revision 4185) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerIPR.h (revision 4185) @@ -0,0 +1,58 @@ +#ifndef MARS_MTriggerIPR +#define MARS_MTriggerIPR + +#ifndef MARS_MCamEvent +#include "MCamEvent.h" +#endif +#ifndef MARS_MParContainer +#include "MParContainer.h" +#endif + +#ifndef ROOT_TArrayL +#include +#endif + +class MTriggerIPR : public MParContainer, public MCamEvent +{ + friend class MReportTrigger; +private: + Byte_t fStatus; // Monitor of the L2T status + + TArrayL fIPR; // [Hz] IPR (Individual Pixel Rates) + + static const Int_t gsNTrigPix=397; // number of trigger pixels + +public: + MTriggerIPR() : fIPR(gsNTrigPix) + { + fName = "MTriggerIPR"; + fTitle = "Container for the Individual Pixel Rate (IPR)"; + } + + Float_t GetMean() const { return fIPR.GetSum()/fIPR.GetSize(); } + + Bool_t GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type=0) const + { + if (idx > gsNTrigPix) + return kFALSE; + + val = fIPR[idx]; + return val>0; + } + + Double_t operator[](const Int_t idx) + { + if (idx > gsNTrigPix) + return kFALSE; + + return fIPR[idx]; + } + + void DrawPixelContent(Int_t num) const + { + } + + ClassDef(MTriggerIPR, 1) // Container for the Individual Pixel Rate (IPR) +}; + +#endif Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerLiveTime.cc =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerLiveTime.cc (revision 4185) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerLiveTime.cc (revision 4185) @@ -0,0 +1,37 @@ +/* ======================================================================== *\ +! +! * +! * This file is part of MARS, the MAGIC Analysis and Reconstruction +! * Software. It is distributed to you in the hope that it can be a useful +! * and timesaving tool in analysing Data of imaging Cerenkov telescopes. +! * It is distributed WITHOUT ANY WARRANTY. +! * +! * Permission to use, copy, modify and distribute this software and its +! * documentation for any purpose is hereby granted without fee, +! * provided that the above copyright notice appear in all copies and +! * that both that copyright notice and this permission notice appear +! * in supporting documentation. It is provided "as is" without express +! * or implied warranty. +! * +! +! +! Author(s): Thomas Bretz, 11/2003 +! Antonio Stamerra, 05/2004 +! +! Copyright: MAGIC Software Development, 2000-2004 +! +! +\* ======================================================================== */ + +///////////////////////////////////////////////////////////////////////////// +// +// MTriggerLiveTime +// This class stores the information about the livetime and deadtime +// measured by the scalers +// +///////////////////////////////////////////////////////////////////////////// +#include "MTriggerLiveTime.h" + +ClassImp(MTriggerLiveTime); + +using namespace std; Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerLiveTime.h =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerLiveTime.h (revision 4185) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerLiveTime.h (revision 4185) @@ -0,0 +1,59 @@ +#ifndef MARS_MTriggerLiveTime +#define MARS_MTriggerLiveTime + +#ifndef MARS_MCamEvent +#include "MCamEvent.h" +#endif +#ifndef MARS_MParContainer +#include "MParContainer.h" +#endif + +#ifndef ROOT_TArrayL +#include +#endif + +class MTriggerLiveTime : public MParContainer, public MCamEvent +{ + friend class MReportTrigger; + +private: + Byte_t fStatus; // Monitor of the L2T status + + static const Int_t gsNScalers=5; // number of scalers + + TArrayL fLiveTime; // Array with the livetime + TArrayL fDeadTime; // Array with the deadtime + +public: + MTriggerLiveTime() : fLiveTime(gsNScalers) + { + fName = "MTriggerLiveTime"; + fTitle = "Container for the Live-deadtime "; + } + + Bool_t GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type=0) const + { + if (idx > gsNScalers) + return kFALSE; + + val = fLiveTime[idx]; + + return val>0; + } + + Double_t operator[](const Int_t idx) + { + if (idx > gsNScalers) + return -1; + + return fLiveTime[idx]; + } + + void DrawPixelContent(Int_t num) const + { + } + + ClassDef(MTriggerLiveTime, 1) // Container for the Live-Deadtime +}; + +#endif Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerPrescFact.cc =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerPrescFact.cc (revision 4185) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerPrescFact.cc (revision 4185) @@ -0,0 +1,37 @@ +/* ======================================================================== *\ +! +! * +! * This file is part of MARS, the MAGIC Analysis and Reconstruction +! * Software. It is distributed to you in the hope that it can be a useful +! * and timesaving tool in analysing Data of imaging Cerenkov telescopes. +! * It is distributed WITHOUT ANY WARRANTY. +! * +! * Permission to use, copy, modify and distribute this software and its +! * documentation for any purpose is hereby granted without fee, +! * provided that the above copyright notice appear in all copies and +! * that both that copyright notice and this permission notice appear +! * in supporting documentation. It is provided "as is" without express +! * or implied warranty. +! * +! +! +! Author(s): Thomas Bretz, 11/2003 +! Antonio Stamerra, 05/2004 +! +! Copyright: MAGIC Software Development, 2000-2004 +! +! +\* ======================================================================== */ + +///////////////////////////////////////////////////////////////////////////// +// +// MTriggerPrescFact +// This class stores the information about the L2 prescaling factors +// +// +///////////////////////////////////////////////////////////////////////////// +#include "MTriggerPrescFact.h" + +ClassImp(MTriggerPrescFact); + +using namespace std; Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerPrescFact.h =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerPrescFact.h (revision 4185) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/MTriggerPrescFact.h (revision 4185) @@ -0,0 +1,58 @@ +#ifndef MARS_MTriggerPrescFact +#define MARS_MTriggerPrescFact + +#ifndef MARS_MCamEvent +#include "MCamEvent.h" +#endif +#ifndef MARS_MParContainer +#include "MParContainer.h" +#endif + +#ifndef ROOT_TArrayL +#include +#endif + +class MTriggerPrescFact : public MParContainer, public MCamEvent +{ + friend class MReportTrigger; + +private: + Byte_t fStatus; // Monitor of the L2T status + + static const Int_t gsNPrescFacts=8; // number of factors + + TArrayL fPrescFact; // Array with the prescaling factors + +public: + MTriggerPrescFact() : fPrescFact(gsNPrescFacts) + { + fName = "MTriggerPrescFact"; + fTitle = "Container for the L2 Prescaling Factors "; + } + + Bool_t GetPixelContent(Double_t &val, Int_t idx, const MGeomCam &cam, Int_t type=0) const + { + if (idx > gsNPrescFacts) + return kFALSE; + + val = fPrescFact[idx]; + + return val>0; + } + + Double_t operator[](const Int_t idx) + { + if (idx > gsNPrescFacts) + return kFALSE; + + return fPrescFact[idx]; + } + + void DrawPixelContent(Int_t num) const + { + } + + ClassDef(MTriggerPrescFact, 1) // Container for the L2 Prescaling Factors +}; + +#endif Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/Makefile =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/Makefile (revision 4185) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/Makefile (revision 4185) @@ -0,0 +1,35 @@ +################################################################## +# +# makefile +# +# for the MARS software +# +################################################################## +include ../Makefile.conf.$(OSTYPE) +include ../Makefile.conf.general + +#------------------------------------------------------------------------------ + +# +# Handling name of the Root Dictionary Files +# +CINT = Trigger + +# +# connect the include files defined in the config.mk file +# +INCLUDES = -I. -I../mbase -I../mgui + +SRCFILES = MTriggerIPR.cc \ + MTriggerCell.cc\ + MTriggerBit.cc\ + MTriggerPrescFact.cc\ + MTriggerLiveTime.cc + +############################################################ + +all: $(OBJS) + +include ../Makefile.rules + +mrproper: clean rmbak Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/TriggerCint.cc =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/TriggerCint.cc (revision 4185) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/TriggerCint.cc (revision 4185) @@ -0,0 +1,1914 @@ +// +// File generated by /data0/root/bin/rootcint at Tue May 25 15:55:57 2004. +// Do NOT change. Changes will be lost next time file is generated +// + +#include "RConfig.h" +#if !defined(R__ACCESS_IN_SYMBOL) +//Break the privacy of classes -- Disabled for the moment +#define private public +#define protected public +#endif + +#include "TriggerCint.h" +#include "TClass.h" +#include "TBuffer.h" +#include "TMemberInspector.h" +#include "TError.h" + +#ifndef G__ROOT +#define G__ROOT +#endif + +// Since CINT ignores the std namespace, we need to do so in this file. +namespace std {} using namespace std; + +#include "RtypesImp.h" + +namespace ROOT { + namespace Shadow { + } // Of namespace ROOT::Shadow +} // Of namespace ROOT + +namespace ROOT { + void MTriggerIPR_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent); + TClass *MTriggerIPR_IsA(const void*); + void *new_MTriggerIPR(void *p = 0); + void *newArray_MTriggerIPR(Long_t size); + void delete_MTriggerIPR(void *p); + void deleteArray_MTriggerIPR(void *p); + void destruct_MTriggerIPR(void *p); + + // Function generating the singleton type initializer + TGenericClassInfo *GenerateInitInstance(const MTriggerIPR*) + { + MTriggerIPR *ptr = 0; + static ROOT::TGenericClassInfo + instance("MTriggerIPR", MTriggerIPR::Class_Version(), "MTriggerIPR.h", 16, + typeid(MTriggerIPR), DefineBehavior(ptr, ptr), + &::MTriggerIPR::Dictionary, &MTriggerIPR_IsA, 4); + instance.SetNew(&new_MTriggerIPR); + instance.SetNewArray(&newArray_MTriggerIPR); + instance.SetDelete(&delete_MTriggerIPR); + instance.SetDeleteArray(&deleteArray_MTriggerIPR); + instance.SetDestructor(&destruct_MTriggerIPR); + return &instance; + } + // Static variable to force the class initialization + static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const MTriggerIPR*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} + +namespace ROOT { + void MTriggerCell_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent); + TClass *MTriggerCell_IsA(const void*); + void *new_MTriggerCell(void *p = 0); + void *newArray_MTriggerCell(Long_t size); + void delete_MTriggerCell(void *p); + void deleteArray_MTriggerCell(void *p); + void destruct_MTriggerCell(void *p); + + // Function generating the singleton type initializer + TGenericClassInfo *GenerateInitInstance(const MTriggerCell*) + { + MTriggerCell *ptr = 0; + static ROOT::TGenericClassInfo + instance("MTriggerCell", MTriggerCell::Class_Version(), "MTriggerCell.h", 16, + typeid(MTriggerCell), DefineBehavior(ptr, ptr), + &::MTriggerCell::Dictionary, &MTriggerCell_IsA, 4); + instance.SetNew(&new_MTriggerCell); + instance.SetNewArray(&newArray_MTriggerCell); + instance.SetDelete(&delete_MTriggerCell); + instance.SetDeleteArray(&deleteArray_MTriggerCell); + instance.SetDestructor(&destruct_MTriggerCell); + return &instance; + } + // Static variable to force the class initialization + static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const MTriggerCell*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} + +namespace ROOT { + void MTriggerBit_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent); + TClass *MTriggerBit_IsA(const void*); + void *new_MTriggerBit(void *p = 0); + void *newArray_MTriggerBit(Long_t size); + void delete_MTriggerBit(void *p); + void deleteArray_MTriggerBit(void *p); + void destruct_MTriggerBit(void *p); + + // Function generating the singleton type initializer + TGenericClassInfo *GenerateInitInstance(const MTriggerBit*) + { + MTriggerBit *ptr = 0; + static ROOT::TGenericClassInfo + instance("MTriggerBit", MTriggerBit::Class_Version(), "MTriggerBit.h", 16, + typeid(MTriggerBit), DefineBehavior(ptr, ptr), + &::MTriggerBit::Dictionary, &MTriggerBit_IsA, 4); + instance.SetNew(&new_MTriggerBit); + instance.SetNewArray(&newArray_MTriggerBit); + instance.SetDelete(&delete_MTriggerBit); + instance.SetDeleteArray(&deleteArray_MTriggerBit); + instance.SetDestructor(&destruct_MTriggerBit); + return &instance; + } + // Static variable to force the class initialization + static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const MTriggerBit*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} + +namespace ROOT { + void MTriggerPrescFact_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent); + TClass *MTriggerPrescFact_IsA(const void*); + void *new_MTriggerPrescFact(void *p = 0); + void *newArray_MTriggerPrescFact(Long_t size); + void delete_MTriggerPrescFact(void *p); + void deleteArray_MTriggerPrescFact(void *p); + void destruct_MTriggerPrescFact(void *p); + + // Function generating the singleton type initializer + TGenericClassInfo *GenerateInitInstance(const MTriggerPrescFact*) + { + MTriggerPrescFact *ptr = 0; + static ROOT::TGenericClassInfo + instance("MTriggerPrescFact", MTriggerPrescFact::Class_Version(), "MTriggerPrescFact.h", 16, + typeid(MTriggerPrescFact), DefineBehavior(ptr, ptr), + &::MTriggerPrescFact::Dictionary, &MTriggerPrescFact_IsA, 4); + instance.SetNew(&new_MTriggerPrescFact); + instance.SetNewArray(&newArray_MTriggerPrescFact); + instance.SetDelete(&delete_MTriggerPrescFact); + instance.SetDeleteArray(&deleteArray_MTriggerPrescFact); + instance.SetDestructor(&destruct_MTriggerPrescFact); + return &instance; + } + // Static variable to force the class initialization + static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const MTriggerPrescFact*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} + +namespace ROOT { + void MTriggerLiveTime_ShowMembers(void *obj, TMemberInspector &R__insp, char *R__parent); + TClass *MTriggerLiveTime_IsA(const void*); + void *new_MTriggerLiveTime(void *p = 0); + void *newArray_MTriggerLiveTime(Long_t size); + void delete_MTriggerLiveTime(void *p); + void deleteArray_MTriggerLiveTime(void *p); + void destruct_MTriggerLiveTime(void *p); + + // Function generating the singleton type initializer + TGenericClassInfo *GenerateInitInstance(const MTriggerLiveTime*) + { + MTriggerLiveTime *ptr = 0; + static ROOT::TGenericClassInfo + instance("MTriggerLiveTime", MTriggerLiveTime::Class_Version(), "MTriggerLiveTime.h", 16, + typeid(MTriggerLiveTime), DefineBehavior(ptr, ptr), + &::MTriggerLiveTime::Dictionary, &MTriggerLiveTime_IsA, 4); + instance.SetNew(&new_MTriggerLiveTime); + instance.SetNewArray(&newArray_MTriggerLiveTime); + instance.SetDelete(&delete_MTriggerLiveTime); + instance.SetDeleteArray(&deleteArray_MTriggerLiveTime); + instance.SetDestructor(&destruct_MTriggerLiveTime); + return &instance; + } + // Static variable to force the class initialization + static ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance((const MTriggerLiveTime*)0x0); R__UseDummy(_R__UNIQUE_(Init)); +} + +//______________________________________________________________________________ +TClass *MTriggerIPR::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *MTriggerIPR::Class_Name() +{ + return "MTriggerIPR"; +} + +//______________________________________________________________________________ +const char *MTriggerIPR::ImplFileName() +{ + return ROOT::GenerateInitInstance((const MTriggerIPR*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int MTriggerIPR::ImplFileLine() +{ + return ROOT::GenerateInitInstance((const MTriggerIPR*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void MTriggerIPR::Dictionary() +{ + fgIsA = ROOT::GenerateInitInstance((const MTriggerIPR*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *MTriggerIPR::Class() +{ + if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const MTriggerIPR*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +TClass *MTriggerCell::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *MTriggerCell::Class_Name() +{ + return "MTriggerCell"; +} + +//______________________________________________________________________________ +const char *MTriggerCell::ImplFileName() +{ + return ROOT::GenerateInitInstance((const MTriggerCell*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int MTriggerCell::ImplFileLine() +{ + return ROOT::GenerateInitInstance((const MTriggerCell*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void MTriggerCell::Dictionary() +{ + fgIsA = ROOT::GenerateInitInstance((const MTriggerCell*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *MTriggerCell::Class() +{ + if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const MTriggerCell*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +TClass *MTriggerBit::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *MTriggerBit::Class_Name() +{ + return "MTriggerBit"; +} + +//______________________________________________________________________________ +const char *MTriggerBit::ImplFileName() +{ + return ROOT::GenerateInitInstance((const MTriggerBit*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int MTriggerBit::ImplFileLine() +{ + return ROOT::GenerateInitInstance((const MTriggerBit*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void MTriggerBit::Dictionary() +{ + fgIsA = ROOT::GenerateInitInstance((const MTriggerBit*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *MTriggerBit::Class() +{ + if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const MTriggerBit*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +TClass *MTriggerPrescFact::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *MTriggerPrescFact::Class_Name() +{ + return "MTriggerPrescFact"; +} + +//______________________________________________________________________________ +const char *MTriggerPrescFact::ImplFileName() +{ + return ROOT::GenerateInitInstance((const MTriggerPrescFact*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int MTriggerPrescFact::ImplFileLine() +{ + return ROOT::GenerateInitInstance((const MTriggerPrescFact*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void MTriggerPrescFact::Dictionary() +{ + fgIsA = ROOT::GenerateInitInstance((const MTriggerPrescFact*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *MTriggerPrescFact::Class() +{ + if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const MTriggerPrescFact*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +TClass *MTriggerLiveTime::fgIsA = 0; // static to hold class pointer + +//______________________________________________________________________________ +const char *MTriggerLiveTime::Class_Name() +{ + return "MTriggerLiveTime"; +} + +//______________________________________________________________________________ +const char *MTriggerLiveTime::ImplFileName() +{ + return ROOT::GenerateInitInstance((const MTriggerLiveTime*)0x0)->GetImplFileName(); +} + +//______________________________________________________________________________ +int MTriggerLiveTime::ImplFileLine() +{ + return ROOT::GenerateInitInstance((const MTriggerLiveTime*)0x0)->GetImplFileLine(); +} + +//______________________________________________________________________________ +void MTriggerLiveTime::Dictionary() +{ + fgIsA = ROOT::GenerateInitInstance((const MTriggerLiveTime*)0x0)->GetClass(); +} + +//______________________________________________________________________________ +TClass *MTriggerLiveTime::Class() +{ + if (!fgIsA) fgIsA = ROOT::GenerateInitInstance((const MTriggerLiveTime*)0x0)->GetClass(); + return fgIsA; +} + +//______________________________________________________________________________ +void R__MTriggerIPR_fIPR(TBuffer &R__b, void *R__p, int) +{ + TArrayL &fIPR = *(TArrayL *)R__p; + if (R__b.IsReading()) { + fIPR.Streamer(R__b); + } else { + fIPR.Streamer(R__b); + } +} + +//______________________________________________________________________________ +void MTriggerIPR::Streamer(TBuffer &R__b) +{ + // Stream an object of class MTriggerIPR. + + if (R__b.IsReading()) { + MTriggerIPR::Class()->ReadBuffer(R__b, this); + } else { + MTriggerIPR::Class()->WriteBuffer(R__b, this); + } +} + +//______________________________________________________________________________ +void MTriggerIPR::ShowMembers(TMemberInspector &R__insp, char *R__parent) +{ + // Inspect the data members of an object of class MTriggerIPR. + + TClass *R__cl = MTriggerIPR::IsA(); + Int_t R__ncp = strlen(R__parent); + if (R__ncp || R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__parent, "fStatus", &fStatus); + R__insp.Inspect(R__cl, R__parent, "fIPR", &fIPR); + fIPR.ShowMembers(R__insp, strcat(R__parent,"fIPR.")); R__parent[R__ncp] = 0; + R__cl->SetStreamer("fIPR",R__MTriggerIPR_fIPR); + MParContainer::ShowMembers(R__insp, R__parent); + MCamEvent::ShowMembers(R__insp, R__parent); +} + +namespace ROOT { + // Return the actual TClass for the object argument + TClass *MTriggerIPR_IsA(const void *obj) { + return ((::MTriggerIPR*)obj)->IsA(); + } + // Wrappers around operator new + void *new_MTriggerIPR(void *p) { + return p ? new(p) ::MTriggerIPR : new ::MTriggerIPR; + } + void *newArray_MTriggerIPR(Long_t size) { + return new ::MTriggerIPR[size]; + } + // Wrapper around operator delete + void delete_MTriggerIPR(void *p) { + delete ((::MTriggerIPR*)p); + } + void deleteArray_MTriggerIPR(void *p) { + delete [] ((::MTriggerIPR*)p); + } + void destruct_MTriggerIPR(void *p) { + typedef ::MTriggerIPR current_t; + ((current_t*)p)->~current_t(); + } +} // end of namespace ROOT for class MTriggerIPR + +//______________________________________________________________________________ +void R__MTriggerCell_fCellRate(TBuffer &R__b, void *R__p, int) +{ + TArrayF &fCellRate = *(TArrayF *)R__p; + if (R__b.IsReading()) { + fCellRate.Streamer(R__b); + } else { + fCellRate.Streamer(R__b); + } +} + +//______________________________________________________________________________ +void MTriggerCell::Streamer(TBuffer &R__b) +{ + // Stream an object of class MTriggerCell. + + if (R__b.IsReading()) { + MTriggerCell::Class()->ReadBuffer(R__b, this); + } else { + MTriggerCell::Class()->WriteBuffer(R__b, this); + } +} + +//______________________________________________________________________________ +void MTriggerCell::ShowMembers(TMemberInspector &R__insp, char *R__parent) +{ + // Inspect the data members of an object of class MTriggerCell. + + TClass *R__cl = MTriggerCell::IsA(); + Int_t R__ncp = strlen(R__parent); + if (R__ncp || R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__parent, "fStatus", &fStatus); + R__insp.Inspect(R__cl, R__parent, "fCellRate", &fCellRate); + fCellRate.ShowMembers(R__insp, strcat(R__parent,"fCellRate.")); R__parent[R__ncp] = 0; + R__cl->SetStreamer("fCellRate",R__MTriggerCell_fCellRate); + MParContainer::ShowMembers(R__insp, R__parent); + MCamEvent::ShowMembers(R__insp, R__parent); +} + +namespace ROOT { + // Return the actual TClass for the object argument + TClass *MTriggerCell_IsA(const void *obj) { + return ((::MTriggerCell*)obj)->IsA(); + } + // Wrappers around operator new + void *new_MTriggerCell(void *p) { + return p ? new(p) ::MTriggerCell : new ::MTriggerCell; + } + void *newArray_MTriggerCell(Long_t size) { + return new ::MTriggerCell[size]; + } + // Wrapper around operator delete + void delete_MTriggerCell(void *p) { + delete ((::MTriggerCell*)p); + } + void deleteArray_MTriggerCell(void *p) { + delete [] ((::MTriggerCell*)p); + } + void destruct_MTriggerCell(void *p) { + typedef ::MTriggerCell current_t; + ((current_t*)p)->~current_t(); + } +} // end of namespace ROOT for class MTriggerCell + +//______________________________________________________________________________ +void R__MTriggerBit_fBit(TBuffer &R__b, void *R__p, int) +{ + TArrayL &fBit = *(TArrayL *)R__p; + if (R__b.IsReading()) { + fBit.Streamer(R__b); + } else { + fBit.Streamer(R__b); + } +} + +//______________________________________________________________________________ +void MTriggerBit::Streamer(TBuffer &R__b) +{ + // Stream an object of class MTriggerBit. + + if (R__b.IsReading()) { + MTriggerBit::Class()->ReadBuffer(R__b, this); + } else { + MTriggerBit::Class()->WriteBuffer(R__b, this); + } +} + +//______________________________________________________________________________ +void MTriggerBit::ShowMembers(TMemberInspector &R__insp, char *R__parent) +{ + // Inspect the data members of an object of class MTriggerBit. + + TClass *R__cl = MTriggerBit::IsA(); + Int_t R__ncp = strlen(R__parent); + if (R__ncp || R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__parent, "fStatus", &fStatus); + R__insp.Inspect(R__cl, R__parent, "fBit", &fBit); + fBit.ShowMembers(R__insp, strcat(R__parent,"fBit.")); R__parent[R__ncp] = 0; + R__cl->SetStreamer("fBit",R__MTriggerBit_fBit); + MParContainer::ShowMembers(R__insp, R__parent); + MCamEvent::ShowMembers(R__insp, R__parent); +} + +namespace ROOT { + // Return the actual TClass for the object argument + TClass *MTriggerBit_IsA(const void *obj) { + return ((::MTriggerBit*)obj)->IsA(); + } + // Wrappers around operator new + void *new_MTriggerBit(void *p) { + return p ? new(p) ::MTriggerBit : new ::MTriggerBit; + } + void *newArray_MTriggerBit(Long_t size) { + return new ::MTriggerBit[size]; + } + // Wrapper around operator delete + void delete_MTriggerBit(void *p) { + delete ((::MTriggerBit*)p); + } + void deleteArray_MTriggerBit(void *p) { + delete [] ((::MTriggerBit*)p); + } + void destruct_MTriggerBit(void *p) { + typedef ::MTriggerBit current_t; + ((current_t*)p)->~current_t(); + } +} // end of namespace ROOT for class MTriggerBit + +//______________________________________________________________________________ +void R__MTriggerPrescFact_fPrescFact(TBuffer &R__b, void *R__p, int) +{ + TArrayL &fPrescFact = *(TArrayL *)R__p; + if (R__b.IsReading()) { + fPrescFact.Streamer(R__b); + } else { + fPrescFact.Streamer(R__b); + } +} + +//______________________________________________________________________________ +void MTriggerPrescFact::Streamer(TBuffer &R__b) +{ + // Stream an object of class MTriggerPrescFact. + + if (R__b.IsReading()) { + MTriggerPrescFact::Class()->ReadBuffer(R__b, this); + } else { + MTriggerPrescFact::Class()->WriteBuffer(R__b, this); + } +} + +//______________________________________________________________________________ +void MTriggerPrescFact::ShowMembers(TMemberInspector &R__insp, char *R__parent) +{ + // Inspect the data members of an object of class MTriggerPrescFact. + + TClass *R__cl = MTriggerPrescFact::IsA(); + Int_t R__ncp = strlen(R__parent); + if (R__ncp || R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__parent, "fStatus", &fStatus); + R__insp.Inspect(R__cl, R__parent, "fPrescFact", &fPrescFact); + fPrescFact.ShowMembers(R__insp, strcat(R__parent,"fPrescFact.")); R__parent[R__ncp] = 0; + R__cl->SetStreamer("fPrescFact",R__MTriggerPrescFact_fPrescFact); + MParContainer::ShowMembers(R__insp, R__parent); + MCamEvent::ShowMembers(R__insp, R__parent); +} + +namespace ROOT { + // Return the actual TClass for the object argument + TClass *MTriggerPrescFact_IsA(const void *obj) { + return ((::MTriggerPrescFact*)obj)->IsA(); + } + // Wrappers around operator new + void *new_MTriggerPrescFact(void *p) { + return p ? new(p) ::MTriggerPrescFact : new ::MTriggerPrescFact; + } + void *newArray_MTriggerPrescFact(Long_t size) { + return new ::MTriggerPrescFact[size]; + } + // Wrapper around operator delete + void delete_MTriggerPrescFact(void *p) { + delete ((::MTriggerPrescFact*)p); + } + void deleteArray_MTriggerPrescFact(void *p) { + delete [] ((::MTriggerPrescFact*)p); + } + void destruct_MTriggerPrescFact(void *p) { + typedef ::MTriggerPrescFact current_t; + ((current_t*)p)->~current_t(); + } +} // end of namespace ROOT for class MTriggerPrescFact + +//______________________________________________________________________________ +void R__MTriggerLiveTime_fLiveTime(TBuffer &R__b, void *R__p, int) +{ + TArrayL &fLiveTime = *(TArrayL *)R__p; + if (R__b.IsReading()) { + fLiveTime.Streamer(R__b); + } else { + fLiveTime.Streamer(R__b); + } +} + +//______________________________________________________________________________ +void R__MTriggerLiveTime_fDeadTime(TBuffer &R__b, void *R__p, int) +{ + TArrayL &fDeadTime = *(TArrayL *)R__p; + if (R__b.IsReading()) { + fDeadTime.Streamer(R__b); + } else { + fDeadTime.Streamer(R__b); + } +} + +//______________________________________________________________________________ +void MTriggerLiveTime::Streamer(TBuffer &R__b) +{ + // Stream an object of class MTriggerLiveTime. + + if (R__b.IsReading()) { + MTriggerLiveTime::Class()->ReadBuffer(R__b, this); + } else { + MTriggerLiveTime::Class()->WriteBuffer(R__b, this); + } +} + +//______________________________________________________________________________ +void MTriggerLiveTime::ShowMembers(TMemberInspector &R__insp, char *R__parent) +{ + // Inspect the data members of an object of class MTriggerLiveTime. + + TClass *R__cl = MTriggerLiveTime::IsA(); + Int_t R__ncp = strlen(R__parent); + if (R__ncp || R__cl || R__insp.IsA()) { } + R__insp.Inspect(R__cl, R__parent, "fStatus", &fStatus); + R__insp.Inspect(R__cl, R__parent, "fLiveTime", &fLiveTime); + fLiveTime.ShowMembers(R__insp, strcat(R__parent,"fLiveTime.")); R__parent[R__ncp] = 0; + R__cl->SetStreamer("fLiveTime",R__MTriggerLiveTime_fLiveTime); + R__insp.Inspect(R__cl, R__parent, "fDeadTime", &fDeadTime); + fDeadTime.ShowMembers(R__insp, strcat(R__parent,"fDeadTime.")); R__parent[R__ncp] = 0; + R__cl->SetStreamer("fDeadTime",R__MTriggerLiveTime_fDeadTime); + MParContainer::ShowMembers(R__insp, R__parent); + MCamEvent::ShowMembers(R__insp, R__parent); +} + +namespace ROOT { + // Return the actual TClass for the object argument + TClass *MTriggerLiveTime_IsA(const void *obj) { + return ((::MTriggerLiveTime*)obj)->IsA(); + } + // Wrappers around operator new + void *new_MTriggerLiveTime(void *p) { + return p ? new(p) ::MTriggerLiveTime : new ::MTriggerLiveTime; + } + void *newArray_MTriggerLiveTime(Long_t size) { + return new ::MTriggerLiveTime[size]; + } + // Wrapper around operator delete + void delete_MTriggerLiveTime(void *p) { + delete ((::MTriggerLiveTime*)p); + } + void deleteArray_MTriggerLiveTime(void *p) { + delete [] ((::MTriggerLiveTime*)p); + } + void destruct_MTriggerLiveTime(void *p) { + typedef ::MTriggerLiveTime current_t; + ((current_t*)p)->~current_t(); + } +} // end of namespace ROOT for class MTriggerLiveTime + +/******************************************************** +* TriggerCint.cc +********************************************************/ + +#ifdef G__MEMTEST +#undef malloc +#undef free +#endif + +extern "C" void G__cpp_reset_tagtableTriggerCint(); + +extern "C" void G__set_cpp_environmentTriggerCint() { + G__add_compiledheader("TROOT.h"); + G__add_compiledheader("TMemberInspector.h"); + G__add_compiledheader("MTriggerIPR.h"); + G__add_compiledheader("MTriggerCell.h"); + G__add_compiledheader("MTriggerBit.h"); + G__add_compiledheader("MTriggerPrescFact.h"); + G__add_compiledheader("MTriggerLiveTime.h"); + G__add_compiledheader("TriggerIncl.h"); + G__cpp_reset_tagtableTriggerCint(); +} +class G__TriggerCintdOcc_tag {}; + +void* operator new(size_t size,G__TriggerCintdOcc_tag* p) { + if(p && G__PVOID!=G__getgvp()) return((void*)p); +#ifndef G__ROOT + return(malloc(size)); +#else + return(::operator new(size)); +#endif +} + +/* dummy, for exception */ +#ifdef G__EH_DUMMY_DELETE +void operator delete(void *p,G__TriggerCintdOcc_tag* x) { + if((long)p==G__getgvp() && G__PVOID!=G__getgvp()) return; +#ifndef G__ROOT + free(p); +#else + ::operator delete(p); +#endif +} +#endif + +static void G__operator_delete(void *p) { + if((long)p==G__getgvp() && G__PVOID!=G__getgvp()) return; +#ifndef G__ROOT + free(p); +#else + ::operator delete(p); +#endif +} + +void G__DELDMY_TriggerCintdOcc() { G__operator_delete(0); } + +extern "C" int G__cpp_dllrevTriggerCint() { return(30051515); } + +/********************************************************* +* Member function Interface Method +*********************************************************/ + +/* MTriggerIPR */ +static int G__TriggerCint_123_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + MTriggerIPR *p=NULL; + if(G__getaryconstruct()) p=new MTriggerIPR[G__getaryconstruct()]; + else p=new MTriggerIPR; + result7->obj.i = (long)p; + result7->ref = (long)p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__TriggerCintLN_MTriggerIPR); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_123_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MTriggerIPR*)(G__getstructoffset()))->GetMean()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_123_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + switch(libp->paran) { + case 4: + G__letint(result7,103,(long)((const MTriggerIPR*)(G__getstructoffset()))->GetPixelContent(*(Double_t*)G__Doubleref(&libp->para[0]),(Int_t)G__int(libp->para[1]) +,*(MGeomCam*)libp->para[2].ref,(Int_t)G__int(libp->para[3]))); + break; + case 3: + G__letint(result7,103,(long)((const MTriggerIPR*)(G__getstructoffset()))->GetPixelContent(*(Double_t*)G__Doubleref(&libp->para[0]),(Int_t)G__int(libp->para[1]) +,*(MGeomCam*)libp->para[2].ref)); + break; + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_123_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,100,(double)((MTriggerIPR*)(G__getstructoffset()))->operator[]((const Int_t)G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_123_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((const MTriggerIPR*)(G__getstructoffset()))->DrawPixelContent((Int_t)G__int(libp->para[0])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_123_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,85,(long)MTriggerIPR::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_123_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MTriggerIPR::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_123_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,115,(long)MTriggerIPR::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_123_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + MTriggerIPR::Dictionary(); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_123_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,85,(long)((const MTriggerIPR*)(G__getstructoffset()))->IsA()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_123_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MTriggerIPR*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_123_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MTriggerIPR*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_123_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MTriggerIPR*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_123_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MTriggerIPR::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_123_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,105,(long)MTriggerIPR::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_123_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MTriggerIPR::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_123_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,105,(long)MTriggerIPR::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic copy constructor +static int G__TriggerCint_123_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) +{ + MTriggerIPR *p; + p=new MTriggerIPR(*(MTriggerIPR*)G__int(libp->para[0])); + result7->obj.i = (long)p; + result7->ref = (long)p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__TriggerCintLN_MTriggerIPR); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef MTriggerIPR G__TMTriggerIPR; +static int G__TriggerCint_123_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + if(0==G__getstructoffset()) return(1); + if(G__getaryconstruct()) + if(G__PVOID==G__getgvp()) + delete[] (MTriggerIPR *)(G__getstructoffset()); + else + for(int i=G__getaryconstruct()-1;i>=0;i--) + delete (MTriggerIPR *)((G__getstructoffset())+sizeof(MTriggerIPR)*i); + else delete (MTriggerIPR *)(G__getstructoffset()); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* MTriggerCell */ +static int G__TriggerCint_126_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + MTriggerCell *p=NULL; + if(G__getaryconstruct()) p=new MTriggerCell[G__getaryconstruct()]; + else p=new MTriggerCell; + result7->obj.i = (long)p; + result7->ref = (long)p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__TriggerCintLN_MTriggerCell); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_126_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,102,(double)((const MTriggerCell*)(G__getstructoffset()))->GetMean()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_126_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + switch(libp->paran) { + case 4: + G__letint(result7,103,(long)((const MTriggerCell*)(G__getstructoffset()))->GetPixelContent(*(Double_t*)G__Doubleref(&libp->para[0]),(Int_t)G__int(libp->para[1]) +,*(MGeomCam*)libp->para[2].ref,(Int_t)G__int(libp->para[3]))); + break; + case 3: + G__letint(result7,103,(long)((const MTriggerCell*)(G__getstructoffset()))->GetPixelContent(*(Double_t*)G__Doubleref(&libp->para[0]),(Int_t)G__int(libp->para[1]) +,*(MGeomCam*)libp->para[2].ref)); + break; + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_126_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,100,(double)((MTriggerCell*)(G__getstructoffset()))->operator[]((const Int_t)G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_126_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((const MTriggerCell*)(G__getstructoffset()))->DrawPixelContent((Int_t)G__int(libp->para[0])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_126_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,85,(long)MTriggerCell::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_126_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MTriggerCell::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_126_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,115,(long)MTriggerCell::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_126_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + MTriggerCell::Dictionary(); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_126_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,85,(long)((const MTriggerCell*)(G__getstructoffset()))->IsA()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_126_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MTriggerCell*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_126_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MTriggerCell*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_126_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MTriggerCell*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_126_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MTriggerCell::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_126_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,105,(long)MTriggerCell::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_126_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MTriggerCell::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_126_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,105,(long)MTriggerCell::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic copy constructor +static int G__TriggerCint_126_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) +{ + MTriggerCell *p; + p=new MTriggerCell(*(MTriggerCell*)G__int(libp->para[0])); + result7->obj.i = (long)p; + result7->ref = (long)p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__TriggerCintLN_MTriggerCell); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef MTriggerCell G__TMTriggerCell; +static int G__TriggerCint_126_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + if(0==G__getstructoffset()) return(1); + if(G__getaryconstruct()) + if(G__PVOID==G__getgvp()) + delete[] (MTriggerCell *)(G__getstructoffset()); + else + for(int i=G__getaryconstruct()-1;i>=0;i--) + delete (MTriggerCell *)((G__getstructoffset())+sizeof(MTriggerCell)*i); + else delete (MTriggerCell *)(G__getstructoffset()); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* MTriggerBit */ +static int G__TriggerCint_127_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + MTriggerBit *p=NULL; + if(G__getaryconstruct()) p=new MTriggerBit[G__getaryconstruct()]; + else p=new MTriggerBit; + result7->obj.i = (long)p; + result7->ref = (long)p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__TriggerCintLN_MTriggerBit); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_127_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + switch(libp->paran) { + case 4: + G__letint(result7,103,(long)((const MTriggerBit*)(G__getstructoffset()))->GetPixelContent(*(Double_t*)G__Doubleref(&libp->para[0]),(Int_t)G__int(libp->para[1]) +,*(MGeomCam*)libp->para[2].ref,(Int_t)G__int(libp->para[3]))); + break; + case 3: + G__letint(result7,103,(long)((const MTriggerBit*)(G__getstructoffset()))->GetPixelContent(*(Double_t*)G__Doubleref(&libp->para[0]),(Int_t)G__int(libp->para[1]) +,*(MGeomCam*)libp->para[2].ref)); + break; + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_127_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,100,(double)((MTriggerBit*)(G__getstructoffset()))->operator[]((const Int_t)G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_127_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((const MTriggerBit*)(G__getstructoffset()))->DrawPixelContent((Int_t)G__int(libp->para[0])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_127_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,85,(long)MTriggerBit::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_127_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MTriggerBit::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_127_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,115,(long)MTriggerBit::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_127_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + MTriggerBit::Dictionary(); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_127_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,85,(long)((const MTriggerBit*)(G__getstructoffset()))->IsA()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_127_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MTriggerBit*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_127_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MTriggerBit*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_127_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MTriggerBit*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_127_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MTriggerBit::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_127_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,105,(long)MTriggerBit::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_127_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MTriggerBit::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_127_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,105,(long)MTriggerBit::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic copy constructor +static int G__TriggerCint_127_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) +{ + MTriggerBit *p; + p=new MTriggerBit(*(MTriggerBit*)G__int(libp->para[0])); + result7->obj.i = (long)p; + result7->ref = (long)p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__TriggerCintLN_MTriggerBit); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef MTriggerBit G__TMTriggerBit; +static int G__TriggerCint_127_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + if(0==G__getstructoffset()) return(1); + if(G__getaryconstruct()) + if(G__PVOID==G__getgvp()) + delete[] (MTriggerBit *)(G__getstructoffset()); + else + for(int i=G__getaryconstruct()-1;i>=0;i--) + delete (MTriggerBit *)((G__getstructoffset())+sizeof(MTriggerBit)*i); + else delete (MTriggerBit *)(G__getstructoffset()); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* MTriggerPrescFact */ +static int G__TriggerCint_128_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + MTriggerPrescFact *p=NULL; + if(G__getaryconstruct()) p=new MTriggerPrescFact[G__getaryconstruct()]; + else p=new MTriggerPrescFact; + result7->obj.i = (long)p; + result7->ref = (long)p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__TriggerCintLN_MTriggerPrescFact); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_128_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + switch(libp->paran) { + case 4: + G__letint(result7,103,(long)((const MTriggerPrescFact*)(G__getstructoffset()))->GetPixelContent(*(Double_t*)G__Doubleref(&libp->para[0]),(Int_t)G__int(libp->para[1]) +,*(MGeomCam*)libp->para[2].ref,(Int_t)G__int(libp->para[3]))); + break; + case 3: + G__letint(result7,103,(long)((const MTriggerPrescFact*)(G__getstructoffset()))->GetPixelContent(*(Double_t*)G__Doubleref(&libp->para[0]),(Int_t)G__int(libp->para[1]) +,*(MGeomCam*)libp->para[2].ref)); + break; + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_128_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,100,(double)((MTriggerPrescFact*)(G__getstructoffset()))->operator[]((const Int_t)G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_128_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((const MTriggerPrescFact*)(G__getstructoffset()))->DrawPixelContent((Int_t)G__int(libp->para[0])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_128_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,85,(long)MTriggerPrescFact::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_128_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MTriggerPrescFact::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_128_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,115,(long)MTriggerPrescFact::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_128_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + MTriggerPrescFact::Dictionary(); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_128_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,85,(long)((const MTriggerPrescFact*)(G__getstructoffset()))->IsA()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_128_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MTriggerPrescFact*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_128_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MTriggerPrescFact*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_128_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MTriggerPrescFact*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_128_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MTriggerPrescFact::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_128_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,105,(long)MTriggerPrescFact::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_128_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MTriggerPrescFact::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_128_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,105,(long)MTriggerPrescFact::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic copy constructor +static int G__TriggerCint_128_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) +{ + MTriggerPrescFact *p; + p=new MTriggerPrescFact(*(MTriggerPrescFact*)G__int(libp->para[0])); + result7->obj.i = (long)p; + result7->ref = (long)p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__TriggerCintLN_MTriggerPrescFact); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef MTriggerPrescFact G__TMTriggerPrescFact; +static int G__TriggerCint_128_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + if(0==G__getstructoffset()) return(1); + if(G__getaryconstruct()) + if(G__PVOID==G__getgvp()) + delete[] (MTriggerPrescFact *)(G__getstructoffset()); + else + for(int i=G__getaryconstruct()-1;i>=0;i--) + delete (MTriggerPrescFact *)((G__getstructoffset())+sizeof(MTriggerPrescFact)*i); + else delete (MTriggerPrescFact *)(G__getstructoffset()); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* MTriggerLiveTime */ +static int G__TriggerCint_129_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + MTriggerLiveTime *p=NULL; + if(G__getaryconstruct()) p=new MTriggerLiveTime[G__getaryconstruct()]; + else p=new MTriggerLiveTime; + result7->obj.i = (long)p; + result7->ref = (long)p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__TriggerCintLN_MTriggerLiveTime); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_129_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + switch(libp->paran) { + case 4: + G__letint(result7,103,(long)((const MTriggerLiveTime*)(G__getstructoffset()))->GetPixelContent(*(Double_t*)G__Doubleref(&libp->para[0]),(Int_t)G__int(libp->para[1]) +,*(MGeomCam*)libp->para[2].ref,(Int_t)G__int(libp->para[3]))); + break; + case 3: + G__letint(result7,103,(long)((const MTriggerLiveTime*)(G__getstructoffset()))->GetPixelContent(*(Double_t*)G__Doubleref(&libp->para[0]),(Int_t)G__int(libp->para[1]) +,*(MGeomCam*)libp->para[2].ref)); + break; + } + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_129_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letdouble(result7,100,(double)((MTriggerLiveTime*)(G__getstructoffset()))->operator[]((const Int_t)G__int(libp->para[0]))); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_129_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((const MTriggerLiveTime*)(G__getstructoffset()))->DrawPixelContent((Int_t)G__int(libp->para[0])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_129_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,85,(long)MTriggerLiveTime::Class()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_129_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MTriggerLiveTime::Class_Name()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_129_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,115,(long)MTriggerLiveTime::Class_Version()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_129_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + MTriggerLiveTime::Dictionary(); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_129_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,85,(long)((const MTriggerLiveTime*)(G__getstructoffset()))->IsA()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_129_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MTriggerLiveTime*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1])); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_129_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MTriggerLiveTime*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_129_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__setnull(result7); + ((MTriggerLiveTime*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_129_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MTriggerLiveTime::DeclFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_129_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,105,(long)MTriggerLiveTime::ImplFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_129_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,67,(long)MTriggerLiveTime::ImplFileName()); + return(1 || funcname || hash || result7 || libp) ; +} + +static int G__TriggerCint_129_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + G__letint(result7,105,(long)MTriggerLiveTime::DeclFileLine()); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic copy constructor +static int G__TriggerCint_129_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) +{ + MTriggerLiveTime *p; + p=new MTriggerLiveTime(*(MTriggerLiveTime*)G__int(libp->para[0])); + result7->obj.i = (long)p; + result7->ref = (long)p; + result7->type = 'u'; + result7->tagnum = G__get_linked_tagnum(&G__TriggerCintLN_MTriggerLiveTime); + return(1 || funcname || hash || result7 || libp) ; +} + +// automatic destructor +typedef MTriggerLiveTime G__TMTriggerLiveTime; +static int G__TriggerCint_129_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) { + if(0==G__getstructoffset()) return(1); + if(G__getaryconstruct()) + if(G__PVOID==G__getgvp()) + delete[] (MTriggerLiveTime *)(G__getstructoffset()); + else + for(int i=G__getaryconstruct()-1;i>=0;i--) + delete (MTriggerLiveTime *)((G__getstructoffset())+sizeof(MTriggerLiveTime)*i); + else delete (MTriggerLiveTime *)(G__getstructoffset()); + G__setnull(result7); + return(1 || funcname || hash || result7 || libp) ; +} + + +/* Setting up global function */ + +/********************************************************* +* Member function Stub +*********************************************************/ + +/* MTriggerIPR */ + +/* MTriggerCell */ + +/* MTriggerBit */ + +/* MTriggerPrescFact */ + +/* MTriggerLiveTime */ + +/********************************************************* +* Global function Stub +*********************************************************/ + +/********************************************************* +* Get size of pointer to member function +*********************************************************/ +class G__Sizep2memfuncTriggerCint { + public: + G__Sizep2memfuncTriggerCint() {p=&G__Sizep2memfuncTriggerCint::sizep2memfunc;} + size_t sizep2memfunc() { return(sizeof(p)); } + private: + size_t (G__Sizep2memfuncTriggerCint::*p)(); +}; + +size_t G__get_sizep2memfuncTriggerCint() +{ + G__Sizep2memfuncTriggerCint a; + G__setsizep2memfunc((int)a.sizep2memfunc()); + return((size_t)a.sizep2memfunc()); +} + + +/********************************************************* +* virtual base class offset calculation interface +*********************************************************/ + + /* Setting up class inheritance */ + +/********************************************************* +* Inheritance information setup/ +*********************************************************/ +extern "C" void G__cpp_setup_inheritanceTriggerCint() { + + /* Setting up class inheritance */ + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerIPR))) { + MTriggerIPR *G__Lderived; + G__Lderived=(MTriggerIPR*)0x1000; + { + MParContainer *G__Lpbase=(MParContainer*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerIPR),G__get_linked_tagnum(&G__TriggerCintLN_MParContainer),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerIPR),G__get_linked_tagnum(&G__TriggerCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + MCamEvent *G__Lpbase=(MCamEvent*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerIPR),G__get_linked_tagnum(&G__TriggerCintLN_MCamEvent),(long)G__Lpbase-(long)G__Lderived,1,1); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerCell))) { + MTriggerCell *G__Lderived; + G__Lderived=(MTriggerCell*)0x1000; + { + MParContainer *G__Lpbase=(MParContainer*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerCell),G__get_linked_tagnum(&G__TriggerCintLN_MParContainer),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerCell),G__get_linked_tagnum(&G__TriggerCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + MCamEvent *G__Lpbase=(MCamEvent*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerCell),G__get_linked_tagnum(&G__TriggerCintLN_MCamEvent),(long)G__Lpbase-(long)G__Lderived,1,1); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerBit))) { + MTriggerBit *G__Lderived; + G__Lderived=(MTriggerBit*)0x1000; + { + MParContainer *G__Lpbase=(MParContainer*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerBit),G__get_linked_tagnum(&G__TriggerCintLN_MParContainer),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerBit),G__get_linked_tagnum(&G__TriggerCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + MCamEvent *G__Lpbase=(MCamEvent*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerBit),G__get_linked_tagnum(&G__TriggerCintLN_MCamEvent),(long)G__Lpbase-(long)G__Lderived,1,1); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerPrescFact))) { + MTriggerPrescFact *G__Lderived; + G__Lderived=(MTriggerPrescFact*)0x1000; + { + MParContainer *G__Lpbase=(MParContainer*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerPrescFact),G__get_linked_tagnum(&G__TriggerCintLN_MParContainer),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerPrescFact),G__get_linked_tagnum(&G__TriggerCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + MCamEvent *G__Lpbase=(MCamEvent*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerPrescFact),G__get_linked_tagnum(&G__TriggerCintLN_MCamEvent),(long)G__Lpbase-(long)G__Lderived,1,1); + } + } + if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerLiveTime))) { + MTriggerLiveTime *G__Lderived; + G__Lderived=(MTriggerLiveTime*)0x1000; + { + MParContainer *G__Lpbase=(MParContainer*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerLiveTime),G__get_linked_tagnum(&G__TriggerCintLN_MParContainer),(long)G__Lpbase-(long)G__Lderived,1,1); + } + { + TObject *G__Lpbase=(TObject*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerLiveTime),G__get_linked_tagnum(&G__TriggerCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0); + } + { + MCamEvent *G__Lpbase=(MCamEvent*)G__Lderived; + G__inheritance_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerLiveTime),G__get_linked_tagnum(&G__TriggerCintLN_MCamEvent),(long)G__Lpbase-(long)G__Lderived,1,1); + } + } +} + +/********************************************************* +* typedef information setup/ +*********************************************************/ +extern "C" void G__cpp_setup_typetableTriggerCint() { + + /* Setting up typedef entry */ + G__search_typename2("Int_t",105,-1,0, +-1); + G__setnewtype(-1,"Signed integer 4 bytes (int)",0); + G__search_typename2("Float_t",102,-1,0, +-1); + G__setnewtype(-1,"Float 4 bytes (float)",0); + G__search_typename2("Double_t",100,-1,0, +-1); + G__setnewtype(-1,"Float 8 bytes (double)",0); + G__search_typename2("Bool_t",103,-1,0, +-1); + G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0); + G__search_typename2("Version_t",115,-1,0, +-1); + G__setnewtype(-1,"Class version identifier (short)",0); +} + +/********************************************************* +* Data Member information setup/ +*********************************************************/ + + /* Setting up class,struct,union tag member variable */ + + /* MTriggerIPR */ +static void G__setup_memvarMTriggerIPR(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerIPR)); + { MTriggerIPR *p; p=(MTriggerIPR*)0x1000; if (p) { } + G__memvar_setup((void*)NULL,98,0,0,-1,G__defined_typename("Byte_t"),-1,4,"fStatus=",0,"Monitor of the L2T status"); + G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TriggerCintLN_TArrayL),-1,-1,4,"fIPR=",0,"[Hz] IPR (Individual Pixel Rates)"); + G__memvar_setup((void*)NULL,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"gsNTrigPix=",0,"number of trigger pixels"); + G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TriggerCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + + + /* MTriggerCell */ +static void G__setup_memvarMTriggerCell(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerCell)); + { MTriggerCell *p; p=(MTriggerCell*)0x1000; if (p) { } + G__memvar_setup((void*)NULL,98,0,0,-1,G__defined_typename("Byte_t"),-1,4,"fStatus=",0,"Monitor of the L2T status"); + G__memvar_setup((void*)NULL,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"gsNCells=",0,"Number of fields with cell rates"); + G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TriggerCintLN_TArrayF),-1,-1,4,"fCellRate=",0,"Array of the measured L1 cell rates"); + G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TriggerCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + + + /* MTriggerBit */ +static void G__setup_memvarMTriggerBit(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerBit)); + { MTriggerBit *p; p=(MTriggerBit*)0x1000; if (p) { } + G__memvar_setup((void*)NULL,98,0,0,-1,G__defined_typename("Byte_t"),-1,4,"fStatus=",0,"Monitor of the L2T status"); + G__memvar_setup((void*)NULL,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"gsNBits=",0,"number of output bits"); + G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TriggerCintLN_TArrayL),-1,-1,4,"fBit=",0,"Array with the prescaling factors"); + G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TriggerCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + + + /* MTriggerPrescFact */ +static void G__setup_memvarMTriggerPrescFact(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerPrescFact)); + { MTriggerPrescFact *p; p=(MTriggerPrescFact*)0x1000; if (p) { } + G__memvar_setup((void*)NULL,98,0,0,-1,G__defined_typename("Byte_t"),-1,4,"fStatus=",0,"Monitor of the L2T status"); + G__memvar_setup((void*)NULL,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"gsNPrescFacts=",0,"number of factors"); + G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TriggerCintLN_TArrayL),-1,-1,4,"fPrescFact=",0,"Array with the prescaling factors"); + G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TriggerCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + + + /* MTriggerLiveTime */ +static void G__setup_memvarMTriggerLiveTime(void) { + G__tag_memvar_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerLiveTime)); + { MTriggerLiveTime *p; p=(MTriggerLiveTime*)0x1000; if (p) { } + G__memvar_setup((void*)NULL,98,0,0,-1,G__defined_typename("Byte_t"),-1,4,"fStatus=",0,"Monitor of the L2T status"); + G__memvar_setup((void*)NULL,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"gsNScalers=",0,"number of scalers"); + G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TriggerCintLN_TArrayL),-1,-1,4,"fLiveTime=",0,"Array with the livetime"); + G__memvar_setup((void*)NULL,117,0,0,G__get_linked_tagnum(&G__TriggerCintLN_TArrayL),-1,-1,4,"fDeadTime=",0,"Array with the deadtime"); + G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__TriggerCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL); + } + G__tag_memvar_reset(); +} + +extern "C" void G__cpp_setup_memvarTriggerCint() { +} +/*********************************************************** +************************************************************ +************************************************************ +************************************************************ +************************************************************ +************************************************************ +************************************************************ +***********************************************************/ + +/********************************************************* +* Member function information setup for each class +*********************************************************/ +static void G__setup_memfuncMTriggerIPR(void) { + /* MTriggerIPR */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerIPR)); + G__memfunc_setup("MTriggerIPR",1036,G__TriggerCint_123_0_0,105,G__get_linked_tagnum(&G__TriggerCintLN_MTriggerIPR),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetMean",673,G__TriggerCint_123_1_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetPixelContent",1533,G__TriggerCint_123_2_0,103,-1,G__defined_typename("Bool_t"),0,4,1,1,8, +"d - 'Double_t' 1 - val i - 'Int_t' 0 - idx " +"u 'MGeomCam' - 11 - cam i - 'Int_t' 0 0 type",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("operator[]",1060,G__TriggerCint_123_3_0,100,-1,G__defined_typename("Double_t"),0,1,1,1,0,"i - 'Int_t' 10 - idx",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DrawPixelContent",1643,G__TriggerCint_123_4_0,121,-1,-1,0,1,1,1,8,"i - 'Int_t' 0 - num",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("Class",502,G__TriggerCint_123_5_0,85,G__get_linked_tagnum(&G__TriggerCintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Class_Name",982,G__TriggerCint_123_6_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Class_Version",1339,G__TriggerCint_123_7_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Dictionary",1046,G__TriggerCint_123_8_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("IsA",253,G__TriggerCint_123_9_0,85,G__get_linked_tagnum(&G__TriggerCintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("ShowMembers",1132,G__TriggerCint_123_0_1,121,-1,-1,0,2,1,1,0, +"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("Streamer",835,G__TriggerCint_123_1_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("StreamerNVirtual",1656,G__TriggerCint_123_2_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DeclFileName",1145,G__TriggerCint_123_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("ImplFileLine",1178,G__TriggerCint_123_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("ImplFileName",1171,G__TriggerCint_123_5_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DeclFileLine",1152,G__TriggerCint_123_6_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + // automatic copy constructor + G__memfunc_setup("MTriggerIPR",1036,G__TriggerCint_123_7_1,(int)('i'),G__get_linked_tagnum(&G__TriggerCintLN_MTriggerIPR),-1,0,1,1,1,0,"u 'MTriggerIPR' - 11 - -",(char*)NULL,(void*)NULL,0); + // automatic destructor + G__memfunc_setup("~MTriggerIPR",1162,G__TriggerCint_123_8_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncMTriggerCell(void) { + /* MTriggerCell */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerCell)); + G__memfunc_setup("MTriggerCell",1185,G__TriggerCint_126_0_0,105,G__get_linked_tagnum(&G__TriggerCintLN_MTriggerCell),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetMean",673,G__TriggerCint_126_1_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetPixelContent",1533,G__TriggerCint_126_2_0,103,-1,G__defined_typename("Bool_t"),0,4,1,1,8, +"d - 'Double_t' 1 - val i - 'Int_t' 0 - idx " +"u 'MGeomCam' - 11 - cam i - 'Int_t' 0 0 type",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("operator[]",1060,G__TriggerCint_126_3_0,100,-1,G__defined_typename("Double_t"),0,1,1,1,0,"i - 'Int_t' 10 - idx",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DrawPixelContent",1643,G__TriggerCint_126_4_0,121,-1,-1,0,1,1,1,8,"i - 'Int_t' 0 - num",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("Class",502,G__TriggerCint_126_5_0,85,G__get_linked_tagnum(&G__TriggerCintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Class_Name",982,G__TriggerCint_126_6_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Class_Version",1339,G__TriggerCint_126_7_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Dictionary",1046,G__TriggerCint_126_8_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("IsA",253,G__TriggerCint_126_9_0,85,G__get_linked_tagnum(&G__TriggerCintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("ShowMembers",1132,G__TriggerCint_126_0_1,121,-1,-1,0,2,1,1,0, +"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("Streamer",835,G__TriggerCint_126_1_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("StreamerNVirtual",1656,G__TriggerCint_126_2_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DeclFileName",1145,G__TriggerCint_126_3_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("ImplFileLine",1178,G__TriggerCint_126_4_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("ImplFileName",1171,G__TriggerCint_126_5_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DeclFileLine",1152,G__TriggerCint_126_6_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + // automatic copy constructor + G__memfunc_setup("MTriggerCell",1185,G__TriggerCint_126_7_1,(int)('i'),G__get_linked_tagnum(&G__TriggerCintLN_MTriggerCell),-1,0,1,1,1,0,"u 'MTriggerCell' - 11 - -",(char*)NULL,(void*)NULL,0); + // automatic destructor + G__memfunc_setup("~MTriggerCell",1311,G__TriggerCint_126_8_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncMTriggerBit(void) { + /* MTriggerBit */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerBit)); + G__memfunc_setup("MTriggerBit",1088,G__TriggerCint_127_0_0,105,G__get_linked_tagnum(&G__TriggerCintLN_MTriggerBit),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetPixelContent",1533,G__TriggerCint_127_1_0,103,-1,G__defined_typename("Bool_t"),0,4,1,1,8, +"d - 'Double_t' 1 - val i - 'Int_t' 0 - idx " +"u 'MGeomCam' - 11 - cam i - 'Int_t' 0 0 type",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("operator[]",1060,G__TriggerCint_127_2_0,100,-1,G__defined_typename("Double_t"),0,1,1,1,0,"i - 'Int_t' 10 - idx",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DrawPixelContent",1643,G__TriggerCint_127_3_0,121,-1,-1,0,1,1,1,8,"i - 'Int_t' 0 - num",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("Class",502,G__TriggerCint_127_4_0,85,G__get_linked_tagnum(&G__TriggerCintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Class_Name",982,G__TriggerCint_127_5_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Class_Version",1339,G__TriggerCint_127_6_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Dictionary",1046,G__TriggerCint_127_7_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("IsA",253,G__TriggerCint_127_8_0,85,G__get_linked_tagnum(&G__TriggerCintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("ShowMembers",1132,G__TriggerCint_127_9_0,121,-1,-1,0,2,1,1,0, +"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("Streamer",835,G__TriggerCint_127_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("StreamerNVirtual",1656,G__TriggerCint_127_1_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DeclFileName",1145,G__TriggerCint_127_2_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("ImplFileLine",1178,G__TriggerCint_127_3_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("ImplFileName",1171,G__TriggerCint_127_4_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DeclFileLine",1152,G__TriggerCint_127_5_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + // automatic copy constructor + G__memfunc_setup("MTriggerBit",1088,G__TriggerCint_127_6_1,(int)('i'),G__get_linked_tagnum(&G__TriggerCintLN_MTriggerBit),-1,0,1,1,1,0,"u 'MTriggerBit' - 11 - -",(char*)NULL,(void*)NULL,0); + // automatic destructor + G__memfunc_setup("~MTriggerBit",1214,G__TriggerCint_127_7_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncMTriggerPrescFact(void) { + /* MTriggerPrescFact */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerPrescFact)); + G__memfunc_setup("MTriggerPrescFact",1692,G__TriggerCint_128_0_0,105,G__get_linked_tagnum(&G__TriggerCintLN_MTriggerPrescFact),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetPixelContent",1533,G__TriggerCint_128_1_0,103,-1,G__defined_typename("Bool_t"),0,4,1,1,8, +"d - 'Double_t' 1 - val i - 'Int_t' 0 - idx " +"u 'MGeomCam' - 11 - cam i - 'Int_t' 0 0 type",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("operator[]",1060,G__TriggerCint_128_2_0,100,-1,G__defined_typename("Double_t"),0,1,1,1,0,"i - 'Int_t' 10 - idx",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DrawPixelContent",1643,G__TriggerCint_128_3_0,121,-1,-1,0,1,1,1,8,"i - 'Int_t' 0 - num",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("Class",502,G__TriggerCint_128_4_0,85,G__get_linked_tagnum(&G__TriggerCintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Class_Name",982,G__TriggerCint_128_5_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Class_Version",1339,G__TriggerCint_128_6_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Dictionary",1046,G__TriggerCint_128_7_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("IsA",253,G__TriggerCint_128_8_0,85,G__get_linked_tagnum(&G__TriggerCintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("ShowMembers",1132,G__TriggerCint_128_9_0,121,-1,-1,0,2,1,1,0, +"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("Streamer",835,G__TriggerCint_128_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("StreamerNVirtual",1656,G__TriggerCint_128_1_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DeclFileName",1145,G__TriggerCint_128_2_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("ImplFileLine",1178,G__TriggerCint_128_3_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("ImplFileName",1171,G__TriggerCint_128_4_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DeclFileLine",1152,G__TriggerCint_128_5_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + // automatic copy constructor + G__memfunc_setup("MTriggerPrescFact",1692,G__TriggerCint_128_6_1,(int)('i'),G__get_linked_tagnum(&G__TriggerCintLN_MTriggerPrescFact),-1,0,1,1,1,0,"u 'MTriggerPrescFact' - 11 - -",(char*)NULL,(void*)NULL,0); + // automatic destructor + G__memfunc_setup("~MTriggerPrescFact",1818,G__TriggerCint_128_7_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__tag_memfunc_reset(); +} + +static void G__setup_memfuncMTriggerLiveTime(void) { + /* MTriggerLiveTime */ + G__tag_memfunc_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerLiveTime)); + G__memfunc_setup("MTriggerLiveTime",1600,G__TriggerCint_129_0_0,105,G__get_linked_tagnum(&G__TriggerCintLN_MTriggerLiveTime),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("GetPixelContent",1533,G__TriggerCint_129_1_0,103,-1,G__defined_typename("Bool_t"),0,4,1,1,8, +"d - 'Double_t' 1 - val i - 'Int_t' 0 - idx " +"u 'MGeomCam' - 11 - cam i - 'Int_t' 0 0 type",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("operator[]",1060,G__TriggerCint_129_2_0,100,-1,G__defined_typename("Double_t"),0,1,1,1,0,"i - 'Int_t' 10 - idx",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DrawPixelContent",1643,G__TriggerCint_129_3_0,121,-1,-1,0,1,1,1,8,"i - 'Int_t' 0 - num",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("Class",502,G__TriggerCint_129_4_0,85,G__get_linked_tagnum(&G__TriggerCintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Class_Name",982,G__TriggerCint_129_5_0,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Class_Version",1339,G__TriggerCint_129_6_0,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("Dictionary",1046,G__TriggerCint_129_7_0,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("IsA",253,G__TriggerCint_129_8_0,85,G__get_linked_tagnum(&G__TriggerCintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("ShowMembers",1132,G__TriggerCint_129_9_0,121,-1,-1,0,2,1,1,0, +"u 'TMemberInspector' - 1 - insp C - - 0 - parent",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("Streamer",835,G__TriggerCint_129_0_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1); + G__memfunc_setup("StreamerNVirtual",1656,G__TriggerCint_129_1_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DeclFileName",1145,G__TriggerCint_129_2_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("ImplFileLine",1178,G__TriggerCint_129_3_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("ImplFileName",1171,G__TriggerCint_129_4_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0); + G__memfunc_setup("DeclFileLine",1152,G__TriggerCint_129_5_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0); + // automatic copy constructor + G__memfunc_setup("MTriggerLiveTime",1600,G__TriggerCint_129_6_1,(int)('i'),G__get_linked_tagnum(&G__TriggerCintLN_MTriggerLiveTime),-1,0,1,1,1,0,"u 'MTriggerLiveTime' - 11 - -",(char*)NULL,(void*)NULL,0); + // automatic destructor + G__memfunc_setup("~MTriggerLiveTime",1726,G__TriggerCint_129_7_1,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0); + G__tag_memfunc_reset(); +} + + +/********************************************************* +* Member function information setup +*********************************************************/ +extern "C" void G__cpp_setup_memfuncTriggerCint() { +} + +/********************************************************* +* Global variable information setup for each class +*********************************************************/ +static void G__cpp_setup_global0() { + + /* Setting up global variables */ + G__resetplocal(); + +} + +static void G__cpp_setup_global1() { + + G__resetglobalenv(); +} +extern "C" void G__cpp_setup_globalTriggerCint() { + G__cpp_setup_global0(); + G__cpp_setup_global1(); +} + +/********************************************************* +* Global function information setup for each class +*********************************************************/ +static void G__cpp_setup_func0() { + G__lastifuncposition(); + +} + +static void G__cpp_setup_func1() { +} + +static void G__cpp_setup_func2() { +} + +static void G__cpp_setup_func3() { + + G__resetifuncposition(); +} + +extern "C" void G__cpp_setup_funcTriggerCint() { + G__cpp_setup_func0(); + G__cpp_setup_func1(); + G__cpp_setup_func2(); + G__cpp_setup_func3(); +} + +/********************************************************* +* Class,struct,union,enum tag information setup +*********************************************************/ +/* Setup class/struct taginfo */ +G__linked_taginfo G__TriggerCintLN_TClass = { "TClass" , 99 , -1 }; +G__linked_taginfo G__TriggerCintLN_TBuffer = { "TBuffer" , 99 , -1 }; +G__linked_taginfo G__TriggerCintLN_TMemberInspector = { "TMemberInspector" , 99 , -1 }; +G__linked_taginfo G__TriggerCintLN_TObject = { "TObject" , 99 , -1 }; +G__linked_taginfo G__TriggerCintLN_MGeomCam = { "MGeomCam" , 99 , -1 }; +G__linked_taginfo G__TriggerCintLN_MCamEvent = { "MCamEvent" , 99 , -1 }; +G__linked_taginfo G__TriggerCintLN_MParContainer = { "MParContainer" , 99 , -1 }; +G__linked_taginfo G__TriggerCintLN_TArrayL = { "TArrayL" , 99 , -1 }; +G__linked_taginfo G__TriggerCintLN_MTriggerIPR = { "MTriggerIPR" , 99 , -1 }; +G__linked_taginfo G__TriggerCintLN_TArrayF = { "TArrayF" , 99 , -1 }; +G__linked_taginfo G__TriggerCintLN_MTriggerCell = { "MTriggerCell" , 99 , -1 }; +G__linked_taginfo G__TriggerCintLN_MTriggerBit = { "MTriggerBit" , 99 , -1 }; +G__linked_taginfo G__TriggerCintLN_MTriggerPrescFact = { "MTriggerPrescFact" , 99 , -1 }; +G__linked_taginfo G__TriggerCintLN_MTriggerLiveTime = { "MTriggerLiveTime" , 99 , -1 }; + +/* Reset class/struct taginfo */ +extern "C" void G__cpp_reset_tagtableTriggerCint() { + G__TriggerCintLN_TClass.tagnum = -1 ; + G__TriggerCintLN_TBuffer.tagnum = -1 ; + G__TriggerCintLN_TMemberInspector.tagnum = -1 ; + G__TriggerCintLN_TObject.tagnum = -1 ; + G__TriggerCintLN_MGeomCam.tagnum = -1 ; + G__TriggerCintLN_MCamEvent.tagnum = -1 ; + G__TriggerCintLN_MParContainer.tagnum = -1 ; + G__TriggerCintLN_TArrayL.tagnum = -1 ; + G__TriggerCintLN_MTriggerIPR.tagnum = -1 ; + G__TriggerCintLN_TArrayF.tagnum = -1 ; + G__TriggerCintLN_MTriggerCell.tagnum = -1 ; + G__TriggerCintLN_MTriggerBit.tagnum = -1 ; + G__TriggerCintLN_MTriggerPrescFact.tagnum = -1 ; + G__TriggerCintLN_MTriggerLiveTime.tagnum = -1 ; +} + + +extern "C" void G__cpp_setup_tagtableTriggerCint() { + + /* Setting up class,struct,union tag entry */ + G__get_linked_tagnum(&G__TriggerCintLN_TClass); + G__get_linked_tagnum(&G__TriggerCintLN_TBuffer); + G__get_linked_tagnum(&G__TriggerCintLN_TMemberInspector); + G__get_linked_tagnum(&G__TriggerCintLN_TObject); + G__get_linked_tagnum(&G__TriggerCintLN_MGeomCam); + G__get_linked_tagnum(&G__TriggerCintLN_MCamEvent); + G__get_linked_tagnum(&G__TriggerCintLN_MParContainer); + G__get_linked_tagnum(&G__TriggerCintLN_TArrayL); + G__tagtable_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerIPR),sizeof(MTriggerIPR),-1,323840,"Container for the Individual Pixel Rate (IPR)",G__setup_memvarMTriggerIPR,G__setup_memfuncMTriggerIPR); + G__get_linked_tagnum(&G__TriggerCintLN_TArrayF); + G__tagtable_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerCell),sizeof(MTriggerCell),-1,323840,"Container for the trigger cell rates",G__setup_memvarMTriggerCell,G__setup_memfuncMTriggerCell); + G__tagtable_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerBit),sizeof(MTriggerBit),-1,323840,"Container for the L2 output bits rates",G__setup_memvarMTriggerBit,G__setup_memfuncMTriggerBit); + G__tagtable_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerPrescFact),sizeof(MTriggerPrescFact),-1,323840,"Container for the L2 Prescaling Factors",G__setup_memvarMTriggerPrescFact,G__setup_memfuncMTriggerPrescFact); + G__tagtable_setup(G__get_linked_tagnum(&G__TriggerCintLN_MTriggerLiveTime),sizeof(MTriggerLiveTime),-1,323840,"Container for the Live-Deadtime",G__setup_memvarMTriggerLiveTime,G__setup_memfuncMTriggerLiveTime); +} +extern "C" void G__cpp_setupTriggerCint(void) { + G__check_setup_version(30051515,"G__cpp_setupTriggerCint()"); + G__set_cpp_environmentTriggerCint(); + G__cpp_setup_tagtableTriggerCint(); + + G__cpp_setup_inheritanceTriggerCint(); + + G__cpp_setup_typetableTriggerCint(); + + G__cpp_setup_memvarTriggerCint(); + + G__cpp_setup_memfuncTriggerCint(); + G__cpp_setup_globalTriggerCint(); + G__cpp_setup_funcTriggerCint(); + + if(0==G__getsizep2memfunc()) G__get_sizep2memfuncTriggerCint(); + return; +} +class G__cpp_setup_initTriggerCint { + public: + G__cpp_setup_initTriggerCint() { G__add_setup_func("TriggerCint",(G__incsetup)(&G__cpp_setupTriggerCint)); G__call_setup_funcs(); } + ~G__cpp_setup_initTriggerCint() { G__remove_setup_func("TriggerCint"); } +}; +G__cpp_setup_initTriggerCint G__cpp_setup_initializerTriggerCint; + Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/TriggerCint.h =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/TriggerCint.h (revision 4185) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/TriggerCint.h (revision 4185) @@ -0,0 +1,54 @@ +/******************************************************************** +* TriggerCint.h +********************************************************************/ +#ifdef __CINT__ +#error TriggerCint.h/C is only for compilation. Abort cint. +#endif +#include +#include +#include +#include +#include +#define G__ANSIHEADER +#define G__DICTIONARY +#include "G__ci.h" +extern "C" { +extern void G__cpp_setup_tagtableTriggerCint(); +extern void G__cpp_setup_inheritanceTriggerCint(); +extern void G__cpp_setup_typetableTriggerCint(); +extern void G__cpp_setup_memvarTriggerCint(); +extern void G__cpp_setup_globalTriggerCint(); +extern void G__cpp_setup_memfuncTriggerCint(); +extern void G__cpp_setup_funcTriggerCint(); +extern void G__set_cpp_environmentTriggerCint(); +} + + +#include "TROOT.h" +#include "TMemberInspector.h" +#include "MTriggerIPR.h" +#include "MTriggerCell.h" +#include "MTriggerBit.h" +#include "MTriggerPrescFact.h" +#include "MTriggerLiveTime.h" +#include "TriggerIncl.h" + +#ifndef G__MEMFUNCBODY +#endif + +extern G__linked_taginfo G__TriggerCintLN_TClass; +extern G__linked_taginfo G__TriggerCintLN_TBuffer; +extern G__linked_taginfo G__TriggerCintLN_TMemberInspector; +extern G__linked_taginfo G__TriggerCintLN_TObject; +extern G__linked_taginfo G__TriggerCintLN_MGeomCam; +extern G__linked_taginfo G__TriggerCintLN_MCamEvent; +extern G__linked_taginfo G__TriggerCintLN_MParContainer; +extern G__linked_taginfo G__TriggerCintLN_TArrayL; +extern G__linked_taginfo G__TriggerCintLN_MTriggerIPR; +extern G__linked_taginfo G__TriggerCintLN_TArrayF; +extern G__linked_taginfo G__TriggerCintLN_MTriggerCell; +extern G__linked_taginfo G__TriggerCintLN_MTriggerBit; +extern G__linked_taginfo G__TriggerCintLN_MTriggerPrescFact; +extern G__linked_taginfo G__TriggerCintLN_MTriggerLiveTime; + +/* STUB derived class for protected member access */ Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/TriggerIncl.h =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/TriggerIncl.h (revision 4185) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/TriggerIncl.h (revision 4185) @@ -0,0 +1,3 @@ +#ifndef __CINT__ + +#endif // __CINT__ Index: trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/TriggerLinkDef.h =================================================================== --- trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/TriggerLinkDef.h (revision 4185) +++ trunk/MagicSoft/Mars/mtemp/mpisa/classes/mtrigger/TriggerLinkDef.h (revision 4185) @@ -0,0 +1,13 @@ +#ifdef __CINT__ + +#pragma link off all globals; +#pragma link off all classes; +#pragma link off all functions; + +#pragma link C++ class MTriggerIPR+; +#pragma link C++ class MTriggerCell+; +#pragma link C++ class MTriggerBit+; +#pragma link C++ class MTriggerPrescFact+; +#pragma link C++ class MTriggerLiveTime+; + +#endif