introducing the US EM calorimeter

diff --git a/EMCAL/AliEMCAL.cxx b/EMCAL/AliEMCAL.cxx
new file mode 100644 (file)
index 0000000..49447c5
--- /dev/null
+++ b/EMCAL/AliEMCAL.cxx
@@ -0,0 +1,157 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+//_________________________________________________________________________
+// Base Class for EMCAL description:
+//    
+// 
+//*-- Author: Yves Schutz (SUBATECH) 
+//////////////////////////////////////////////////////////////////////////////
+
+// --- Standard library ---
+#include <strstream.h>
+
+// --- ROOT system ---
+#include "TBranch.h" 
+#include "TClonesArray.h" 
+#include "TTree.h" 
+
+// --- AliRoot header files ---
+
+#include "AliEMCAL.h"
+#include "AliEMCALGeometry.h"
+#include "AliMC.h"
+#include "AliRun.h"
+#include "AliMagF.h"
+
+ClassImp(AliEMCAL)
+
+//____________________________________________________________________________
+AliEMCAL::AliEMCAL():AliDetector()
+{
+  // ctor 
+  //We do not create objects, because these pointers will be overwritten during reading from file.
+  fSDigits       = 0 ;
+}
+//____________________________________________________________________________
+AliEMCAL::AliEMCAL(const char* name, const char* title): AliDetector(name,title) 
+{
+  // ctor : title is used to identify the layout
+  
+  // gets an instance of the geometry parameters class  
+  
+  if (strcmp(GetTitle(),"") != 0 ) 
+    fGeom =  AliEMCALGeometry::GetInstance(GetTitle(), "") ; 
+}
+//____________________________________________________________________________
+AliEMCAL::~AliEMCAL()
+{
+  // dtor
+
+}
+
+//____________________________________________________________________________
+void AliEMCAL::CreateMaterials()
+{
+  // Definitions of materials to build EMCAL and associated tracking media.
+  // media number in idtmed are 1599 to 1698.
+
+  // --- Air ---
+  AliMaterial(0, "Air$", 14.61, 7.3, 0.001205, 30420., 67500., 0, 0) ;
+
+  // --- Lead ---                                                                     
+  AliMaterial(1, "Pb$", 207.2, 82, 11.35, 0.56, 0., 0, 0) ;
+
+  // --- Average properties of the active material ---                                                                     
+  AliMaterial(2, "EmcalMat$", fGeom->GetAmat(), 
+                             fGeom->GetZmat(),
+                             fGeom->GetDmat(),
+                             fGeom->GetRmat(), 
+                             0) ;
+
+  // DEFINITION OF THE TRACKING MEDIA
+
+  // for EMCAL: idtmed[1599->1698] equivalent to fIdtmed[0->100]
+  Int_t * idtmed = fIdtmed->GetArray() - 1599 ; 
+  Int_t   isxfld = gAlice->Field()->Integ() ;
+  Float_t sxmgmx = gAlice->Field()->Max() ;
+
+   // Air                                                                           -> idtmed[1599] 
+  AliMedium(0, "Air          $", 0, 0,
+            isxfld, sxmgmx, 10.0, 1.0, 0.1, 0.1, 10.0, 0, 0) ;
+
+  // The Lead                                                                       -> idtmed[1600]
+ 
+  AliMedium(1, "Lead      $", 1, 0,
+            isxfld, sxmgmx, 10.0, 0.1, 0.1, 0.1, 0.1, 0, 0) ;
+
+  // The Average properties of the active material                                  -> idtmed[1601]
+
+  AliMedium(2, "EmcalMat  $", 2, 0,
+            isxfld, sxmgmx, 10.0, 0.1, 0.1, 0.1, 0.1, 0, 0) ;
+
+ // --- Set decent energy thresholds for gamma and electron tracking
+
+  // Tracking threshold for photons and electrons in Lead 
+  gMC->Gstpar(idtmed[1600], "CUTGAM",0.5E-4) ; 
+  gMC->Gstpar(idtmed[1600], "CUTELE",1.0E-4) ;
+  gMC->Gstpar(idtmed[1601], "CUTGAM",0.5E-4) ; 
+  gMC->Gstpar(idtmed[1601], "CUTELE",1.0E-4) ;
+
+  // --- Generate explicitly delta rays in Lead ---
+  gMC->Gstpar(idtmed[1600], "LOSS",3.) ;
+  gMC->Gstpar(idtmed[1600], "DRAY",1.) ;
+  gMC->Gstpar(idtmed[1601], "LOSS",3.) ;
+  gMC->Gstpar(idtmed[1601], "DRAY",1.) ;
+ 
+}
+//____________________________________________________________________________
+void AliEMCAL::SetTreeAddress()
+{ 
+
+  TBranch *branch;
+  char branchname[20];
+  sprintf(branchname,"%s",GetName());
+  
+  // Branch address for hit tree
+  TTree *treeH = gAlice->TreeH();
+  if (treeH && fHits) {
+    branch = treeH->GetBranch(branchname);
+    if (branch) branch->SetAddress(&fHits);
+  }
+ 
+  // Branch address for digit tree
+  TTree *treeD = gAlice->TreeD();
+  
+  if(fDigits)
+    fDigits->Clear();
+
+  if (treeD && fDigits) {
+    branch = treeD->GetBranch(branchname);
+    if (branch) branch->SetAddress(&fDigits);
+  }
+
+  if(fSDigits)
+    fSDigits->Clear();
+
+  if (gAlice->TreeS()  && fSDigits ) {
+    branch = gAlice->TreeS()->GetBranch("EMCAL");
+    if (branch) branch->SetAddress(&fSDigits) ;
+  } 
+}
+
+

diff --git a/EMCAL/AliEMCAL.h b/EMCAL/AliEMCAL.h
new file mode 100644 (file)
index 0000000..1005caa
--- /dev/null
+++ b/EMCAL/AliEMCAL.h
@@ -0,0 +1,59 @@
+#ifndef ALIEMCAL_H
+#define ALIEMCAL_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice     */
+
+/* $Id$ */
+
+//_________________________________________________________________________
+//  Base Class for EMCAL     
+//                  
+//*-- Author: Yves Schutz (SUBATECH)
+
+#include <assert.h>
+
+// --- ROOT system ---
+class TString ;
+class TClonesArray ;
+
+// --- AliRoot header files ---
+
+#include "AliDetector.h"
+class AliEMCALGeometry ; 
+
+class AliEMCAL : public AliDetector {
+
+ public:
+
+  AliEMCAL() ;
+  AliEMCAL(const char* name, const char* title="");
+  AliEMCAL(const AliEMCAL & emcal) {
+    // cpy ctor: no implementation yet
+    // requested by the Coding Convention
+    assert(0==1) ; 
+  }
+  virtual ~AliEMCAL() ; 
+  virtual void   CreateMaterials() ;                     
+  virtual AliEMCALGeometry * GetGeometry() { return fGeom ; }  
+  Int_t   IsVersion(void) const { return -1 ; } 
+  virtual void  SetTreeAddress() ;               
+  TClonesArray *SDigits() const {return fSDigits;}
+  virtual TString Version() {return TString(" ") ; }  
+  AliEMCAL & operator = (const AliEMCAL & rvalue)  {
+    // assignement operator requested by coding convention
+    // but not needed
+    assert(0==1) ;
+    return *this ; 
+  }
+ 
+protected:
+
+  AliEMCALGeometry * fGeom ;                       // Geometry definition
+  TClonesArray   *fSDigits      ; // List of summable digits
+  TClonesArray   *fDigits      ;  // List of digits
+
+  ClassDef(AliEMCAL,2) // Electromagnetic calorimeter (base class)
+
+} ;
+
+#endif // ALIEMCAL_H

diff --git a/EMCAL/AliEMCALGeometry.cxx b/EMCAL/AliEMCALGeometry.cxx
new file mode 100644 (file)
index 0000000..a7f6428
--- /dev/null
+++ b/EMCAL/AliEMCALGeometry.cxx
@@ -0,0 +1,113 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$*/
+
+//_________________________________________________________________________
+// Geometry class  for EMCAL : singleton  
+// EMCAL consists of a shell of Pb 
+//                  
+//*-- Author: Yves Schutz (SUBATECH)
+
+// --- ROOT system ---
+
+// --- Standard library ---
+
+#include <iostream.h>
+
+// --- AliRoot header files ---
+
+#include "AliEMCALGeometry.h"
+#include "AliConst.h"
+
+ClassImp(AliEMCALGeometry) ;
+
+AliEMCALGeometry * AliEMCALGeometry::fgGeom = 0 ;
+Bool_t            AliEMCALGeometry::fgInit = kFALSE ;
+
+//____________________________________________________________________________
+AliEMCALGeometry::~AliEMCALGeometry(void)
+{
+  // dtor
+
+}
+
+//____________________________________________________________________________
+
+void AliEMCALGeometry::Init(void)
+{
+  // Initializes the EMCAL parameters
+
+  fgInit = kTRUE ; 
+
+  // geometry 
+  fAirGap     = 5.0 ; 
+  fArm1PhiMin = 130.0 ; 
+  fArm1PhiMax = 210.0 ; 
+  fArm2PhiMin = 330.0 ; 
+  fArm2PhiMax = 410.0 ; 
+  fIPDistance = 423.0 ; 
+  fShellThickness = 50.0 ; 
+  fZLength = 817.0 ; 
+  fEnvelop[0] = fIPDistance ; 
+  fEnvelop[1] = fIPDistance + fShellThickness ;
+  fEnvelop[2] = fZLength ; 
+
+  // material
+  fAmat = 207.2;  
+  fZmat = 82.;   
+  fDmat = 5.798167 ;  
+  fRmat = 1.261061;  
+  fEmat = 23 ;  
+ 
+}
+
+//____________________________________________________________________________
+AliEMCALGeometry *  AliEMCALGeometry::GetInstance() 
+{ 
+  // Returns the pointer of the unique instance
+  return (AliEMCALGeometry *) fgGeom ; 
+}
+
+//____________________________________________________________________________
+AliEMCALGeometry *  AliEMCALGeometry::GetInstance(const Text_t* name, const Text_t* title) 
+{
+  // Returns the pointer of the unique instance
+  AliEMCALGeometry * rv = 0  ; 
+  if ( fgGeom == 0 ) {
+    if ( strcmp(name,"") == 0 ) 
+      rv = 0 ;
+    else {    
+      fgGeom = new AliEMCALGeometry(name, title) ;
+      if ( fgInit )
+       rv = (AliEMCALGeometry * ) fgGeom ;
+      else {
+       rv = 0 ; 
+       delete fgGeom ; 
+       fgGeom = 0 ; 
+      }
+    }
+  }
+  else {
+    if ( strcmp(fgGeom->GetName(), name) != 0 ) {
+      cout << "AliEMCALGeometry <E> : current geometry is " << fgGeom->GetName() << endl
+          << "                      you cannot call     " << name << endl ; 
+    }
+    else
+      rv = (AliEMCALGeometry *) fgGeom ; 
+  } 
+  return rv ; 
+}
+

