Remove gAlice from the reconstruction code
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 28 Sep 2006 13:53:03 +0000 (13:53 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 28 Sep 2006 13:53:03 +0000 (13:53 +0000)
TRD/AliTRDCommonParam.cxx
TRD/AliTRDReconstructor.cxx
TRD/AliTRDTriggerL1.cxx
TRD/AliTRDclusterizer.cxx
TRD/AliTRDclusterizerV1.cxx
TRD/AliTRDgeometry.cxx
TRD/AliTRDsegmentArray.cxx
TRD/AliTRDsegmentArrayBase.cxx
TRD/AliTRDtrigger.cxx

index b0cb8da..b8289c5 100644 (file)
 //                                                                           //
 ///////////////////////////////////////////////////////////////////////////////
 
-#include "AliRun.h"
+#include <TObjArray.h>
+
+#include "AliTracker.h"
 
 #include "AliTRDCommonParam.h"
 #include "AliTRDpadPlane.h"
 
 ClassImp(AliTRDCommonParam)
 
-AliTRDCommonParam* AliTRDCommonParam::fgInstance = 0;
+AliTRDCommonParam *AliTRDCommonParam::fgInstance = 0;
 Bool_t AliTRDCommonParam::fgTerminated = kFALSE;
 
 //_ singleton implementation __________________________________________________
@@ -42,12 +44,14 @@ AliTRDCommonParam* AliTRDCommonParam::Instance()
   // Returns an instance of this class, it is created if neccessary
   // 
   
-  if (fgTerminated != kFALSE)
+  if (fgTerminated != kFALSE) {
     return 0;
+  }
 
-  if (fgInstance == 0)
+  if (fgInstance == 0) {
     fgInstance = new AliTRDCommonParam();
-  
+  }  
+
   return fgInstance;
 
 }
@@ -63,8 +67,7 @@ void AliTRDCommonParam::Terminate()
   
   fgTerminated = kTRUE;
   
-  if (fgInstance != 0)
-  {
+  if (fgInstance != 0) {
     delete fgInstance;
     fgInstance = 0;
   }
@@ -97,10 +100,7 @@ void AliTRDCommonParam::Init()
   fExBOn          = kTRUE;
 
   // The magnetic field strength in Tesla
-  Double_t x[3] = { 0.0, 0.0, 0.0 };
-  Double_t b[3];
-  gAlice->Field(x,b);  // b[] is in kilo Gauss
-  fField = b[2] * 0.1; // Tesla
+  fField          = AliTracker::GetBz() * 0.1; 
   
   // ----------------------------------------------------------------------------
   // The pad planes
@@ -152,7 +152,10 @@ AliTRDCommonParam &AliTRDCommonParam::operator=(const AliTRDCommonParam &p)
   // Assignment operator
   //
 
-  if (this != &p) ((AliTRDCommonParam &) p).Copy(*this);
+  if (this != &p) {
+    ((AliTRDCommonParam &) p).Copy(*this);
+  }
+
   return *this;
 
 }
@@ -164,7 +167,7 @@ void AliTRDCommonParam::Copy(TObject &p) const
   // Copy function
   //
   
-  AliTRDCommonParam* target = dynamic_cast<AliTRDCommonParam*> (&p);
+  AliTRDCommonParam *target = dynamic_cast<AliTRDCommonParam*> (&p);
   if (!target) {
     return;
   }  
index dbe04b0..f6e5094 100644 (file)
@@ -26,7 +26,6 @@
 #include "AliRunLoader.h"
 #include "AliRawReader.h"
 #include "AliLog.h"
-#include "AliRun.h"
 #include "AliESDTrdTrack.h"
 #include "AliESD.h"
 
@@ -77,16 +76,8 @@ void AliTRDReconstructor::Reconstruct(AliRunLoader *runLoader) const
   AliTRDtrigParam *trigp = new AliTRDtrigParam("TRDtrigParam"
                                               ,"TRD Trigger parameters");
 
