reconstruction with lookup table
authoralla <alla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 30 Jan 2007 12:35:03 +0000 (12:35 +0000)
committeralla <alla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 30 Jan 2007 12:35:03 +0000 (12:35 +0000)
T0/AliT0.cxx
T0/AliT0.h
T0/AliT0CalibData.cxx
T0/AliT0CalibData.h
T0/AliT0Parameters.cxx
T0/AliT0Parameters.h
T0/AliT0RawReader.cxx
T0/AliT0RawReader.h
T0/AliT0Reconstructor.cxx
T0/AliT0Reconstructor.h

index 7020921..3f1330c 100644 (file)
@@ -61,6 +61,7 @@
 #include "AliT0Digitizer.h"
 #include "AliT0RawData.h"
 #include "AliT0RecPoint.h"
+#include "AliT0Parameters.h"
 #include "AliLog.h"
 
 ClassImp(AliT0)
@@ -357,3 +358,62 @@ void AliT0::Digits2Raw()
   fLoader->UnloadDigits();
   
 }
+
+//____________________________________________________________________________
+void AliT0::Raw2Digits(AliRawReader *rawReader,TTree* digitsTree)
+{
+
+ //T0 raw data-> digits conversion
+ // reconstruct time information from raw data
+ // cout<<"  AliT0::Raw2Digits(AliRawReader *rawReader,TTree* digitsTree) "<<
+  // rawReader<<" "<<digitsTree<<endl;
+
+  //  AliT0RawReader myrawreader(rawReader,digitsTree);
+   AliT0RawReader myrawreader(rawReader);
+   if (!myrawreader.Next())
+     AliDebug(1,Form(" no raw data found!! %i", myrawreader.Next()));
+   Int_t allData[110][5];
+   for (Int_t i=0; i<110; i++) {
+     allData[i][0]=myrawreader.GetData(i,0);
+   }
+
+
+   AliT0digit* fDigits = new AliT0digit();
+   digitsTree->Branch("T0","AliT0digit",&fDigits,405,1);
+   
+   
+   TArrayI *timeLED = new TArrayI(24);
+   TArrayI * timeCFD = new TArrayI(24);
+   TArrayI *chargeQT0 = new TArrayI(24);
+   TArrayI *chargeQT1 = new TArrayI(24);
+   
+   for (Int_t in=0; in<24; in++)
+     {
+       timeLED->AddAt(allData[in+1][0],in);
+       timeCFD->AddAt(allData[in+25][0],in);
+       chargeQT0->AddAt(allData[in+55][0],in);
+       chargeQT1->AddAt(allData[in+79][0],in);
+       AliDebug(2, Form(" readed Raw %i %i %i %i %i", in, timeLED->At(in),timeCFD->At(in),chargeQT0->At(in),chargeQT1->At(in)));
+     }
+  
+   fDigits->SetTime(*timeCFD);
+   fDigits->SetADC(*chargeQT1);
+
+   fDigits->SetTimeAmp(*timeLED);
+   fDigits->SetADCAmp(*chargeQT1);
+
+   fDigits->SetMeanTime(allData[49][0]);
+   fDigits->SetDiffTime(allData[50][0]);
+   fDigits->SetTimeBestRight(allData[51][0]);
+   fDigits->SetTimeBestLeft(allData[52][0]);
+   digitsTree->Fill();
+   fDigits->Write();
+   delete timeCFD ;
+   delete chargeQT0;
+   delete timeLED ;
+   delete chargeQT1;
+
+
+}
index dd674b0..de26eac 100644 (file)
@@ -13,6 +13,7 @@
 #include "AliT0RecPoint.h"
 #include "AliT0digit.h"
 #include "AliT0Trigger.h"
+#include "AliT0RawReader.h"
 
 class TDirectory;
 class TFile;
@@ -52,6 +53,7 @@ public:
    // virtual AliLoader* MakeLoader(const char* topfoldername);
    virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
    void  Digits2Raw ();
+   void  Raw2Digits (AliRawReader *reader,TTree* digitsTree);
    virtual AliTriggerDetector* CreateTriggerDetector() const 
      { return new  AliT0Trigger(); }
 