diff --git a/EMCAL/AliEMCALGeometry.h b/EMCAL/AliEMCALGeometry.h
new file mode 100644 (file)
index 0000000..605728c
--- /dev/null
+++ b/EMCAL/AliEMCALGeometry.h
@@ -0,0 +1,113 @@
+#ifndef ALIEMCALGEOMETRY_H
+#define ALIEMCALGEOMETRY_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+//_________________________________________________________________________
+// Geometry class  for EMCAL : singleton
+// EMCAL consists of a shell of Pb
+//                  
+//*-- Author: Yves Schutz (SUBATECH)
+
+#include <assert.h> 
+
+// --- ROOT system ---
+
+class TObjArray ;  
+class TVector3; 
+class TMatrix ; 
+
+// --- AliRoot header files ---
+
+#include "AliGeometry.h"
+
+
+class AliEMCALGeometry : public AliGeometry {
+
+public: 
+
+  AliEMCALGeometry() {
+    // default ctor 
+    // must be kept public for root persistency purposes, but should never be called by the outside world
+  } ;  
+
+  AliEMCALGeometry(const AliEMCALGeometry & geom) {
+    // cpy ctor requested by Coding Convention but not yet needed
+    assert(0==1) ;
+  } 
+  
+  virtual ~AliEMCALGeometry(void) ; 
+  static AliEMCALGeometry * GetInstance(const Text_t* name, const Text_t* title="") ; 
+  static AliEMCALGeometry * GetInstance() ; 
+
+  AliEMCALGeometry & operator = (const AliEMCALGeometry  & rvalue) const {
+    // assignement operator requested by coding convention but not needed
+    assert(0==1) ;
+    return *(GetInstance()) ; 
+  }
+  virtual void GetGlobal(const AliRecPoint *, TVector3 &, TMatrix &) const {}
+  virtual void GetGlobal(const AliRecPoint *, TVector3 &) const {}
+  // General
+
+  Bool_t  IsInitialized(void) const { return fgInit ; }  
+                                                                       
+  // Return EMCA geometrical parameters
+
+  // geometry
+  const Float_t GetAirGap() const { return fAirGap ; }
+  const Float_t GetArm1PhiMin() const { return fArm1PhiMin ; }
+  const Float_t GetArm1PhiMax() const { return fArm1PhiMax ; }
+  const Float_t GetArm2PhiMin() const { return fArm2PhiMin ; }
+  const Float_t GetArm2PhiMax() const { return fArm2PhiMax ; }
+  const Float_t GetIPDistance()   const { return  fIPDistance  ; } 
+  const Float_t GetEnvelop(Int_t index) const { return fEnvelop[index] ; }  
+  const Float_t GetShellThickness() const { return fShellThickness ; }
+  const Float_t GetZLength() const { return fZLength ; } 
+
+  // material 
+  const Float_t GetAmat()   const { return  fAmat ; }  
+  const Float_t GetZmat()   const { return  fZmat ; }   
+  const Float_t GetDmat()   const { return  fDmat ; }  
+  const Float_t GetRmat()   const { return  fRmat ; }  
+  const Float_t GetEmat()   const { return  fEmat ; }  
+  const Float_t GetLmat()   const { return  fEmat * fRmat ; }  
+
+protected:
+
+  AliEMCALGeometry(const Text_t* name, const Text_t* title="") : AliGeometry(name, title) { 
+    // ctor only for internal usage (singleton)
+    Init() ; 
+  }
+  void Init(void) ;            // initializes the parameters of EMCAL 
+
+private:
+
+  static AliEMCALGeometry * fgGeom ; // pointer to the unique instance of the singleton 
+  static Bool_t fgInit ;             // Tells if geometry has been succesfully set up 
+
+  // geometry
+  Float_t fAirGap ;                  // Distance between envelop and active material 
+  Float_t fArm1PhiMin ;              // Minimum phi angle covered by Arm 1 
+  Float_t fArm1PhiMax ;              // Maximum phi angle covered by Arm 1       
+  Float_t fArm2PhiMin ;              // Minimum phi angle covered by Arm 2        
+  Float_t fArm2PhiMax ;              // Maximum phi angle covered by Arm 2
+  // It is assumed that Arm1 and Arm2 have the same following parameters
+  Float_t fEnvelop[3] ;              // the GEANT TUB that contains the 2 arms
+  Float_t fIPDistance ;              // Distance of the inner surface to the interaction point
+  Float_t fShellThickness ;          // Total thickness in (x,y) direction
+  Float_t fZLength ;                 // Total length in z direction
+
+  //material
+  Float_t fAmat ;  // average atomic weight of the active material
+  Float_t fZmat ;  // average atomic number of the active material 
+  Float_t fDmat ;  // average density of the active material
+  Float_t fRmat ;  // average radiation length of the active material
+  Float_t fEmat ;  // thickness of the active material in radiation length units
+ 
+  ClassDef(AliEMCALGeometry,1)       // EMCAL geometry class 
+
+} ;
+
+#endif // AliEMCALGEOMETRY_H

