calibration Zposition of vertex added
authoralla <alla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 27 Aug 2008 07:26:54 +0000 (07:26 +0000)
committeralla <alla@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 27 Aug 2008 07:26:54 +0000 (07:26 +0000)
T0/AliT0CalibTimeEq.cxx
T0/AliT0CalibTimeEq.h
T0/AliT0Parameters.cxx
T0/AliT0Parameters.h
T0/AliT0Reconstructor.cxx
T0/T0Physda.cxx

index cddb17c..195ecc5 100644 (file)
@@ -37,6 +37,7 @@ ClassImp(AliT0CalibTimeEq)
   AliT0CalibTimeEq::AliT0CalibTimeEq():TNamed()
 {
   //
+
 }
 
 //________________________________________________________________
@@ -94,6 +95,7 @@ void  AliT0CalibTimeEq::Print(Option_t*) const
   printf("\n   ----    PM Arrays       ----\n\n");
   printf(" Time delay CFD \n");
   for (Int_t i=0; i<24; i++) printf(" CFD  %f ",fTimeEq[i]);
+  printf("\n Mean Vertex %f \n", fMeanVertex);
 } 
 
 
@@ -101,9 +103,9 @@ void  AliT0CalibTimeEq::Print(Option_t*) const
 void AliT0CalibTimeEq::ComputeOnlineParams(const char* filePhys)
 {
   // compute online equalized time
-  Double_t mean=0;
+  Double_t mean=0, meanver=0;
   gFile = TFile::Open(filePhys);
-
+  
   if(!gFile) {
     AliError("No input PHYS data found ");
   }
@@ -114,13 +116,16 @@ void AliT0CalibTimeEq::ComputeOnlineParams(const char* filePhys)
        {
          sprintf(buf1,"CFD1-CFD%d",i+1);
          TH1F *cfd = (TH1F*) gFile->Get(buf1);
+         if(!cfd) AliWarning(Form("no histograms collected by PHYS DA for channel %i", i));
          //      printf(" i = %d buf1 = %s\n", i, buf1);
          if(cfd) mean=cfd->GetMean();
          SetTimeEq(i,mean);
-         if(!cfd) AliWarning(Form("no histograms collected by PHYS DA for channel %i", i));
-    if (cfd) delete cfd;
+         if (cfd) delete cfd;
        }
-      
+      TH1F *ver = (TH1F*) gFile->Get("hVertex");
+      if(!ver) AliWarning("no Vertex histograms collected by PHYS DA for Zvertex");
+      if(ver)  meanver = ver->GetMean();
+      SetMeanVertex(meanver);
       
       gFile->Close();
       delete gFile;
index 5056503..dd6e3ac 100644 (file)
@@ -31,14 +31,17 @@ class AliT0CalibTimeEq: public TNamed {
   void SetCFDvalue(Int_t channel, Int_t number, Float_t val) {fCFDvalue[channel][number]=val;}
   void SetTimeEq(Int_t channel, Float_t val) {fTimeEq[channel]=val;}
   
+  void SetMeanVertex(Float_t mean=0) { fMeanVertex = mean; };
+  Float_t GetMeanVertex () {return fMeanVertex;};
+
 
  protected:
 
   Float_t     fCFDvalue[24][5];       // CFD values
   Float_t     fTimeEq[24];           // Time Equalized for OCDB         
-
+  Float_t fMeanVertex;
   //
-  ClassDef(AliT0CalibTimeEq,2)    // T0 Sensor Calibration data
+  ClassDef(AliT0CalibTimeEq,3)    // T0 Sensor Calibration data
 };
 
 typedef AliT0CalibTimeEq AliSTARTCalibTimeEq; // for backward compatibility
index bda64a7..af8ddcc 100644 (file)
@@ -197,6 +197,19 @@ AliT0Parameters::GetTimeDelayCFD(Int_t ipmt)
 }
 //__________________________________________________________________
 