index 68c952f..8208646 100644 (file)
@@ -28,6 +28,7 @@
 #include <TCanvas.h>
 
 #include "AliT0CalibData.h"
+#include "AliT0LookUpValue.h"
 #include "TObjArray.h"
 #include "TGraph.h"
 #include "TFile.h"
@@ -82,7 +83,7 @@ AliT0CalibData &AliT0CalibData::operator =(const AliT0CalibData& calibda)
 //________________________________________________________________
 AliT0CalibData::~AliT0CalibData()
 {
-
+  //
 }
 //________________________________________________________________
 void AliT0CalibData::Reset()
@@ -107,7 +108,32 @@ void  AliT0CalibData::Print(Option_t*) const
   printf(" \n");
 } 
 
+//________________________________________________________________
+void  AliT0CalibData::PrintLookup(Option_t*, Int_t iTRM, Int_t iTDC, Int_t iChannel) const
+{
+
+   AliT0LookUpKey* lookkey= new AliT0LookUpKey();
+   AliT0LookUpValue*  lookvalue= new AliT0LookUpValue();
+     lookvalue->SetTRM(iTRM);
+     lookvalue->SetTDC(iTDC);
+     lookvalue->SetChain(0);
+     lookvalue->SetChannel(iChannel);
+
+     printf(" AliT0CalibData::PrintLookup ::start GetValue %i %i %i \n",iTRM, iTDC, iChannel);
+     lookkey = (AliT0LookUpKey*) fLookup.GetValue((TObject*)lookvalue);
+     
+     cout<<"  AliT0CalibData::PrintLookup :: lookkey "<< lookkey<<endl;
+     if (lookkey)
+       {
+        cout<<" lookup KEY!!! "<<lookkey->GetKey()<<" VALUE "<<lookvalue->GetTRM()<<" "
+            <<lookvalue->GetTDC()<<" "
+            << lookvalue->GetChain()<<" "
+            <<lookvalue->GetChannel()<<endl;
+       }
+     
 
+}
 
 //________________________________________________________________
 void AliT0CalibData::SetTimeDelayCFD(Float_t* TimeDelay)
@@ -197,3 +223,64 @@ void AliT0CalibData::SetSlewingRec(Int_t ipmt,const Char_t *filename)
 }
 
 
+void AliT0CalibData::ReadAsciiLookup(const Char_t *filename)
+{
+
+  if(filename == 0){
+    AliError(Form("Please, specify file with database")) ;
+    return ;
+  }
+
+  //  AliT0LookUpKey * lookkey= new AliT0LookUpKey();
+  //AliT0LookUpValue * lookvalue= new AliT0LookUpValue();
+
+  ifstream lookup;
+  lookup.open(filename);
+  if(!lookup) {AliError(Form("Cannot open file %s !",filename));}
+  Char_t varname[11];
+  Int_t key, trm, tdc, chain, channel;
+  // while(lookup.eof())
+
+ for (Int_t i=0; i<108; i++)
+//    for (Int_t i=0;i<3;i++)
+    {
+       AliT0LookUpKey * lookkey= new AliT0LookUpKey();
+       AliT0LookUpValue * lookvalue= new AliT0LookUpValue();
+
+ lookup>>varname>>key>>trm>>chain>>tdc>>channel;
+      lookvalue->SetTRM(trm);
+      lookvalue->SetTDC(tdc);
+      lookvalue->SetChain(chain);
+      lookvalue->SetChannel(channel);
+      lookkey->SetKey(key);
+
+      //      cout<<"TRM="<<trm<<" TDC="<<tdc<<" chain="<<chain<<" channel="<<channel<<" key="<<key<<endl;
+
+      cout<<"AliT0CalibData:: "<<varname<<" "<<key<<" "<<trm<<" "<<chain<<" "<<tdc<<" "<<channel<<endl;
+
+      //    fLookup.Add((TObject*)lookkey,(TObject*)lookvalue);
+      // ar_key.AddAt(lookkey,i);
+      // ar_val.AddAt(lookvalue,i);
+
+        fLookup.Add((TObject*)lookvalue,(TObject*)lookkey);
+
+    }
+
+   lookup.close();
+
+}
+
+//________________________________________________________________
+
+Int_t AliT0CalibData::GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel)
+{
+
+  AliT0LookUpKey * lookkey;//= new AliT0LookUpKey();
+  AliT0LookUpValue * lookvalue= new AliT0LookUpValue(trm,tdc,chain,channel);
+
+     lookkey = (AliT0LookUpKey*) fLookup.GetValue((TObject*)lookvalue);
+    cout<<"AliT0CalibData:: key "<<lookkey->GetKey()<<endl;
+  return lookkey->GetKey();
+
+}
+
index 29a4e3a..9025e5c 100644 (file)
@@ -16,6 +16,7 @@
 #include "TString.h"
 #include "TObjArray.h"
 #include "AliT0.h"