-  if (runLoader->GetAliRun() == 0x0) {
-    runLoader->LoadgAlice();
-  }
-  gAlice = runLoader->GetAliRun();
-  Double_t x[3]  = { 0.0, 0.0, 0.0 };
-  Double_t b[3];
-  gAlice->Field(x,b);          // b[] is in kilo Gauss
-  Float_t  field = b[2] * 0.1; // Tesla
+  Float_t field = AliTracker::GetBz() * 0.1; // Tesla
   AliInfo(Form("Trigger set for magnetic field = %f Tesla \n",field));
-
   trigp->SetField(field);
   trigp->Init();
   trdTrigger.SetParameter(trigp);
@@ -144,16 +135,8 @@ void AliTRDReconstructor::Reconstruct(AliRunLoader *runLoader
   AliTRDtrigParam *trigp = new AliTRDtrigParam("TRDtrigParam"
                                               ,"TRD Trigger parameters");
 
-  if (runLoader->GetAliRun() == 0x0) {
-    runLoader->LoadgAlice();
-  }
-  gAlice = runLoader->GetAliRun();
-  Double_t x[3]  = { 0.0, 0.0, 0.0 };
-  Double_t b[3];
-  gAlice->Field(x,b);          // b[] is in kilo Gauss
-  Float_t  field = b[2] * 0.1; // Tesla
+  Float_t field = AliTracker::GetBz() * 0.1; // Tesla
   AliInfo(Form("Trigger set for magnetic field = %f Tesla \n",field));
-
   trigp->SetField(field);
   trigp->Init();
   trdTrigger.SetParameter(trigp);
@@ -187,7 +170,7 @@ AliTracker *AliTRDReconstructor::CreateTracker(AliRunLoader *runLoader) const
 
 //_____________________________________________________________________________
 void AliTRDReconstructor::FillESD(AliRunLoader *runLoader
-                                , AliESD *esd) const
+                               , AliESD *esd) const
 {
   //
   // Make PID
@@ -204,16 +187,8 @@ void AliTRDReconstructor::FillESD(AliRunLoader *runLoader
   AliTRDtrigParam *trigp = new AliTRDtrigParam("TRDtrigParam"
                                               ,"TRD Trigger parameters");
 
-  if (runLoader->GetAliRun() == 0x0) {
-    runLoader->LoadgAlice();
-  }
-  gAlice = runLoader->GetAliRun();
-  Double_t x[3]  = { 0.0, 0.0, 0.0 };
-  Double_t b[3];
-  gAlice->Field(x,b);          // b[] is in kilo Gauss
-  Float_t  field = b[2] * 0.1; // Tesla
+  Float_t field = AliTracker::GetBz() * 0.1; // Tesla
   AliInfo(Form("Trigger set for magnetic field = %f Tesla \n",field));
-
   trigp->SetField(field);
   trigp->Init();
 
index 00df344..a8cb2fe 100644 (file)
@@ -23,7 +23,9 @@
 
 #include <TMath.h>
 
-#include "AliRun.h"
+#include "AliRunLoader.h"
+#include "AliConfig.h"
+#include "AliTracker.h"
 #include "AliTriggerInput.h"
 
 #include "AliTRDTriggerL1.h"
@@ -35,7 +37,8 @@
 ClassImp(AliTRDTriggerL1)
 
 //_____________________________________________________________________________
-AliTRDTriggerL1::AliTRDTriggerL1():AliTriggerDetector()
+AliTRDTriggerL1::AliTRDTriggerL1()
+  :AliTriggerDetector()
 {
   //
   // Default constructor
@@ -84,23 +87,16 @@ void AliTRDTriggerL1::Trigger()
   // Run the online tracking and trigger
   // 
 
-  AliRunLoader* runLoader = gAlice->GetRunLoader();
-
-  AliLoader *loader=runLoader->GetLoader("TRDLoader");
-
-  // Trigger (tracklets, LTU)
-
-  AliTRDgeometry *geo = AliTRDgeometry::GetGeometry(runLoader);
+  TString          evfoldname = AliConfig::GetDefaultEventFolderName();
+  AliRunLoader    *runLoader  = AliRunLoader::GetRunLoader(evfoldname);
+  AliLoader       *loader     = runLoader->GetLoader("TRDLoader");
+  AliTRDgeometry  *geo        = AliTRDgeometry::GetGeometry(runLoader);
+  AliTRDtrigParam *trigp      = new AliTRDtrigParam("TRDtrigParam","TRD Trigger parameters");
 
   AliTRDtrigger trdTrigger("Trigger","Trigger class"); 
 
-  AliTRDtrigParam *trigp = new AliTRDtrigParam("TRDtrigParam","TRD Trigger parameters");
-
-  Double_t x[3] = { 0.0, 0.0, 0.0 };
-  Double_t b[3];
-  gAlice->Field(x,b);  // b[] is in kilo Gauss
-  Float_t field = b[2] * 0.1; // Tesla
-  Info("Trigger","Trigger set for magnetic field = %f Tesla \n",field);
+  Float_t field = AliTracker::GetBz() * 0.1; // Tesla
+  AliInfo(Form("Trigger set for magnetic field = %f Tesla \n",field));
 
   trigp->SetField(field);
   trigp->Init();
@@ -120,26 +116,33 @@ void AliTRDTriggerL1::Trigger()
   Float_t jetLowPt  = trigp->GetJetLowPt();
   Float_t jetHighPt = trigp->GetJetHighPt();
 
-  Float_t pid, pt;
-  Int_t   det, sec;
+  Float_t pid;
+  Float_t pt;
+  Int_t   det;
+  Int_t   sec;
   Bool_t  isElectron;
 
   const Int_t maxEle = 1000;
 
-  Int_t   electronPlus,          electronMinus;
-  Int_t   sectorElePlus[maxEle], sectorEleMinus[maxEle];
-  Float_t ptElePlus[maxEle],     ptEleMinus[maxEle];
-  Int_t   hadronLowPt, hadronHighPt;
-  Int_t   hadronJetLowPt, hadronJetHighPt;
+  Int_t   electronPlus;
+  Int_t   electronMinus;
+  Int_t   sectorElePlus[maxEle];
+  Int_t   sectorEleMinus[maxEle];
+  Float_t ptElePlus[maxEle];   
+  Float_t ptEleMinus[maxEle];
+  Int_t   hadronLowPt;
+  Int_t   hadronHighPt;
+  Int_t   hadronJetLowPt;
+  Int_t   hadronJetHighPt;
 
   hadronJetLowPt  = 0;
   hadronJetHighPt = 0;
 
-  hadronLowPt  = 0;
-  hadronHighPt = 0;
+  hadronLowPt     = 0;
+  hadronHighPt    = 0;
 
-  electronPlus  = 0;
-  electronMinus = 0;
+  electronPlus    = 0;
+  electronMinus   = 0;
 
   AliTRDgtuTrack *gtuTrack;
   Int_t nTracks = trdTrigger.GetNumberOfTracks();
@@ -151,7 +154,6 @@ void AliTRDTriggerL1::Trigger()
     isElectron = gtuTrack->IsElectron();
     pt         = gtuTrack->GetPt();
     det        = gtuTrack->GetDetector();
-
     sec        = geo->GetSector(det);
 
     if (isElectron) {
@@ -160,22 +162,29 @@ void AliTRDTriggerL1::Trigger()
        sectorEleMinus[electronMinus] = sec;
        ptEleMinus[electronMinus]     = pt;
        electronMinus++;
-      } else {
-       sectorElePlus[electronPlus] = sec;
-       ptElePlus[electronPlus]     = pt;
+      } 
+      else {
+       sectorElePlus[electronPlus]   = sec;
+       ptElePlus[electronPlus]       = pt;
        electronPlus++;
       }
 
-    } else {
+    } 
+    else {
 
       if (TMath::Abs(pt) < highPt) {
        hadronLowPt++;
-      } else {
+      } 
+      else {
        hadronHighPt++;
       }
 
-      if (TMath::Abs(pt) > jetLowPt ) hadronJetLowPt++;
-      if (TMath::Abs(pt) > jetHighPt) hadronJetHighPt++;
+      if (TMath::Abs(pt) > jetLowPt ) {
+        hadronJetLowPt++;
+      }
+      if (TMath::Abs(pt) > jetHighPt) {
+        hadronJetHighPt++;
+      }
 
     }
 
@@ -183,32 +192,43 @@ void AliTRDTriggerL1::Trigger()
 
   loader->UnloadTracks();
 
-  // hadrons
-
-  if (hadronLowPt)  SetInput("TRD_Hadr_LPt_L1");
-  if (hadronHighPt) SetInput("TRD_Hadr_HPt_L1");
-
-  // hadrons from jets
-
-  if (hadronJetLowPt  >= trigp->GetNPartJetLow() )  SetInput("TRD_Jet_LPt_L1");
-  if (hadronJetHighPt >= trigp->GetNPartJetHigh())  SetInput("TRD_Jet_HPt_L1");
+  // Hadrons
+  if (hadronLowPt) {
+    SetInput("TRD_Hadr_LPt_L1");
+  }
+  if (hadronHighPt) {
+    SetInput("TRD_Hadr_HPt_L1");
+  }
 
-  // electron-positron pairs (open angle > 80 deg)
+  // Hadrons from jets
+  if (hadronJetLowPt  >= trigp->GetNPartJetLow() ) {
+    SetInput("TRD_Jet_LPt_L1");
+  }
+  if (hadronJetHighPt >= trigp->GetNPartJetHigh()) {
+    SetInput("TRD_Jet_HPt_L1");
+  }
 
-  Int_t  secPlus, secMinus, secDiff;
+  // Electron-positron pairs (open angle > 80 deg)
+  Int_t  secPlus;
+  Int_t  secMinus;
+  Int_t  secDiff;
   Bool_t electronUnlikePair    = kFALSE;
   Bool_t electronUnlikePairHPt = kFALSE;
 
-  if (electronMinus > 0 && electronPlus > 0) {
+  if ((electronMinus > 0) && 
+      (electronPlus  > 0)) {
     for (Int_t iPlus = 0; iPlus < electronPlus; iPlus++) {
       secPlus = sectorElePlus[iPlus];
       for (Int_t iMinus = 0; iMinus < electronMinus; iMinus++) {
        secMinus = sectorEleMinus[iMinus];
-       secDiff = TMath::Abs(secPlus-secMinus);
-       if (secDiff >  9) secDiff = 18 - secDiff;
+       secDiff  = TMath::Abs(secPlus-secMinus);
+       if (secDiff >  9) {
+          secDiff = 18 - secDiff;
+       }
        if (secDiff >= 5) {
          electronUnlikePair = kTRUE;
-         if (TMath::Abs(ptElePlus[iPlus]) > highPt && TMath::Abs(ptEleMinus[iMinus]) > highPt) {
+         if ((TMath::Abs(ptElePlus[iPlus]) > highPt) && 
+              (TMath::Abs(ptEleMinus[iMinus]) > highPt)) {
            electronUnlikePairHPt = kTRUE;
          }
        }
@@ -216,69 +236,85 @@ void AliTRDTriggerL1::Trigger()
     }
   }
 
-  if (electronUnlikePair)    SetInput("TRD_Unlike_EPair_L1");
-  //if (electronUnlikePairHPt) SetInput("TRD_Unlike_EPair_HPt_L1");
-
-  // like electron/positron pairs
-
-  Bool_t ele1, ele1HPt;
-  Bool_t ele2, ele2HPt;
+  if (electronUnlikePair) {
+    SetInput("TRD_Unlike_EPair_L1");
+  }
+  //if (electronUnlikePairHPt) {
+  //  SetInput("TRD_Unlike_EPair_HPt_L1");
+  //}
 
-  // positive
+  // Like electron/positron pairs
+  Bool_t ele1;
+  Bool_t ele1HPt;
+  Bool_t ele2;
+  Bool_t ele2HPt;
 
+  // Positive
   ele1    = kFALSE;
   ele2    = kFALSE;
   ele1HPt = kFALSE;
   ele2HPt = kFALSE;
   if (electronPlus > 1) {
     for (Int_t iPlus = 0; iPlus < electronPlus; iPlus++) {
-      if (!ele1) {
+      if      (!ele1) {
        ele1 = kTRUE;
-      } else if (!ele2) {
+      } 
+      else if (!ele2) {
        ele2 = kTRUE;
       }
       if (TMath::Abs(ptElePlus[iPlus]) > highPt) {
-       if (!ele1HPt) {
+       if      (!ele1HPt) {
          ele1HPt = kTRUE;
-       } else if (!ele2HPt) {
+       } 
+        else if (!ele2HPt) {
          ele2HPt = kTRUE;
        }
       }
     }
   }
 
-  if (ele1    && ele2   ) SetInput("TRD_Like_EPair_L1");
-  //if (ele1HPt && ele2HPt) SetInput("TRD_Like_EPair_HPt_L1");
-  
-  // negative
+  if (ele1    && ele2   ) {
+    SetInput("TRD_Like_EPair_L1");
+  }
+  //if (ele1HPt && ele2HPt) {
+  //  SetInput("TRD_Like_EPair_HPt_L1");
+  //}  
 
+  // Negative
   ele1    = kFALSE;
   ele2    = kFALSE;
   ele1HPt = kFALSE;
   ele2HPt = kFALSE;
   if (electronMinus > 1) {
     for (Int_t iMinus = 0; iMinus < electronMinus; iMinus++) {
-      if (!ele1) {
+      if      (!ele1) {
        ele1 = kTRUE;
-      } else if (!ele2) {
+      } 
+      else if (!ele2) {
        ele2 = kTRUE;
       }
       if (TMath::Abs(ptEleMinus[iMinus]) > highPt) {
-       if (!ele1HPt) {
+       if      (!ele1HPt) {
          ele1HPt = kTRUE;
-       } else if (!ele2HPt) {
+       } 
+        else if (!ele2HPt) {
          ele2HPt = kTRUE;
        }
       }
     }
   }
 
-  if (ele1    && ele2   ) SetInput("TRD_Like_EPair_L1");
-  //if (ele1HPt && ele2HPt) SetInput("TRD_Like_EPair_HPt_L1");
+  if (ele1    && ele2   ) {
+    SetInput("TRD_Like_EPair_L1");
+  }
+  //if (ele1HPt && ele2HPt) {
+  //  SetInput("TRD_Like_EPair_HPt_L1");
+  //}
   
-  // single electron/positron
+  // Single electron/positron
 
-  if (electronPlus > 0 || electronMinus > 0) {
+  if ((electronPlus  > 0) || 
+      (electronMinus > 0)) {
     SetInput("TRD_Electron_L1");
     /*
     for (Int_t iPlus = 0; iPlus < electronPlus; iPlus++) {
index ed3a96e..0ac9df2 100644 (file)
@@ -26,7 +26,6 @@
 #include <TFile.h>
 #include <TObjArray.h>
 
-#include "AliRun.h"
 #include "AliRunLoader.h"
 #include "AliLoader.h"
 #include "AliLog.h"
@@ -168,21 +167,6 @@ Bool_t AliTRDclusterizer::OpenInput(Int_t nEvent)
   // Opens a ROOT-file with TRD-hits and reads in the digits-tree
   //
 
-  // Connect the AliRoot file containing Geometry, Kine, and Hits
-  if (fRunLoader->GetAliRun() == 0x0) {
-    fRunLoader->LoadgAlice();
-  }
-  gAlice = fRunLoader->GetAliRun();
-
-  if (!(gAlice)) {
-    fRunLoader->LoadgAlice();
-    gAlice = fRunLoader->GetAliRun();
-    if (!(gAlice)) {
-      AliError("Could not find AliRun object.\n");
-      return kFALSE;
-    }
-  }
-
   // Import the Trees for the event nEvent in the file
   fRunLoader->GetEvent(nEvent);
   
index 5f73b86..1ac7441 100644 (file)
@@ -27,7 +27,6 @@
 #include <TH1.h>
 #include <TFile.h>
 
-#include "AliRun.h"
 #include "AliRunLoader.h"
 #include "AliLoader.h"
 #include "AliRawReader.h"
index 39f2b80..665936d 100644 (file)
@@ -1314,7 +1314,9 @@ AliTRDgeometry* AliTRDgeometry::GetGeometry(AliRunLoader *runLoader)
   // Load the geometry from the galice file
   //
 
-  if (!runLoader) runLoader = AliRunLoader::GetRunLoader();
+  if (!runLoader) {
+    runLoader = AliRunLoader::GetRunLoader();
+  }
   if (!runLoader) {
     AliErrorGeneral("AliTRDgeometry::GetGeometry","No run loader");
     return NULL;
@@ -1327,8 +1329,7 @@ AliTRDgeometry* AliTRDgeometry::GetGeometry(AliRunLoader *runLoader)
   AliTRDgeometry *geom = (AliTRDgeometry *) gDirectory->Get("TRDgeometry");
 
   if (!geom) {
-    // It is not in the file, try to get it from gAlice, 
-    // which corresponds to the run loader 
+    // If it is not in the file, try to get it from the run loader 
     AliTRD *trd = (AliTRD *) runLoader->GetAliRun()->GetDetector("TRD");
     geom = trd->GetGeometry();
   }
index b94a020..9c40402 100644 (file)
@@ -23,7 +23,7 @@
 
 #include <TTree.h>
 
-#include "AliRun.h"
+#include "AliLog.h"
 
 #include "AliTRDgeometry.h"
 #include "AliTRDsegmentArray.h"
@@ -114,18 +114,15 @@ Bool_t AliTRDsegmentArray::LoadArray(const Char_t *branchname, TTree *tree)
 
   fTree = tree;
 
-  // Connect the digits tree as default
   if (!fTree) {
-    AliWarning("Use default TreeD\n");
-    fTree = gAlice->TreeD();
-    if (!fTree) {
-      return kFALSE;
-    }
+    AliError("Digits tree is not defined\n");
+    return kFALSE;
   }
 
   // Get the branch
   fBranch = fTree->GetBranch(branchname);
   if (!fBranch) {
+    AliError(Form("Branch %s is not defined\n",branchname));
     return kFALSE;
   }
 
@@ -155,18 +152,15 @@ Bool_t AliTRDsegmentArray::StoreArray(const Char_t *branchname, TTree *tree)
 
   fTree = tree;
 
-  // Connect the digits tree as default
   if (!fTree) {
-    AliWarning("Use default TreeD\n");
-    fTree = gAlice->TreeD();
-    if (!fTree) {
-      return kFALSE;
-    }
+    AliError("Digits tree is not defined\n");
+    return kFALSE;
   }
 
   // Get the branch
   fBranch = fTree->GetBranch(branchname);
   if (!fBranch) {
+    AliError(Form("Branch %s is not defined\n",branchname));
     return kFALSE;
   }
 
@@ -207,18 +201,7 @@ AliTRDdataArray *AliTRDsegmentArray::GetDataArray(Int_t pla
   // Returns the data array for a given detector
   //
 
-  if (gAlice) {
-
-    AliTRDgeometry *geo = AliTRDgeometry::GetGeometry(gAlice->GetRunLoader());  
-    Int_t det = geo->GetDetector(pla,cha,sec);
-    return GetDataArray(det);
-
-  }
-  else {
-
-    AliError("gAlice is not defined\n");
-    return NULL;
-
-  }
+  Int_t det = AliTRDgeometry::GetDetector(pla,cha,sec);
+  return GetDataArray(det);
 
 }
index ca30954..c8f9110 100644 (file)
@@ -187,7 +187,9 @@ AliTRDsegmentID *AliTRDsegmentArrayBase::NewSegment()
   // Create a new object according to the class information
   //
 
-  if (fClass  == 0) return 0;
+  if (fClass  == 0) {
+    return 0;
+  }
 
   AliTRDsegmentID *segment = (AliTRDsegmentID *) fClass->New();
 
@@ -207,9 +209,15 @@ Bool_t AliTRDsegmentArrayBase::AddSegment(AliTRDsegmentID *segment)
   // Add a segment to the array
   //
 
-  if (segment  == 0) return kFALSE;
-  if (fSegment == 0) return kFALSE;
-  if (fClass   == 0) return kFALSE;
+  if (segment  == 0) {
+    return kFALSE;
+  }
+  if (fSegment == 0) {
+    return kFALSE;
+  }
+  if (fClass   == 0) {
+    return kFALSE;
+  }
 
   if (!(segment->IsA()->InheritsFrom(fClass))) {
     AliError(Form("added class %s is not of proper type"
@@ -225,17 +233,23 @@ Bool_t AliTRDsegmentArrayBase::AddSegment(AliTRDsegmentID *segment)
 }
 
 //_____________________________________________________________________________
-AliTRDsegmentID * AliTRDsegmentArrayBase::AddSegment(Int_t index)
+AliTRDsegmentID *AliTRDsegmentArrayBase::AddSegment(Int_t index)
 {
   //
   // Add a segment to the array
   //
 
-  if (fSegment == 0) return 0;
-  if (fClass   == 0) return 0;
+  if (fSegment == 0) {
+    return 0;
+  }
+  if (fClass   == 0) {
+    return 0;
+  }
 
   AliTRDsegmentID *segment = NewSegment();
-  if (segment  == 0) return 0;
+  if (segment  == 0) {
+    return 0;
+  }
 
   fSegment->AddAt(segment,index);
   segment->SetID(index);
@@ -293,10 +307,13 @@ void AliTRDsegmentArrayBase::MakeTree(char *file)
 
   AliTRDsegmentID *psegment = NewSegment();  
 
-  if (fTree) delete fTree;
-  fTree   = new TTree("Segment Tree","Tree with segments");
+  if (fTree) {
+    delete fTree;
+  }
 
+  fTree   = new TTree("Segment Tree","Tree with segments");
   fBranch = fTree->Branch("Segment",psegment->IsA()->GetName(),&psegment,64000);
+
   if (file) {
     fBranch->SetFile(file);      
   }
@@ -306,7 +323,7 @@ void AliTRDsegmentArrayBase::MakeTree(char *file)
 }              
 
 //_____________________________________________________________________________
-Bool_t AliTRDsegmentArrayBase::ConnectTree(const char * treeName)
+Bool_t AliTRDsegmentArrayBase::ConnectTree(const char *treeName)
 {
   //
   // Connect a tree from current directory  
@@ -318,10 +335,14 @@ Bool_t AliTRDsegmentArrayBase::ConnectTree(const char * treeName)
     fBranch = 0;
   }
 
-  fTree   = (TTree*) gDirectory->Get(treeName);
-  if (fTree   == 0) return kFALSE;
+  fTree = (TTree *) gDirectory->Get(treeName);
+  if (fTree   == 0) {
+    return kFALSE;
+  }
   fBranch = fTree->GetBranch("Segment");
-  if (fBranch == 0) return kFALSE;
+  if (fBranch == 0) {
+    return kFALSE;
+  }
 
   MakeDictionary(TMath::Max(fNSegment,Int_t(fTree->GetEntries())));
 
@@ -336,15 +357,25 @@ AliTRDsegmentID *AliTRDsegmentArrayBase::LoadSegment(Int_t index)
   // Load a segment with index <index> into the memory
   //
 
-  if (fTreeIndex == 0) MakeDictionary(3000);
+  if (fTreeIndex == 0) {
+    MakeDictionary(3000);
+  }
 
   // First try to load dictionary 
-  if (fTreeIndex == 0)        return 0;
-  if (fBranch    == 0)        return 0;
-  if (index > fTreeIndex->fN) return 0;
+  if (fTreeIndex == 0) {
+    return 0;
+  }
+  if (fBranch    == 0) {
+    return 0;
+  }
+  if (index > fTreeIndex->fN) {
+    return 0;
+  }
 
-  AliTRDsegmentID *s = (AliTRDsegmentID*) fSegment->At(index);
-  if (s == 0) s = NewSegment();
+  AliTRDsegmentID *s = (AliTRDsegmentID *) fSegment->At(index);
+  if (s == 0) {
+    s = NewSegment();
+  }
   s->SetID(index);
   
   if (s != 0) {
@@ -374,8 +405,12 @@ AliTRDsegmentID *AliTRDsegmentArrayBase::LoadEntry(Int_t index)
   // Load a segment at position <index> in the tree into the memory
   //
 
-  if (fBranch == 0)                return 0;
-  if (index > fTree->GetEntries()) return 0;
+  if (fBranch == 0) {
+    return 0;
+  }
+  if (index > fTree->GetEntries()) {
+    return 0;
+  }
 
   AliTRDsegmentID *s = NewSegment();  
   if (s) {
@@ -402,8 +437,12 @@ void AliTRDsegmentArrayBase::StoreSegment(Int_t index)
   //
 
   const AliTRDsegmentID *kSegment = (*this)[index];
-  if (kSegment == 0) return;
-  if (fTree    == 0) MakeTree();
+  if (kSegment == 0) {
+    return;
+  }
+  if (fTree    == 0) {
+    MakeTree();
+  }
   fBranch->SetAddress(&kSegment);
   fTree->Fill();
 
@@ -416,8 +455,12 @@ Bool_t  AliTRDsegmentArrayBase::MakeDictionary(Int_t size)
   // Create an index table for the tree
   //  
 
-  if (size < 1)   return kFALSE;
-  if (fTreeIndex) delete fTreeIndex;
+  if (size < 1) {
+    return kFALSE;
+  }
+  if (fTreeIndex) {
+    delete fTreeIndex;
+  }
 
   fTreeIndex = new AliTRDarrayI(); 
   fTreeIndex->Set(size);
@@ -429,11 +472,12 @@ Bool_t  AliTRDsegmentArrayBase::MakeDictionary(Int_t size)
   TBranch *brindix = fTree->GetBranch("fSegmentID");
 
   Int_t nevent = (Int_t) fTree->GetEntries();  
-  for (Int_t i = 0; i < nevent; i++){
+  for (Int_t i = 0; i < nevent; i++) {
     brindix->GetEvent(i);
     Int_t treeIndex = segment.GetID();
-    if (fTreeIndex->fN < treeIndex) 
+    if (fTreeIndex->fN < treeIndex) {
       fTreeIndex->Expand(Int_t (Float_t(treeIndex) * 1.5) + 1);
+    }
     (*fTreeIndex)[treeIndex] = i + 1; 
   }
 
@@ -448,7 +492,11 @@ const AliTRDsegmentID * AliTRDsegmentArrayBase::operator[](Int_t i) const
   // Returns a segment with the given index <i>
   //
 
-  if ((i < 0) || (i >= fNSegment)) return 0; 
+  if ((i <          0) || 
+      (i >= fNSegment)) {
+    return 0; 
+  }
+
   return (AliTRDsegmentID *) fSegment->At(i);
 
 }
@@ -460,7 +508,11 @@ const AliTRDsegmentID *AliTRDsegmentArrayBase::At(Int_t i) const
   // Returns a segment with the given index <i>
   //
 
-  if ((i < 0) || (i >= fNSegment)) return 0; 
+  if ((i <          0) || 
+      (i >= fNSegment)) {
+    return 0; 
+  }
+
   return (AliTRDsegmentID *) fSegment->At(i);
 
 }
index b505330..33fef5e 100644 (file)
@@ -230,20 +230,6 @@ Bool_t AliTRDtrigger::Open(const Char_t *name, Int_t nEvent)
     return kFALSE;
   }
 
-  // Open input
-  if (fRunLoader->GetAliRun() == 0x0) {
-    fRunLoader->LoadgAlice();
-  }
-  gAlice = fRunLoader->GetAliRun();
-  if (!(gAlice)) {
-    fRunLoader->LoadgAlice();
-    gAlice = fRunLoader->GetAliRun();
-    if (!(gAlice)) {
-      AliError("Could not find AliRun object.");
-      return kFALSE;
-    }
-  }
-
   // Import the Trees for the event nEvent in the file
   fRunLoader->GetEvent(nEvent);