+Float_t
+AliT0Parameters:: GetMeanVertex()
+{ 
+  if (!fCalibentry) 
+    {
+      fMeanVertex=0;
+      return fMeanVertex;
+    }
+   
+  return fgCalibData->GetMeanVertex();
+}
+//__________________________________________________________________
+
 TGraph *AliT0Parameters::GetAmpLEDRec(Int_t ipmt) const
 {
    if (!fSlewCorr) {
index 0dbe81d..ba37850 100644 (file)
@@ -76,8 +76,10 @@ public:
   Float_t GetTimeDelayCFD(Int_t ipmt);
 //  Float_t GetTimeV0(Int_t ipmt = 512) {return  fTimeV0;}
 
-  void SetMeanT0(Int_t mean=512) { fMeanT0 = mean; };
-  Int_t GetMeanT0 () {return fMeanT0;};
+  void SetMeanT0(Float_t mean=512) { fMeanT0 = mean; };
+  Float_t GetMeanT0 () {return fMeanT0;};
+  void SetMeanVertex(Float_t mean=0) { fMeanVertex = mean; };
+   Float_t GetMeanVertex ();
 
   TMap * GetMapLookup();
   Int_t GetChannel(Int_t trm,  Int_t tdc, Int_t chain, Int_t channel);
@@ -105,7 +107,8 @@ public:
   Float_t   fTimeDelayCFD;  // sum time delay for CFD channel
  // Float_t   fTimeV0;  // sum time delay for CFD channel
   Float_t   fTimeDelayTVD;  //time delay for TVD (vertex trigger channel)
-  Int_t     fMeanT0; //mean of T0distribution with vertex=0;
+  Float_t     fMeanT0; //mean of T0distribution with vertex=0;
+  Float_t     fMeanVertex; // mean of vertex distribution;
   
   TMap      fLookUp;           //lookup table
   Int_t     fNumberOfTRMs;    // number of TRMs in setup
@@ -123,7 +126,7 @@ public:
   AliT0Parameters(const  AliT0Parameters&);
   AliT0Parameters& operator=(const AliT0Parameters&);
   
-  ClassDef(AliT0Parameters,4)
+  ClassDef(AliT0Parameters,5)
  
 };
 
index a3c254e..47e5123 100644 (file)
@@ -123,7 +123,7 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
   //  Int_t mV2Mip = param->GetmV2Mip();     
   //mV2Mip = param->GetmV2Mip();     
   Float_t channelWidth = fParam->GetChannelWidth() ;  
-  //  Int_t meanT0 = fParam->GetMeanT0();
+  Float_t meanVertex = fParam->GetMeanVertex();
   
   AliDebug(1,Form("Start DIGITS reconstruction "));
   
@@ -159,7 +159,7 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
   AliT0RecPoint* frecpoints= new AliT0RecPoint ();
   clustersTree->Branch( "T0", "AliT0RecPoint" ,&frecpoints, 405,1);
   
- Float_t time[24], adc[24];
 Float_t time[24], adc[24];
   for (Int_t ipmt=0; ipmt<24; ipmt++) {
     if(timeCFD->At(ipmt)>0 ){
       Double_t qt0 = Double_t(chargeQT0->At(ipmt));
@@ -215,7 +215,7 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
     timeDiff = (besttimeC - besttimeA)*channelWidth;
     meanTime = (Float_t((besttimeA + besttimeC -4000)/2) * channelWidth); 
     //    meanTime = (meanT0 - (besttimeA + besttimeC)/2) * channelWidth;
-    vertex = c*(timeDiff)/2. + (fdZonA - fdZonC)/2; //-(lenr-lenl))/2;
+    vertex = meanVertex - c*(timeDiff)/2. + (fdZonA - fdZonC)/2; 
     frecpoints->SetVertex(vertex);
     frecpoints->SetMeanTime(Int_t(meanTime));
     //online mean
@@ -223,17 +223,7 @@ void AliT0Reconstructor::Reconstruct(TTree*digitsTree, TTree*clustersTree) const
     AliDebug(1,Form("  timeDiff %f ps,  meanTime %f ps, vertex %f cm online mean %i ps",timeDiff, meanTime,vertex, Int_t(onlineMean * channelWidth )));
     
   }
-  //time in each channel as time[ipmt]-MeanTimeinThisChannel(with vertex=0)
-  /*  
-  for (Int_t ipmt=0; ipmt<24; ipmt++) {
-    if(time[ipmt]>1) {
-      //      time[ipmt] = (time[ipmt] - fTime0vertex[ipmt])*channelWidth;
-      time[ipmt] =Int_t  ( Float_t(time[ipmt]) * channelWidth);
-      frecpoints->SetTime(ipmt,time[ipmt]);
-    }
-  }
-*/
+  
   clustersTree->Fill();
 
   delete timeCFD;
@@ -270,7 +260,9 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
   Float_t timeDiff=9999999, meanTime=0;
   Double_t qt=0;
   Int_t mv2MIP = fParam-> GetmV2Mip();     
-  UInt_t type =rawReader->GetType();    
+  Float_t meanVertex = fParam->GetMeanVertex();
+
+  //  UInt_t type =rawReader->GetType();        
   
   AliT0RecPoint* frecpoints= new AliT0RecPoint ();
   
@@ -304,7 +296,7 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
          }
        }
       