+#include "AliT0LookUpValue.h"
 
 class AliT0CalibData: public TNamed {
 
@@ -59,6 +60,14 @@ class AliT0CalibData: public TNamed {
   void SetTimeDelayTVD(Int_t r=150)   { fTimeDelayTVD = r; };
   Float_t GetTimeDelayTVD()   { return fTimeDelayTVD; }
 
+  void ReadAsciiLookup(const Char_t *filename);
+  Int_t GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel);
+  void PrintLookup(Option_t* option= "", Int_t iTRM=0, Int_t iTDC=0, Int_t iChannel=0) const;
+  TMap *GetMapLookup(void) {return &fLookup;}
+
+  //Int_t GetA(void) {return fa;}
+  //void SetA (Int_t a) {fa=a;}
+  
  protected:
 
   Float_t  fTimeDelayCFD[24]; // Coeff. for time delay (24 different cables & CFD )
@@ -68,8 +77,11 @@ class AliT0CalibData: public TNamed {
   TObjArray fWalk;  //time - amp. walk
   TObjArray fSlewingLED;  //time - amp.LED slew
   TObjArray fSlewingRec;  //time - amp. LED slew for reconstruction
+  TMap fLookup;           //lookup table
+  //Int_t fa;
+
   //
-  ClassDef(AliT0CalibData,1)    // T0 Sensor Calibration data
+  ClassDef(AliT0CalibData,2)    // T0 Sensor Calibration data
 };
 
 typedef AliT0CalibData AliSTARTCalibData; // for backward compatibility
index 52b2240..83db0b4 100644 (file)
 #include "AliLog.h"              
 #include "AliT0Parameters.h"     
 #include "AliT0CalibData.h"   
+#include "AliT0LookUpValue.h"
 #include <AliCDBManager.h>        
 #include <AliCDBEntry.h>          
-#include <AliCDBStorage.h>         
+#include <AliCDBStorage.h>          
 #include <Riostream.h>
 
 AliT0CalibData* AliT0Parameters::fgCalibData = 0;
+AliT0CalibData* AliT0Parameters::fgLookUp = 0;
 //====================================================================
 ClassImp(AliT0Parameters)
 #if 0
@@ -94,6 +96,14 @@ AliT0Parameters::Init()
   if (fCalibentry){
    fgCalibData  = (AliT0CalibData*)fCalibentry->GetObject();
   }
+ fLookUpentry  = cdb->Get("T0/Calib/LookUp_Table");
+  if (fLookUpentry){
+    fgLookUp  = (AliT0CalibData*)fLookUpentry->GetObject();
+    //   fgLookUp->Dump();
+  }
+  else {
+    fgLookUp->ReadAsciiLookup("$ALICE_ROOT/T0/lookUpTable.txt");
+  }
 
   fIsInit = kTRUE;
 }
@@ -237,3 +247,24 @@ AliT0Parameters::SetPMTeff(Int_t ipmt)
   TGraph* gr = new TGraph(50,lambda,eff);
   fPMTeff.AddAtAndExpand(gr,ipmt);
 }
