Federico: AliHLTEMCALGeometry handles transformation from local to global coordinates
authorodjuvsla <odjuvsla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 24 Mar 2010 10:35:47 +0000 (10:35 +0000)
committerodjuvsla <odjuvsla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 24 Mar 2010 10:35:47 +0000 (10:35 +0000)
HLT/CALO/AliHLTCaloConstants.h
HLT/EMCAL/AliHLTEMCALClusterizerComponent.cxx
HLT/EMCAL/AliHLTEMCALConstants.cxx
HLT/EMCAL/AliHLTEMCALConstants.h
HLT/EMCAL/AliHLTEMCALGeometry.cxx
HLT/EMCAL/AliHLTEMCALGeometry.h

index 2905bf4..725be2c 100644 (file)
@@ -77,8 +77,17 @@ public:
   virtual Int_t GetNALTROS() const = 0;                                                        
   virtual Int_t GetNALTROCHANNELS() const = 0;                                                 
   virtual Int_t GetNBRANCHES() const = 0;                                              
-                                                               
-  virtual Float_t GetCELLSTEP() const = 0;                                     
+  virtual Float_t GetCELLSTEP() const = 0;
+  // EMCAL specific
+  virtual Float_t GetMAXCELLSTEPETA() const { return 0; };  //FR
+  virtual Float_t GetMINCELLSTEPETA() const  { return 0;  }//FR
+  virtual Float_t GetCELLSTEPPHI() const { return 0; }          //FR
+  virtual Float_t GetCELLHEIGHT() const { return 0; }       //FR
+  virtual Float_t GetCELLANGLE() const { return 0; }      //FR
+  virtual Float_t GetRADLENGTH() const { return 0; }       //FR
+  virtual Float_t GetCRITICENERGY() const { return 0; };        //FR
+  virtual Float_t GetCJ() const { return 0; }
+  // end
   virtual Int_t GetNRCUSPERSECTOR() const = 0;                                                 
   virtual Int_t GetDDLOFFSET() const = 0;
 
index 680d5b1..2af6356 100644 (file)
@@ -52,7 +52,7 @@ AliHLTEMCALClusterizerComponent::AliHLTEMCALClusterizerComponent():
 
   //AliHLTEMCALGeometry *geom = new AliHLTEMCALGeometry;
   
-  fAnalyserPtr->SetGeometry(new AliHLTEMCALGeometry("EMCAL"));
+  fAnalyserPtr->SetGeometry(new AliHLTEMCALGeometry());
   
 }
 
index 0127e59..b097492 100644 (file)
@@ -61,7 +61,7 @@ AliHLTEMCALConstants::AliHLTEMCALConstants() :
   fkZ1(1),
   fkX0(0),
   fkX1(1),
-  fkNMODULES(13),
+  fkNMODULES(10),
   fkNRCUS(4),
   fkNRCUSPERMODULE(2),
   fkNRCUSPERTOTAL(fkNMODULES*fkNRCUSPERMODULE),
@@ -69,7 +69,15 @@ AliHLTEMCALConstants::AliHLTEMCALConstants() :
   fkNALTROS(4),
   fkNALTROCHANNELS(16),
   fkNBRANCHES(2), 
