Updates on Dummy Geometry. (M. Estienne)
authormorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 21 Nov 2007 10:25:41 +0000 (10:25 +0000)
committermorsch <morsch@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 21 Nov 2007 10:25:41 +0000 (10:25 +0000)
JETAN/AliJetDummyGeo.cxx
JETAN/AliJetDummyGeo.h
JETAN/AliJetDummyShishKebabTrd1Module.cxx [new file with mode: 0644]
JETAN/AliJetDummyShishKebabTrd1Module.h [new file with mode: 0644]
JETAN/JETANLinkDef.h
JETAN/libJETAN.pkg

index 960bc2a..02994e4 100644 (file)
 //
 // Temporarily added to define part of the EMCal geometry
 // necessary for the jet finder
-// Author: Magali Estienne
-// Magali.Estienne@cern.ch
+//
+// M. Estienne
 //
 
+#include <Riostream.h>
 #include <assert.h>
+#include <TList.h>
 
 // --- Root header files ---
 #include <TVector3.h>
 #include <TGeoNode.h>
 
 // --- AliRoot header files ---
+#include "AliLog.h"
 #include "AliJetDummyGeo.h"
+#include "AliJetDummyShishKebabTrd1Module.h"
 
 ClassImp(AliJetDummyGeo)
 
 AliJetDummyGeo::AliJetDummyGeo():