+//________________________________________________________________
+
+Int_t 
+AliT0Parameters::GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel)
+{
+
+  
+  AliT0LookUpKey * lookkey;  //= new AliT0LookUpKey();
+  AliT0LookUpValue * lookvalue= new AliT0LookUpValue(trm,tdc,chain,channel);
+    
+   lookkey = (AliT0LookUpKey*) fgLookUp->GetMapLookup()->GetValue((TObject*)lookvalue);
+  if (!lookkey ) {
+    cout<<" no such address "<<endl; return -1;
+  }
+  
+
+  //cout<<"AliT0Parameters:: key "<<lookkey->GetKey()<<endl;
+  return lookkey->GetKey();
+  
+
+}
index 92b7f58..c694cde 100644 (file)
@@ -16,6 +16,7 @@
 //
 # include <TNamed.h>
 # include <TF1.h>
+# include <TMap.h>
 # include <TGraph.h>
 #include <TObjArray.h>
 class AliT0CalibData;
@@ -97,6 +98,10 @@ public:
   Float_t GetTimeDelayCFD(Int_t ipmt);
   Float_t GetTimeDelayLED(Int_t ipmt);
 
+  //  TMap *LookupTable;
+
+  Int_t GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel);
+
 protected:
   AliT0Parameters();
   virtual ~AliT0Parameters() {}
@@ -125,19 +130,21 @@ protected:
   Float_t fTimeDelayCFD;  // sum time delay for CFD channel
   Float_t  fTimeDelayTVD;  //time delay for TVD (vertex trigger channel)
   
+  TMap fLookUp;           //lookup table
+  
   static AliT0CalibData * fgCalibData; // singleton for Calibration data
-
+  static AliT0CalibData * fgLookUp; // singleton for Calibration data
+  
   AliCDBEntry*   fCalibentry ;  // pointer to T0 calibration object
-
+  AliCDBEntry*   fLookUpentry ;  // pointer to T0 lokkup table
+  
   ClassDef(AliT0Parameters,2)
-private:
+    private:
   AliT0Parameters(const  AliT0Parameters&);
   AliT0Parameters& operator=(const AliT0Parameters&);
 
 };
 
-typedef AliT0Parameters AliSTARTParameters; // for backward compatibility
-
 #endif
 //____________________________________________________________________
 
index 1b33d15..dd1e72a 100644 (file)
@@ -1,6 +1,5 @@
 #include "AliT0RawReader.h"
-#include "AliT0RawData.h"
-#include "AliT0digit.h"
+#include "AliT0Parameters.h"
 #include "AliBitPacking.h"
 #include "TBits.h"
 
  
 ClassImp(AliT0RawReader)
   
-  AliT0RawReader::AliT0RawReader (AliRawReader *rawReader, TTree* tree)
+  AliT0RawReader::AliT0RawReader (AliRawReader *rawReader)
     :  TTask("T0RawReader","read raw T0 data"),
-       fDigits(NULL),
-       fTree(tree),
        fRawReader(rawReader),
        fData(NULL),
        fPosition(0)
@@ -23,8 +20,6 @@ ClassImp(AliT0RawReader)
   //
 // create an object to read T0raw digits
   AliDebug(1,"Start ");
-  if (fDigits == 0x0) fDigits = new AliT0digit(); 
-  fTree->Branch("T0","AliT0digit",&fDigits,405,1);
  
   fRawReader->Reset();
   fRawReader->Select("T0");
@@ -64,19 +59,26 @@ Bool_t  AliT0RawReader::Next()
 //  allData[48]  mean (T0) signal  
 // allData[49]   time difference (vertex)
 
+
+ //  if (fDigits == 0x0) fDigits = new AliT0digit(); 
+  // fTree->Branch("T0","AliT0digit",&fDigits,405,1);
   UInt_t word;
   Int_t time=0,  itdc=0, ichannel=0; 
   Int_t numberOfWordsInTRM=0, iTRM=0;
-  Int_t tdcTime, koef, meanTime, timeDiff ;
-  Int_t allData[107];
+  Int_t tdcTime, koef,hit, meanTime, timeDiff ;
 
