reading Zposition from DB, the same RawReader for sim. and test data, reading detecto...
authoralla <alla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 4 Apr 2007 10:16:09 +0000 (10:16 +0000)
committeralla <alla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 4 Apr 2007 10:16:09 +0000 (10:16 +0000)
12 files changed:
T0/AliT0CalibData.cxx
T0/AliT0CalibData.h
T0/AliT0Digitizer.cxx
T0/AliT0Parameters.cxx
T0/AliT0Parameters.h
T0/AliT0RawData.cxx
T0/AliT0RawData.h
T0/AliT0RawReader.cxx
T0/AliT0RawReader.h
T0/AliT0Reconstructor.cxx
T0/AliT0SetCDB.C
T0/lookUpTable.txt

index 5f29939..815f417 100644 (file)
@@ -96,8 +96,8 @@ void  AliT0CalibData::Print(Option_t*) const
 {
 
   printf("\n   ----    PM Arrays       ----\n\n");
-  printf(" Time delay CFD \n");
-  for (Int_t i=0; i<24; i++) printf("  %f",fTimeDelayCFD[i]);
+  printf(" Time delay CFD & LED\n");
+  for (Int_t i=0; i<24; i++) printf(" CFD  %f LED %f ",fTimeDelayCFD[i], fTimeDelayLED[i]);
 } 
 
 //________________________________________________________________
@@ -106,11 +106,13 @@ void  AliT0CalibData::PrintLookup(Option_t*, Int_t iTRM, Int_t iTDC, Int_t iChan
   
   AliT0LookUpKey* lookkey= new AliT0LookUpKey();
   AliT0LookUpValue*  lookvalue= new AliT0LookUpValue();
-  
+
+  cout<<" Number Of TRMs in setup "<<GetNumberOfTRMs()<<endl;
   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);
@@ -153,7 +155,7 @@ void AliT0CalibData::SetWalk(Int_t ipmt)
   ifstream inFile(filename);
   if(!inFile) AliError(Form("Cannot open file %s !",filename));
   
-  Int_t i=0, i1=0, i2=0;
+  Int_t i=0;
   while(getline(inFile,buffer)){
     inFile >> ps >> mv;
 
@@ -161,11 +163,12 @@ void AliT0CalibData::SetWalk(Int_t ipmt)
     i++;
   }
   inFile.close();
+  cout<<" number of data "<<i<<endl;
  
   TMath::Sort(i, y, index,down);
   Int_t amp=0, iin=0, isum=0, sum=0;
   Int_t ind=0;
-  for (Int_t ii=0; ii<70000; ii++)
+  for (Int_t ii=0; ii<i; ii++)
     {
       ind=index[ii];
       if(y[ind] == amp)
@@ -182,7 +185,7 @@ void AliT0CalibData::SetWalk(Int_t ipmt)
            time[isum] =Float_t (x[ind]);
          amplitude[isum] = Float_t (amp);
          amp=y[ind];
-         cout<<ii<<" "<<ind<<" "<<y[ind]<<" "<<x[ind]<<" iin "<<iin<<" mean "<<time[isum]<<" amp "<< amplitude[isum]<<" "<<isum<<endl;
+         //      cout<<ii<<" "<<ind<<" "<<y[ind]<<" "<<x[ind]<<" iin "<<iin<<" mean "<<time[isum]<<" amp "<< amplitude[isum]<<" "<<isum<<endl;
          iin=0;
          isum++;
          sum=0;
@@ -230,7 +233,7 @@ void AliT0CalibData::SetSlewingRec(Int_t ipmt)
   Float_t x[100], y[100];
   string buffer;
   
- const char * filename = gSystem->ExpandPathName("$ALICE_ROOT/T0/data/re.root");
+ const char * filename = gSystem->ExpandPathName("$ALICE_ROOT/T0/data/CFD-LED.root");
    ifstream inFile(filename);
   if(!inFile) {AliError(Form("Cannot open file %s !",filename));}
   
@@ -251,6 +254,7 @@ void AliT0CalibData::SetSlewingRec(Int_t ipmt)
   
 }
 