-      if(option == "cosmic" && type == 7 )
+      if(option == "cosmic"  ) //&& type == 7 )
        {
          
          for (Int_t in=0; in<12; in++)  
@@ -362,7 +354,8 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
           
           
             //for physics  data
-          if(option == "cosmic" && type == 7) {
+          if(option == "cosmic") // && type == 7)
+            {
             if(( chargeQT1[ipmt] - chargeQT0[ipmt])>0)  
               adc[ipmt] = chargeQT1[ipmt] - chargeQT0[ipmt];
             else
@@ -421,7 +414,7 @@ void AliT0Reconstructor::Reconstruct(AliRawReader* rawReader, TTree*recTree) con
           meanTime =  Float_t((besttimeA + besttimeC)/2);  
           onlineMean = onlineMean -allData[0][0];;
         }
-        vertex = c*(timeDiff)/2.+ (fdZonA - fdZonC)/2; 
+        vertex =  meanVertex -c*(timeDiff)/2.; //+ (fdZonA - fdZonC)/2; 
         frecpoints->SetVertex(vertex);
         frecpoints->SetMeanTime(Int_t(meanTime));
         AliDebug(1,Form("  timeDiff %f ps,  meanTime %f ps, vertex %f cm online mean %i ",timeDiff, meanTime,vertex, onlineMean));
index a2aae81..0e7bded 100644 (file)
@@ -63,28 +63,28 @@ int main(int argc, char **argv) {
                                         "TStreamerInfo",
                                         "RIO",
                                         "TStreamerInfo()");
-
+  
   if(daqDA_DB_getFile(FILE_IN, FILE_IN)){
-     printf("Couldn't get input file >>inPhys.dat<< from DAQ_DB !!!\n");
-     return -1;
+    printf("Couldn't get input file >>inPhys.dat<< from DAQ_DB !!!\n");
+    return -1;
   }
-
+  
   
   FILE *inp;
   char c;
   inp = fopen(FILE_IN, "r");
   if(!inp){
-        printf("Input file >>inPhys.dat<< not found !!!\n");
-        return -1;
+    printf("Input file >>inPhys.dat<< not found !!!\n");
+    return -1;
   }
-
+  
   while((c=getc(inp))!=EOF) {
     switch(c) {
-      case 'a': {fscanf(inp, "%d", &ccbx ); break;} //N of X bins hCFD1_CFD
-      case 'b': {fscanf(inp, "%f", &cclx ); break;} //Low x hCFD1_CFD
-      case 'c': {fscanf(inp, "%f", &ccmx ); break;} //High x hCFD1_CFD
-//      case 'd': {fscanf(inp, "%d", &cbx ); break;} //N of X bins hCFD
-//      case 'e': {fscanf(inp, "%f", &clx ); break;} //Low x hCFD
+    case 'a': {fscanf(inp, "%d", &ccbx ); break;} //N of X bins hCFD1_CFD
+    case 'b': {fscanf(inp, "%f", &cclx ); break;} //Low x hCFD1_CFD
+    case 'c': {fscanf(inp, "%f", &ccmx ); break;} //High x hCFD1_CFD
+      //      case 'd': {fscanf(inp, "%d", &cbx ); break;} //N of X bins hCFD
+      //      case 'e': {fscanf(inp, "%f", &clx ); break;} //Low x hCFD
 //      case 'f': {fscanf(inp, "%f", &cmx ); break;} //High x hCFD
     }
   }
@@ -94,7 +94,7 @@ int main(int argc, char **argv) {
     printf("Wrong number of arguments\n");
     return -1;
   }
-
+  
 
   /* define data source : this is argument 1 */  
   status=monitorSetDataSource( argv[1] );
@@ -102,32 +102,35 @@ int main(int argc, char **argv) {
     printf("monitorSetDataSource() failed : %s\n",monitorDecodeError(status));
     return -1;
   }
-
-
+  
+  
   /* declare monitoring program */
   status=monitorDeclareMp( __FILE__ );
   if (status!=0) {
     printf("monitorDeclareMp() failed : %s\n",monitorDecodeError(status));
     return -1;
   }
-
-
+  
+  
   /* define wait event timeout - 1s max */
   monitorSetNowait();
   monitorSetNoWaitNetworkTimeout(1000);
   
-
+  
   /* log start of process */
   printf("T0 monitoring program started\n");  
-
+  
   // Allocation of histograms - start
 
   TH1F *hCFD1minCFD[24];  
    
-   for(Int_t ic=0; ic<24; ic++) {
-        hCFD1minCFD[ic] = new TH1F(Form("CFD1-CFD%d",ic+1),"CFD-CFD",ccbx,cclx,ccmx);
-    }
-
+  for(Int_t ic=0; ic<24; ic++) {
+    hCFD1minCFD[ic] = new TH1F(Form("CFD1-CFD%d",ic+1),"CFD-CFD",ccbx,cclx,ccmx);
+  }
+  TH1F *hVertex = new TH1F("hVertex","Z vertex",ccbx,cclx,ccmx);
+  
+  Float_t meanShift[24];
+  
   // Allocation of histograms - end
 
   Int_t iev=0;
@@ -135,7 +138,7 @@ int main(int argc, char **argv) {
   for(;;) {
     struct eventHeaderStruct *event;
     eventTypeType eventT;
-  
+    
     /* check shutdown condition */
     if (daqDA_checkShutdown()) {break;}
     
@@ -150,75 +153,101 @@ int main(int argc, char **argv) {
       printf("monitorGetEventDynamic() failed : %s\n",monitorDecodeError(status));
       break;
     }
-
+    
     /* retry if got no event */
     if (event==NULL) {
       continue;
     }
-
+    
     /* use event - here, just write event id to result file */
     eventT=event->eventType;
-   
+    
     switch (event->eventType){
-
+      
       case START_OF_RUN:
        break;
-
-      case END_OF_RUN:
-       break;
-
+       
+    case END_OF_RUN:
+      break;
+      
     case PHYSICS_EVENT:
-      //  case CALIBRATION_EVENT:
+      //    case CALIBRATION_EVENT:
       iev++;
-
+      
       if(iev==1){
-           printf("First event - %i\n",iev);
+       printf("First event - %i\n",iev);
       }
-
+      
       // Initalize raw-data reading and decoding
       AliRawReader *reader = new AliRawReaderDate((void*)event);
-          
+      
       // Enable the following two lines in case of real-data
-         reader->RequireHeader(kTRUE);
+      reader->RequireHeader(kTRUE);
       AliT0RawReader *start = new AliT0RawReader(reader, kTRUE);
-
+      
       // Read raw data
       Int_t allData[105][5];
       for(Int_t i0=0;i0<105;i0++)
        for(Int_t j0=0;j0<5;j0++)
-               allData[i0][j0] = 0;
-
-       if(start->Next()){
-       for (Int_t i=0; i<105; i++) {
-       for(Int_t iHit=0;iHit<5;iHit++){
-         allData[i][iHit]= start->GetData(i,iHit);
-        }
-       }
+         allData[i0][j0] = 0;
+      
+      if(start->Next()){
+       for (Int_t i=0; i<105; i++) {
+         for(Int_t iHit=0;iHit<5;iHit++){
+           allData[i][iHit]= start->GetData(i,iHit);
+         }
+       }
       }
-       else 
+      else 
        printf("No T0 data found!!!\n");
-
+      
       // Fill the histograms
-       
+      Float_t besttimeA=9999999;
+      Float_t besttimeC=9999999;
+      Float_t time[24]; 
       for (Int_t ik = 0; ik<24; ik++)
-         for (Int_t iHt=0; iHt<1; iHt++){
-                if(allData[ik+1][iHt]!=0 ){
-                 if(ik<12){
-                        hCFD1minCFD[ik]->Fill(allData[ik+1][iHt]-allData[1][iHt]);
-                 }
-                  if(ik>11){
-                         hCFD1minCFD[ik]->Fill(allData[ik+45][iHt]-allData[57][iHt]);
-                  }
-               }
+       if(allData[ik+1][0]!=0 ){
+         if(ik<12){
+            hCFD1minCFD[ik]->Fill(allData[ik+1][0]-allData[1][0]);
+            if(iev == 20000)   meanShift[ik] =  hCFD1minCFD[ik]->GetMean();  
+         }
+         if(ik>11){
+           hCFD1minCFD[ik]->Fill(allData[ik+45][0]-allData[57][0]);
+           if(iev == 20000)    
+             meanShift[ik] =  hCFD1minCFD[ik]->GetMean();  
+         }
        }
-
-     delete start;
-       start = 0x0;
-     reader->Reset();
+      //fill vertex & mean time _ fast reconstruction
+      if (iev > 20000 && iev <50000)
+       {
+         for (Int_t in=0; in<12; in++)  
+           {
+             time[in] = allData[in+1][0] - meanShift[in] + 5000 - allData[0][0] ;
+             time[in+12] = allData[in+56+1][0] - meanShift[in+12] + 5000 - allData[0][0];
+           }
+         for (Int_t ipmt=0; ipmt<12; ipmt++){
+           if(time[ipmt] > 1 ) {
+             if(time[ipmt]<besttimeC)
+               besttimeC=time[ipmt]; //timeC
+           }
+         }
+          for ( Int_t ipmt=12; ipmt<24; ipmt++){
+            if(time[ipmt] > 1) {
+              if(time[ipmt]<besttimeA) 
+                besttimeA=time[ipmt]; //timeA
+            }
+          }
+          Float_t vertex = 0.0299792 *(besttimeC - besttimeA)*24.4/2.; 
+          hVertex->Fill(vertex);
+          
+       }
+      delete start;
+      start = 0x0;
+      reader->Reset();
       // End of fill histograms
-
+      
     }
-
+    
     /* free resources */
     free(event);
     
@@ -236,6 +265,7 @@ int main(int argc, char **argv) {
   for(Int_t j=0;j<24;j++){
      hCFD1minCFD[j]->Write();
     }
+  hVertex->Write();
   hist->Close();
   delete hist;