-  TArrayI *timeTDC1 = new TArrayI(24);
-  TArrayI * chargeTDC1 = new TArrayI(24);
-  TArrayI *timeTDC2 = new TArrayI(24);
-  TArrayI *chargeTDC2 = new TArrayI(24);
-   
-  for ( Int_t k=0; k<107; k++)  allData[k]=0;
-  do {
+
+
+  AliT0Parameters* param = AliT0Parameters::Instance();   //-->Zhenya
+  param->Init();
+ for ( Int_t k=0; k<110; k++) {
+    for ( Int_t jj=0; jj<5; jj++) {
+      fAllData[k][jj]=0;
+    }
+  }
+    do {
     if (!fRawReader->ReadNextData(fData)) return kFALSE;
   } while (fRawReader->GetDataSize() == 0);
   
@@ -93,6 +95,7 @@ Bool_t  AliT0RawReader::Next()
    iTRM=AliBitPacking::UnpackWord(word,0,3);
 
    //chain header
+   Int_t ichain=0;
    word = GetNextWord();
   
    for (Int_t i=0; i<numberOfWordsInTRM; i++) {
@@ -104,8 +107,11 @@ Bool_t  AliT0RawReader::Next()
         itdc=AliBitPacking::UnpackWord(word,24,27);
         ichannel=AliBitPacking::UnpackWord(word,21,23);
         time=AliBitPacking::UnpackWord(word,0,20);
-        koef = itdc*4 + ichannel/2;
-        allData[koef]=time;
+        //  koef = itdc*4 + ichannel/2;
+        koef = param->GetChannel(iTRM,itdc,ichain,ichannel);
+        //      cout<<" RawReader::Next ::"<<iTRM<<"  "<<itdc<<" "<<ichain<<" "<<ichannel<<" "<<  koef<<" "<<time<<endl;
+        if(fAllData[koef][0] == 0)  fAllData[koef][0]=time;  // yield only 1st particle
+         
        }
    }
    word = GetNextWord(); //chain trailer
@@ -115,6 +121,7 @@ Bool_t  AliT0RawReader::Next()
    word = GetNextWord();
    numberOfWordsInTRM=AliBitPacking::UnpackWord(word,4,16);
    iTRM=AliBitPacking::UnpackWord(word,0,3);
+   
    //chain header
    word = GetNextWord();
    
@@ -127,57 +134,21 @@ Bool_t  AliT0RawReader::Next()
         itdc=AliBitPacking::UnpackWord(word,24,27);
         ichannel=AliBitPacking::UnpackWord(word,21,23);
         time=AliBitPacking::UnpackWord(word,0,20);
-        koef = itdc*4 + ichannel/2;
-        allData[koef+54]=time;
+        //      koef = itdc*4 + ichannel/2;
+        koef = param->GetChannel(iTRM,itdc,ichain,ichannel);
+          if(fAllData[koef][0] == 0)    fAllData[koef][0]=time;
+                //      if(allData[koef+55] == 0) allData[koef+55]=time; // yield only 1st particle
        }
    }
-      
-   for (Int_t in=0; in<24; in++)
-     {
-       timeTDC1->AddAt(allData[in],in);
-       timeTDC2->AddAt(allData[in+24],in);
-       chargeTDC1->AddAt(allData[in+54],in);
-       chargeTDC2->AddAt(allData[in+78],in);
-     }      
-
-   meanTime = allData[48];  // T0 !!!!!!
-   timeDiff = allData[49];
+   meanTime = fAllData[49][0];  // T0 !!!!!!
+   timeDiff = fAllData[50][0];
 
    word = GetNextWord();
    word = GetNextWord();
-   
-   fDigits->SetTime(*timeTDC2);
-   fDigits->SetADC(*chargeTDC1);
-   
-   fDigits->SetTimeAmp(*timeTDC1);
-   fDigits->SetADCAmp(*chargeTDC2);
-
-   fDigits->SetMeanTime(meanTime);
-   fDigits->SetDiffTime(timeDiff);
-   fTree->Fill();
-   
-   delete timeTDC1 ;
-   delete chargeTDC1;
-   delete timeTDC2 ;
-   delete chargeTDC2;
-   
    return kTRUE;
 }
 //_____________________________________________________________________________
