Index: trunk/MagicSoft/Mars/mtemp/mpisa/Changelog_pisa
===================================================================
--- trunk/MagicSoft/Mars/mtemp/mpisa/Changelog_pisa	(revision 4157)
+++ 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 4157)
+++ 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 4157)
+++ 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 <mailto:tbretz@astro.uni-wuerzburg.de>
+!              Antonio Stamerra, 05/2004 <mailto:antonio.stamerra@pi.infn.it> 
+!
+!   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 <TArrayL.h>
+#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 <mailto:tbretz@astro.uni-wuerzburg.de>
+!              Antonio Stamerra, 05/2004 <mailto:antonio.stamerra@pi.infn.it> 
+!
+!   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 <TArrayF.h>
+#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 <mailto:tbretz@astro.uni-wuerzburg.de>
+!              Antonio Stamerra, 05/2004 <mailto:antonio.stamerra@pi.infn.it> 
+!
+!   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 <TArrayL.h>
+#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 <mailto:tbretz@astro.uni-wuerzburg.de>
+!              Antonio Stamerra, 05/2004 <mailto:antonio.stamerra@pi.infn.it> 
+!
+!   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 <TArrayL.h>
+#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 <mailto:tbretz@astro.uni-wuerzburg.de>
+!              Antonio Stamerra, 05/2004 <mailto:antonio.stamerra@pi.infn.it> 
+!
+!   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 <TArrayL.h>
+#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 <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#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