-  fkCELLSTEP(-999999999.9),
+  fkCELLSTEP(6.0),
+  fkMAXCELLSTEPETA(6.32),      // FR: max tower dimension along eta
+  fkMINCELLSTEPETA(5.99),      // FR: min tower dimension along eta
+  fkCELLSTEPPHI(6.04667),      // FR: tower dimension along phi
+  fkCELLHEIGHT(27.74),         // FR: tower height
+  fkCELLANGLE(1.50),           // FR: tower tapeiring angle (DEG)
+  fkCRITICENERGY(8),
+  fkRADLENGTH(1.23),
+  fkCJ(0.5),
   fkNRCUSPERSECTOR(4),
   fkDDLOFFSET(4608)
 {
index 02415e9..7fe5dfc 100644 (file)
@@ -84,7 +84,15 @@ public:
   Int_t GetNALTROCHANNELS() const { return fkNALTROCHANNELS;} 
   Int_t GetNBRANCHES() const { return fkNBRANCHES;} 
 
-  Float_t GetCELLSTEP() const { return fkCELLSTEP; }   
+  Float_t GetCELLSTEP() const { return fkCELLSTEP; }
+  Float_t GetMAXCELLSTEPETA() const { return fkMAXCELLSTEPETA; }  //FR
+  Float_t GetMINCELLSTEPETA() const { return fkMINCELLSTEPETA; }  //FR
+  Float_t GetCELLSTEPPHI() const { return fkCELLSTEPPHI; }        //FR
+  Float_t GetCELLHEIGHT() const { return fkCELLHEIGHT; }        //FR
+  Float_t GetCELLANGLE() const { return fkCELLANGLE; }        //FR
+  Float_t GetRADLENGTH() const { return fkRADLENGTH; }        //FR
+  Float_t GetCRITICENERGY() const { return fkCRITICENERGY; }        //FR
+  Float_t GetGJ() const { return fkCJ;} //FR
   Int_t GetNRCUSPERSECTOR() const { return fkNRCUSPERSECTOR; }                                         
   Int_t GetDDLOFFSET() const { return fkDDLOFFSET; }
 
@@ -145,6 +153,15 @@ private:
   const Int_t fkNBRANCHES; //Constant
    
   const Float_t fkCELLSTEP; //Constant
+  const Float_t fkMAXCELLSTEPETA;
+  const Float_t fkMINCELLSTEPETA;
+  const Float_t fkCELLSTEPPHI;
+  const Float_t fkCELLHEIGHT;
+  const Float_t fkCELLANGLE;
+  const Float_t fkRADLENGTH;
+  const Float_t fkCRITICENERGY;
+  const Float_t fkCJ;
+
   const Int_t fkNRCUSPERSECTOR; //Constant
   
   const Int_t fkDDLOFFSET;   //Constant
index 2a7e05a..21eb94b 100644 (file)
@@ -13,7 +13,9 @@
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
+
 #include "AliHLTEMCALGeometry.h"
+#include "AliHLTEMCALConstants.h"
 #include "AliHLTEMCALConstant.h"
 #include "assert.h"
 #include "AliHLTCaloConstantsHandler.h"
 using namespace EmcalHLTConst;
 
 ClassImp(AliHLTEMCALGeometry);
+TGeoManager *gGeoManager = 0;
 
-AliHLTEMCALGeometry::AliHLTEMCALGeometry( TString det) : 
-       AliHLTCaloGeometry (det), 
+AliHLTEMCALGeometry::AliHLTEMCALGeometry() :
+       AliHLTCaloGeometry ("EMCAL"),
        fShmPtr(0),
-       fGeo(0)
+       fGeo(0),
+       fEMCALGeometry(0)
 {
        //fGeo = new AliEMCALGeoUtils("EMCAL_COMPLETE","EMCAL");
        //fGeo = new AliEMCALGeometry("EMCAL_COMPLETE","EMCAL");
        //fGeo =  AliEMCALGeometry::GetInstance(AliEMCALGeometry::GetDefaultGeometryName());
-//     TGeoManager::Import("/home/fedro/work/AliRoot/test/QA/geometry.root");
+       //TGeoManager::Import("/home/fedro/work/AliRoot/test/QA/geometry.root");
+       fGeo = new AliEMCALGeoUtils("EMCAL_COMPLETE","EMCAL");
        fShmPtr = new AliHLTEMCALSharedMemoryInterface();
+       GetGeometryFromCDB();
 }
 
 
@@ -43,28 +49,186 @@ AliHLTEMCALGeometry::~AliHLTEMCALGeometry()
 }
   
 void 