diff --git a/EMCAL/AliEMCALv0.cxx b/EMCAL/AliEMCALv0.cxx
new file mode 100644 (file)
index 0000000..fe9d307
--- /dev/null
+++ b/EMCAL/AliEMCALv0.cxx
@@ -0,0 +1,219 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+//_________________________________________________________________________
+// Implementation version v0 of EMCAL Manager class 
+// An object of this class does not produce hits nor digits
+// It is the one to use if you do not want to produce outputs in TREEH or TREED
+//                  
+//*-- Author: Yves Schutz (SUBATECH)
+
+
+// --- ROOT system ---
+
+#include "TTUBS.h"
+#include "TNode.h"
+#include "TRandom.h"
+#include "TGeometry.h"
+
+
+// --- Standard library ---
+
+#include <iostream.h> 
+
+// --- AliRoot header files ---
+
+#include "AliEMCALv0.h"
+#include "AliEMCALGeometry.h"
+#include "AliRun.h"
+#include "AliMC.h"
+
+ClassImp(AliEMCALv0)
+
+//____________________________________________________________________________
+AliEMCALv0::AliEMCALv0(const char *name, const char *title):
+  AliEMCAL(name,title)
+{
+  // ctor
+
+}
+
+//____________________________________________________________________________
+void AliEMCALv0::BuildGeometry()
+{
+
+  const Int_t kColorArm1   = kBlue ;
+  const Int_t kColorArm2   = kBlue ;
+  const Int_t kColorArm1Active   = kRed ;
+  const Int_t kColorArm2Active   = kRed ;
+
+  // make the container of  Arm1
+  
+  new TTUBS("Envelop1", "Tubs that contains arm 1", "void", 
+           fGeom->GetEnvelop(0),     // rmin 
+           fGeom->GetEnvelop(1),     // rmax
+           fGeom->GetEnvelop(2)/2.0, // half length in Z
+           fGeom->GetArm1PhiMin(),   // minimun phi angle
+           fGeom->GetArm1PhiMax()   // maximun phi angle
+           ) ; 
+   // Active material of  Arm1
+ 
+  new TTUBS("Arm1", "Active material of  arm 1", "void", 
+           fGeom->GetEnvelop(0),     // rmin 
+           fGeom->GetEnvelop(1),     // rmax
+           fGeom->GetLmat()/2.0,     // half length in Z
+           fGeom->GetArm1PhiMin(),   // minimun phi angle
+           fGeom->GetArm1PhiMax()   // maximun phi angle
+           ) ; 
+  // make the container of  Arm2
+ 
+  new TTUBS("Envelop2", "Tubs that contains arm 2", "void", 
+           fGeom->GetEnvelop(0),     // rmin 
+           fGeom->GetEnvelop(1),     // rmax
+           fGeom->GetEnvelop(2)/2.0, // half length in Z
+           fGeom->GetArm2PhiMin(),   // minimun phi angle
+           fGeom->GetArm2PhiMax()   // maximun phi angle
+           ) ;
+          
+  // Active material of  Arm2
+ 
+  new TTUBS("Arm2", "Active material of  arm 2", "void", 
+           fGeom->GetEnvelop(0),     // rmin 
+           fGeom->GetEnvelop(1),     // rmax
+           fGeom->GetLmat()/2.0,     // half length in Z           ) ; 
+           fGeom->GetArm2PhiMin(),   // minimun phi angle
+           fGeom->GetArm2PhiMax()   // maximun phi angle
+           ) ;
+
+  TNode * top = gAlice->GetGeometry()->GetNode("alice") ;
+  top->cd();
+  
+  // Arm 1 inside alice
+  TNode * envelop1node = new TNode("Arm1 Envelop", "Arm1 Envelop", "Envelop1") ;
+  envelop1node->SetLineColor(kColorArm1) ;
+  fNodes->Add(envelop1node) ;
+
+  // Arm 2 inside alice
+  TNode * envelop2node = new TNode("Arm2 Envelop", "Arm2 Envelop", "Envelop2") ;
+  envelop2node->SetLineColor(kColorArm2) ;
+  fNodes->Add(envelop2node) ;
+
+  // active material inside Arm 1
+  envelop1node->cd() ; 
+  TNode * arm1node = new TNode("Arm1 Mat", "Arm1 Mat", "Arm1Mat") ;
+  arm1node->SetLineColor(kColorArm1Active) ;
+  fNodes->Add(arm1node) ; 
+
+  // active material inside Arm 2
+  envelop2node->cd() ; 
+  TNode * arm2node = new TNode("Arm2 Mat", "Arm2 Mat", "Arm2Mat") ;
+  arm2node->SetLineColor(kColorArm2Active) ;
+  fNodes->Add(arm2node) ; 
+  
+}
+
+
+//____________________________________________________________________________
+void AliEMCALv0::CreateGeometry()
+{
+  // Create the EMCAL geometry for Geant
+
+  AliEMCALv0 *emcaltmp = (AliEMCALv0*)gAlice->GetModule("EMCAL") ;
+
+  if ( emcaltmp == NULL ) {
+    
+    fprintf(stderr, "EMCAL detector not found!\n") ;
+    return;
+    
+  }
+  // Get pointer to the array containing media indices
+  Int_t *idtmed = fIdtmed->GetArray() - 1599 ;
+
+
+  // Create a tube sector that contains Arm 1 
+ 
+  Float_t envelopA[5] ; 
+  envelopA[0] = fGeom->GetEnvelop(0) ;         // rmin
+  envelopA[1] = fGeom->GetEnvelop(1) ;         // rmax
+  envelopA[2] = fGeom->GetEnvelop(2) / 2.0 ;   // dz
+  envelopA[3] = fGeom->GetArm1PhiMin() ;       // minimun phi angle
+  envelopA[4] = fGeom->GetArm1PhiMax() ;       // maximun phi angle
+
+  gMC->Gsvolu("XEN1", "TUBS ", idtmed[1599], envelopA, 5) ; // filled with air
+
+  // Create a tube sector that contains active material Arm 1 
+ 
+  envelopA[2] = fGeom->GetLmat() / 2.0 ;       // dz
+
+  gMC->Gsvolu("XAR1", "TUBS ", idtmed[1601], envelopA, 5) ; // filled with active material (average)
+
+
+  // Create a tube sector that contains Arm 2 
+ 
+  envelopA[3] = fGeom->GetArm2PhiMin() ;       // minimun phi angle
+  envelopA[4] = fGeom->GetArm2PhiMax() ;       // maximun phi angle
+
+  gMC->Gsvolu("XEN2", "TUBS ", idtmed[1599], envelopA, 5) ; // filled with air
+
+  // Create a tube sector that contains active material Arm 1 
+ 
+  envelopA[2] = fGeom->GetLmat() / 2.0 ;       // dz
+
+  gMC->Gsvolu("XAR2", "TUBS ", idtmed[1601], envelopA, 5) ; // filled with active material (average)
+  
+  Int_t idrotm =1;
+  AliMatrix(idrotm, 90.0, 0., 90.0, 90.0, 0.0, 0.0) ;
+
+  // Position  ENV1 container in ALIC
+  gMC->Gspos("XEN1", 1, "ALIC", 0.0, 0.0, 0.0, idrotm, "ONLY") ;
+  
+  // Position  ARM1  into ENV1
+  gMC->Gspos("XAR1", 1, "XEN1", 0.0, 0.0, 0.0, idrotm, "ONLY") ;
+
+  // Position  ENV2 container in ALIC  
+  gMC->Gspos("XEN2", 1, "ALIC", 0.0, 0.0, 0.0, idrotm, "ONLY") ;
+
+  // Position  ARM2  into ENV2
+  gMC->Gspos("XAR2", 1, "XEN2", 0.0, 0.0, 0.0, idrotm, "ONLY") ;
+  
+}
+
+//____________________________________________________________________________
+void AliEMCALv0::Init(void)
+{
+  // Just prints an information message
+  
+  Int_t i;
+
+  printf("\n");
+  for(i=0;i<35;i++) printf("*");
+  printf(" EMCAL_INIT ");
+  for(i=0;i<35;i++) printf("*");
+  printf("\n");
+
+  // Here the EMCAL initialisation code (if any!)
+
+  if (fGeom!=0)  
+    cout << "AliEMCAL" << Version() << " : EMCAL geometry intialized for " << fGeom->GetName() << endl ;
+  else
+    cout << "AliEMCAL" << Version() << " : EMCAL geometry initialization failed !" << endl ;   
+  
+  for(i=0;i<80;i++) printf("*");
+  printf("\n");
+  
+}
+

diff --git a/EMCAL/AliEMCALv0.h b/EMCAL/AliEMCALv0.h
new file mode 100644 (file)
index 0000000..16c8aed
--- /dev/null
+++ b/EMCAL/AliEMCALv0.h
@@ -0,0 +1,59 @@
+#ifndef ALIEMCALV0_H
+#define ALIEMCALV0_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                      
+         */
+/* $Id$ */
+
+//_________________________________________________________________________
+// Implementation version v0 of EMCAL Manager class 
+//*--                  
+//*-- Author: Yves Schutz (SUBATECH)
+
+#include <assert.h>
+
+// --- ROOT system ---
+
+// --- AliRoot header files ---
+#include "AliEMCAL.h"
+class AliEMCALGeometry ; 
+
+class AliEMCALv0 : public AliEMCAL {
+
+ public:
+
+  AliEMCALv0() {fGeom=0;}
+  AliEMCALv0(const char *name, const char *title="") ;
+  AliEMCALv0(const AliEMCALv0 & emcal) {
+    // cpy ctor: no implementation yet
+    // requested by the Coding Convention
+    assert(0==1) ; 
+  } 
+  virtual ~AliEMCALv0(void){} 
+
+  virtual void   BuildGeometry(void) ;             // creates the geometry for the ROOT display
+  virtual void   CreateGeometry(void) ;            // creates the geometry for GEANT
+
+  virtual void   Init(void) ;                                       // does nothing
+  virtual Int_t  IsVersion(void) const { 
+    // Gives the version number 
+    return 0 ; 
+  }
+  virtual TString Version(void){ 
+    // As above
+    return TString("v0") ; 
+  }
+  
+  AliEMCALv0 & operator = (const AliEMCALv0 & rvalue)  {
+    // assignement operator requested by coding convention but not needed
+    assert(0==1) ;
+    return *this ; 
+  }
+  
+ protected:
+    
+  ClassDef(AliEMCALv0,1)  // Implementation of EMCAL manager class for layout EMC+PPSD
+    
+    };
+    
+#endif // AliEMCALV0_H