+//________________________________________________________________
 
 void AliT0CalibData::ReadAsciiLookup(const Char_t *filename)
 {
@@ -268,46 +272,53 @@ void AliT0CalibData::ReadAsciiLookup(const Char_t *filename)
     {
       //  AliLog(Form("Cannot open file %s ! Getting hardcoded value",filename));
 
-    trm=0; tdc=0; chain=0; channel=0; key=0;
-    for (Int_t ik=0; ik<108; ik++)
-      {
-       AliT0LookUpKey * lookkey= new AliT0LookUpKey();
-       AliT0LookUpValue * lookvalue= new AliT0LookUpValue();
-       
-      lookvalue->SetTRM(trm);
-      lookvalue->SetTDC(tdc);
-      lookvalue->SetChain(chain);
-      lookvalue->SetChannel(channel);
-      lookkey->SetKey(ik);
-      if(ik>53) { trm=1; tdc=0; channel=0;}
-      if (channel<7) channel +=2;
-      else {channel = 0; tdc++;}
-      }
+      //      fNumberOfTRMs = 2;
+      SetNumberOfTRMs(2);
+      trm=0; tdc=0; chain=0; channel=0; key=0;
+      for (Int_t ik=0; ik<108; ik++)
+       {
+         AliT0LookUpKey * lookkey= new AliT0LookUpKey();
+         AliT0LookUpValue * lookvalue= new AliT0LookUpValue();
+         
+         lookvalue->SetTRM(trm);
+         lookvalue->SetTDC(tdc);
+         lookvalue->SetChain(chain);
+         lookvalue->SetChannel(channel);
+         lookkey->SetKey(ik);
+         if(ik>53) { trm=1; tdc=0; channel=0;}
+         if (channel<7) channel +=2;
+         else {channel = 0; tdc++;}
+       }
     }
   Char_t varname[11];
-  // while(lookup.eof())
-
- for (Int_t i=0; i<108; i++)
+  Int_t ntrms;
+  if(lookup)
     {
-       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);
-
+      lookup>>ntrms;
+      cout<<" !!!!!!! ntrms "<<ntrms<<endl;
+      //      fNumberOfTRMs=ntrms;
+      SetNumberOfTRMs(ntrms);
+       while(!lookup.eof())
+       {
+         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<<"lookup "<<varname<<" "<<key<<" "<<trm<<" "<<chain<<" "<<tdc<<" "<<channel<<endl;         
+         
+         fLookup.Add((TObject*)lookvalue,(TObject*)lookkey);
+         
+       }
+      
+      lookup.close();
       
-      fLookup.Add((TObject*)lookvalue,(TObject*)lookkey);
-
     }
-
-   lookup.close();
-
 }
-
 //________________________________________________________________
 
 Int_t AliT0CalibData::GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel)
index dca2195..fc9ce80 100644 (file)
@@ -61,10 +61,9 @@ class AliT0CalibData: public TNamed {
   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 GetNumberOfTRMs() const {return fNumberOfTRMs;}
+  void SetNumberOfTRMs(Int_t ntrms=2) {fNumberOfTRMs = ntrms;}
 
-  //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 )
@@ -74,10 +73,10 @@ class AliT0CalibData: public TNamed {
   TObjArray fSlewingLED;  //time - amp.LED slew
   TObjArray fSlewingRec;  //time - amp. LED slew for reconstruction
   TMap fLookup;           //lookup table
-  //Int_t fa;
+  Int_t fNumberOfTRMs;    // number of TRMs in setup
 
   //
-  ClassDef(AliT0CalibData,3)    // T0 Sensor Calibration data
+  ClassDef(AliT0CalibData,4)    // T0 Sensor Calibration data
 };
 
 typedef AliT0CalibData AliSTARTCalibData; // for backward compatibility
index f45ff53..d65e899 100644 (file)
@@ -155,7 +155,7 @@ void AliT0Digitizer::Exec(Option_t* /*option*/)
   Float_t delayVertex = param->GetTimeDelayTVD();
   for (Int_t i=0; i<24; i++){
     timeDelayCFD[i] = param->GetTimeDelayCFD(i);
-   timeDelayLED[i] = param->GetTimeDelayLED(i);
+    timeDelayLED[i] = param->GetTimeDelayLED(i);
     TGraph* gr = param ->GetSlew(i);
     slewingLED.AddAtAndExpand(gr,i);
 
@@ -165,13 +165,14 @@ void AliT0Digitizer::Exec(Option_t* /*option*/)
     TGraph* grEff = param ->GetPMTeff(i);
     fEffPMT.AddAtAndExpand(grEff,i);
   }
-  
-  zdetC = param->GetZposition(0);
-  zdetA = param->GetZposition(1);
-  
-  AliT0hit  *startHit;
-  TBranch *brHits=0;
-  
+   zdetC = TMath::Abs(param->GetZPosition("T0/C/PMT1"));
+   zdetA  = TMath::Abs(param->GetZPosition("T0/A/PMT15"));
+
+   AliT0hit  *startHit;
+   TBranch *brHits=0;
+   
   Int_t nFiles=fManager->GetNinputs();
   for (Int_t inputFile=0; inputFile<nFiles;  inputFile++) {
     if (inputFile < nFiles-1) {
@@ -315,7 +316,6 @@ void AliT0Digitizer::Exec(Option_t* /*option*/)
        Float_t maxValue=hr->GetMaximum(50);
        trCFD=trCFD-Int_t((maxValue-slew)/channelWidth);
        ftimeCFD->AddAt(Int_t (trCFD),i);
-       cout<<" slew "<<slew<<" "<<maxValue<<" "<<trCFD<<endl;
        }
       } //pmt loop
 
index b937a53..2c89c6c 100644 (file)
@@ -34,6 +34,8 @@
 #include <TMath.h>
 #include <TSystem.h>
 #include <Riostream.h>
+#include <TGeoManager.h>
+#include <TGeoPhysicalNode.h>
 
 AliT0CalibData* AliT0Parameters::fgCalibData = 0;
 AliT0CalibData* AliT0Parameters::fgLookUp = 0;
@@ -57,7 +59,14 @@ AliT0Parameters::Instance()
 
 //____________________________________________________________________
 AliT0Parameters::AliT0Parameters()
-  :fIsInit(kFALSE),fPh2Mip(0),fmV2Mip(0),fChannelWidth(0),fmV2Channel(0),fQTmin(0),fQTmax(0),fSlewingLED(),fSlewingRec(),fPMTeff(),fTimeDelayLED(0),fTimeDelayCFD(0),fTimeDelayTVD(0),fCalibentry(), fLookUpentry(),fSlewCorr()
+  :fIsInit(kFALSE),
+   fPh2Mip(0),fmV2Mip(0),
+   fChannelWidth(0),fmV2Channel(0),
+   fQTmin(0),fQTmax(0),
+   fSlewingLED(),fSlewingRec(),
+   fPMTeff(),
+   fTimeDelayLED(0),fTimeDelayCFD(0),fTimeDelayTVD(0),
+   fCalibentry(), fLookUpentry(),fSlewCorr()
 {
   // Default constructor 
 
@@ -77,6 +86,7 @@ AliT0Parameters::AliT0Parameters()
    }
   SetTimeDelayTVD();
   SetZposition();
+  SetNumberOfTRMs(2);
   
 }
 