-/*
-void AliT0RawReader::UnpackTime(Int_t outTime, Int_t outCh)
-{
-      UInt_t word=0;
-      UInt_t unpackword=0;
-    
-      word = GetNextWord();
-      unpackword=AliBitPacking::UnpackWord(word,0,12);
-      outTime=unpackword;
-      unpackword= AliBitPacking::UnpackWord(word,21,27);
-      outCh=unpackword;  
- }
- */
-//_____________________________________________________________________________
 Int_t AliT0RawReader::GetPosition()
 {
   // Sets the position in the
index 144edbe..07fde3d 100644 (file)
@@ -3,32 +3,32 @@
  
 #include <TTask.h>
 #include <Riostream.h>
-#include "TTree.h"
-#include "AliT0digit.h"
 #include "AliRawReader.h"
  
 class AliT0RawReader : public TTask {
   public :
 
-  AliT0RawReader(AliRawReader *rawReader, TTree* tree) ;
+  AliT0RawReader(AliRawReader *rawReader) ;
 
   virtual  ~AliT0RawReader();
+  AliT0RawReader(const AliT0RawReader& o)
+    : TTask(o)
+  {}
+  AliT0RawReader& operator=(const AliT0RawReader&) { return *this; }
 
 
   Bool_t  Next(); //read next raw digit
   Int_t            GetPosition();
-  // void UnpackTime(Int_t outTime, Int_t outCh);
   UInt_t         GetNextWord();
+  Int_t GetData(Int_t channel, Int_t hit) {return fAllData[channel][hit];}
   
   protected :
 
-  AliT0digit* fDigits;
-  TTree*        fTree;
   AliRawReader*    fRawReader;    // object for reading the raw data
 
   UChar_t*         fData;         // raw data
   Int_t            fPosition;     // current (32 bit) position in fData
-
+  Int_t fAllData[110][5];
   
  ClassDef(AliT0RawReader, 0) //class for reading T0 Raw data
 };
index 9fbca54..c1e40fe 100644 (file)
@@ -25,6 +25,7 @@
 #include "AliLog.h"
 #include <TClonesArray.h>
 #include "AliT0RecPoint.h"
+#include "AliT0.h"
 #include "AliRawReader.h"
 #include "AliT0RawReader.h"
 #include "AliT0Loader.h"
 
 ClassImp(AliT0Reconstructor)
 
+//____________________________________________________________________
+void
+AliT0Reconstructor::Init(AliRunLoader* runLoader,TTree* digitsTree ) const
+{
+
+ // Initialize the reconstructor
+  AliDebug(2, Form("Init called with runloader 0x%x", runLoader));
+  // Initialize the parameters
+   AliT0Loader* pStartLoader = (AliT0Loader*) runLoader->GetLoader("T0Loader");
+  pStartLoader->LoadDigits("READ");
+
+  digitsTree = pStartLoader->TreeD();
+
+}
+
+//____________________________________________________________________
   void  AliT0Reconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const
 {
   //T0 raw data-> digits conversion
  // reconstruct time information from raw data
-  AliT0RawReader myrawreader(rawReader,digitsTree);
-  if (!myrawreader.Next())
-    AliDebug(1,Form(" no raw data found!! %i", myrawreader.Next()));
+    AliT0 *baseT0;
+    baseT0->Raw2Digits(rawReader, digitsTree);
+  
+
 }
 void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
+  //void AliT0Reconstructor::Reconstruct(AliRunLoader *runLoader) const
 {
 // T0 digits reconstruction
 // T0RecPoint writing 
@@ -83,37 +104,43 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
   zdetA  = param->GetZposition(1);
     
   AliDebug(1,Form("Start DIGITS reconstruction "));
+
   TBranch *brDigits=digitsTree->GetBranch("T0");
-  AliT0digit *fDigits = new AliT0digit();
+  AliT0digit *fDigits = new AliT0digit() ;
   if (brDigits) {
     brDigits->SetAddress(&fDigits);
   }else{
     cerr<<"EXEC Branch T0 digits not found"<<endl;
     return;
   }
-  brDigits->GetEntry(0);
+  
+   digitsTree->GetEvent(0);
+   digitsTree->GetEntry(0);
+   brDigits->GetEntry(0);
   fDigits->GetTime(*fTimeCFD);
   fDigits->GetADC(*fADC);
   fDigits->GetTimeAmp(*fTimeLED);
   fDigits->GetADCAmp(*fADCLED);
 
+
   Float_t besttimeright=999999;
   Float_t besttimeleft=999999;
   Int_t pmtBestRight=99999;
   Int_t pmtBestLeft=99999;
   Float_t timeDiff=999999, meanTime=0;
   
-  AliT0RecPoint* frecpoints= new AliT0RecPoint ();
-  clustersTree->Branch( "T0", "AliT0RecPoint" ,&frecpoints, 405,1);
+
+
+   AliT0RecPoint* frecpoints= new AliT0RecPoint ();
+   clustersTree->Branch( "T0", "AliT0RecPoint" ,&frecpoints, 405,1);
 
   Float_t time[24], adc[24];
   for (Int_t ipmt=0; ipmt<24; ipmt++) {
-      
     if(fTimeCFD->At(ipmt)>0 ){
       time[ipmt] = channelWidth *( fTimeCFD->At(ipmt)) - 1000*timeDelayCFD[ipmt];
-      Float_t adc_digPs = channelWidth * Float_t (fADCLED->At(ipmt)) ;
-      adc[ipmt] = TMath::Exp(adc_digPs/1000) /gain[ipmt];
+      //   Float_t adc_digPs = channelWidth * Float_t (fADCLED->At(ipmt)) ;
+      //      adc[ipmt] = TMath::Exp(adc_digPs/1000) /gain[ipmt];
+      adc[ipmt]=1;
       AliDebug(1,Form(" time %f ps,  adc %f mv in MIP %i\n ",
                      time[ipmt], adc[ipmt], Int_t (adc[ipmt]/mV2Mip +0.5)));
       frecpoints->SetTime(ipmt,time[ipmt]);
@@ -124,6 +151,7 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
       adc[ipmt] = 0;
     }
   }
+
   for (Int_t ipmt=0; ipmt<12; ipmt++){
     if(time[ipmt] > 1 ) {
       if(time[ipmt]<besttimeleft){
index 265a748..797296d 100644 (file)
@@ -7,19 +7,23 @@
 
 #include "AliReconstructor.h"
 #include "AliT0digit.h"
+#include "AliT0.h"
 class AliRunLoader;
 
 class AliT0Reconstructor: public AliReconstructor {
-public:
+ public:
   AliT0Reconstructor(): AliReconstructor() {};
   virtual ~AliT0Reconstructor() {};
+
+  virtual void Init(AliRunLoader* runLoader, TTree* fdigits ) const;
   virtual  void   ConvertDigits( AliRawReader* rawReader, TTree* fdigits) const;
-  virtual  void   Reconstruct(TTree* fdigits, TTree * frecpoints) const ;
+                    virtual  void   Reconstruct(TTree* fdigits, TTree * frecpoints) const;
+ //  virtual  void   Reconstruct(TTree* , TTree * ) const {};
  
   virtual  void   Reconstruct(AliRunLoader* , AliRawReader*   ) const {};
   virtual  void   Reconstruct(AliRawReader* ) const {};
   virtual  void   Reconstruct(AliRawReader* , TTree*) const {};
-  virtual  void   Reconstruct(AliRunLoader* ) const {};
+  virtual  void   Reconstruct(AliRunLoader* ) const  {};
   
   virtual void         FillESD(AliRunLoader* runLoader, AliESD* esd) const;
   virtual void         FillESD(AliRunLoader* , AliRawReader*, AliESD* ) const  {};
@@ -29,8 +33,11 @@ public:
   virtual Bool_t       HasDigitConversion() const {return kTRUE;};
  public:
  
-  AliT0digit *fdigits   ; // digits
+  //  AliRunLoader*  fRunLoader;     // Run loader passed to Init
+  //  AliT0digit *fDigits   ; // digits
   Float_t fZposition; // vertex position
+  // AliT0 *baseT0;
+ protected:
 
   ClassDef(AliT0Reconstructor, 0)   // class for the T0 reconstruction