-AliHLTEMCALGeometry::GetGlobalCoordinates(AliHLTCaloRecPointDataStruct &/*recPoint*/, AliHLTCaloGlobalCoordinate &globalCoord)
+AliHLTEMCALGeometry::GetGlobalCoordinates(AliHLTEMCALRecPointDataStruct &recPoint, AliHLTCaloGlobalCoordinate &globalCoord)
 {
-       //TVector3 v1;
-       Double_t glob[3] = {0, 0, 0};
-       //Int_t AbsId;
 
-//     GetCellAbsId(recPoint.fModule, recPoint.fX, recPoint.fZ, AbsId);
+        Int_t istrip = 0;
+        Float_t z0 = 0;
+        Float_t zb = 0;
+        Float_t z_is = 0;
+        Float_t d = 0;
+
+        Float_t x,y,z; // return variables in terry's RF
+
+        Float_t dz = fCaloConstants->GetMINCELLSTEPETA(); // base cell width in eta
+        Float_t dx = fCaloConstants->GetCELLSTEPPHI(); // base cell width in phi
+
+         // parameters for shower depth calculation
+        Float_t X0 = fCaloConstants->GetRADLENGTH();
+        Float_t Ecr = fCaloConstants->GetCRITICENERGY();
+        Float_t Cj;
+
+        Float_t teta0 = fCaloConstants->GetCELLANGLE(); //tapering angle (deg)
+        Float_t teta1; //working angle
+
+        Float_t L = fCaloConstants->GetCELLHEIGHT();
+
+        // converting to MEV
+        Float_t E = recPoint.fAmp * 1000;
+
+        //TVector3 v1;
+               Double_t glob[3];
+               Double_t loc[3];
+
+        if (recPoint.fZ >= 47.5 || recPoint.fZ<-0.5) {
+                Logging(kHLTLogError, "HLT", "EMCAL", "AliHLTEMCALGeometry::GetGlobalCoordinates: invalid Z recpoint ");
+                return;
+         }
+
+         if (recPoint.fX >= 23.5 || recPoint.fX<-0.5) {
+                 Logging(kHLTLogError, "HLT", "EMCAL", "AliHLTEMCALGeometry::GetGlobalCoordinates: invalid X recpoint ");
+                 return;
+         }
+
+
+         switch ( recPoint.fParticle )
+         {
+         case 0:
+                 Cj = - fCaloConstants->GetCJ(); // photon
+                 d = X0 * TMath::Log( E / Ecr + Cj);
+                 break;
+
+         case 1:
+                 Cj = + fCaloConstants->GetCJ(); // electron
+                 d = X0 * TMath::Log( E / Ecr + Cj);
+                 break;
+
+         case 2:
+                 // hadron
+                 d = 0.5 * L;
+                 break;
+
+         default:
+                 Cj = - fCaloConstants->GetCJ(); // defaulting to photon
+                 d = X0 * TMath::Log( E / Ecr + Cj);
+         }
+
+          istrip = int ((recPoint.fZ + 0.5 ) / 2);
+
+          // module angle
+          teta1 = TMath::DegToRad() * istrip * teta0;
+
+          // calculation of module corner along z
+          // as a function of strip
+
+          for (Int_t is=0; is<= istrip; is++) {
+
+            teta1 = TMath::DegToRad() * is * teta0;
+
+            z_is = z_is + 2*dz*(TMath::Sin(teta1)*TMath::Tan(teta1) + TMath::Cos(teta1));
+
+          }
+
+          z0 = dz * (recPoint.fZ - 2*istrip + 0.5);
+          zb = (2*dz-z0-d*TMath::Tan(teta1))*TMath::Cos(teta1);
 
-       //fGeo->GetGlobalEMCAL(const AliEMCALRecPoint *rp, TVector3 &vglob);
-//     fGeo->GetGlobal(AbsId, glob);
+          z = z_is - zb*TMath::Cos(teta1);
 
-       globalCoord.fX = glob[0];
-       globalCoord.fY = glob[1];
-       globalCoord.fZ = glob[2];       
+//        cout << "----> istrip: " << istrip << endl;
+//        cout << "----> z0: "<< z0 << endl;
+//        cout << "----> zb: "<< zb << endl;
+//        cout << "----> corner z: "<< z_is << endl;
+
+//        cout << "----> teta1: "<< TMath::RadToDeg()*teta1 << endl;
+
+          y = d/TMath::Cos(teta1) + zb*TMath::Sin(teta1);
+
+          x = (recPoint.fX + 0.5)*dx;
+
+          // cout << "x: " << x << " y: "<< y << " z " << z << endl;
+
+       // check coordinate origin
+       loc[0] = x;
+       loc[1] = y;
+       loc[2] = z;
+
+        if(!fGeo)
+   {
+      Logging(kHLTLogError, "HLT", "EMCAL", "AliHLTEMCALGeometry::GetGlobalCoordinates: no geometry initialised");
+      return;
+   }
+
+        ConvertRecPointCoordinates(loc[1], loc[2], loc[3]);
+
+        fGeo->GetGlobal(loc, glob, recPoint.fModule);
+
+        globalCoord.fX = glob[0];
+        globalCoord.fY = glob[1];
+        globalCoord.fZ = glob[2];
 }
  
 void 
-AliHLTEMCALGeometry::GetCellAbsId(UInt_t /*module*/, UInt_t /*x*/, UInt_t /*z*/, Int_t& /*AbsId*/) 
+AliHLTEMCALGeometry::GetCellAbsId(UInt_t module, UInt_t y, UInt_t z, Int_t& AbsId)
 {
+
+       if(!fGeo)
+       {
+                Logging(kHLTLogError, "HLT", "EMCAL", "AliHLTEMCALGeometry::GetCellAbsId: no geometry initialised");
+                return;
+
+       }
        
-//     AbsId = fGeo->GetAbsCellIdFromCellIndexes(module, x, z); 
+       AbsId = fGeo->GetAbsCellIdFromCellIndexes(module, y, z);
        
 }
 