-    TObject(),
-    fArm1PhiMin(80.0), 
-    fArm1PhiMax(200.0),
-    fArm1EtaMin(-0.7), 
-    fArm1EtaMax(+0.7), 
-    fNumberOfSuperModules(12), 
-    fSteelFrontThick(0.0), 
-    fIPDistance(428.0), 
-    fZLength(),
-    fPhiGapForSM(2.), 
-    fNPhi(12),       
-    fNZ(24),      
-    fPhiModuleSize(12.26 - fPhiGapForSM / Float_t(fNPhi)), 
-    fEtaModuleSize(fPhiModuleSize), 
-    fNPHIdiv(2), 
-    fNETAdiv(2), 
-    fNECLayers(77), 
-    fECScintThick(0.16), 
-    fECPbRadThickness(0.16), 
-    fSampling(12.327),
-    fTrd1Angle(1.5), 
-    fNCellsInModule(fNPHIdiv*fNETAdiv), 
-    fNCellsInSupMod(fNCellsInModule*fNPhi*fNZ), 
-    fNCells(fNCellsInSupMod*fNumberOfSuperModules-fNCellsInSupMod), 
-    fLongModuleSize(fNECLayers*(fECScintThick + fECPbRadThickness)), 
-    f2Trd1Dx2(fEtaModuleSize + 2.*fLongModuleSize*TMath::Tan(fTrd1Angle*TMath::DegToRad()/2.)), 
-    fShellThickness(TMath::Sqrt(fLongModuleSize*fLongModuleSize + f2Trd1Dx2*f2Trd1Dx2)+fSteelFrontThick),
-    fEtaMaxOfTRD1(0.67064) // Value extracted from ShishKebab
+  fArm1EtaMin(-0.7), 
+  fArm1EtaMax(+0.7), 
+  fArm1PhiMin(80.0), 
+  fArm1PhiMax(200.0),
+  fNumberOfSuperModules(12), 
+  fSteelFrontThick(0.0), 
+  fLateralSteelStrip(0.01),
+  fIPDistance(428.0), 
+  fPhiGapForSM(2.), 
+  fNPhi(12),       
+  fNZ(24),      
+  fPhiModuleSize(12.26 - fPhiGapForSM / Float_t(fNPhi)), 
+  fEtaModuleSize(fPhiModuleSize),
+  fNPHIdiv(2), 
+  fNETAdiv(2), 
+  fPhiTileSize(fPhiModuleSize/Double_t(fNPHIdiv) - fLateralSteelStrip),
+  fEtaTileSize(fEtaModuleSize/Double_t(fNETAdiv) - fLateralSteelStrip),
+  fNECLayers(77), 
+  fECScintThick(0.16), 
+  fECPbRadThickness(0.16), 
+  fSampling(12.327),
+  fTrd1Angle(1.5), 
+  fNCellsInModule(fNPHIdiv*fNETAdiv), 
+  fNCellsInSupMod(fNCellsInModule*fNPhi*fNZ), 
+  fNCells(fNCellsInSupMod*fNumberOfSuperModules-fNCellsInSupMod), 
+  fLongModuleSize(fNECLayers*(fECScintThick + fECPbRadThickness)), 
+  f2Trd1Dx2(fEtaModuleSize + 2.*fLongModuleSize*TMath::Tan(fTrd1Angle*TMath::DegToRad()/2.)), 
+  fShellThickness(TMath::Sqrt(fLongModuleSize*fLongModuleSize + f2Trd1Dx2*f2Trd1Dx2)+fSteelFrontThick),
+  fZLength(2.*ZFromEtaR(fIPDistance+fShellThickness,fArm1EtaMax)),
+  fEtaMaxOfTRD1(0.), 
+  fPhiBoundariesOfSM(0),
+  fPhiCentersOfSM(0),
+  fCentersOfCellsEtaDir(0),
+  fCentersOfCellsXDir(0),
+  fCentersOfCellsPhiDir(0),
+  fEtaCentersOfCells(0),
+  fPhiCentersOfCells(0),
+  fShishKebabTrd1Modules(0),
+  fDebug(0)
 {
   // Constructor
+
   // Local coordinates
   fParSM[0] = GetShellThickness()/2.;        
   fParSM[1] = GetPhiModuleSize() * GetNPhi()/2.;
   fParSM[2] = 350./2.;
 
-  fZLength    = 2.*ZFromEtaR(fIPDistance+fShellThickness,fArm1EtaMax); // Z coverage
   fEnvelop[0] = fIPDistance; // mother volume inner radius
   fEnvelop[1] = fIPDistance + fShellThickness; // mother volume outer r.
   fEnvelop[2] = 1.00001*fZLength; // add some padding for mother volume. 
@@ -80,7 +95,7 @@ AliJetDummyGeo::AliJetDummyGeo():
   fPhiBoundariesOfSM[0] = TMath::PiOver2() - TMath::ATan2(fParSM[1] , fIPDistance); // 1th and 2th modules)
   fPhiBoundariesOfSM[1] = TMath::PiOver2() + TMath::ATan2(fParSM[1] , fIPDistance);
   fPhiCentersOfSM[0]    = TMath::PiOver2();
-  for(int i=1; i<=4; i++) { // from 2th ro 9th
+  for(Int_t i=1; i<=4; i++) { // from 2th ro 9th
     fPhiBoundariesOfSM[2*i]   = fPhiBoundariesOfSM[0] + 20.*TMath::DegToRad()*i;
     fPhiBoundariesOfSM[2*i+1] = fPhiBoundariesOfSM[1] + 20.*TMath::DegToRad()*i;
     fPhiCentersOfSM[i]        = fPhiCentersOfSM[0]    + 20.*TMath::DegToRad()*i;
@@ -89,19 +104,11 @@ AliJetDummyGeo::AliJetDummyGeo():
   fPhiBoundariesOfSM[10] = fPhiBoundariesOfSM[11] - TMath::ATan2((fParSM[1]) , fIPDistance);
   fPhiCentersOfSM[5]     = (fPhiBoundariesOfSM[10]+fPhiBoundariesOfSM[11])/2.; 
 
-  //  for(int i=0; i<fNumberOfSuperModules; i++) fMatrixOfSM[i] = 0;
-
-  fCentersOfCellsEtaDir.Set(fNZ*fNETAdiv);
-  fCentersOfCellsXDir.Set(fNZ*fNETAdiv);
-  fCentersOfCellsPhiDir.Set(fNPhi*fNPHIdiv);
-  fEtaCentersOfCells.Set(fNZ*fNETAdiv*fNPhi*fNPHIdiv);
-  fPhiCentersOfCells.Set(fNPhi*fNPHIdiv);
-
-  int nphism  = GetNumberOfSuperModules()/2;
-  double dphi = (GetArm1PhiMax() - GetArm1PhiMin())/nphism;
-  double rpos = (GetEnvelop(0) + GetEnvelop(1))/2.;
-  double phi, phiRad, xpos, ypos, zpos;
-  for(int i=0; i<nphism; i++){
+  Int_t nphism  = GetNumberOfSuperModules()/2;
+  Double_t dphi = (GetArm1PhiMax() - GetArm1PhiMin())/nphism;
+  Double_t rpos = (GetEnvelop(0) + GetEnvelop(1))/2.;
+  Double_t phi, phiRad, xpos, ypos, zpos;
+  for(Int_t i=0; i<nphism; i++){
     phi    = GetArm1PhiMin() + dphi*(2*i+1)/2.; // phi= 90, 110, 130, 150, 170, 190
     phiRad = phi*TMath::Pi()/180.;
     xpos = rpos * TMath::Cos(phiRad);
@@ -112,49 +119,95 @@ AliJetDummyGeo::AliJetDummyGeo():
       ypos -= (fParSM[1]/2. * TMath::Cos(phiRad));
     }
     // pozitive z
-    int ind = 2*i;
+    Int_t ind = 2*i;
     TGeoRotation *geoRot0 = new TGeoRotation("geoRot0", 90.0, phi, 90.0, 90.0+phi, 0.0, 0.0);
     fMatrixOfSM[ind] = new TGeoCombiTrans(Form("EmcalSM%2.2i",ind),
                                          xpos,ypos, zpos, geoRot0);
     // negaive z
     ind++;
-    double phiy = 90. + phi + 180.;
+    Double_t phiy = 90. + phi + 180.;
     if(phiy>=360.) phiy -= 360.;
     TGeoRotation *geoRot1 = new TGeoRotation("geoRot1", 90.0, phi, 90.0, phiy, 180.0, 0.0);
     fMatrixOfSM[ind] = new TGeoCombiTrans(Form("EmcalSM%2.2i",ind),
                                          xpos,ypos,-zpos, geoRot1);
   } // for
 
+  CreateListOfTrd1Modules();
+
+  if(fDebug > 0){
+    for(Int_t i=0; i<6; i++){
+      cout << "fMatrixOfSM[" << i << "]: " << fMatrixOfSM[i] << endl;
+    }
+    cout << "fArm1EtaMin: " << fArm1EtaMin << endl;
+    cout << "fArm1EtaMax: " << fArm1EtaMax << endl;
+    cout << "fArm1PhiMin: " << fArm1PhiMin << endl;
+    cout << "fArm1PhiMax: " << fArm1PhiMax << endl;
+    cout << "fNumberOfSuperModules: " << fNumberOfSuperModules << endl;
+    cout << "fSteelFrontThick: " << fSteelFrontThick << endl;
+    cout << "fIPDistance: " << fIPDistance  << endl;
+    cout << "fZLength: " << fZLength << endl;
+    cout << "fPhiGapForSM: " << fPhiGapForSM << endl;
+    cout << "fNPhi: " << fNPhi << endl;
+    cout << "fNZ: " << fNZ << endl;
+    cout << "fPhiModuleSize: " << fPhiModuleSize << endl;
+    cout << "fEtaModuleSize: " << fEtaModuleSize << endl;
+    cout << "fNPHIdiv: " << fNPHIdiv << endl;
+    cout << "fNETAdiv: " << fNETAdiv << endl;
+    cout << "fNECLayers: " << fNECLayers << endl;
+    cout << "fECScintThick: " <<  fECScintThick << endl;
+    cout << "fECPbRadThickness: " << fECPbRadThickness << endl;
+    cout << "fSampling: " << fSampling << endl;
+    cout << "fTrd1Angle: " << fTrd1Angle << endl;
+    cout << "fNCellsInModule: " << fNCellsInModule << endl;
+    cout << "fNCellsInSupMod: " << fNCellsInSupMod << endl;
+    cout << "fNCells: " << fNCells << endl;
+    cout << "fLongModuleSize: " <<  fLongModuleSize << endl;
+    cout << "f2Trd1Dx2: " << f2Trd1Dx2 << endl;
+    cout << "fShellThickness: " << fShellThickness << endl;
+    cout << "fEtaMaxOfTRD1: " << fEtaMaxOfTRD1 << endl;
+  }
 }
 
 AliJetDummyGeo::AliJetDummyGeo(const AliJetDummyGeo& geom):
-    TObject(),  
-    fArm1PhiMin(geom.fArm1PhiMin),
-    fArm1PhiMax(geom.fArm1PhiMax),
-    fArm1EtaMin(geom.fArm1EtaMin),
-    fArm1EtaMax(geom.fArm1EtaMax),
-    fNumberOfSuperModules(geom.fNumberOfSuperModules),
-    fSteelFrontThick(geom.fSteelFrontThick),
-    fIPDistance(geom.fIPDistance),
-    fPhiGapForSM(geom.fPhiGapForSM),
-    fNPhi(geom.fNPhi),
-    fNZ(geom.fNZ),
-    fPhiModuleSize(geom.fPhiModuleSize),
-    fEtaModuleSize(geom.fEtaModuleSize),
-    fNPHIdiv(geom.fNPHIdiv),
-    fNETAdiv(geom.fNETAdiv),
-    fNECLayers(geom.fNECLayers),
-    fECScintThick(geom.fECScintThick),
-    fECPbRadThickness(geom.fECPbRadThickness),
-    fSampling(geom.fSampling),
-    fTrd1Angle(geom.fTrd1Angle),
-    fNCellsInModule(geom.fNCellsInModule),
-    fNCellsInSupMod(geom.fNCellsInSupMod),
-    fNCells(geom.fNCells),
-    fLongModuleSize(geom.fLongModuleSize),
-    f2Trd1Dx2(geom.f2Trd1Dx2),
-    fShellThickness(geom.fShellThickness),
-    fEtaMaxOfTRD1(geom.fEtaMaxOfTRD1) 
+  fArm1EtaMin(geom.fArm1EtaMin), 
+  fArm1EtaMax(geom.fArm1EtaMax), 
+  fArm1PhiMin(geom.fArm1PhiMin), 
+  fArm1PhiMax(geom.fArm1PhiMax),
+  fNumberOfSuperModules(geom.fNumberOfSuperModules), 
+  fSteelFrontThick(geom.fSteelFrontThick), 
+  fLateralSteelStrip(geom.fLateralSteelStrip),
+  fIPDistance(geom.fIPDistance), 
+  fPhiGapForSM(geom.fPhiGapForSM), 
+  fNPhi(geom.fNPhi),       
+  fNZ(geom.fNZ),      
+  fPhiModuleSize(geom.fPhiModuleSize), 
+  fEtaModuleSize(geom.fEtaModuleSize),
+  fNPHIdiv(geom.fNPHIdiv), 
+  fNETAdiv(geom.fNETAdiv), 
+  fPhiTileSize(geom.fPhiTileSize),
+  fEtaTileSize(geom.fEtaTileSize),
+  fNECLayers(geom.fNECLayers), 
+  fECScintThick(geom.fECScintThick), 
+  fECPbRadThickness(geom.fECPbRadThickness), 
+  fSampling(geom.fSampling),
+  fTrd1Angle(geom.fTrd1Angle), 
+  fNCellsInModule(geom.fNCellsInModule), 
+  fNCellsInSupMod(geom.fNCellsInSupMod), 
+  fNCells(geom.fNCells),
+  fLongModuleSize(geom.fLongModuleSize),
+  f2Trd1Dx2(geom.f2Trd1Dx2),
+  fShellThickness(geom.fShellThickness),
+  fZLength(geom.fZLength),
+  fEtaMaxOfTRD1(geom.fEtaMaxOfTRD1),
+  fPhiBoundariesOfSM(geom.fPhiBoundariesOfSM),
+  fPhiCentersOfSM(geom.fPhiCentersOfSM),
+  fCentersOfCellsEtaDir(geom.fCentersOfCellsEtaDir),
+  fCentersOfCellsXDir(geom.fCentersOfCellsXDir),
+  fCentersOfCellsPhiDir(geom.fCentersOfCellsPhiDir),
+  fEtaCentersOfCells(geom.fEtaCentersOfCells),
+  fPhiCentersOfCells(geom.fPhiCentersOfCells),
+  fShishKebabTrd1Modules(geom.fShishKebabTrd1Modules),
+  fDebug(geom.fDebug)
 {
   // Constructor
   // Local coordinates
@@ -162,13 +215,17 @@ AliJetDummyGeo::AliJetDummyGeo(const AliJetDummyGeo& geom):
   fParSM[1] = GetPhiModuleSize() * GetNPhi()/2.;
   fParSM[2] = 350./2.;
 
+  fEnvelop[0] = fIPDistance; // mother volume inner radius
+  fEnvelop[1] = fIPDistance + fShellThickness; // mother volume outer r.
+  fEnvelop[2] = 1.00001*fZLength; // add some padding for mother volume. 
+
   // SM phi boundaries - (0,1),(2,3) .. (10,11) - has the same boundaries; Nov 7, 2006 
   fPhiBoundariesOfSM.Set(fNumberOfSuperModules);
   fPhiCentersOfSM.Set(fNumberOfSuperModules/2);
   fPhiBoundariesOfSM[0] = TMath::PiOver2() - TMath::ATan2(fParSM[1] , fIPDistance); // 1th and 2th modules)
   fPhiBoundariesOfSM[1] = TMath::PiOver2() + TMath::ATan2(fParSM[1] , fIPDistance);
   fPhiCentersOfSM[0]    = TMath::PiOver2();
-  for(int i=1; i<=4; i++) { // from 2th ro 9th
+  for(Int_t i=1; i<=4; i++) { // from 2th ro 9th
     fPhiBoundariesOfSM[2*i]   = fPhiBoundariesOfSM[0] + 20.*TMath::DegToRad()*i;
     fPhiBoundariesOfSM[2*i+1] = fPhiBoundariesOfSM[1] + 20.*TMath::DegToRad()*i;
     fPhiCentersOfSM[i]        = fPhiCentersOfSM[0]    + 20.*TMath::DegToRad()*i;
@@ -177,19 +234,11 @@ AliJetDummyGeo::AliJetDummyGeo(const AliJetDummyGeo& geom):
   fPhiBoundariesOfSM[10] = fPhiBoundariesOfSM[11] - TMath::ATan2((fParSM[1]) , fIPDistance);
   fPhiCentersOfSM[5]     = (fPhiBoundariesOfSM[10]+fPhiBoundariesOfSM[11])/2.; 
 
-  //  for(int i=0; i<fNumberOfSuperModules; i++) fMatrixOfSM[i] = 0;
-
-  fCentersOfCellsEtaDir.Set(fNZ*fNETAdiv);
-  fCentersOfCellsXDir.Set(fNZ*fNETAdiv);
-  fCentersOfCellsPhiDir.Set(fNPhi*fNPHIdiv);
-  fEtaCentersOfCells.Set(fNZ*fNETAdiv*fNPhi*fNPHIdiv);
-  fPhiCentersOfCells.Set(fNPhi*fNPHIdiv);
-
-  int nphism  = GetNumberOfSuperModules()/2;
-  double dphi = (GetArm1PhiMax() - GetArm1PhiMin())/nphism;
-  double rpos = (GetEnvelop(0) + GetEnvelop(1))/2.;
-  double phi, phiRad, xpos, ypos, zpos;
-  for(int i=0; i<nphism; i++){
+  Int_t nphism  = GetNumberOfSuperModules()/2;
+  Double_t dphi = (GetArm1PhiMax() - GetArm1PhiMin())/nphism;
+  Double_t rpos = (GetEnvelop(0) + GetEnvelop(1))/2.;
+  Double_t phi, phiRad, xpos, ypos, zpos;
+  for(Int_t i=0; i<nphism; i++){
     phi    = GetArm1PhiMin() + dphi*(2*i+1)/2.; // phi= 90, 110, 130, 150, 170, 190
     phiRad = phi*TMath::Pi()/180.;
     xpos = rpos * TMath::Cos(phiRad);
@@ -200,13 +249,13 @@ AliJetDummyGeo::AliJetDummyGeo(const AliJetDummyGeo& geom):
       ypos -= (fParSM[1]/2. * TMath::Cos(phiRad));
     }
     // pozitive z
-    int ind = 2*i;
+    Int_t ind = 2*i;
     TGeoRotation *geoRot0 = new TGeoRotation("geoRot0", 90.0, phi, 90.0, 90.0+phi, 0.0, 0.0);
     fMatrixOfSM[ind] = new TGeoCombiTrans(Form("EmcalSM%2.2i",ind),
                                          xpos,ypos, zpos, geoRot0);
     // negaive z
     ind++;
-    double phiy = 90. + phi + 180.;
+    Double_t phiy = 90. + phi + 180.;
     if(phiy>=360.) phiy -= 360.;
     TGeoRotation *geoRot1 = new TGeoRotation("geoRot1", 90.0, phi, 90.0, phiy, 180.0, 0.0);
     fMatrixOfSM[ind] = new TGeoCombiTrans(Form("EmcalSM%2.2i",ind),
@@ -217,11 +266,15 @@ AliJetDummyGeo::AliJetDummyGeo(const AliJetDummyGeo& geom):
 
   } // for
 
+  CreateListOfTrd1Modules();
+
 }
 
+//------------------------------------------------------------------------------------
 AliJetDummyGeo::~AliJetDummyGeo()
 {
   // Destructor
+  delete [] fMatrixOfSM;
 }
 
 //------------------------------------------------------------------------------------
@@ -237,7 +290,7 @@ void AliJetDummyGeo::EtaPhiFromIndex(Int_t absId, Float_t& eta, Float_t& phi)
 }
 
 //------------------------------------------------------------------------------------
-void AliJetDummyGeo::GetGlobal(const Double_t *loc, Double_t *glob, int ind) const
+void AliJetDummyGeo::GetGlobal(const Double_t *loc, Double_t *glob, Int_t ind) const
 {
   // Figure out the global numbering of a given supermodule from the
   // local numbering
@@ -250,11 +303,11 @@ void AliJetDummyGeo::GetGlobal(const Double_t *loc, Double_t *glob, int ind) con
 }
 
 //------------------------------------------------------------------------------------
-void AliJetDummyGeo::GetGlobal(Int_t absId , double glob[3]) const
+void AliJetDummyGeo::GetGlobal(Int_t absId , Double_t glob[3]) const
 { 
   // Alice numbering scheme - Jun 03, 2006
   static Int_t nSupMod, nModule, nIphi, nIeta;
-  static double loc[3];
+  static Double_t loc[3];
 
   glob[0]=glob[1]=glob[2]=0.0; // bad case
   if(RelPosCellInSModule(absId, loc)) {
@@ -298,7 +351,7 @@ Bool_t AliJetDummyGeo::RelPosCellInSModule(Int_t absId, Double_t &xr, Double_t &
 
   // Shift index taking into account the difference between standard SM 
   // and SM of half size in phi direction
-  const Int_t kPhiIndexShift = fCentersOfCellsPhiDir.GetSize()/4; // Nov 22, 2006; was 6 for cas 2X2
+  const Int_t phiIndexShift = fCentersOfCellsPhiDir.GetSize()/4; // Nov 22, 2006; was 6 for cas 2X2
   static Int_t nSupMod, nModule, nIphi, nIeta, iphi, ieta;
   if(!CheckAbsCellId(absId)) return kFALSE;
 
@@ -311,7 +364,7 @@ Bool_t AliJetDummyGeo::RelPosCellInSModule(Int_t absId, Double_t &xr, Double_t &
   if(nSupMod<10) {
     yr = fCentersOfCellsPhiDir.At(iphi);
   } else {
-    yr = fCentersOfCellsPhiDir.At(iphi + kPhiIndexShift);
+    yr = fCentersOfCellsPhiDir.At(iphi + phiIndexShift);
   }
 
   return kTRUE;
@@ -360,7 +413,7 @@ Bool_t AliJetDummyGeo::GetCellIndex(Int_t absId,Int_t &nSupMod,Int_t &nModule,In
 }
 
 //------------------------------------------------------------------------------------
-void AliJetDummyGeo::GetCellPhiEtaIndexInSModule(Int_t nSupMod, Int_t nModule, Int_t nIphi, Int_t nIeta, int &iphi, int &ieta) const
+void AliJetDummyGeo::GetCellPhiEtaIndexInSModule(Int_t nSupMod, Int_t nModule, Int_t nIphi, Int_t nIeta, Int_t &iphi, Int_t &ieta) const
 { 
   // 
   // Added nSupMod; Nov 25, 05
@@ -387,7 +440,7 @@ void AliJetDummyGeo::GetCellPhiEtaIndexInSModule(Int_t nSupMod, Int_t nModule, I
 
 
 //------------------------------------------------------------------------------------
-void AliJetDummyGeo::GetModulePhiEtaIndexInSModule(Int_t nSupMod, Int_t nModule,  int &iphim, int &ietam) const
+void AliJetDummyGeo::GetModulePhiEtaIndexInSModule(Int_t nSupMod, Int_t nModule,  Int_t &iphim, Int_t &ietam) const
 { 
   // added nSupMod; - 19-oct-05 !
   // Alice numbering scheme        - Jun 01,2006 
@@ -545,6 +598,136 @@ Bool_t AliJetDummyGeo::GetPhiBoundariesOfSMGap(Int_t nPhiSec, Double_t &phiMin,
 }
 
 //------------------------------------------------------------------------------------
+void AliJetDummyGeo::CreateListOfTrd1Modules()
+{
+  // Generate the list of Trd1 modules
+  // which will make up the EMCAL
+  // geometry
+
+  AliJetDummyShishKebabTrd1Module *mod=0, *mTmp=0; // current module
+  if(fShishKebabTrd1Modules == 0) {
+    fShishKebabTrd1Modules = new TList;
+    fShishKebabTrd1Modules->SetName("ListOfTRD1");
+    for(Int_t iz=0; iz< GetNZ(); iz++) { 
+      if(iz==0) { 
+        mod  = new AliJetDummyShishKebabTrd1Module(TMath::Pi()/2.,this);
+      } else {
+        mTmp  = new AliJetDummyShishKebabTrd1Module(*mod);
+        mod   = mTmp;
+      }
+      fShishKebabTrd1Modules->Add(mod);
+    }
+  } else {
+    printf(" Already exits : ");
+  }
+  mod = (AliJetDummyShishKebabTrd1Module*)fShishKebabTrd1Modules->At(fShishKebabTrd1Modules->GetSize()-1);
+  fEtaMaxOfTRD1 = mod->GetMaxEtaOfModule(0);
+
+  //  printf(" fShishKebabTrd1Modules has %i modules : max eta %5.4f \n", 
+  //             fShishKebabTrd1Modules->GetSize(),fEtaMaxOfTRD1);
+
+  // Feb 20,2006;
+  // Jun 01, 2006 - ALICE numbering scheme
+  // define grid for cells in eta(z) and x directions in local coordinates system of SM
+  // Works just for 2x2 case only -- ?? start here
+  // 
+  //
+  // Define grid for cells in phi(y) direction in local coordinates system of SM
+  // as for 2X2 as for 3X3 - Nov 8,2006
+  // 
+
+  //  printf(" Cells grid in phi directions : size %i\n", fCentersOfCellsPhiDir.GetSize());
+
+  Int_t ind=0; // this is phi index
+  Int_t ieta=0, nModule=0, iphiTemp;
+  Double_t xr, zr, theta, phi, eta, r, x,y;
+  TVector3 vglob;
+  Double_t ytCenterModule=0.0, ytCenterCell=0.0;
+
+  fCentersOfCellsPhiDir.Set(fNPhi*fNPHIdiv);
+  fPhiCentersOfCells.Set(fNPhi*fNPHIdiv);
+
+  Double_t R0 = GetIPDistance() + GetLongModuleSize()/2.;
+  for(Int_t it=0; it<fNPhi; it++) { // cycle on modules
+    ytCenterModule = -fParSM[1] + fPhiModuleSize*(2*it+1)/2;  // center of module
+    for(Int_t ic=0; ic<fNPHIdiv; ic++) { // cycle on cells in module
+      if(fNPHIdiv==2) {
+        ytCenterCell = ytCenterModule + fPhiTileSize *(2*ic-1)/2.;
+      } else if(fNPHIdiv==3){
+        ytCenterCell = ytCenterModule + fPhiTileSize *(ic-1);
+      } else if(fNPHIdiv==1){
+        ytCenterCell = ytCenterModule;
+      }
+      fCentersOfCellsPhiDir.AddAt(ytCenterCell,ind);
+      // Define grid on phi direction
+      // Grid is not the same for different eta bin;
+      // Effect is small but is still here
+      phi = TMath::ATan2(ytCenterCell, R0);
+      fPhiCentersOfCells.AddAt(phi, ind);
+
+      //      printf(" ind %2.2i : y %8.3f ", ind, fCentersOfCellsPhiDir.At(ind)); 
+      ind++;
+    }
+  }
+
+  fCentersOfCellsEtaDir.Set(fNZ *fNETAdiv);
+  fCentersOfCellsXDir.Set(fNZ *fNETAdiv);
+  fEtaCentersOfCells.Set(fNZ *fNETAdiv * fNPhi*fNPHIdiv);
+  if(fDebug>1) AliInfo(Form(" Cells grid in eta directions : size %i\n", fCentersOfCellsEtaDir.GetSize()));
+  for(Int_t it=0; it<fNZ; it++) {
+    AliJetDummyShishKebabTrd1Module *trd1 = GetShishKebabModule(it);
+    nModule = fNPhi*it;
+    for(Int_t ic=0; ic<fNETAdiv; ic++) {
+      if(fNPHIdiv==2) {
+        trd1->GetCenterOfCellInLocalCoordinateofSM(ic, xr, zr);      // case of 2X2
+        GetCellPhiEtaIndexInSModule(0, nModule, 0, ic, iphiTemp, ieta); 
+      } if(fNPHIdiv==3) {
+        trd1->GetCenterOfCellInLocalCoordinateofSM_3X3(ic, xr, zr);  // case of 3X3
+        GetCellPhiEtaIndexInSModule(0, nModule, 0, ic, iphiTemp, ieta); 
+      } if(fNPHIdiv==1) {
+        trd1->GetCenterOfCellInLocalCoordinateofSM_1X1(xr, zr);      // case of 1X1
+        GetCellPhiEtaIndexInSModule(0, nModule, 0, ic, iphiTemp, ieta); 
+      }
+      fCentersOfCellsXDir.AddAt(Float_t(xr) - fParSM[0],ieta);
+      fCentersOfCellsEtaDir.AddAt(Float_t(zr) - fParSM[2],ieta);
+      // Define grid on eta direction for each bin in phi
+      for(Int_t iphi=0; iphi<fCentersOfCellsPhiDir.GetSize(); iphi++) {
+        x = xr + trd1->GetRadius();
+        y = fCentersOfCellsPhiDir[iphi];
+        r = TMath::Sqrt(x*x + y*y + zr*zr);
+        theta = TMath::ACos(zr/r);
+        eta   = AliJetDummyShishKebabTrd1Module::ThetaToEta(theta);
+       //        ind   = ieta*fCentersOfCellsPhiDir.GetSize() + iphi;
+        ind   = iphi*fCentersOfCellsEtaDir.GetSize() + ieta;
+        fEtaCentersOfCells.AddAt(eta, ind);
+      }
+      //printf(" ieta %i : xr + trd1->GetRadius() %f : zr %f : eta %f \n", ieta, xr + trd1->GetRadius(), zr, eta);
+    }
+  }
+
+  if(fDebug>1){
+    for(Int_t i=0; i<fCentersOfCellsEtaDir.GetSize(); i++) {
+      AliInfo(Form(" ind %2.2i : z %8.3f : x %8.3f", i+1, 
+                  fCentersOfCellsEtaDir.At(i),fCentersOfCellsXDir.At(i)));
+    }
+  }
+}
+
+//------------------------------------------------------------------------------------
+AliJetDummyShishKebabTrd1Module* AliJetDummyGeo::GetShishKebabModule(Int_t neta)
+{
+  // This method was too long to be included in the header file - the
+  // rule checker complained about it's length, so we move it here. It
+  // returns the shishkebabmodule at a given eta index point.
+
+  static AliJetDummyShishKebabTrd1Module* trd1=0;
+  if(fShishKebabTrd1Modules && neta>=0 && neta<fShishKebabTrd1Modules->GetSize()) {
+    trd1 = (AliJetDummyShishKebabTrd1Module*)fShishKebabTrd1Modules->At(neta);
+  } else trd1 = 0;
+  return trd1;
+}
+
+//------------------------------------------------------------------------------------
 void  AliJetDummyGeo::GetTransformationForSM()
 {
   // Uses the geometry manager to load the transformation matrix
@@ -555,7 +738,7 @@ void  AliJetDummyGeo::GetTransformationForSM()
   static Bool_t transInit=kFALSE;
   if(transInit) return;
 
-  int i=0;
+  Int_t i=0;
   if(gGeoManager == 0) {
     Info("CreateTransformationForSM() "," Load geometry : TGeoManager::Import()");
     assert(0);
@@ -577,12 +760,12 @@ void  AliJetDummyGeo::GetTransformationForSM()
     GetNameOfEMCALEnvelope());
     assert(0);
   }
-  printf(" i %i : EMCAL Envelope is %s : #SM %i \n", i, xen1->GetName(), xen1->GetNdaughters());
+  AliInfo(Form(" i %i : EMCAL Envelope is %s : #SM %i \n", i, xen1->GetName(), xen1->GetNdaughters()));
   for(i=0; i<xen1->GetNdaughters(); i++) {
     TGeoNodeMatrix *sm = (TGeoNodeMatrix*)xen1->GetDaughter(i);
     fMatrixOfSM[i] = sm->GetMatrix();
   }
-  printf("transInit %d: ", transInit);
+  AliInfo(Form("transInit %d: ", transInit));
   transInit = kTRUE;
 }
 
index 7edee38..18db57d 100644 (file)
@@ -7,9 +7,7 @@
 //
 // Temporarily added to define part of the EMCal geometry
 // necessary for the jet finder
-// Author: Magali Estienne
-// Magali.Estienne@cern.ch
-
+//
 
 #include <TObject.h>
 #include <TArrayD.h>
@@ -17,6 +15,7 @@
 #include <TVector3.h>
 
 class TGeoMatrix;
+class AliJetDummyShishKebabTrd1Module;
 
 class AliJetDummyGeo : public TObject 
 {
@@ -38,26 +37,32 @@ class AliJetDummyGeo : public TObject
     // pseudorapidity and r=sqrt(x*x+y*y).
     return r/TMath::Tan(AngleFromEta(eta));
   }
-  Int_t   GetNCells()               const {return fNCells;}
-  Float_t GetPhiModuleSize()        const {return fPhiModuleSize;}
-  Float_t GetEtaModuleSize()        const {return fEtaModuleSize;}
-  Float_t GetShellThickness()       const {return fShellThickness;}
-  Int_t   GetNPhi()                 const {return fNPhi;}
+  Int_t   GetNCells()               {return fNCells;}
+  Float_t GetPhiModuleSize() const  {return fPhiModuleSize;}
+  Float_t GetEtaModuleSize() const  {return fEtaModuleSize;}
+  Float_t GetShellThickness() const {return fShellThickness;}
+  Float_t GetSteelFrontThickness() const { return fSteelFrontThick;}
+  Float_t GetLongModuleSize() const {return fLongModuleSize;}
+  Float_t GetTrd1Angle() const      {return fTrd1Angle;}
+  Float_t Get2Trd1Dx2()  const      {return f2Trd1Dx2;}
+  Int_t   GetNPhi() const {return fNPhi;}
+  Int_t   GetNZ() const   {return fNZ ;}
   Int_t   GetNumberOfSuperModules() const {return fNumberOfSuperModules;}
-  Float_t GetArm1EtaMin()           const {return fArm1EtaMin;}
-  Float_t GetArm1EtaMax()           const {return fArm1EtaMax;}
-  Float_t GetArm1PhiMin()           const {return fArm1PhiMin;}
-  Float_t GetArm1PhiMax()           const {return fArm1PhiMax;}
-  void    EtaPhiFromIndex(Int_t id, Float_t& eta, Float_t& phi);
-  void    GetGlobal(const Double_t *loc, Double_t *glob, int ind) const;
+  Float_t GetArm1EtaMin() {return fArm1EtaMin;}
+  Float_t GetArm1EtaMax() {return fArm1EtaMax;}
+  Float_t GetArm1PhiMin() {return fArm1PhiMin;}
+  Float_t GetArm1PhiMax() {return fArm1PhiMax;}
+  Float_t GetIPDistance() const { return fIPDistance;} 
+  void    EtaPhiFromIndex(Int_t /*id*/, Float_t& /*eta*/, Float_t& /*phi*/);
+  void    GetGlobal(const Double_t *loc, Double_t *glob, Int_t ind) const;
   void    GetGlobal(Int_t absId, Double_t glob[3]) const;
   void    GetGlobal(Int_t absId, TVector3 &vglob) const;
   Bool_t  RelPosCellInSModule(Int_t absId, Double_t loc[3]) const;
   Bool_t  RelPosCellInSModule(Int_t absId, Double_t &xr, Double_t &yr, Double_t &zr) const;
   Bool_t  CheckAbsCellId(Int_t absId) const;
   Bool_t  GetCellIndex(Int_t absId,Int_t &nSupMod,Int_t &nModule,Int_t &nIphi,Int_t &nIeta) const;
-  void    GetCellPhiEtaIndexInSModule(Int_t nSupMod, Int_t nModule, Int_t nIphi, Int_t nIeta, int &iphi, int &ieta) const;
-  void    GetModulePhiEtaIndexInSModule(Int_t nSupMod, Int_t nModule,  int &iphim, int &ietam) const;
+  void    GetCellPhiEtaIndexInSModule(Int_t nSupMod, Int_t nModule, Int_t nIphi, Int_t nIeta, Int_t &iphi, Int_t &ieta) const;
+  void    GetModulePhiEtaIndexInSModule(Int_t nSupMod, Int_t nModule,  Int_t &iphim, Int_t &ietam) const;
   Bool_t  GetAbsCellIdFromEtaPhi(Double_t eta,Double_t phi, Int_t &absId) const;
   Bool_t  SuperModuleNumberFromEtaPhi(Double_t eta, Double_t phi, Int_t &nSupMod) const;
   Int_t   GetAbsCellIdFromCellIndexes(Int_t nSupMod, Int_t iphi, Int_t ieta) const;
@@ -70,20 +75,25 @@ class AliJetDummyGeo : public TObject
     if(nSupMod>=10) return fNPhi/2;
     else            return fNPhi;
   }
+
+  void    CreateListOfTrd1Modules();
+  TList  *GetShishKebabTrd1Modules() const {return fShishKebabTrd1Modules;}
+  AliJetDummyShishKebabTrd1Module *GetShishKebabModule(Int_t neta);
+
   Bool_t  GetPhiBoundariesOfSMGap(Int_t nPhiSec, Double_t &phiMin, Double_t &phiMax) const;
   void    GetTransformationForSM();
-  Float_t GetSampling() const {return fSampling;}
+  Float_t GetSampling() {return fSampling;}
 
  protected:
-  Float_t fArm1PhiMin;                         // Minimum angular position of EMCAL in Phi (degrees)
-  Float_t fArm1PhiMax;                 // Maximum angular position of EMCAL in Phi (degrees)
   Float_t fArm1EtaMin;                 // Minimum pseudorapidity position of EMCAL in Eta
   Float_t fArm1EtaMax;                         // Maximum pseudorapidity position of EMCAL in Eta
-  Int_t   fNumberOfSuperModules;        // Number of super modules
+  Float_t fArm1PhiMin;                         // Minimum angular position of EMCAL in Phi (degrees)
+  Float_t fArm1PhiMax;                 // Maximum angular position of EMCAL in Phi (degrees)
+  Int_t   fNumberOfSuperModules;
   Float_t fSteelFrontThick;             // Thickness of the front stell face of the support box - 9-sep-04
+  Float_t fLateralSteelStrip;           // 13-may-05
   Float_t fEnvelop[3];                 // the GEANT TUB for the detector 
   Float_t fIPDistance;                  // Radial Distance of the inner surface of the EMCAL
-  Float_t fZLength;                    // Total length in z direction
   Float_t fPhiGapForSM;                 // Gap betweeen supermodules in phi direction
   Int_t   fNPhi;                       // Number of Towers in the PHI direction  
   Int_t   fNZ;                         // Number of Towers in the Z direction
@@ -91,6 +101,8 @@ class AliJetDummyGeo : public TObject
   Float_t fEtaModuleSize;               // Eta -> Y
   Int_t   fNPHIdiv;                     // number phi divizion of module
   Int_t   fNETAdiv;                     // number eta divizion of module
+  Float_t fPhiTileSize;                 // Size of phi tile
+  Float_t fEtaTileSize;                 // Size of eta tile
   Int_t   fNECLayers;                   // number of scintillator layers
   Float_t fECScintThick;                // cm, Thickness of the scintillators
   Float_t fECPbRadThickness;            // cm, Thickness of the Pb radiators
@@ -102,6 +114,7 @@ class AliJetDummyGeo : public TObject
   Float_t fLongModuleSize;              // Size of long module
   Float_t f2Trd1Dx2;                    // 2*dx2 for TRD1
   Float_t fShellThickness;             // Total thickness in (x,y) direction
+  Float_t fZLength;                    // Total length in z direction
   Float_t fEtaMaxOfTRD1;                // max eta in case of TRD1 geometry (see AliEMCALShishKebabTrd1Module)
   Float_t fParSM[3];                    // SM sizes as in GEANT (TRD1)
   TArrayD fPhiBoundariesOfSM;           // phi boundaries of SM in rad; size is fNumberOfSuperModules;
@@ -113,7 +126,8 @@ class AliJetDummyGeo : public TObject
   TArrayD fEtaCentersOfCells;           // [fNEta*fNETAdiv*fNPhi*fNPHIdiv], positive direction (eta>0); 
                                         // eta depend from phi position; 
   TArrayD fPhiCentersOfCells;           // [fNPhi*fNPHIdiv] from center of SM (-10. < phi < +10.)
-
+  TList  *fShishKebabTrd1Modules;       //! list of modules
+  Int_t   fDebug;                       //  Debug flag 
   ClassDef(AliJetDummyGeo,1)
 };
  
diff --git a/JETAN/AliJetDummyShishKebabTrd1Module.cxx b/JETAN/AliJetDummyShishKebabTrd1Module.cxx
new file mode 100644 (file)
index 0000000..9de2f51
--- /dev/null
@@ -0,0 +1,298 @@
+/**************************************************************************
+ * Copyright(c) 1998-2004, 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$ */
+
+//_________________________________________________________________________
+// Main class for TRD1 geometry of Shish-Kebab case.
+// Author: Aleksei Pavlinov(WSU).
+// Sep 20004 - Nov 2006
+// See web page with description of Shish-Kebab geometries:
+// http://pdsfweb01.nersc.gov/~pavlinov/ALICE/SHISHKEBAB/RES/shishkebabALICE.html
+// Nov 9,2006 - added cas of 3X3
+//_________________________________________________________________________
+
+//
+// Class modified and implemented in JETAN 
+//
+// M. Estienne
+// 
+
+#include "AliLog.h"
+#include "AliJetDummyShishKebabTrd1Module.h"
+#include "AliJetDummyGeo.h"
+
+#include <Riostream.h>
+
+ClassImp(AliJetDummyShishKebabTrd1Module)
+
+  AliJetDummyGeo *AliJetDummyShishKebabTrd1Module::fgGeometry=0; 
+  Double_t AliJetDummyShishKebabTrd1Module::fga=0.; 
+  Double_t AliJetDummyShishKebabTrd1Module::fga2=0.; 
+  Double_t AliJetDummyShishKebabTrd1Module::fgb=0.; 
+  Double_t AliJetDummyShishKebabTrd1Module::fgr=0.; 
+  Double_t AliJetDummyShishKebabTrd1Module::fgangle=0.;   // around one degree 
+  Double_t AliJetDummyShishKebabTrd1Module::fgtanBetta=0; //
+
+//_____________________________________________________________________________
+AliJetDummyShishKebabTrd1Module::AliJetDummyShishKebabTrd1Module(Double_t theta, AliJetDummyGeo *g) 
+  : TNamed(),
+    fOK(),
+    fA(0.),
+    fB(0.),
+    fThetaA(0.),
+    fTheta(theta),
+    fOK1(),
+    fOK2(),
+    fOB(),
+    fOB1(),
+    fOB2(),
+    fOK3X3(),
+    fDebug(0)
+{ 
+  // theta in radians ; first object shold be with theta=pi/2.
+  if(fgGeometry==0) {
+    fTheta = TMath::PiOver2();
+    fgGeometry = g;
+    if(GetParameters()) {
+      DefineFirstModule();
+    }
+  } else Warning("AliJetDummyShishKebabTrd1Module(theta)","You should call this constractor just once !!");
+  DefineName(fTheta);
+  AliInfo(Form("AliJetDummyShishKebabTrd1Module - first module:  theta %1.4f geometry %s",fTheta,g->GetName()));  
+}
+
+//_____________________________________________________________________________
+AliJetDummyShishKebabTrd1Module::AliJetDummyShishKebabTrd1Module(AliJetDummyShishKebabTrd1Module &leftNeighbor) 
+  : TNamed(),
+    fOK(),
+    fA(0.),
+    fB(0.),
+    fThetaA(0.),
+    fTheta(0.),
+    fOK1(),
+    fOK2(),
+    fOB(),
+    fOB1(),
+    fOB2(),
+    fOK3X3(),
+    fDebug(0)
+{ 
+  //  printf("** Left Neighbor : %s **\n", leftNeighbor.GetName());
+  fTheta  = leftNeighbor.GetTheta() - fgangle; 
+
+  TObject::SetUniqueID(leftNeighbor.GetUniqueID()+1);
+
+  Init(leftNeighbor.GetA(),leftNeighbor.GetB());
+}
+
+//________________________________________________________________
+AliJetDummyShishKebabTrd1Module::AliJetDummyShishKebabTrd1Module(const AliJetDummyShishKebabTrd1Module& mod) 
+  : TNamed(mod.GetName(),mod.GetTitle()),
+    fOK(mod.fOK),
+    fA(mod.fA),
+    fB(mod.fB),
+    fThetaA(mod.fThetaA),
+    fTheta(mod.fTheta),
+    fOK1(mod.fOK1),
+    fOK2(mod.fOK2),
+    fOB(mod.fOB),
+    fOB1(mod.fOB1),
+    fOB2(mod.fOB2)
+{
+  //copy ctor
+  for (Int_t i=0; i<3; i++) fOK3X3[i] = mod.fOK3X3[i];
+}
+
+//________________________________________________________________
+void AliJetDummyShishKebabTrd1Module::Init(Double_t A, Double_t B)
+{ 
+  // Define parameter module from parameters A,B from previos.
+  Double_t yl = (fgb/2)*TMath::Sin(fTheta) + (fga/2)*TMath::Cos(fTheta) + fgr, y = yl;
+  Double_t xl = (yl - B) / A;     // y=A*x+B
+
+  if(fDebug>1){
+    Double_t xp1 = (fga/2. + fgb/2.*fgtanBetta)/(TMath::Sin(fTheta) + fgtanBetta*TMath::Cos(fTheta));
+    printf(" xp1 %9.3f \n ", xp1);
+  }
+  // xp1 == xp => both methods give the same results - 3-feb-05
+  Double_t alpha = TMath::Pi()/2. + fgangle/2;
+  Double_t xt = (fga+fga2)*TMath::Tan(fTheta)*TMath::Tan(alpha)/(4.*(1.-TMath::Tan(fTheta)*TMath::Tan(alpha)));
+  Double_t yt = xt / TMath::Tan(fTheta), xp = TMath::Sqrt(xt*xt + yt*yt);
+  Double_t x  = xl + xp;
+  fOK.Set(x, y);
+  if(fDebug>1) printf(" yl %9.3f | xl %9.3f | xp %9.3f \n", yl, xl, xp);
+
+  // have to define A and B; 
+  Double_t yCprev = fgr + fga*TMath::Cos(fTheta);
+  Double_t xCprev = (yCprev - B) / A;
+  Double_t xA     = xCprev + fga*TMath::Sin(fTheta), yA = fgr;
+
+  fThetaA = fTheta - fgangle/2.;
+  fA = TMath::Tan(fThetaA); // !!
+  fB = yA - fA*xA;
+
+  DefineAllStaff();
+}
+
+//_____________________________________________________________________________
+void AliJetDummyShishKebabTrd1Module::DefineAllStaff()
+{
+  DefineName(fTheta);
+  // Centers of module - 2X2 case
+  Double_t kk1 = (fga+fga2)/(2.*4.); // kk1=kk2 
+
+  Double_t xk1 = fOK.X() - kk1*TMath::Sin(fTheta);
+  Double_t yk1 = fOK.Y() + kk1*TMath::Cos(fTheta) - fgr;
+  fOK1.Set(xk1,yk1);
+
+  Double_t xk2 = fOK.X() + kk1*TMath::Sin(fTheta);
+  Double_t yk2 = fOK.Y() - kk1*TMath::Cos(fTheta) - fgr;
+  fOK2.Set(xk2,yk2);
+
+  // Centers of module - 3X3 case; Nov 9,2006
+  fOK3X3[1].Set(fOK.X(), fOK.Y()-fgr); // coincide with module center
+
+  kk1 = ((fga+fga2)/4. + fga/6.)/2.; 
+
+  xk1 = fOK.X() - kk1*TMath::Sin(fTheta);
+  yk1 = fOK.Y() + kk1*TMath::Cos(fTheta) - fgr;
+  fOK3X3[0].Set(xk1,yk1);
+
+  xk2 = fOK.X() + kk1*TMath::Sin(fTheta);
+  yk2 = fOK.Y() - kk1*TMath::Cos(fTheta) - fgr;
+  fOK3X3[2].Set(xk2,yk2);
+
+  // May 15, 2006; position of cell face of cells 
+  fOB.Set(fOK.X()-fgb/2.*TMath::Cos(fTheta),  fOK.Y()-fgb/2.*TMath::Sin(fTheta)-fgr);
+  fOB1.Set(fOB.X()-fga/4.*TMath::Sin(fTheta), fOB.Y()+fga/4.*TMath::Cos(fTheta));
+  fOB2.Set(fOB.X()+fga/4.*TMath::Sin(fTheta), fOB.Y()-fga/4.*TMath::Cos(fTheta));
+
+}
+
+//_____________________________________________________________________________
+void AliJetDummyShishKebabTrd1Module::DefineFirstModule()
+{
+  // Define first module
+  fOK.Set(fga2/2., fgr + fgb/2.); // position the center of module vs o
+
+  // parameters of right line : y = A*z + B in system where zero point is IP.
+  fThetaA = fTheta - fgangle/2.;
+  fA      = TMath::Tan(fThetaA);
+  Double_t xA = fga/2. + fga2/2., yA = fgr;
+  fB = yA - fA*xA;
+
+  TObject::SetUniqueID(1); //
+
+  DefineAllStaff();
+}
+
+//_____________________________________________________________________________
+void AliJetDummyShishKebabTrd1Module::DefineName(Double_t theta)
+{
+  // Define name of object
+  SetName(Form("%2i(%5.2f)", TObject::GetUniqueID(), theta*TMath::RadToDeg()));
+}
+
+//_____________________________________________________________________________
+Bool_t AliJetDummyShishKebabTrd1Module::GetParameters()
+{
+ // Get needing module parameters from EMCAL geometry
+  if(!fgGeometry) fgGeometry = AliJetDummyGeo::GetInstance();
+  TString sn(fgGeometry->GetName()); // 2-Feb-05
+  sn.ToUpper();
+  if(!fgGeometry) {
+    Warning("GetParameters()"," No geometry ");
+    return kFALSE; 
+  }
+
+  fga        = (Double_t)fgGeometry->GetEtaModuleSize();
+  fgb        = (Double_t)fgGeometry->GetLongModuleSize();
+  fgangle    = Double_t(fgGeometry->GetTrd1Angle())*TMath::DegToRad();
+  fgtanBetta = TMath::Tan(fgangle/2.);
+  fgr        = (Double_t)fgGeometry->GetIPDistance();
+
+  if(!sn.Contains("TRD2")) fgr += fgGeometry->GetSteelFrontThickness();
+
+  fga2       = Double_t(fgGeometry->Get2Trd1Dx2());
+  //PH  PrintShish(0);
+  return kTRUE;
+}
+
+// service methods
+//_____________________________________________________________________________
+void AliJetDummyShishKebabTrd1Module::PrintShish(Int_t pri) const
+{
+  // service method
+  if(pri>=0) {
+    printf("PrintShish() \n a %7.3f:%7.3f | b %7.2f | r %7.2f \n TRD1 angle %7.6f(%5.2f) | tanBetta %7.6f", 
+    fga, fga2, fgb, fgr, fgangle, fgangle*TMath::RadToDeg(), fgtanBetta);
+    printf(" fTheta %f : %5.2f : cos(theta) %f\n", 
+    fTheta, GetThetaInDegree(),TMath::Cos(fTheta)); 
+    if(pri>=1) {
+      printf(" %i |%s| theta %f :  fOK.Phi = %f(%5.2f)\n", 
+      GetUniqueID(), GetName(), fTheta, fOK.Phi(),fOK.Phi()*TMath::RadToDeg());
+      printf(" A %f B %f | fThetaA %7.6f(%5.2f)\n", fA,fB, fThetaA,fThetaA*TMath::RadToDeg());
+      printf(" fOK  : X %9.4f: Y %9.4f : eta  %5.3f\n",  fOK.X(), fOK.Y(), GetEtaOfCenterOfModule());
+      printf(" fOK1 : X %9.4f: Y %9.4f :   (local, ieta=2)\n", fOK1.X(), fOK1.Y());
+      printf(" fOK2 : X %9.4f: Y %9.4f :   (local, ieta=1)\n\n", fOK2.X(), fOK2.Y());
+      printf(" fOB  : X %9.4f: Y %9.4f \n", fOB.X(), fOB.Y());
+      printf(" fOB1 : X %9.4f: Y %9.4f (local, ieta=2)\n", fOB1.X(), fOB1.Y());
+      printf(" fOB2 : X %9.4f: Y %9.4f (local, ieta=1)\n", fOB2.X(), fOB2.Y());
+      // 3X3 
+      printf(" 3X3 \n");
+      for(Int_t ieta=0; ieta<3; ieta++) {
+        printf(" fOK3X3[%i] : X %9.4f: Y %9.4f (local) \n", ieta, fOK3X3[ieta].X(), fOK3X3[ieta].Y());
+      }
+      //      fOK.Dump();
+      GetMaxEtaOfModule(pri);
+    }
+  }
+}
+
+//_____________________________________________________________________________
+Double_t  AliJetDummyShishKebabTrd1Module::GetThetaInDegree() const 
+{
+  return fTheta*TMath::RadToDeg();
+}
+
+//_____________________________________________________________________________
+Double_t  AliJetDummyShishKebabTrd1Module::GetEtaOfCenterOfModule() const 
+{ 
+  return -TMath::Log(TMath::Tan(fOK.Phi()/2.));
+}
+
+//_____________________________________________________________________________
+Double_t  AliJetDummyShishKebabTrd1Module::GetMaxEtaOfModule(Int_t pri) const 
+{ 
+  // Right bottom point of module
+  Double_t xBottom     = (fgr - fB) / fA;
+  Double_t thetaBottom = TMath::ATan2(fgr, xBottom);
+  Double_t etaBottom   = ThetaToEta(thetaBottom);
+  // Right top point of module
+  Double_t l = fgb / TMath::Cos(fgangle/2.); // length of lateral module side
+  Double_t xTop = xBottom + l*TMath::Cos(TMath::ATan(fA));
+  Double_t yTop = fA*xTop + fB;
+  Double_t thetaTop = TMath::ATan2(yTop, xTop);
+  Double_t etaTop   = ThetaToEta(thetaTop);
+
+  if(pri) { 
+    printf(" Right bottom point of module : eta %5.4f : theta %6.4f (%6.2f) \n", 
+    etaBottom, thetaBottom, thetaBottom * TMath::RadToDeg());
+    printf(" Right    top point of module : eta %5.4f : theta %6.4f (%6.2f) \n", 
+    etaTop, thetaTop, thetaTop * TMath::RadToDeg());
+  }
+  return etaBottom>etaTop ? etaBottom : etaTop;
+}
diff --git a/JETAN/AliJetDummyShishKebabTrd1Module.h b/JETAN/AliJetDummyShishKebabTrd1Module.h
new file mode 100644 (file)
index 0000000..2b61f7f
--- /dev/null
@@ -0,0 +1,125 @@
+#ifndef ALIJETDUMMYSHISHKEBABTRD1MODULE_H
+#define ALIJETDUMMYSHISHKEBABTRD1MODULE_H
+
+/* Copyright(c) 1998-2004, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+//_________________________________________________________________________
+// Main class for TRD1 geometry of Shish-Kebab case.
+// Author: Aleksei Pavlinov(WSU).
+// Nov 2004; Feb 2006
+
+//
+// Class modified and implemented in JETAN
+//
+// M. Estienne
+//
+
+
+#include <TNamed.h>
+#include <TMath.h>
+#include <TVector2.h>
+
+class AliJetDummyGeo;
+
+class AliJetDummyShishKebabTrd1Module : public TNamed {
+ public:
+  AliJetDummyShishKebabTrd1Module(Double_t theta=0.0, AliJetDummyGeo *g=0);
+  AliJetDummyShishKebabTrd1Module(AliJetDummyShishKebabTrd1Module &leftNeighbor);
+  void Init(Double_t A, Double_t B);
+  void DefineAllStaff();
+  AliJetDummyShishKebabTrd1Module(const AliJetDummyShishKebabTrd1Module& mod);
+
+  AliJetDummyShishKebabTrd1Module & operator = (const AliJetDummyShishKebabTrd1Module& /*rvalue*/)  {
+    Fatal("operator =", "not implemented") ;  
+    return *this ; 
+  }
+
+  virtual   ~AliJetDummyShishKebabTrd1Module(void) {}
+  Bool_t    GetParameters();
+  void      DefineName(Double_t theta);
+  void      DefineFirstModule();
+
+  Double_t  GetTheta() const {return fTheta;}
+  TVector2& GetCenterOfModule() {return fOK;}
+
+  Double_t  GetPosX() const {return fOK.Y();}
+  Double_t  GetPosZ() const {return fOK.X();}
+  Double_t  GetPosXfromR() const {return fOK.Y() - fgr;}
+  Double_t  GetA() const {return fA;}
+  Double_t  GetB() const {return fB;}
+  Double_t  GetRadius() const {return fgr;}
+  //  Additional offline staff 
+  //  ieta=0 or 1 - Jun 02, 2006
+  TVector2& GetCenterOfCellInLocalCoordinateofSM(Int_t ieta)
+  { if(ieta<=0) return fOK2;
+    else        return fOK1;}
+  void GetCenterOfCellInLocalCoordinateofSM(Int_t ieta, Double_t &xr, Double_t &zr) const
+  { 
+    if(ieta<=0) {xr = fOK2.Y(); zr = fOK2.X();
+    } else      {xr = fOK1.Y(); zr = fOK1.X();
+    }
+  }
+  void GetCenterOfCellInLocalCoordinateofSM_3X3(Int_t ieta, Double_t &xr, Double_t &zr) const
+  { // 3X3 case - Nov 9,2006
+    ieta = ieta<0? ieta=0 : ieta; // check index
+    ieta = ieta>2? ieta=2 : ieta;
+    xr   = fOK3X3[2-ieta].Y();
+    zr   = fOK3X3[2-ieta].X();
+  }
+  void GetCenterOfCellInLocalCoordinateofSM_1X1(Double_t &xr, Double_t &zr) const
+  { // 1X1 case - Nov 27,2006
+    // Center of cell is center of module
+    xr   = fOK.Y() - fgr;
+    zr   = fOK.X();
+  }
+  // 15-may-06
+  TVector2& GetCenterOfModuleFace() {return fOB;}  
+  TVector2& GetCenterOfModuleFace(Int_t ieta) {
+    if(ieta<=0) return fOB2;
+    else        return fOB1;
+  }  
+  // 
+  Double_t        GetTanBetta() const {return fgtanBetta;}
+  Double_t        Getb()        const {return fgb;}
+  // service methods
+  void            PrintShish(Int_t pri=1) const;  // *MENU*
+  Double_t        GetThetaInDegree() const;
+  Double_t        GetEtaOfCenterOfModule() const;
+  Double_t        GetMaxEtaOfModule(Int_t pri=0) const;
+  static Double_t ThetaToEta(Double_t theta) 
+  {return -TMath::Log(TMath::Tan(theta/2.));}
+
+ protected:
+  // geometry info
+  static AliJetDummyGeo *fgGeometry; //!
+  static Double_t fga;        // 2*dx1=2*dy1
+  static Double_t fga2;       // 2*dx2
+  static Double_t fgb;        // 2*dz1
+  static Double_t fgangle;    // ~1 degree
+  static Double_t fgtanBetta; // tan(fgangle/2.)
+  static Double_t fgr;        // radius to IP
+
+  TVector2 fOK;     // position the module center in ALICE system; x->y; z->x;
+  Double_t fA;      // parameters of right line : y = A*z + B
+  Double_t fB;      // system where zero point is IP.
+  Double_t fThetaA; // angle coresponding fA - for convinience
+  Double_t fTheta;  // theta angle of perpendicular to SK module
+  // position of towers(cells) with differents ieta (1 or 2) in local coordinate of SM
+  // Nov 04,2004; Feb 19,2006 
+  TVector2 fOK1;    // ieta=1
+  TVector2 fOK2;    // ieta=0
+  // May 13, 2006; local position of module (cells) face  
+  TVector2 fOB;     // module
+  TVector2 fOB1;    // ieta=1
+  TVector2 fOB2;    // ieta=0
+  // 3X3 case - Nov 9,2006
+  TVector2 fOK3X3[3];
+  Int_t    fDebug;
+
+  // public:
+  ClassDef(AliJetDummyShishKebabTrd1Module,1) // TRD1 Shish-Kebab module 
+};
+
+#endif
index f94acd3..24953fb 100644 (file)
@@ -29,6 +29,7 @@
 #pragma link C++ class AliJetFillUnitArrayTracks+;
 #pragma link C++ class AliJetFillUnitArrayEMCalDigits+;
 #pragma link C++ class AliJetDummyGeo+;
+#pragma link C++ class AliJetDummyShishKebabTrd1Module+;
 #pragma link C++ class AliAnalysisTaskJets+;
 #pragma link C++ class AliDAJetFinder+;
 #pragma link C++ class AliDAJetHeader+;
index 01e1e80..8cc12c7 100644 (file)
@@ -11,7 +11,7 @@ SRCS =        AliJet.cxx AliJetHeader.cxx \
        AliJetGrid.cxx AliJetUnitArray.cxx AliJetHadronCorrection.cxx \
        AliJetHadronCorrectionv0.cxx AliJetHadronCorrectionv1.cxx \
        AliJetFillUnitArrayTracks.cxx AliJetFillUnitArrayEMCalDigits.cxx\
-       AliJetDummyGeo.cxx \
+       AliJetDummyGeo.cxx AliJetDummyShishKebabTrd1Module.cxx\
        AliJetFinderTypes.cxx \
        AliAnalysisTaskJets.cxx \
        AliDAJetFinder.cxx \