@@ -92,15 +102,14 @@ AliT0Parameters::Init()
   AliCDBStorage *stor =AliCDBManager::Instance()->GetStorage("local://$ALICE_ROOT");
   //time equalizing
   AliCDBEntry* fCalibentry  = stor->Get("T0/Calib/TimeDelay",0);
- if (fCalibentry){
+  if (fCalibentry)
    fgCalibData  = (AliT0CalibData*)fCalibentry->GetObject();
-  }
- else 
-   { AliError(" ALARM !!!! No time delays in CDB "); }
+  else 
+    AliError(" ALARM !!!! No time delays in CDB "); 
  //slewing correction
   AliCDBEntry* fSlewCorr  = stor->Get("T0/Calib/Slewing_Walk",0);
- if (fSlewCorr){
-   fgSlewCorr  = (AliT0CalibData*)fSlewCorr->GetObject();
+  if (fSlewCorr){
+    fgSlewCorr  = (AliT0CalibData*)fSlewCorr->GetObject();
   }
   fLookUpentry  = stor->Get("T0/Calib/LookUp_Table",0);
   if (fLookUpentry){
@@ -300,7 +309,6 @@ Float_t AliT0Parameters::GetWalkVal(Int_t ipmt, Float_t mv) const
   return fgCalibData -> GetWalkVal(ipmt, mv) ;
 }
 
-//__________________________________________________________________
 
 //__________________________________________________________________
 void 
@@ -343,3 +351,42 @@ AliT0Parameters::GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel)
   
 
 }
+//__________________________________________________________________
+Int_t
+AliT0Parameters::GetNumberOfTRMs() 
+{
+  // return number of trms
+  // 
+  if (!fgLookUp) {
+    fNumberOfTRMs = 2;
+    return  fNumberOfTRMs;
+  } 
+  return  fgLookUp ->GetNumberOfTRMs();
+}
+//________________________________________________________________________________
+Double_t AliT0Parameters::GetZPosition(const char* symname){
+// Get the global z coordinate of the given T0 alignable volume
+//
+  Double_t *tr;
+  
+  cout<<symname<<endl;
+  TGeoPNEntry *pne = gGeoManager->GetAlignableEntry(symname);
+  if (!pne) return 0;
+  
+
+  TGeoPhysicalNode *pnode = pne->GetPhysicalNode();
+  if(pnode){
+          TGeoHMatrix* hm = pnode->GetMatrix();
+           tr = hm->GetTranslation();
+  }else{
+          const char* path = pne->GetTitle();
+          if(!gGeoManager->cd(path)){
+                  AliErrorClass(Form("Volume path %s not valid!",path));
+                  return 0;
+          }
+         tr = gGeoManager->GetCurrentMatrix()->GetTranslation();
+  }
+  return tr[2];
+
+}
+
index ced59b4..6c94bc8 100644 (file)
@@ -54,8 +54,9 @@ public:
   Int_t GetmV2channel()     const { return fmV2Channel; }
   Int_t GetQTmin() const {return fQTmin;}
   Int_t GetQTmax() const {return fQTmax;}