diff --git a/EMCAL/EMCALCint.cxx b/EMCAL/EMCALCint.cxx
new file mode 100644 (file)
index 0000000..82a4cc5
--- /dev/null
+++ b/EMCAL/EMCALCint.cxx
@@ -0,0 +1,1331 @@
+//
+// File generated by rootcint at Wed Apr  4 13:09:04 2001.
+// Do NOT change. Changes will be lost next time file is generated
+//
+#include "EMCALCint.h"
+
+#include "TClass.h"
+#include "TBuffer.h"
+#include "TMemberInspector.h"
+#include "TError.h"
+
+#ifndef G__ROOT
+#define G__ROOT
+#endif
+
+//______________________________________________________________________________
+TBuffer &operator>>(TBuffer &buf, AliEMCALGeometry *&obj)
+{
+   // Read a pointer to an object of class AliEMCALGeometry.
+
+   obj = (AliEMCALGeometry *) buf.ReadObject(AliEMCALGeometry::Class());
+   return buf;
+}
+
+//______________________________________________________________________________
+TBuffer &operator>>(TBuffer &buf, AliEMCAL *&obj)
+{
+   // Read a pointer to an object of class AliEMCAL.
+
+   obj = (AliEMCAL *) buf.ReadObject(AliEMCAL::Class());
+   return buf;
+}
+
+//______________________________________________________________________________
+TBuffer &operator>>(TBuffer &buf, AliEMCALv0 *&obj)
+{
+   // Read a pointer to an object of class AliEMCALv0.
+
+   obj = (AliEMCALv0 *) buf.ReadObject(AliEMCALv0::Class());
+   return buf;
+}
+
+//______________________________________________________________________________
+void R__AliEMCAL_fGeom(TBuffer &R__b, void *R__p, int)
+{
+   AliEMCALGeometry** fGeom = (AliEMCALGeometry**)R__p;
+   if (R__b.IsReading()) {
+      R__b >> *fGeom;
+   } else {
+      R__b << (TObject*)*fGeom;
+   }
+}
+
+//______________________________________________________________________________
+void R__AliEMCAL_fSDigits(TBuffer &R__b, void *R__p, int)
+{
+   TClonesArray** fSDigits = (TClonesArray**)R__p;
+   if (R__b.IsReading()) {
+      R__b >> *fSDigits;
+   } else {
+      R__b << (TObject*)*fSDigits;
+   }
+}
+
+//______________________________________________________________________________
+void R__AliEMCAL_fDigits(TBuffer &R__b, void *R__p, int)
+{
+   TClonesArray** fDigits = (TClonesArray**)R__p;
+   if (R__b.IsReading()) {
+      R__b >> *fDigits;
+   } else {
+      R__b << (TObject*)*fDigits;
+   }
+}
+
+//______________________________________________________________________________
+void AliEMCAL::Streamer(TBuffer &R__b)
+{
+   // Stream an object of class AliEMCAL.
+
+   if (R__b.IsReading()) {
+      AliEMCAL::Class()->ReadBuffer(R__b, this);
+   } else {
+      AliEMCAL::Class()->WriteBuffer(R__b, this);
+   }
+}
+
+//______________________________________________________________________________
+void AliEMCAL::ShowMembers(TMemberInspector &R__insp, char *R__parent)
+{
+   // Inspect the data members of an object of class AliEMCAL.
+
+   TClass *R__cl  = AliEMCAL::IsA();
+   Int_t   R__ncp = strlen(R__parent);
+   if (R__ncp || R__cl || R__insp.IsA()) { }
+   R__insp.Inspect(R__cl, R__parent, "*fGeom", &fGeom);
+   R__cl->SetStreamer("*fGeom",R__AliEMCAL_fGeom);
+   R__insp.Inspect(R__cl, R__parent, "*fSDigits", &fSDigits);
+   R__cl->SetStreamer("*fSDigits",R__AliEMCAL_fSDigits);
+   R__insp.Inspect(R__cl, R__parent, "*fDigits", &fDigits);
+   R__cl->SetStreamer("*fDigits",R__AliEMCAL_fDigits);
+   AliDetector::ShowMembers(R__insp, R__parent);
+}
+
+//______________________________________________________________________________
+const char *AliEMCAL::Class_Name()
+{
+   // Return the class name for AliEMCAL.
+   return "AliEMCAL";
+}
+
+// Static variable to hold initialization object
+static AliEMCAL::R__Init __gR__InitAliEMCAL(4);
+
+//______________________________________________________________________________
+void AliEMCALGeometry::Streamer(TBuffer &R__b)
+{
+   // Stream an object of class AliEMCALGeometry.
+
+   if (R__b.IsReading()) {
+      AliEMCALGeometry::Class()->ReadBuffer(R__b, this);
+   } else {
+      AliEMCALGeometry::Class()->WriteBuffer(R__b, this);
+   }
+}
+
+//______________________________________________________________________________
+void AliEMCALGeometry::ShowMembers(TMemberInspector &R__insp, char *R__parent)
+{
+   // Inspect the data members of an object of class AliEMCALGeometry.
+
+   TClass *R__cl  = AliEMCALGeometry::IsA();
+   Int_t   R__ncp = strlen(R__parent);
+   if (R__ncp || R__cl || R__insp.IsA()) { }
+   R__insp.Inspect(R__cl, R__parent, "fAirGap", &fAirGap);
+   R__insp.Inspect(R__cl, R__parent, "fArm1PhiMin", &fArm1PhiMin);
+   R__insp.Inspect(R__cl, R__parent, "fArm1PhiMax", &fArm1PhiMax);
+   R__insp.Inspect(R__cl, R__parent, "fArm2PhiMin", &fArm2PhiMin);
+   R__insp.Inspect(R__cl, R__parent, "fArm2PhiMax", &fArm2PhiMax);
+   R__insp.Inspect(R__cl, R__parent, "fEnvelop[3]", fEnvelop);
+   R__insp.Inspect(R__cl, R__parent, "fIPDistance", &fIPDistance);
+   R__insp.Inspect(R__cl, R__parent, "fShellThickness", &fShellThickness);
+   R__insp.Inspect(R__cl, R__parent, "fZLength", &fZLength);
+   R__insp.Inspect(R__cl, R__parent, "fAmat", &fAmat);
+   R__insp.Inspect(R__cl, R__parent, "fZmat", &fZmat);
+   R__insp.Inspect(R__cl, R__parent, "fDmat", &fDmat);
+   R__insp.Inspect(R__cl, R__parent, "fRmat", &fRmat);
+   R__insp.Inspect(R__cl, R__parent, "fEmat", &fEmat);
+   AliGeometry::ShowMembers(R__insp, R__parent);
+}
+
+//______________________________________________________________________________
+const char *AliEMCALGeometry::Class_Name()
+{
+   // Return the class name for AliEMCALGeometry.
+   return "AliEMCALGeometry";
+}
+
+// Static variable to hold initialization object
+static AliEMCALGeometry::R__Init __gR__InitAliEMCALGeometry(4);
+
+//______________________________________________________________________________
+void AliEMCALv0::Streamer(TBuffer &R__b)
+{
+   // Stream an object of class AliEMCALv0.
+
+   if (R__b.IsReading()) {
+      AliEMCALv0::Class()->ReadBuffer(R__b, this);
+   } else {
+      AliEMCALv0::Class()->WriteBuffer(R__b, this);
+   }
+}
+
+//______________________________________________________________________________
+void AliEMCALv0::ShowMembers(TMemberInspector &R__insp, char *R__parent)
+{
+   // Inspect the data members of an object of class AliEMCALv0.
+
+   TClass *R__cl  = AliEMCALv0::IsA();
+   Int_t   R__ncp = strlen(R__parent);
+   if (R__ncp || R__cl || R__insp.IsA()) { }
+   AliEMCAL::ShowMembers(R__insp, R__parent);
+}
+
+//______________________________________________________________________________
+const char *AliEMCALv0::Class_Name()
+{
+   // Return the class name for AliEMCALv0.
+   return "AliEMCALv0";
+}
+
+// Static variable to hold initialization object
+static AliEMCALv0::R__Init __gR__InitAliEMCALv0(4);
+
+/********************************************************
+* EMCALCint.cxx
+********************************************************/
+
+#ifdef G__MEMTEST
+#undef malloc
+#undef free
+#endif
+
+extern "C" void G__cpp_reset_tagtableEMCALCint();
+
+extern "C" void G__set_cpp_environmentEMCALCint() {
+  G__add_compiledheader("TROOT.h");
+  G__add_compiledheader("TMemberInspector.h");
+  G__add_compiledheader("AliEMCAL.h");
+  G__add_compiledheader("AliEMCALGeometry.h");
+  G__add_compiledheader("AliEMCALv0.h");
+  G__add_compiledheader("/usr/remote/prive/alice/root/new/include/TTree.h");
+  G__cpp_reset_tagtableEMCALCint();
+}
+class G__EMCALCintdOcxx_tag {};
+
+void* operator new(size_t size,G__EMCALCintdOcxx_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__EMCALCintdOcxx_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_EMCALCintdOcxx() { G__operator_delete(0); }
+
+extern "C" int G__cpp_dllrevEMCALCint() { return(30051472); }
+
+/*********************************************************
+* Member function Interface Method
+*********************************************************/
+
+/* AliEMCALGeometry */
+static int G__AliEMCALGeometry_AliEMCALGeometry_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliEMCALGeometry *p=NULL;
+   if(G__getaryconstruct()) p=new AliEMCALGeometry[G__getaryconstruct()];
+   else                    p=new AliEMCALGeometry;
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_AliEMCALGeometry_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliEMCALGeometry *p=NULL;
+      p = new AliEMCALGeometry(*(AliEMCALGeometry*)libp->para[0].ref);
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetInstance_3_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   switch(libp->paran) {
+   case 2:
+      G__letint(result7,85,(long)((AliEMCALGeometry*)(G__getstructoffset()))->GetInstance((const Text_t*)G__int(libp->para[0]),(const Text_t*)G__int(libp->para[1])));
+      break;
+   case 1:
+      G__letint(result7,85,(long)((AliEMCALGeometry*)(G__getstructoffset()))->GetInstance((const Text_t*)G__int(libp->para[0])));
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetInstance_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliEMCALGeometry*)(G__getstructoffset()))->GetInstance());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_operatoreQ_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      {
+        const AliEMCALGeometry& obj=((const AliEMCALGeometry*)(G__getstructoffset()))->operator=(*(AliEMCALGeometry*)libp->para[0].ref);
+         result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
+      }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetGlobal_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((const AliEMCALGeometry*)(G__getstructoffset()))->GetGlobal((const AliRecPoint*)G__int(libp->para[0]),*(TVector3*)libp->para[1].ref
+,*(TMatrix*)libp->para[2].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetGlobal_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((const AliEMCALGeometry*)(G__getstructoffset()))->GetGlobal((const AliRecPoint*)G__int(libp->para[0]),*(TVector3*)libp->para[1].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_IsInitialized_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,98,(long)((const AliEMCALGeometry*)(G__getstructoffset()))->IsInitialized());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetAirGap_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliEMCALGeometry*)(G__getstructoffset()))->GetAirGap());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetArm1PhiMin_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliEMCALGeometry*)(G__getstructoffset()))->GetArm1PhiMin());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetArm1PhiMax_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliEMCALGeometry*)(G__getstructoffset()))->GetArm1PhiMax());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetArm2PhiMin_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliEMCALGeometry*)(G__getstructoffset()))->GetArm2PhiMin());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetArm2PhiMax_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliEMCALGeometry*)(G__getstructoffset()))->GetArm2PhiMax());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetIPDistance_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliEMCALGeometry*)(G__getstructoffset()))->GetIPDistance());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetEnvelop_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliEMCALGeometry*)(G__getstructoffset()))->GetEnvelop((Int_t)G__int(libp->para[0])));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetShellThickness_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliEMCALGeometry*)(G__getstructoffset()))->GetShellThickness());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetZLength_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliEMCALGeometry*)(G__getstructoffset()))->GetZLength());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetAmat_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliEMCALGeometry*)(G__getstructoffset()))->GetAmat());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetZmat_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliEMCALGeometry*)(G__getstructoffset()))->GetZmat());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetDmat_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliEMCALGeometry*)(G__getstructoffset()))->GetDmat());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetRmat_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliEMCALGeometry*)(G__getstructoffset()))->GetRmat());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetEmat_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliEMCALGeometry*)(G__getstructoffset()))->GetEmat());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_GetLmat_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letdouble(result7,102,(double)((const AliEMCALGeometry*)(G__getstructoffset()))->GetLmat());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_Class_6_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliEMCALGeometry*)(G__getstructoffset()))->Class());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_Class_Name_7_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliEMCALGeometry*)(G__getstructoffset()))->Class_Name());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_Class_Version_8_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,115,(long)((AliEMCALGeometry*)(G__getstructoffset()))->Class_Version());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_Dictionary_9_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCALGeometry*)(G__getstructoffset()))->Dictionary();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_IsA_0_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((const AliEMCALGeometry*)(G__getstructoffset()))->IsA());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_ShowMembers_1_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCALGeometry*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_Streamer_2_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCALGeometry*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_StreamerNVirtual_3_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCALGeometry*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_DeclFileName_4_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliEMCALGeometry*)(G__getstructoffset()))->DeclFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_DeclFileLine_5_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliEMCALGeometry*)(G__getstructoffset()))->DeclFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_ImplFileName_6_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliEMCALGeometry*)(G__getstructoffset()))->ImplFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALGeometry_ImplFileLine_7_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliEMCALGeometry*)(G__getstructoffset()))->ImplFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+// automatic destructor
+typedef AliEMCALGeometry G__TAliEMCALGeometry;
+static int G__AliEMCALGeometry_wAAliEMCALGeometry_8_3(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   if(G__getaryconstruct())
+     if(G__PVOID==G__getgvp())
+       delete[] (AliEMCALGeometry *)(G__getstructoffset());
+     else
+       for(int i=G__getaryconstruct()-1;i>=0;i--)
+         delete (AliEMCALGeometry *)((G__getstructoffset())+sizeof(AliEMCALGeometry)*i);
+   else  delete (AliEMCALGeometry *)(G__getstructoffset());
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+
+/* AliEMCAL */
+static int G__AliEMCAL_AliEMCAL_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliEMCAL *p=NULL;
+   if(G__getaryconstruct()) p=new AliEMCAL[G__getaryconstruct()];
+   else                    p=new AliEMCAL;
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_AliEMCAL_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliEMCAL *p=NULL;
+   switch(libp->paran) {
+   case 2:
+      p = new AliEMCAL((const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1]));
+      break;
+   case 1:
+      p = new AliEMCAL((const char*)G__int(libp->para[0]));
+      break;
+   }
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_AliEMCAL_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliEMCAL *p=NULL;
+      p = new AliEMCAL(*(AliEMCAL*)libp->para[0].ref);
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_CreateMaterials_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCAL*)(G__getstructoffset()))->CreateMaterials();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_GetGeometry_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliEMCAL*)(G__getstructoffset()))->GetGeometry());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_IsVersion_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((const AliEMCAL*)(G__getstructoffset()))->IsVersion());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_SetTreeAddress_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCAL*)(G__getstructoffset()))->SetTreeAddress();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_SDigits_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((const AliEMCAL*)(G__getstructoffset()))->SDigits());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_Version_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      {
+        TString *pobj,xobj=((AliEMCAL*)(G__getstructoffset()))->Version();
+        pobj=new TString(xobj);
+        result7->obj.i=(long)((void*)pobj); result7->ref=result7->obj.i;
+        G__store_tempobject(*result7);
+      }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_operatoreQ_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      {
+        AliEMCAL& obj=((AliEMCAL*)(G__getstructoffset()))->operator=(*(AliEMCAL*)libp->para[0].ref);
+         result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
+      }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_Class_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliEMCAL*)(G__getstructoffset()))->Class());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_Class_Name_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliEMCAL*)(G__getstructoffset()))->Class_Name());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_Class_Version_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,115,(long)((AliEMCAL*)(G__getstructoffset()))->Class_Version());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_Dictionary_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCAL*)(G__getstructoffset()))->Dictionary();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_IsA_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((const AliEMCAL*)(G__getstructoffset()))->IsA());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_ShowMembers_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCAL*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_Streamer_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCAL*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_StreamerNVirtual_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCAL*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_DeclFileName_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliEMCAL*)(G__getstructoffset()))->DeclFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_DeclFileLine_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliEMCAL*)(G__getstructoffset()))->DeclFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_ImplFileName_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliEMCAL*)(G__getstructoffset()))->ImplFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCAL_ImplFileLine_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliEMCAL*)(G__getstructoffset()))->ImplFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+// automatic destructor
+typedef AliEMCAL G__TAliEMCAL;
+static int G__AliEMCAL_wAAliEMCAL_3_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   if(G__getaryconstruct())
+     if(G__PVOID==G__getgvp())
+       delete[] (AliEMCAL *)(G__getstructoffset());
+     else
+       for(int i=G__getaryconstruct()-1;i>=0;i--)
+         delete (AliEMCAL *)((G__getstructoffset())+sizeof(AliEMCAL)*i);
+   else  delete (AliEMCAL *)(G__getstructoffset());
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+
+/* AliEMCALv0 */
+static int G__AliEMCALv0_AliEMCALv0_0_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliEMCALv0 *p=NULL;
+   if(G__getaryconstruct()) p=new AliEMCALv0[G__getaryconstruct()];
+   else                    p=new AliEMCALv0;
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_AliEMCALv0_1_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliEMCALv0 *p=NULL;
+   switch(libp->paran) {
+   case 2:
+      p = new AliEMCALv0((const char*)G__int(libp->para[0]),(const char*)G__int(libp->para[1]));
+      break;
+   case 1:
+      p = new AliEMCALv0((const char*)G__int(libp->para[0]));
+      break;
+   }
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_AliEMCALv0_2_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   AliEMCALv0 *p=NULL;
+      p = new AliEMCALv0(*(AliEMCALv0*)libp->para[0].ref);
+      result7->obj.i = (long)p;
+      result7->ref = (long)p;
+      result7->type = 'u';
+      result7->tagnum = G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_BuildGeometry_4_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCALv0*)(G__getstructoffset()))->BuildGeometry();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_CreateGeometry_5_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCALv0*)(G__getstructoffset()))->CreateGeometry();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_Init_6_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCALv0*)(G__getstructoffset()))->Init();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_IsVersion_7_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((const AliEMCALv0*)(G__getstructoffset()))->IsVersion());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_Version_8_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      {
+        TString *pobj,xobj=((AliEMCALv0*)(G__getstructoffset()))->Version();
+        pobj=new TString(xobj);
+        result7->obj.i=(long)((void*)pobj); result7->ref=result7->obj.i;
+        G__store_tempobject(*result7);
+      }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_operatoreQ_9_0(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      {
+        AliEMCALv0& obj=((AliEMCALv0*)(G__getstructoffset()))->operator=(*(AliEMCALv0*)libp->para[0].ref);
+         result7->ref=(long)(&obj); result7->obj.i=(long)(&obj);
+      }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_Class_0_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((AliEMCALv0*)(G__getstructoffset()))->Class());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_Class_Name_1_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliEMCALv0*)(G__getstructoffset()))->Class_Name());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_Class_Version_2_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,115,(long)((AliEMCALv0*)(G__getstructoffset()))->Class_Version());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_Dictionary_3_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCALv0*)(G__getstructoffset()))->Dictionary();
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_IsA_4_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,85,(long)((const AliEMCALv0*)(G__getstructoffset()))->IsA());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_ShowMembers_5_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCALv0*)(G__getstructoffset()))->ShowMembers(*(TMemberInspector*)libp->para[0].ref,(char*)G__int(libp->para[1]));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_Streamer_6_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCALv0*)(G__getstructoffset()))->Streamer(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_StreamerNVirtual_7_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__setnull(result7);
+      ((AliEMCALv0*)(G__getstructoffset()))->StreamerNVirtual(*(TBuffer*)libp->para[0].ref);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_DeclFileName_8_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliEMCALv0*)(G__getstructoffset()))->DeclFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_DeclFileLine_9_1(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliEMCALv0*)(G__getstructoffset()))->DeclFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_ImplFileName_0_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,67,(long)((AliEMCALv0*)(G__getstructoffset()))->ImplFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AliEMCALv0_ImplFileLine_1_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+      G__letint(result7,105,(long)((AliEMCALv0*)(G__getstructoffset()))->ImplFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+// automatic destructor
+typedef AliEMCALv0 G__TAliEMCALv0;
+static int G__AliEMCALv0_wAAliEMCALv0_2_2(G__value *result7,G__CONST char *funcname,struct G__param *libp,int hash) {
+   if(G__getaryconstruct())
+     if(G__PVOID==G__getgvp())
+       delete[] (AliEMCALv0 *)(G__getstructoffset());
+     else
+       for(int i=G__getaryconstruct()-1;i>=0;i--)
+         delete (AliEMCALv0 *)((G__getstructoffset())+sizeof(AliEMCALv0)*i);
+   else  delete (AliEMCALv0 *)(G__getstructoffset());
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+
+/* Setting up global function */
+
+/*********************************************************
+* Member function Stub
+*********************************************************/
+
+/* AliEMCALGeometry */
+
+/* AliEMCAL */
+
+/* AliEMCALv0 */
+
+/*********************************************************
+* Global function Stub
+*********************************************************/
+
+/*********************************************************
+* Get size of pointer to member function
+*********************************************************/
+class G__Sizep2memfuncEMCALCint {
+ public:
+  G__Sizep2memfuncEMCALCint() {p=&G__Sizep2memfuncEMCALCint::sizep2memfunc;}
+    size_t sizep2memfunc() { return(sizeof(p)); }
+  private:
+    size_t (G__Sizep2memfuncEMCALCint::*p)();
+};
+
+size_t G__get_sizep2memfuncEMCALCint()
+{
+  G__Sizep2memfuncEMCALCint 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_inheritanceEMCALCint() {
+
+   /* Setting up class inheritance */
+   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry))) {
+     AliEMCALGeometry *G__Lderived;
+     G__Lderived=(AliEMCALGeometry*)0x1000;
+     {
+       AliGeometry *G__Lpbase=(AliGeometry*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry),G__get_linked_tagnum(&G__EMCALCintLN_AliGeometry),(long)G__Lpbase-(long)G__Lderived,1,1);
+     }
+     {
+       TNamed *G__Lpbase=(TNamed*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry),G__get_linked_tagnum(&G__EMCALCintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TObject *G__Lpbase=(TObject*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry),G__get_linked_tagnum(&G__EMCALCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+   }
+   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL))) {
+     AliEMCAL *G__Lderived;
+     G__Lderived=(AliEMCAL*)0x1000;
+     {
+       AliDetector *G__Lpbase=(AliDetector*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL),G__get_linked_tagnum(&G__EMCALCintLN_AliDetector),(long)G__Lpbase-(long)G__Lderived,1,1);
+     }
+     {
+       AliModule *G__Lpbase=(AliModule*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL),G__get_linked_tagnum(&G__EMCALCintLN_AliModule),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TNamed *G__Lpbase=(TNamed*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL),G__get_linked_tagnum(&G__EMCALCintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TObject *G__Lpbase=(TObject*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL),G__get_linked_tagnum(&G__EMCALCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL),G__get_linked_tagnum(&G__EMCALCintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL),G__get_linked_tagnum(&G__EMCALCintLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       AliRndm *G__Lpbase=(AliRndm*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL),G__get_linked_tagnum(&G__EMCALCintLN_AliRndm),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+   }
+   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__EMCALCintLN_AliGeometry))) {
+     AliGeometry *G__Lderived;
+     G__Lderived=(AliGeometry*)0x1000;
+     {
+       TNamed *G__Lpbase=(TNamed*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliGeometry),G__get_linked_tagnum(&G__EMCALCintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
+     }
+     {
+       TObject *G__Lpbase=(TObject*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliGeometry),G__get_linked_tagnum(&G__EMCALCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+   }
+   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0))) {
+     AliEMCALv0 *G__Lderived;
+     G__Lderived=(AliEMCALv0*)0x1000;
+     {
+       AliEMCAL *G__Lpbase=(AliEMCAL*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0),G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL),(long)G__Lpbase-(long)G__Lderived,1,1);
+     }
+     {
+       AliDetector *G__Lpbase=(AliDetector*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0),G__get_linked_tagnum(&G__EMCALCintLN_AliDetector),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       AliModule *G__Lpbase=(AliModule*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0),G__get_linked_tagnum(&G__EMCALCintLN_AliModule),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TNamed *G__Lpbase=(TNamed*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0),G__get_linked_tagnum(&G__EMCALCintLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TObject *G__Lpbase=(TObject*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0),G__get_linked_tagnum(&G__EMCALCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0),G__get_linked_tagnum(&G__EMCALCintLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0),G__get_linked_tagnum(&G__EMCALCintLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+     {
+       AliRndm *G__Lpbase=(AliRndm*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0),G__get_linked_tagnum(&G__EMCALCintLN_AliRndm),(long)G__Lpbase-(long)G__Lderived,1,0);
+     }
+   }
+}
+
+/*********************************************************
+* typedef information setup/
+*********************************************************/
+extern "C" void G__cpp_setup_typetableEMCALCint() {
+
+   /* Setting up typedef entry */
+   G__search_typename2("Char_t",99,-1,0,
+-1);
+   G__setnewtype(-1,"Signed Character 1 byte",0);
+   G__search_typename2("UChar_t",98,-1,0,
+-1);
+   G__setnewtype(-1,"Unsigned Character 1 byte",0);
+   G__search_typename2("Short_t",115,-1,0,
+-1);
+   G__setnewtype(-1,"Signed Short integer 2 bytes",0);
+   G__search_typename2("UShort_t",114,-1,0,
+-1);
+   G__setnewtype(-1,"Unsigned Short integer 2 bytes",0);
+   G__search_typename2("Int_t",105,-1,0,
+-1);
+   G__setnewtype(-1,"Signed integer 4 bytes",0);
+   G__search_typename2("UInt_t",104,-1,0,
+-1);
+   G__setnewtype(-1,"Unsigned integer 4 bytes",0);
+   G__search_typename2("Seek_t",105,-1,0,
+-1);
+   G__setnewtype(-1,"File pointer",0);
+   G__search_typename2("Long_t",108,-1,0,
+-1);
+   G__setnewtype(-1,"Signed long integer 4 bytes",0);
+   G__search_typename2("ULong_t",107,-1,0,
+-1);
+   G__setnewtype(-1,"Unsigned long integer 4 bytes",0);
+   G__search_typename2("Float_t",102,-1,0,
+-1);
+   G__setnewtype(-1,"Float 4 bytes",0);
+   G__search_typename2("Double_t",100,-1,0,
+-1);
+   G__setnewtype(-1,"Float 8 bytes",0);
+   G__search_typename2("Text_t",99,-1,0,
+-1);
+   G__setnewtype(-1,"General string",0);
+   G__search_typename2("Bool_t",98,-1,0,
+-1);
+   G__setnewtype(-1,"Boolean (0=false, 1=true)",0);
+   G__search_typename2("Byte_t",98,-1,0,
+-1);
+   G__setnewtype(-1,"Byte (8 bits)",0);
+   G__search_typename2("Version_t",115,-1,0,
+-1);
+   G__setnewtype(-1,"Class version identifier",0);
+   G__search_typename2("Option_t",99,-1,0,
+-1);
+   G__setnewtype(-1,"Option string",0);
+   G__search_typename2("Ssiz_t",105,-1,0,
+-1);
+   G__setnewtype(-1,"String size",0);
+   G__search_typename2("Real_t",102,-1,0,
+-1);
+   G__setnewtype(-1,"TVector and TMatrix element type",0);
+   G__search_typename2("Streamer_t",89,-1,0,
+-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("VoidFuncPtr_t",89,-1,0,
+-1);
+   G__setnewtype(-1,"pointer to void function",0);
+   G__search_typename2("FreeHookFun_t",89,-1,0,
+-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("ReAllocFun_t",81,-1,0,
+-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("ReAllocCFun_t",81,-1,0,
+-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("Axis_t",100,-1,0,
+-1);
+   G__setnewtype(-1,"Axis values type",0);
+   G__search_typename2("Stat_t",100,-1,0,
+-1);
+   G__setnewtype(-1,"Statistics type",0);
+   G__search_typename2("Font_t",115,-1,0,
+-1);
+   G__setnewtype(-1,"Font number",0);
+   G__search_typename2("Style_t",115,-1,0,
+-1);
+   G__setnewtype(-1,"Style number",0);
+   G__search_typename2("Marker_t",115,-1,0,
+-1);
+   G__setnewtype(-1,"Marker number",0);
+   G__search_typename2("Width_t",115,-1,0,
+-1);
+   G__setnewtype(-1,"Line width",0);
+   G__search_typename2("Color_t",115,-1,0,
+-1);
+   G__setnewtype(-1,"Color number",0);
+   G__search_typename2("SCoord_t",115,-1,0,
+-1);
+   G__setnewtype(-1,"Screen coordinates",0);
+   G__search_typename2("Coord_t",100,-1,0,
+-1);
+   G__setnewtype(-1,"Pad world coordinates",0);
+   G__search_typename2("Angle_t",102,-1,0,
+-1);
+   G__setnewtype(-1,"Graphics angle",0);
+   G__search_typename2("Size_t",102,-1,0,
+-1);
+   G__setnewtype(-1,"Attribute size",0);
+}
+
+/*********************************************************
+* Data Member information setup/
+*********************************************************/
+
+   /* Setting up class,struct,union tag member variable */
+
+   /* AliEMCALGeometry */
+static void G__setup_memvarAliEMCALGeometry(void) {
+   G__tag_memvar_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry));
+   { AliEMCALGeometry *p; p=(AliEMCALGeometry*)0x1000; if (p) { }
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry),-1,-2,4,"fgGeom=",0,"pointer to the unique instance of the singleton ");
+   G__memvar_setup((void*)NULL,98,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgInit=",0,"Tells if geometry has been succesfully set up ");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fAirGap=",0,"Distance between envelop and active material ");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fArm1PhiMin=",0,"Minimum phi angle covered by Arm 1 ");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fArm1PhiMax=",0,"Maximum phi angle covered by Arm 1       ");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fArm2PhiMin=",0,"Minimum phi angle covered by Arm 2        ");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fArm2PhiMax=",0,"Maximum phi angle covered by Arm 2");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fEnvelop[3]=",0,"the GEANT TUB that contains the 2 arms");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fIPDistance=",0,"Distance of the inner surface to the interaction point");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fShellThickness=",0,"Total thickness in (x,y) direction");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fZLength=",0,"Total length in z direction");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fAmat=",0,"average atomic weight of the active material");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fZmat=",0,"average atomic number of the active material ");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fDmat=",0,"average density of the active material");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fRmat=",0,"average radiation length of the active material");
+   G__memvar_setup((void*)NULL,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fEmat=",0,"thickness of the active material in radiation length units");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__EMCALCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
+   }
+   G__tag_memvar_reset();
+}
+
+
+   /* AliEMCAL */
+static void G__setup_memvarAliEMCAL(void) {
+   G__tag_memvar_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL));
+   { AliEMCAL *p; p=(AliEMCAL*)0x1000; if (p) { }
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry),-1,-1,2,"fGeom=",0,"Geometry definition");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__EMCALCintLN_TClonesArray),-1,-1,2,"fSDigits=",0,"List of summable digits");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__EMCALCintLN_TClonesArray),-1,-1,2,"fDigits=",0,"List of digits");
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__EMCALCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
+   }
+   G__tag_memvar_reset();
+}
+
+
+   /* AliEMCALv0 */
+static void G__setup_memvarAliEMCALv0(void) {
+   G__tag_memvar_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0));
+   { AliEMCALv0 *p; p=(AliEMCALv0*)0x1000; if (p) { }
+   G__memvar_setup((void*)NULL,85,0,0,G__get_linked_tagnum(&G__EMCALCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
+   }
+   G__tag_memvar_reset();
+}
+
+extern "C" void G__cpp_setup_memvarEMCALCint() {
+}
+/***********************************************************
+************************************************************
+************************************************************
+************************************************************
+************************************************************
+************************************************************
+************************************************************
+***********************************************************/
+
+/*********************************************************
+* Member function information setup for each class
+*********************************************************/
+static void G__setup_memfuncAliEMCALGeometry(void) {
+   /* AliEMCALGeometry */
+   G__tag_memfunc_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry));
+   G__memfunc_setup("AliEMCALGeometry",1476,G__AliEMCALGeometry_AliEMCALGeometry_0_0,105,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("AliEMCALGeometry",1476,G__AliEMCALGeometry_AliEMCALGeometry_1_0,105,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry),-1,0,1,1,1,0,"u 'AliEMCALGeometry' - 11 - geom",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetInstance",1109,G__AliEMCALGeometry_GetInstance_3_0,85,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry),-1,0,2,3,1,0,
+"C - 'Text_t' 10 - name C - 'Text_t' 10 \"\" title",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetInstance",1109,G__AliEMCALGeometry_GetInstance_4_0,85,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("operator=",937,G__AliEMCALGeometry_operatoreQ_5_0,117,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry),-1,1,1,1,1,8,"u 'AliEMCALGeometry' - 11 - rvalue",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetGlobal",881,G__AliEMCALGeometry_GetGlobal_6_0,121,-1,-1,0,3,1,1,8,
+"U 'AliRecPoint' - 10 - - u 'TVector3' - 1 - - "
+"u 'TMatrix' - 1 - -",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("GetGlobal",881,G__AliEMCALGeometry_GetGlobal_7_0,121,-1,-1,0,2,1,1,8,
+"U 'AliRecPoint' - 10 - - u 'TVector3' - 1 - -",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("IsInitialized",1330,G__AliEMCALGeometry_IsInitialized_8_0,98,-1,G__defined_typename("Bool_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetAirGap",852,G__AliEMCALGeometry_GetAirGap_9_0,102,-1,G__defined_typename("Float_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetArm1PhiMin",1206,G__AliEMCALGeometry_GetArm1PhiMin_0_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetArm1PhiMax",1208,G__AliEMCALGeometry_GetArm1PhiMax_1_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetArm2PhiMin",1207,G__AliEMCALGeometry_GetArm2PhiMin_2_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetArm2PhiMax",1209,G__AliEMCALGeometry_GetArm2PhiMax_3_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetIPDistance",1252,G__AliEMCALGeometry_GetIPDistance_4_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetEnvelop",1017,G__AliEMCALGeometry_GetEnvelop_5_1,102,-1,G__defined_typename("Float_t"),0,1,1,1,9,"i - 'Int_t' 0 - index",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetShellThickness",1732,G__AliEMCALGeometry_GetShellThickness_6_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetZLength",988,G__AliEMCALGeometry_GetZLength_7_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetAmat",675,G__AliEMCALGeometry_GetAmat_8_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetZmat",700,G__AliEMCALGeometry_GetZmat_9_1,102,-1,G__defined_typename("Float_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetDmat",678,G__AliEMCALGeometry_GetDmat_0_2,102,-1,G__defined_typename("Float_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetRmat",692,G__AliEMCALGeometry_GetRmat_1_2,102,-1,G__defined_typename("Float_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetEmat",679,G__AliEMCALGeometry_GetEmat_2_2,102,-1,G__defined_typename("Float_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("GetLmat",686,G__AliEMCALGeometry_GetLmat_3_2,102,-1,G__defined_typename("Float_t"),0,0,1,1,9,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("AliEMCALGeometry",1476,(G__InterfaceMethod)NULL,105,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry),-1,0,2,1,2,0,
+"C - 'Text_t' 10 - name C - 'Text_t' 10 \"\" title",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Init",404,(G__InterfaceMethod)NULL,121,-1,-1,0,0,1,2,0,"","initializes the parameters of EMCAL ",(void*)NULL,0);
+   G__memfunc_setup("Class",502,G__AliEMCALGeometry_Class_6_2,85,G__get_linked_tagnum(&G__EMCALCintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Name",982,G__AliEMCALGeometry_Class_Name_7_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Version",1339,G__AliEMCALGeometry_Class_Version_8_2,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Dictionary",1046,G__AliEMCALGeometry_Dictionary_9_2,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("IsA",253,G__AliEMCALGeometry_IsA_0_3,85,G__get_linked_tagnum(&G__EMCALCintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("ShowMembers",1132,G__AliEMCALGeometry_ShowMembers_1_3,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__AliEMCALGeometry_Streamer_2_3,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("StreamerNVirtual",1656,G__AliEMCALGeometry_StreamerNVirtual_3_3,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileName",1145,G__AliEMCALGeometry_DeclFileName_4_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileLine",1152,G__AliEMCALGeometry_DeclFileLine_5_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileName",1171,G__AliEMCALGeometry_ImplFileName_6_3,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileLine",1178,G__AliEMCALGeometry_ImplFileLine_7_3,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   // automatic destructor
+   G__memfunc_setup("~AliEMCALGeometry",1602,G__AliEMCALGeometry_wAAliEMCALGeometry_8_3,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__tag_memfunc_reset();
+}
+
+static void G__setup_memfuncAliEMCAL(void) {
+   /* AliEMCAL */
+   G__tag_memfunc_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL));
+   G__memfunc_setup("AliEMCAL",632,G__AliEMCAL_AliEMCAL_0_0,105,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("AliEMCAL",632,G__AliEMCAL_AliEMCAL_1_0,105,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL),-1,0,2,1,1,0,
+"C - - 10 - name C - - 10 \"\" title",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("AliEMCAL",632,G__AliEMCAL_AliEMCAL_2_0,105,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL),-1,0,1,1,1,0,"u 'AliEMCAL' - 11 - emcal",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("CreateMaterials",1526,G__AliEMCAL_CreateMaterials_4_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("GetGeometry",1132,G__AliEMCAL_GetGeometry_5_0,85,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("IsVersion",930,G__AliEMCAL_IsVersion_6_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SetTreeAddress",1410,G__AliEMCAL_SetTreeAddress_7_0,121,-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("SDigits",695,G__AliEMCAL_SDigits_8_0,85,G__get_linked_tagnum(&G__EMCALCintLN_TClonesArray),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Version",742,G__AliEMCAL_Version_9_0,117,G__get_linked_tagnum(&G__EMCALCintLN_TString),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("operator=",937,G__AliEMCAL_operatoreQ_0_1,117,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL),-1,1,1,1,1,0,"u 'AliEMCAL' - 11 - rvalue",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class",502,G__AliEMCAL_Class_1_1,85,G__get_linked_tagnum(&G__EMCALCintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Name",982,G__AliEMCAL_Class_Name_2_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Version",1339,G__AliEMCAL_Class_Version_3_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Dictionary",1046,G__AliEMCAL_Dictionary_4_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("IsA",253,G__AliEMCAL_IsA_5_1,85,G__get_linked_tagnum(&G__EMCALCintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("ShowMembers",1132,G__AliEMCAL_ShowMembers_6_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__AliEMCAL_Streamer_7_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("StreamerNVirtual",1656,G__AliEMCAL_StreamerNVirtual_8_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileName",1145,G__AliEMCAL_DeclFileName_9_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileLine",1152,G__AliEMCAL_DeclFileLine_0_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileName",1171,G__AliEMCAL_ImplFileName_1_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileLine",1178,G__AliEMCAL_ImplFileLine_2_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   // automatic destructor
+   G__memfunc_setup("~AliEMCAL",758,G__AliEMCAL_wAAliEMCAL_3_2,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__tag_memfunc_reset();
+}
+
+static void G__setup_memfuncAliEMCALv0(void) {
+   /* AliEMCALv0 */
+   G__tag_memfunc_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0));
+   G__memfunc_setup("AliEMCALv0",798,G__AliEMCALv0_AliEMCALv0_0_0,105,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("AliEMCALv0",798,G__AliEMCALv0_AliEMCALv0_1_0,105,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0),-1,0,2,1,1,0,
+"C - - 10 - name C - - 10 \"\" title",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("AliEMCALv0",798,G__AliEMCALv0_AliEMCALv0_2_0,105,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0),-1,0,1,1,1,0,"u 'AliEMCALv0' - 11 - emcal",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("BuildGeometry",1340,G__AliEMCALv0_BuildGeometry_4_0,121,-1,-1,0,0,1,1,0,"","creates the geometry for the ROOT display",(void*)NULL,1);
+   G__memfunc_setup("CreateGeometry",1440,G__AliEMCALv0_CreateGeometry_5_0,121,-1,-1,0,0,1,1,0,"","creates the geometry for GEANT",(void*)NULL,1);
+   G__memfunc_setup("Init",404,G__AliEMCALv0_Init_6_0,121,-1,-1,0,0,1,1,0,"","does nothing",(void*)NULL,1);
+   G__memfunc_setup("IsVersion",930,G__AliEMCALv0_IsVersion_7_0,105,-1,G__defined_typename("Int_t"),0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("Version",742,G__AliEMCALv0_Version_8_0,117,G__get_linked_tagnum(&G__EMCALCintLN_TString),-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("operator=",937,G__AliEMCALv0_operatoreQ_9_0,117,G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0),-1,1,1,1,1,0,"u 'AliEMCALv0' - 11 - rvalue",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class",502,G__AliEMCALv0_Class_0_1,85,G__get_linked_tagnum(&G__EMCALCintLN_TClass),-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Name",982,G__AliEMCALv0_Class_Name_1_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Class_Version",1339,G__AliEMCALv0_Class_Version_2_1,115,-1,G__defined_typename("Version_t"),0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("Dictionary",1046,G__AliEMCALv0_Dictionary_3_1,121,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("IsA",253,G__AliEMCALv0_IsA_4_1,85,G__get_linked_tagnum(&G__EMCALCintLN_TClass),-1,0,0,1,1,8,"",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("ShowMembers",1132,G__AliEMCALv0_ShowMembers_5_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__AliEMCALv0_Streamer_6_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,1);
+   G__memfunc_setup("StreamerNVirtual",1656,G__AliEMCALv0_StreamerNVirtual_7_1,121,-1,-1,0,1,1,1,0,"u 'TBuffer' - 1 - b",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileName",1145,G__AliEMCALv0_DeclFileName_8_1,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("DeclFileLine",1152,G__AliEMCALv0_DeclFileLine_9_1,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileName",1171,G__AliEMCALv0_ImplFileName_0_2,67,-1,-1,0,0,3,1,1,"",(char*)NULL,(void*)NULL,0);
+   G__memfunc_setup("ImplFileLine",1178,G__AliEMCALv0_ImplFileLine_1_2,105,-1,-1,0,0,3,1,0,"",(char*)NULL,(void*)NULL,0);
+   // automatic destructor
+   G__memfunc_setup("~AliEMCALv0",924,G__AliEMCALv0_wAAliEMCALv0_2_2,(int)('y'),-1,-1,0,0,1,1,0,"",(char*)NULL,(void*)NULL,1);
+   G__tag_memfunc_reset();
+}
+
+
+/*********************************************************
+* Member function information setup
+*********************************************************/
+extern "C" void G__cpp_setup_memfuncEMCALCint() {
+}
+
+/*********************************************************
+* Global variable information setup for each class
+*********************************************************/
+extern "C" void G__cpp_setup_globalEMCALCint() {
+
+   /* Setting up global variables */
+   G__resetplocal();
+
+
+   G__resetglobalenv();
+}
+
+/*********************************************************
+* Global function information setup for each class
+*********************************************************/
+extern "C" void G__cpp_setup_funcEMCALCint() {
+   G__lastifuncposition();
+
+
+   G__resetifuncposition();
+}
+
+/*********************************************************
+* Class,struct,union,enum tag information setup
+*********************************************************/
+/* Setup class/struct taginfo */
+G__linked_taginfo G__EMCALCintLN_TClass = { "TClass" , 99 , -1 };
+G__linked_taginfo G__EMCALCintLN_TObject = { "TObject" , 99 , -1 };
+G__linked_taginfo G__EMCALCintLN_TString = { "TString" , 99 , -1 };
+G__linked_taginfo G__EMCALCintLN_TNamed = { "TNamed" , 99 , -1 };
+G__linked_taginfo G__EMCALCintLN_TClonesArray = { "TClonesArray" , 99 , -1 };
+G__linked_taginfo G__EMCALCintLN_TAttLine = { "TAttLine" , 99 , -1 };
+G__linked_taginfo G__EMCALCintLN_TAttMarker = { "TAttMarker" , 99 , -1 };
+G__linked_taginfo G__EMCALCintLN_AliRndm = { "AliRndm" , 99 , -1 };
+G__linked_taginfo G__EMCALCintLN_AliModule = { "AliModule" , 99 , -1 };
+G__linked_taginfo G__EMCALCintLN_AliDetector = { "AliDetector" , 99 , -1 };
+G__linked_taginfo G__EMCALCintLN_AliEMCALGeometry = { "AliEMCALGeometry" , 99 , -1 };
+G__linked_taginfo G__EMCALCintLN_AliEMCAL = { "AliEMCAL" , 99 , -1 };
+G__linked_taginfo G__EMCALCintLN_AliGeometry = { "AliGeometry" , 99 , -1 };
+G__linked_taginfo G__EMCALCintLN_AliEMCALv0 = { "AliEMCALv0" , 99 , -1 };
+
+/* Reset class/struct taginfo */
+extern "C" void G__cpp_reset_tagtableEMCALCint() {
+  G__EMCALCintLN_TClass.tagnum = -1 ;
+  G__EMCALCintLN_TObject.tagnum = -1 ;
+  G__EMCALCintLN_TString.tagnum = -1 ;
+  G__EMCALCintLN_TNamed.tagnum = -1 ;
+  G__EMCALCintLN_TClonesArray.tagnum = -1 ;
+  G__EMCALCintLN_TAttLine.tagnum = -1 ;
+  G__EMCALCintLN_TAttMarker.tagnum = -1 ;
+  G__EMCALCintLN_AliRndm.tagnum = -1 ;
+  G__EMCALCintLN_AliModule.tagnum = -1 ;
+  G__EMCALCintLN_AliDetector.tagnum = -1 ;
+  G__EMCALCintLN_AliEMCALGeometry.tagnum = -1 ;
+  G__EMCALCintLN_AliEMCAL.tagnum = -1 ;
+  G__EMCALCintLN_AliGeometry.tagnum = -1 ;
+  G__EMCALCintLN_AliEMCALv0.tagnum = -1 ;
+}
+
+
+extern "C" void G__cpp_setup_tagtableEMCALCint() {
+
+   /* Setting up class,struct,union tag entry */
+   G__tagtable_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALGeometry),sizeof(AliEMCALGeometry),-1,32512,"EMCAL geometry class ",G__setup_memvarAliEMCALGeometry,G__setup_memfuncAliEMCALGeometry);
+   G__tagtable_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCAL),sizeof(AliEMCAL),-1,32512,"Electromagnetic calorimeter (base class)",G__setup_memvarAliEMCAL,G__setup_memfuncAliEMCAL);
+   G__tagtable_setup(G__get_linked_tagnum(&G__EMCALCintLN_AliEMCALv0),sizeof(AliEMCALv0),-1,32512,"Implementation of EMCAL manager class for layout EMC+PPSD",G__setup_memvarAliEMCALv0,G__setup_memfuncAliEMCALv0);
+}
+extern "C" void G__cpp_setupEMCALCint(void) {
+  G__check_setup_version(30051472,"G__cpp_setupEMCALCint()");
+  G__set_cpp_environmentEMCALCint();
+  G__cpp_setup_tagtableEMCALCint();
+
+  G__cpp_setup_inheritanceEMCALCint();
+
+  G__cpp_setup_typetableEMCALCint();
+
+  G__cpp_setup_memvarEMCALCint();
+
+  G__cpp_setup_memfuncEMCALCint();
+  G__cpp_setup_globalEMCALCint();
+  G__cpp_setup_funcEMCALCint();
+
+   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncEMCALCint();
+  return;
+}
+class G__cpp_setup_initEMCALCint {
+  public:
+    G__cpp_setup_initEMCALCint() { G__add_setup_func("EMCALCint",(G__incsetup)(&G__cpp_setupEMCALCint)); }
+   ~G__cpp_setup_initEMCALCint() { G__remove_setup_func("EMCALCint"); }
+};
+G__cpp_setup_initEMCALCint G__cpp_setup_initializerEMCALCint;
+

diff --git a/EMCAL/EMCALLinkDef.h b/EMCAL/EMCALLinkDef.h
new file mode 100644 (file)
index 0000000..836c8b3
--- /dev/null
+++ b/EMCAL/EMCALLinkDef.h
@@ -0,0 +1,11 @@
+#ifdef __CINT__
+ 
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+#pragma link C++ class AliEMCAL+;
+#pragma link C++ class AliEMCALGeometry+; 
+#pragma link C++ class AliEMCALv0+;
+
+#endif

diff --git a/EMCAL/Makefile b/EMCAL/Makefile
new file mode 100644 (file)
index 0000000..0341f8d
--- /dev/null
+++ b/EMCAL/Makefile
@@ -0,0 +1,65 @@
+############################### EMCAL Makefile #################################
+
+# Include machine specific definitions
+
+include $(ALICE_ROOT)/conf/GeneralDef
+include $(ALICE_ROOT)/conf/MachineDef.$(ALICE_TARGET)
+
+PACKAGE = EMCAL
+
+# C++ sources
+
+SRCS          =  AliEMCAL.cxx  AliEMCALGeometry.cxx AliEMCALv0.cxx 
+
+# C++ Headers
+
+HDRS          = $(SRCS:.cxx=.h) $(ROOTSYS)/include/TTree.h EMCALLinkDef.h
+
+# Library dictionary
+
+DICT          = EMCALCint.cxx
+DICTH         = $(DICT:.cxx=.h)
+DICTO         = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(DICT))
+
+# C++ Objects
+
+OBJS          = $(patsubst %.cxx,tgt_$(ALICE_TARGET)/%.o,$(SRCS)) $(DICTO)
+
+# C++ compilation flags
+
+CXXFLAGS      = $(CXXOPTS) -I$(ROOTSYS)/include -I. -I$(ALICE_ROOT)/include/
+
+ALSRCS  = $(SRCS) $(SHSRCS) $(RCSRCS) $(DUSRCS) dummies.c
+
+ALOBJS  = $(SHOBJS) $(RCOBJS) $(DUOBJS)
+
+##### COMMANDS ##### 
+
+SLIBRARY       = $(LIBDIR)/libEMCAL.$(SL)
+
+default:       $(SLIBRARY)
+
+$(LIBDIR)/libEMCAL.$(SL):                      $(OBJS) $(FOBJS)
+
+$(DICT):                                       $(HDRS)
+
+depend:                                $(SRCS) 
+
+TOCLEAN                =        $(OBJS) *Cint.cxx *Cint.h
+
+CHECKS        = $(patsubst %.cxx,check/%.viol,$(SRCS))
+
+############################### General Macros ################################
+
+include $(ALICE_ROOT)/conf/GeneralMacros
+
+############################ Dependencies #####################################
+
+-include tgt_$(ALICE_TARGET)/Make-depend 
+
+
+
+
+
+
+