+void AliHLTEMCALGeometry::ConvertRecPointCoordinates(Double_t &x, Double_t &y, Double_t &z) const
+{
+       Double_t DX = 13.869008;
+       Double_t DY = 72.559998;
+       Double_t DZ = 175.00000;
 
+        x = y - DX;  //fixme
+        y = -x + DY; //fixme
+        z = z - DZ;  //fixme
+
+}
+
+
+int
+AliHLTEMCALGeometry::GetGeometryFromCDB()
+{
+  cout << "Getting geometry..." << endl;
+
+ // AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+
+  AliCDBPath path("GRP","Geometry","Data");
+  if(path.GetPath())
+    {
+      //      HLTInfo("configure from entry %s", path.GetPath());
+      AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
+      if (pEntry)
+       {
+         if(!fEMCALGeometry)
+           {
+             delete fEMCALGeometry;
+             fEMCALGeometry = 0;
+           }
+
+         gGeoManager = (TGeoManager*) pEntry->GetObject();
+         cout<< "gGeoManager = 0x%x" << gGeoManager << endl;
+
+         if(gGeoManager)
+           {
+             fGeo = new AliEMCALGeoUtils("EMCAL_COMPLETE","EMCAL");
+             //fClusterAnalyserPtr->SetGeometry(fEMCALGeometry);
+           }
+
+       }
+      else
+       {
+                 //HLTError("can not fetch object \"%s\" from OCDB", path);
+       }
+    }
+  return 0;
+}
index 2435da4..8b7cfc8 100644 (file)
@@ -1,6 +1,5 @@
 #ifndef ALIHLTEMCALGEOMETRY_H
 #define ALIHLTEMCALGEOMETRY_H
-
 /**************************************************************************
  * This file is property of and copyright by the Experimental Nuclear     *
  * Physics Group, Dep. of Physics                                         *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-
-#include  "AliHLTCaloGeometry.h"
+#include "AliHLTCaloGeometry.h"
 #include "AliHLTEMCALSharedMemoryInterface.h" 
 #include "AliEMCALGeoUtils.h"
 #include "AliEMCALGeometry.h"
 #include "TGeoManager.h"
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+#include "AliCDBPath.h"
+#include "AliHLTEMCALRecPointDataStruct.h"
 
-class  AliHLTEMCALGeometry : public AliHLTCaloGeometry
+class AliEMCALGeoUtils;
+
+class  AliHLTEMCALGeometry : public AliHLTCaloGeometry, public AliHLTLogging
 {
  public:
-  AliHLTEMCALGeometry( TString det );
-  virtual ~AliHLTEMCALGeometry();
-  void GetGlobalCoordinates(AliHLTCaloRecPointDataStruct &recPoint, AliHLTCaloGlobalCoordinate &globalCoord );
-  void GetCellAbsId(UInt_t module, UInt_t x, UInt_t z, Int_t& AbsId);
+       AliHLTEMCALGeometry();
+       virtual ~AliHLTEMCALGeometry();
+       void GetGlobalCoordinates(AliHLTEMCALRecPointDataStruct &recPoint, AliHLTCaloGlobalCoordinate &globalCoord );
+       void GetCellAbsId(UInt_t module, UInt_t x, UInt_t z, Int_t& AbsId);
+       virtual void ConvertRecPointCoordinates(Double_t &x, Double_t &y, Double_t &z) const;
+       virtual Int_t InitialiseGeometry() {return 0; }
+
+protected:
+       int GetGeometryFromCDB();
 private:
-       AliHLTEMCALGeometry();
+       //AliHLTEMCALGeometry();
+       void GetGlobalCoordinates(AliHLTCaloRecPointDataStruct &, AliHLTCaloGlobalCoordinate &) {}
+
        AliHLTEMCALSharedMemoryInterface* fShmPtr;  
        //AliEMCALGeometry *fGeo;
        AliEMCALGeoUtils *fGeo;
-      AliHLTEMCALGeometry(const AliHLTEMCALGeometry & );
-      AliHLTEMCALGeometry & operator = (const AliHLTEMCALGeometry &);
-  
-};
+       /** The EMCAL geometry */
+       AliEMCALGeoUtils *fEMCALGeometry;                  //!transient
+       AliHLTEMCALGeometry(const AliHLTEMCALGeometry & );
+       AliHLTEMCALGeometry & operator = (const AliHLTEMCALGeometry &);
+       //      static TGeoManager *fgGeoManager;
 
+
+};
 #endif