-  Float_t GetZposition(Int_t i) const {return fT0zPosition[i];}
-  TGraph *  GetPMTeff(Int_t ipmt) const  
+  Double_t GetZposition(Int_t i) const {return fT0zPosition[i];}
+  Double_t GetZPosition(const char* symname) ;
+   TGraph *  GetPMTeff(Int_t ipmt) const  
   {return (TGraph*)fPMTeff.At(ipmt);}
   Float_t GetpmtEFF(Int_t ipmt, Float_t lambda) const
   {return((TGraph*)fPMTeff.At(ipmt))->Eval(lambda);} 
@@ -80,6 +81,8 @@ public:
   //  TMap *LookupTable;
 
   Int_t GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel);
+  Int_t GetNumberOfTRMs();
+  void SetNumberOfTRMs(Int_t ntrms=2) {fNumberOfTRMs = ntrms;}
 
 protected:
   AliT0Parameters();
@@ -105,7 +108,8 @@ protected:
   Float_t  fTimeDelayTVD;  //time delay for TVD (vertex trigger channel)
   
   TMap fLookUp;           //lookup table
-  
+  Int_t fNumberOfTRMs;    // number of TRMs in setup
+
   static AliT0CalibData * fgCalibData; // singleton for Calibration data
   static AliT0CalibData * fgLookUp; // singleton for Calibration data
   static AliT0CalibData * fgSlewCorr; // singleton for Calibration data
index 51cb2ef..fb1604b 100644 (file)
@@ -171,7 +171,7 @@ void AliT0RawData::GetDigits(AliT0digit *fDigits)
     allData->AddAt(fTimeCFD->At(i-1),i+24);
     allData->AddAt(fADC0->At(i-1),i+54);
     allData->AddAt(fADC1->At(i-1),i+78);
-    //    cout<<i<<" led "<<fTimeLED->At(i-1)<<" cfd "<<fTimeCFD->At(i-1)<<" qt0 "<<fADC0->At(i-1)<<" qt1 "<<fADC1->At(i-1)<<endl;
+
   }
   allData->AddAt(meantime,49);
   allData->AddAt(timediff,50);
@@ -185,82 +185,88 @@ void AliT0RawData::GetDigits(AliT0digit *fDigits)
   allData->AddAt(mult1,54);
   allData->AddAt(mult1,107); //trigger semi-central
 
-  // cout<<" new Event "<<endl;
-  //   for (Int_t ia=0; ia<110; ia++) cout<<ia<<" "<<allData->At(ia)<<endl;
+  // cout.setf( ios_base::hex, ios_base::basefield );
+  
   //space for DRM header
-  fIndex += 4;
+  fIndex += 6;
 
+  Int_t startTRM=fIndex;
   //space for 1st TRM header
   fIndex ++;
   positionOfTRMHeader= fIndex;
 
   //space for chain  header
   fIndex ++;
-
+  WriteChainDataHeader(0, 0); // 
   // Loop through all PMT
   Int_t chain=0; 
   Int_t iTDC = 0;
   Int_t channel=0;
   Int_t trm1words=0;
-  Int_t fWordsIn1stTRM=0;
+
   //LED
   for (Int_t det = 0; det < 55; det++) {
     time = allData->At(det);
-
-    if (time >0) { 
+    if (time >0)  
       FillTime(channel,  iTDC,  time); 
-      trm1words++;   
-     }
     if (channel < 6) channel +=2;
     else {
       channel = 0; 
       iTDC++;
       if (iTDC>15) { chain++; iTDC=0;}
     }
-    //  cout<<det<<" "<<time<<" "<<iTDC<<" "<<channel<<" "<<endl;
   }
   
-  WriteTrailer(0,0,fEventNumber,1); // 1st chain trailer
+
+  WriteChainDataTrailer(1); // 1st chain trailer
+  fIndex++;
+  WriteChainDataHeader(2, 1); // 
+  WriteChainDataTrailer(3); // 2st chain trailer
   WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
-  fWordsIn1stTRM = trm1words + 4;
-  //  WriteTRMDataHeader(3, trm1words , positionOfTRMHeader);
+  trm1words = fIndex - startTRM;
   WriteTRMDataHeader(0, trm1words , positionOfTRMHeader);
 
 
   //space for 2st TRM header
+  startTRM=fIndex;
   fIndex ++;
   positionOfTRMHeader= fIndex;
-
-  //space for chain  header
+  // chain  header
   fIndex ++;
-
-
+  WriteChainDataHeader(0, 0); // 
   chain=0; 
   iTDC = 0;
   channel=0;
-  Int_t trm2words=0;
+
   for (Int_t det = 55; det < 108; det++) {
     time = allData->At(det);
-
-    if (time >0) { 
+    
+    if (time >0)  
       FillTime(channel,  iTDC,  time); 
-      trm2words++;}
+     
     if (channel < 6) channel +=2;
     else {
       channel = 0; 
       iTDC++;
       if (iTDC>15) { chain++; iTDC=0;}
     }
-    //    cout<<det<<" "<<time<<" "<<channel<<" "<<iTDC<<endl;
- }
-
-  WriteTrailer(0,0,fEventNumber,1); // 1st chain trailer
-  WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
-  //  WriteTRMDataHeader(5,trm2words,positionOfTRMHeader);
-  WriteTRMDataHeader(1,trm2words,positionOfTRMHeader);
+    
+    
+  }
+    WriteChainDataTrailer(1); // 1st chain trailer
+    fIndex++;
+    WriteChainDataHeader(2, 1); // 
+    WriteChainDataTrailer(3); // 2st chain trailer
+    WriteTrailer(15,0,fEventNumber,5); // 1st TRM trailer
+    trm1words = fIndex - startTRM;
+    WriteTRMDataHeader(1, trm1words , positionOfTRMHeader);
+    //DRM trailer
+    WriteTrailer(1,0,fEventNumber,5); // 1st TRM trailer
+    
+    WriteDRMDataHeader();
 
-  WriteTrailer(1,fEventNumber,0,5); //DRM trailer
-  WriteDRMDataHeader();
+    delete allData;
 
 }
 //------------------------------------------------------------------------------
@@ -304,6 +310,7 @@ void  AliT0RawData::WriteDRMDataHeader()
   PackWord(baseWord,word,28,31); // 0100 marks header
   fBuffer[0]=  baseWord;
 
+
   //DRM status header 1
   word = 1;
   PackWord(baseWord,word,0, 3); // 0001 
@@ -317,8 +324,9 @@ void  AliT0RawData::WriteDRMDataHeader()
   PackWord(baseWord,word,28,31); // 0100 marks header
    fBuffer[1] = baseWord;
 
-  word=0;
-  baseWord=0;
+
+   word=0;
+   baseWord=0;
 
     //DRM status header 2
     word = 1;
@@ -332,6 +340,7 @@ void  AliT0RawData::WriteDRMDataHeader()
     word=4;
     PackWord(baseWord,word,28,31); // 0100 marks header
     fBuffer[2]=  baseWord;
 
     
     word=0;
@@ -345,7 +354,10 @@ void  AliT0RawData::WriteDRMDataHeader()
     PackWord(baseWord,word,28,31); // 0100 marks header
     fBuffer[3]=  baseWord;
 
-
+    // new DRM format
+    fBuffer[4]=  baseWord;
+    fBuffer[5]=  baseWord;
+    
     word=0;
     baseWord=0;
     
@@ -378,7 +390,7 @@ void  AliT0RawData::WriteTRMDataHeader(UInt_t slotID, Int_t nWordsInTRM,
   word=4;
   PackWord(baseWord,word,28,31); // 0100 marks header
   fBuffer[positionOfTRMHeader] =  baseWord;
- cout<<" TRM header "<<baseWord<<endl;   
+
   word=0; 
   baseWord=0;
      
@@ -407,7 +419,31 @@ void  AliT0RawData::WriteChainDataHeader(UInt_t chainNumber,UInt_t slotID)
   PackWord(baseWord,word,27,27); //  TS
   word=chainNumber;
   PackWord(baseWord,word,28,31); // 0100 marks header
-  fBuffer[4] =  baseWord;
+  fBuffer[fIndex] =  baseWord;
+
+  word=0;
+  baseWord=0;     
+  
+}
+//_____________________________________________________________________________
+
+void  AliT0RawData::WriteChainDataTrailer(UInt_t chainNumber )
+{
+//Write a (dummy or real) DDL Chain  data trailer 
+//set the compression bit if compressed
+//  chainNumber 00 or 10
+  UInt_t word;
+  UInt_t baseWord=0;
+  word = 0; // ask Tatiana 7 or 9 
+  PackWord(baseWord,word,0, 3); // status
+  word = 0;
+  PackWord(baseWord,word,4, 15); // MBZ
+  word=fEventNumber;
+  PackWord(baseWord,word,16,27); // event counter
+  word=chainNumber;
+  PackWord(baseWord,word,28,31); // chain number
+  fIndex++;
+  fBuffer[fIndex] =  baseWord;
 
   word=0;
   baseWord=0;     
@@ -456,7 +492,7 @@ void  AliT0RawData::WriteTrailer(UInt_t slot, Int_t word1, UInt_t word2, UInt_t
   PackWord(baseWord,word,28,31); //  marks trailer
   fIndex++;
   fBuffer[fIndex] =  baseWord;
-  
+
   word=0;
   baseWord=0;
 
index 070f782..e29b207 100644 (file)
@@ -45,6 +45,7 @@ class AliT0RawData : public TObject {
    //this method is used to write the data header
    void  WriteTrailer(UInt_t slot, Int_t word1, UInt_t word2, UInt_t word3); 
    void  WriteChainDataHeader(UInt_t chainNumber,UInt_t slotID);
+   void  WriteChainDataTrailer(UInt_t chainNumber);
    void  FillTime(Int_t ch, Int_t iTDC, Int_t time);
 
  //T0 digits arrays
index 7171dd0..bb72b1c 100644 (file)
@@ -16,7 +16,6 @@ ClassImp(AliT0RawReader)
        fRawReader(rawReader),
        fData(NULL),
        fPosition(0)
-       
 {
   //
 // create an object to read T0raw digits
@@ -25,7 +24,6 @@ ClassImp(AliT0RawReader)
   fRawReader->Reset();
   fRawReader->Select("T0");
  
-  cout<<"  AliT0RawReader::AliT0RawReaderfRawReader->Select "<<endl;
 }
  AliT0RawReader::~AliT0RawReader ()
 {
@@ -70,25 +68,32 @@ 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 time=0,  itdc=0, ichannel=0, uu; 
   Int_t numberOfWordsInTRM=0, iTRM=0;
-  Int_t tdcTime, koef,hit, meanTime, timeDiff ;
-  Int_t numTRM=2; // number of TRMs in game For test =1 !!!!!
-
+  Int_t tdcTime, koef,hit=0;
+  Int_t koefhits[110];
 
-
-  AliT0Parameters* param = AliT0Parameters::Instance();   //-->Zhenya
+  Int_t fDRM_GLOBAL_HEADER = 0x40000001;
+  Int_t fDRM_GLOBAL_TRAILER  = 0x50000001;
+  
+  Int_t  TRM_GLOBAL_HEADER  = 0x40000000;
+  Int_t  TRM_CHAIN_0_HEADER =  0x00000000;
+  Int_t  TRM_CHAIN_1_HEADER =  0x20000000;
+  Int_t  TRM_CHAIN_0_TRAILER =  0x10000000;
+  Int_t  TRM_CHAIN_1_TRAILER =  0x30000000;
+  Int_t  TRM_GLOBAL_TRAILER =  0x5000000f;
+
+  AliT0Parameters* param = AliT0Parameters::Instance();   
   param->Init();
+  Int_t fNTRM = param->GetNumberOfTRMs();
  
  for ( Int_t k=0; k<110; k++) {
-    for ( Int_t jj=0; jj<5; jj++) {
-      fAllData[k][jj]=0;
-    }
+   koefhits[k]=0;
+   for ( Int_t jj=0; jj<5; jj++) {
+     fAllData[k][jj]=0;
+   }
   }
     do {
     if (!fRawReader->ReadNextData(fData)) return kFALSE;
@@ -96,24 +101,43 @@ Bool_t  AliT0RawReader::Next()
   
   //  fPosition = GetPosition();
   fPosition = 0;
+  //   cout.setf( ios_base::hex, ios_base::basefield );
 
   //DRM header
-  for (Int_t i=0; i<4; i++) {
-    word = GetNextWord();
-  }
-
-  for (Int_t ntrm=0; ntrm< numTRM; ntrm++)
-    {
+    for (Int_t i=0; i<6; i++) {
+      word = GetNextWord();
+      uu = word&fDRM_GLOBAL_HEADER;
+      if(uu != fDRM_GLOBAL_HEADER ) 
+       {
+         AliError(Form(" !!!! wrong  DRM header  %x!!!!", word));
+         break;
+      }
+    }
+    
+     for (Int_t ntrm=0; ntrm< fNTRM; ntrm++)
+     {
       //TRMheader  
       word = GetNextWord();
+      uu = word&TRM_GLOBAL_HEADER;
+      if(uu != TRM_GLOBAL_HEADER )
+       {
+         AliError(Form(" !!!! wrong TRM header  %x!!!!", word));
+         break;
+       }
       numberOfWordsInTRM=AliBitPacking::UnpackWord(word,4,16);
       iTRM=AliBitPacking::UnpackWord(word,0,3);
       
       //chain header
-      Int_t ichain=0;
       word = GetNextWord();
+      uu = word & TRM_CHAIN_0_HEADER;
+      if(uu != TRM_CHAIN_0_HEADER) 
+       {
+         AliError(Form(" !!!! wrong CHAIN  0  header %x!!!!", word));
+         break;
+       }
+      Int_t ichain=AliBitPacking::UnpackWord(word,0,3);
       
-      for (Int_t i=0; i<numberOfWordsInTRM; i++) {
+      for (Int_t i=0; i<numberOfWordsInTRM-6; i++) {
        word = GetNextWord();
        tdcTime =  AliBitPacking::UnpackWord(word,31,31);   
 
@@ -122,16 +146,58 @@ 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;
            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
+           if (koef ==-1 ){
+             AliError(Form("Incorrect lookup table ! "));
+             break;
+           }
+           hit=koefhits[koef];
+           if(fAllData[koef][hit] == 0)  fAllData[koef][hit]=time; 
+           koefhits[koef]++;
+           //      cout<<koef<<" "<<iTRM<<" "<<itdc<<" "<<ichannel<<" "<<time<<endl;
            
          }
       }
+      word = GetNextWord(); //chain 0  trailer
+      uu = word&TRM_CHAIN_0_TRAILER;
+      if(uu != TRM_CHAIN_0_TRAILER )
+       {
+       AliError(Form(" !!!! wrong CHAIN 0 trailer %x !!!!", word));
+       break;
+       }
+      
+     
+      word = GetNextWord(); //chain 1 header
+      uu = word & TRM_CHAIN_1_HEADER;
+      if(uu != TRM_CHAIN_1_HEADER) 
+       {
+         AliError(Form(" !!!! wrong CHAIN 1  header %x !!!!", word));
+         break;
+       }
       word = GetNextWord(); //chain trailer
+      uu = word&TRM_CHAIN_1_TRAILER;
+      if(uu != TRM_CHAIN_1_TRAILER )
+       {
+         AliError(Form(" !!!! wrong CHAIN 1 trailer  %x!!!!", word));
+       break;
+       }
+      
       word = GetNextWord(); //TRM trailer
-    } //TRM loop
+      uu = word& TRM_GLOBAL_TRAILER;
+      if(uu != TRM_GLOBAL_TRAILER )
+       {
+         AliError(Form(" !!!! wrong TRM GLOBAL trailer  %x!!!!", word));
+         break;
+       }
+     } //TRM loop
+      word = GetNextWord(); //
+      uu = word& fDRM_GLOBAL_TRAILER;
+      if(uu != fDRM_GLOBAL_TRAILER )
+       {
+         AliError(Form(" !!!! wrong DRM GLOBAL trailer  %x!!!!", word));
+         //      break;
+       }
+  
    return kTRUE;
 }
 //_____________________________________________________________________________
index 346308c..a444d26 100644 (file)
@@ -23,6 +23,7 @@ class AliT0RawReader : public TTask {
   Int_t            GetPosition();
   UInt_t         GetNextWord();
   Int_t GetData(Int_t channel, Int_t hit) {return fAllData[channel][hit];}
+  //  void SetNumberOfTRM(Int_t trm=2) {fNTRM=trm;}
   
   protected :
 
@@ -30,6 +31,8 @@ class AliT0RawReader : public TTask {
 
   UChar_t*         fData;         // raw data
   Int_t            fPosition;     // current (32 bit) position in fData
+  //  Int_t            fNTRM; //number of TRMs, 1 - testbeam; 2 - simulation
   Int_t fAllData[110][5];
   
  ClassDef(AliT0RawReader, 0) //class for reading T0 Raw data
index a04ea10..8fbdea8 100644 (file)
@@ -109,8 +109,9 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
     TGraph* gr = param ->GetSlewRec(i);
     slewingLEDrec.AddAtAndExpand(gr,i) ;  
   }
-  zdetC = param->GetZposition(0);
-  zdetA  = param->GetZposition(1);
+  zdetC = param->GetZPosition("C");
+  zdetA  = param->GetZPosition("A");
+
     
   AliDebug(1,Form("Start DIGITS reconstruction "));
 
@@ -211,7 +212,8 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
     //Q->T-> coefficients !!!! should be asked!!!
   Float_t  timeDelayLED[24];
   Float_t zdetA,zdetC;
-  TObjArray slewingLEDrec;
+  Int_t allData[110][5];
+   TObjArray slewingLEDrec;
   TObjArray walk;
     
   TArrayI * timeCFD = new TArrayI(24); 
@@ -219,10 +221,13 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
   TArrayI * chargeQT0 = new TArrayI(24); 
   TArrayI * chargeQT1 = new TArrayI(24); 
 
+   for (Int_t i=0; i<110; i++) {
+     allData[i][0]=0;
+   }
+
    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);
    }
@@ -240,12 +245,10 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
     slewingLEDrec.AddAtAndExpand(gr,i) ;  
   }
   
-    zdetC = param->GetZposition(0);
-    zdetA  = param->GetZposition(1);
-    //  zdetC=GetZdet("C");
-    // zdetA=GetZdet("A");
-  cout<<" !!!!!  zdetC "<<zdetC<<"  zdetA "<< zdetA<<endl;    
-   for (Int_t in=0; in<24; in++)
+  zdetC = param->GetZPosition("T0/C/PMT1");
+  zdetA  = param->GetZPosition("T0/A/PMT15");
+
+  for (Int_t in=0; in<24; in++)
      {
        timeLED->AddAt(allData[in+1][0],in);
        timeCFD->AddAt(allData[in+25][0],in);
@@ -272,7 +275,7 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
       Int_t qt0= chargeQT0->At(ipmt);
       Int_t qt1= chargeQT1->At(ipmt);
       if((qt1-qt0)>0)  adc[ipmt] = TMath::Exp( Double_t (channelWidth*(qt1-qt0)/1000));
-      time[ipmt] = channelWidth * (calib-> WalkCorrection( ipmt,qt1 , timeCFD->At(ipmt) ) ) ;
+       time[ipmt] = channelWidth * (calib-> WalkCorrection( ipmt,qt1 , timeCFD->At(ipmt) ) ) ;
       Double_t sl = (timeLED->At(ipmt) - timeCFD->At(ipmt)- (1000.*timeDelayLED[ipmt]/channelWidth))*channelWidth;
       Double_t qt=((TGraph*)slewingLEDrec.At(ipmt))->Eval(sl/1000.);
       frecpoints->SetTime(ipmt,time[ipmt]);
@@ -376,7 +379,8 @@ void AliT0Reconstructor::FillESD(AliRunLoader* runLoader, AliESD *pESD) const
     pESD->SetT0(timeStart);        // interaction time 
     pESD->SetT0time(time);         // best TOF on each PMT 
     pESD->SetT0amplitude(amp);     // number of particles(MIPs) on each PMT
-    cout<<" ESD >> "<<Zposition<<" "<<timeStart<<endl;
+    AliDebug(1,Form(" Z position %f cm,  T0  %f ps",Zposition , timeStart));
 
     pStartLoader->UnloadRecPoints();
    
index 855c77c..adc4bb8 100644 (file)
@@ -31,13 +31,13 @@ void AliT0SetCDB()
                  "Set time dalay");
   menu->AddButton("Set walk","SetWalk()",
                  "Set slewing coorection");
- menu->AddButton("Set Align","SetAC()",
+  menu->AddButton("Set Align","SetAC()",
                  "Set alignment coefficients");
   menu->AddButton("Set LookUpTable","SetLookUp()",
                   "Set LookUp table");
   menu->AddButton("Read time delay","GetTimeDelay()",
                  "Read time delay");
- menu->AddButton("Read walk","GetWalk()",
+  menu->AddButton("Read walk","GetWalk()",
                  "Read amplitude-time correction");
   menu->AddButton("Read alignment CC","GetAC()",
                  "Read face detector position ");
@@ -159,9 +159,12 @@ void SetWalk()
   TRandom rn;
   
   for(Int_t ipmt=0; ipmt<24; ipmt++) {
-    calibda->SetWalk(ipmt,"data/CFD-Amp.txt");
-    calibda->SetSlewingLED(ipmt,"data/CFD-LED.txt");
-    calibda->SetSlewingRec(ipmt,"data/CFD-LED.txt");
+    //    calibda->SetWalk(ipmt,"data/CFD-Amp.txt");
+    //    calibda->SetSlewingLED(ipmt,"data/CFD-LED.txt");
+    //  calibda->SetSlewingRec(ipmt,"data/CFD-LED.txt");
+    calibda->SetWalk(ipmt);
+    calibda->SetSlewingLED(ipmt);
+    calibda->SetSlewingRec(ipmt);
   }
   //Store calibration data into database
   AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
@@ -259,7 +262,7 @@ void SetLookUp()
   AliT0CalibData *calibda=new AliT0CalibData("T0");
 
   calibda->ReadAsciiLookup("lookUpTable.txt");
-//calibda->SetA(5);
+
   //Store calibration data into database
   AliCDBManager::Instance()->SetDefaultStorage("local://$ALICE_ROOT");
 
index 30804ef..6600b03 100644 (file)
@@ -1,3 +1,4 @@
+ 2
  RefPoint     0    0    0      0    0
  T0_A_1_A     1    0    0      0    2
  T0_A_2_A     2    0    0      0    4