a/ AliTRDCalibTask.cxx .h: one histo more to quantify the event selection if any...
authorcblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Jan 2011 13:29:56 +0000 (13:29 +0000)
committercblume <cblume@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Jan 2011 13:29:56 +0000 (13:29 +0000)
b/ AliTRDCalibraVdriftLinear.cxx, .h: the number 1199 of entries has to be avoid with the robust fit from root TLinearFitter...otherwise it breaks...

c/ AliTRDPreprocessorOffline.cxx .h: I modify a bit the first implementation of Julian for the condition to mask or not (no entries OR gain above 15 rms away of mean gain over the chambers OR vdrift above 15 rms away of the mean vdrift over the chambers). I added some basic functions to produce automaticely in pass0 a chamber status. This can still change a bit...

d/ AliTRDCalDet.cxx .h: I introduce the robust rms used in c/. This removes the chambers very far away due to small anode voltages to have a more realistic rms.

TRD/AliTRDCalibTask.cxx
TRD/AliTRDCalibTask.h
TRD/AliTRDCalibraVdriftLinearFit.cxx
TRD/AliTRDCalibraVdriftLinearFit.h
TRD/AliTRDPreprocessorOffline.cxx
TRD/AliTRDPreprocessorOffline.h
TRD/Cal/AliTRDCalDet.cxx
TRD/Cal/AliTRDCalDet.h

index 737e9f2..6db5da5 100644 (file)
@@ -91,6 +91,7 @@ ClassImp(AliTRDCalibTask)
       fListHist(0),
       fTRDCalibraFillHisto(0),
       fNEvents(0),
+      fNEventsInput(0),
       fNbTRDTrack(0),
       fNbTRDTrackOffline(0),
       fNbTRDTrackStandalone(0),
@@ -174,6 +175,7 @@ AliTRDCalibTask::~AliTRDCalibTask()
 
   // Pointeur
   if(fNEvents) delete fNEvents;
+  if(fNEventsInput) delete fNEventsInput;
   if(fNbTRDTrack) delete fNbTRDTrack;
   if(fNbTRDTrackOffline) delete fNbTRDTrackOffline;
   if(fNbTRDTrackStandalone) delete fNbTRDTrackStandalone;
@@ -275,6 +277,8 @@ void AliTRDCalibTask::UserCreateOutputObjects()
   if(fVector2d) fListHist->Add((TObject *) fTRDCalibraFillHisto->GetCalibraVector()); //calibra vector  
   fNEvents = new TH1I("NEvents","NEvents", 2, 0, 2);
   fListHist->Add(fNEvents);
+  fNEventsInput = new TH1I("NEventsInput","NEventsInput", 2, 0, 2);
+  fListHist->Add(fNEventsInput);
   
   // absolute gain calibration even without AliESDfriend
   Int_t nBinsPt = 25;
@@ -449,6 +453,8 @@ void AliTRDCalibTask::UserExec(Option_t *)
   //printf("Counter %d\n",fCounter);
   
   fCounter++;
+  fNEventsInput->Fill(1);
+
   //cout << "maxEvent = " << fMaxEvent << endl;
   //if(fCounter%100==0) cout << "fCounter = " << fCounter << endl;
   if((fMaxEvent != 0) && (fMaxEvent < fCounter)) {
@@ -1093,6 +1099,7 @@ void  AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) {
   if(!listcalibTask) return;
 
   TH1I *nEvents  = (TH1I *) listcalibTask->FindObject("NEvents");
+  TH1I *nEventsInput  = (TH1I *) listcalibTask->FindObject("NEventsInput");
   TH2F *absoluteGain  = (TH2F *) listcalibTask->FindObject("AbsoluteGain");
 
   TH1F *trdTrack = (TH1F *) listcalibTask->FindObject("TRDTrack");
@@ -1128,6 +1135,7 @@ void  AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) {
 
   //
 
+  TH1I *inEventsInput  = (TH1I *) fListHist->FindObject("NEventsInput");
   TH1I *inEvents  = (TH1I *) fListHist->FindObject("NEvents");
   TH2F *iabsoluteGain  = (TH2F *) fListHist->FindObject("AbsoluteGain");
 
@@ -1164,6 +1172,18 @@ void  AliTRDCalibTask::AddTask(const AliTRDCalibTask * calibTask) {
 
 
   // Add
+
+  if(nEventsInput) {
+    if(inEventsInput) {
+      inEventsInput->Add(nEventsInput);
+      //printf("Add Events\n");
+    }
+    else {
+      //printf("Create new Events\n");
+      inEventsInput = new TH1I(*nEventsInput);
+      fListHist->Add(inEventsInput);
+    }
+  }
   
   if(nEvents) {
     if(inEvents) {
index e06e02e..3f17857 100644 (file)
@@ -105,6 +105,7 @@ class AliTRDCalibTask : public AliAnalysisTaskSE {
   AliTRDCalibraFillHisto *fTRDCalibraFillHisto;  //! calibration analyse object
 
   TH1I        *fNEvents;                         //! counter  
+  TH1I        *fNEventsInput;                    //! counter  
   
   TH1F        *fNbTRDTrack;                      //! nb ESD tracks with TRD clusters
   TH1F        *fNbTRDTrackOffline;               //! nb ESD tracks with TRD clusters
index eb07591..a2a2581 100644 (file)
@@ -318,15 +318,29 @@ void AliTRDCalibraVdriftLinearFit::FillPEArray()
       TAxis *yaxis = linearfitterhisto->GetYaxis();
       TLinearFitter linearfitter = TLinearFitter(2,"pol1");
       //printf("test\n");
+      Double_t integral = linearfitterhisto->Integral();
+      //printf("Integral is %f\n",integral);
+      Bool_t securitybreaking = kFALSE;
+      if(TMath::Abs(integral-1199) < 0.00001) securitybreaking = kTRUE;
       for(Int_t ibinx = 0; ibinx < linearfitterhisto->GetNbinsX(); ibinx++){
        for(Int_t ibiny = 0; ibiny < linearfitterhisto->GetNbinsY(); ibiny++){
          if(linearfitterhisto->GetBinContent(ibinx+1,ibiny+1)>0){
            Double_t x = xaxis->GetBinCenter(ibinx+1);
            Double_t y = yaxis->GetBinCenter(ibiny+1);
+           
            for(Int_t k = 0; k < (Int_t)linearfitterhisto->GetBinContent(ibinx+1,ibiny+1); k++){
-             linearfitter.AddPoint(&x,y);
-             arrayI[cb]++;
+             if(!securitybreaking){
+               linearfitter.AddPoint(&x,y);
+               arrayI[cb]++;
+             }
+             else {
+               if(arrayI[cb]< 1198){
+                 linearfitter.AddPoint(&x,y);
+                 arrayI[cb]++; 
+               }
+             }
            }
+           
          }
        }
       }
@@ -338,10 +352,12 @@ void AliTRDCalibraVdriftLinearFit::FillPEArray()
        TVectorD  *par  = new TVectorD(2);
        TVectorD   pare = TVectorD(2);
        TVectorD  *parE = new TVectorD(3);
+       //printf("Fit\n");
        if((linearfitter.EvalRobust(0.8)==0)) {
-       //if((linearfitter.Eval()==0)) {
-         
+         //if((linearfitter.Eval()==0)) {
+         //printf("Take the param\n");
          linearfitter.GetParameters(*par);
+         //printf("Done\n");
          //linearfitter.GetErrors(pare);
          //Float_t  ppointError =  TMath::Sqrt(TMath::Abs(linearfitter.GetChisquare())/arrayI[cb]);
          //(*parE)[0] = pare[0]*ppointError;
@@ -356,6 +372,7 @@ void AliTRDCalibraVdriftLinearFit::FillPEArray()
          //par->Print();
          //parE->Print();
        }
+       //printf("Finish\n");
       }
       
       //delete linearfitterhisto;
index 0dc5b58..95d1f7c 100644 (file)
@@ -62,3 +62,4 @@ class AliTRDCalibraVdriftLinearFit : public TObject {
 
 
 #endif
+
index 140e9e8..3858665 100644 (file)
@@ -130,6 +130,7 @@ void AliTRDPreprocessorOffline::CalibVdriftT0(const Char_t* file, Int_t startRun
   // 2. extraction of the information
   //
   if(ReadVdriftT0Global(file)) AnalyzeVdriftT0();
+  //printf("Finish PH\n");
   if(ReadVdriftLinearFitGlobal(file)) AnalyzeVdriftLinearFit();
   //
   // 3. Append QA plots
@@ -235,6 +236,41 @@ void AliTRDPreprocessorOffline::CalibPRF(const Char_t* file, Int_t startRunNumbe
   UpdateOCDBPRF(startRunNumber,endRunNumber,ocdbStorage);
   
 }
+//________________________________________________________________________________________________________________
+
+void AliTRDPreprocessorOffline::CalibChamberStatus(Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){
+  //
+  // make calibration of the chamber status
+  // Input parameters:
+  //      startRunNumber, endRunNumber     - run validity period 
+  //      ocdbStorage                      - path to the OCDB storage
+  //                                       - if empty - local storage 'pwd' uesed
+  if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB";
+  //
+  //
+  // 2. extraction of the information
+  //
+  if(!AnalyzeChamberStatus()) return;
+  //
+  // 3. Append QA plots
+  //
+  //MakeDefaultPlots(fVdriftArray,fVdriftArray);
+  //
+  //
+  //
+  // 4. validate OCDB entries
+  //
+  if(fSwitchOnValidation==kTRUE && ValidateChamberStatus()==kFALSE) { 
+    AliError("TRD Chamber status OCDB parameters not ok!");
+    return;
+  }
+  //
+  // 5. update of OCDB
+  //
+  //
+  UpdateOCDBChamberStatus(startRunNumber,endRunNumber,ocdbStorage);
+  
+}
 //______________________________________________________________________________________________________
 Bool_t AliTRDPreprocessorOffline::Init(const Char_t* fileName){
   //
@@ -470,10 +506,15 @@ Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){
   // Analyze vdrift linear fit - produce the calibration objects
   //
 
+  //printf("Analyse linear fit\n");
+
   AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance();
   calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit
+  //printf("Fill PE Array\n");
   fAliTRDCalibraVdriftLinearFit->FillPEArray();
+  //printf("AliTRDCalibraFit\n");
   calibra->AnalyseLinearFitters(fAliTRDCalibraVdriftLinearFit);
+  //printf("After\n");
 
   //Int_t nbtg        = 540;
   Int_t nbfit       = calibra->GetNumberFit();
@@ -546,263 +587,393 @@ Bool_t AliTRDPreprocessorOffline::AnalyzePRF(){
   return ok;
   
 }
-//________________________________________________________________________________________________
-void AliTRDPreprocessorOffline::CorrectFromDetGainUsed() {
+
+//_____________________________________________________________________________
+Bool_t AliTRDPreprocessorOffline::AnalyzeChamberStatus()
+{
   //
-  // Correct from the gas gain used afterwards
+  // Produce AliTRDCalChamberStatus out of calibration results
   //
-  AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
-  if(!calDetGain) return;
 
-  // Calculate mean
-  Double_t mean = 0.0;
-  Int_t nbdet = 0;
-  
-  for(Int_t det = 0; det < 540; det++) {
-    
-    Float_t gaininit = fCalDetGainUsed->GetValue(det);
-    Float_t gainout = calDetGain->GetValue(det);
+  // set up AliTRDCalChamberStatus
+  AliTRDCalChamberStatus *CalChamberStatus = new AliTRDCalChamberStatus();
+  for(Int_t det = 0; det < 540; det++) CalChamberStatus->SetStatus(det,1);
 
-   
-    if(TMath::Abs(gainout-1.0) > 0.000001) {
-      mean += (gaininit*gainout);
-      nbdet++;
-    }  
-  }
-  if(nbdet > 0) mean = mean/nbdet;
-   
-  for(Int_t det = 0; det < 540; det++) {
-    
-    Float_t gaininit = fCalDetGainUsed->GetValue(det);
-    Float_t gainout = calDetGain->GetValue(det);
+  // get calibration objects
+  AliTRDCalDet *calDetGain   = (AliTRDCalDet *) fCalibObjects->At(kGain);
+  AliTRDCalDet *calDetVDrift = (AliTRDCalDet *) fCalibObjects->At(kVdriftLinear);
+
+  // Check
+  if((!calDetGain) || (!calDetVDrift)) return kFALSE;
+
+  // Gain
+  Double_t gainmean = calDetGain->GetMean();
+  Double_t vdriftmean = calDetVDrift->GetMean();
+
+  Double_t gainrms = calDetGain->GetRMSRobust();
+  Double_t vdriftrms = calDetVDrift->GetRMSRobust();
+
+  //printf("Gain mean: %f, rms: %f\n",gainmean,gainrms);
+  //printf("Vdrift mean: %f, rms: %f\n",vdriftmean,vdriftrms);
   
-    if(TMath::Abs(gainout-1.0) > 0.000001) calDetGain->SetValue(det,gaininit*gainout);
-    else calDetGain->SetValue(det,mean);
-  }
+  // Check
+  if((TMath::Abs(gainrms) < 0.001) || (TMath::Abs(vdriftrms) < 0.001)) return kFALSE;
 
+  // mask chambers with empty gain entries
+  //Int_t counter = 0;
+  for (Int_t idet = 0; idet < 540; idet++) {
 
-}
-//________________________________________________________________________________________________
-void AliTRDPreprocessorOffline::CorrectFromDetVdriftUsed() {
-  //
-  // Correct from the drift velocity
-  //
+    // ch2d
+    TH1I *projch =  (TH1I *) fCH2d->ProjectionX("projch",idet+1,idet+1,(Option_t *)"e");
+    Double_t entries = projch->GetEntries();
 
-  //printf("Correct for vdrift\n");
+    // gain
+    Double_t gain = calDetGain->GetValue(idet);
 
-  AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
-  if(!calDetGain) return;
+    // vdrift
+    Double_t vdrift = calDetVDrift->GetValue(idet);
 
-  Int_t detVdrift = kVdriftPHDet;
-  if(fMethodSecond) detVdrift = kVdriftLinear;
-  AliTRDCalDet *calDetVdrift = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
-  if(!calDetVdrift) return;
 
-  // Calculate mean
-  
-  for(Int_t det = 0; det < 540; det++) {
-    
-    Float_t vdriftinit = fCalDetVdriftUsed->GetValue(det);
-    Float_t vdriftout = calDetVdrift->GetValue(det);
+    if(entries<=0.5 ||
+       TMath::Abs(gainmean-gain) > (15.0*gainrms) ||
+       TMath::Abs(vdriftmean-vdrift) > (15.0*vdriftrms)) {
+     
+      //printf(" chamber det %03d masked \n",idet);
+      //printf(" gainmean %f and gain %f, gainrms %f \n",gainmean,gain,gainrms);
+      //printf(" vdriftmean %f and vdrift %f, vdriftrms %f \n",vdriftmean,vdrift,vdriftrms);
+      CalChamberStatus->SetStatus(idet,AliTRDCalChamberStatus::kMasked);
+      //counter++;
+    }
 
-    Float_t gain = calDetGain->GetValue(det);
-    if(vdriftout > 0.0) gain = gain*vdriftinit/vdriftout;
-    calDetGain->SetValue(det,gain);
+     /*
+     // installed supermodules+1 -> abort
+     if(counter > (7+1)*30) {
+       printf("ERROR: more than one SM to be masked!! \n Abort...\n");
+       if(projch) delete projch;
+       return 0x0;
+     }
+     */
 
-    
-  }
-}
-//_________________________________________________________________________________________________________________
-void AliTRDPreprocessorOffline::UpdateOCDBGain(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
-  //
-  // Update OCDB entry
-  //
-  
-  AliCDBMetaData *metaData= new AliCDBMetaData();
-  metaData->SetObjectClassName("AliTRDCalDet");
-  metaData->SetResponsible("Raphaelle Bailhache");
-  metaData->SetBeamPeriod(1);
-  
-  AliCDBId id1("TRD/Calib/ChamberGainFactor", startRunNumber, endRunNumber);
-  AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
-  AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
-  if(calDet) gStorage->Put(calDet, id1, metaData);
-    
+     if(projch) delete projch;
 
-}
-//___________________________________________________________________________________________________________________
-void AliTRDPreprocessorOffline::UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
-  //
-  // Update OCDB entry
-  //
+   }
 
-  Int_t detVdrift = kVdriftPHDet;
-  
-  if(fMethodSecond) detVdrift = kVdriftLinear;
-  
-  AliCDBMetaData *metaData= new AliCDBMetaData();
-  metaData->SetObjectClassName("AliTRDCalDet");
-  metaData->SetResponsible("Raphaelle Bailhache");
-  metaData->SetBeamPeriod(1);
-  
-  AliCDBId id1("TRD/Calib/ChamberVdrift", startRunNumber, endRunNumber);
-  AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
-  AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
-  if(calDet) gStorage->Put(calDet, id1, metaData);
-  
-  //
+   // Security
+   for(Int_t sm=0; sm < 18; sm++) {
+     Int_t counter = 0;
+     for(Int_t det = 0; det < 30; det++){
+       Int_t detector = sm*30+det;
+       if(CalChamberStatus->IsMasked(detector)) counter++;
+     }
+     if(counter >= 10) {
+       for(Int_t det = 0; det < 30; det++){
+        Int_t detector = sm*30+det;
+        CalChamberStatus->SetStatus(detector,AliTRDCalChamberStatus::kInstalled);
+       }
+     }
+   }
 
-  if(!fMethodSecond) {
-    
-    AliCDBMetaData *metaDataPad= new AliCDBMetaData();
-    metaDataPad->SetObjectClassName("AliTRDCalPad");
-    metaDataPad->SetResponsible("Raphaelle Bailhache");
-    metaDataPad->SetBeamPeriod(1);
-    
-    AliCDBId id1Pad("TRD/Calib/LocalVdrift", startRunNumber, endRunNumber);
-    AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
-    if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
-     
-  }
+   fCalibObjects->AddAt(CalChamberStatus,kChamberStatus);
+   return kTRUE;
 
-}
-//________________________________________________________________________________________________________________________
-void AliTRDPreprocessorOffline::UpdateOCDBT0(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
-  //
-  // Update OCDB entry
-  //
-  
-  AliCDBMetaData *metaData= new AliCDBMetaData();
-  metaData->SetObjectClassName("AliTRDCalDet");
-  metaData->SetResponsible("Raphaelle Bailhache");
-  metaData->SetBeamPeriod(1);
-  
-  AliCDBId id1("TRD/Calib/ChamberT0", startRunNumber, endRunNumber);
-  AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
-  AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
-  if(calDet) gStorage->Put(calDet, id1, metaData);
-  //
+ }
 
-  AliCDBMetaData *metaDataPad= new AliCDBMetaData();
-  metaDataPad->SetObjectClassName("AliTRDCalPad");
-  metaDataPad->SetResponsible("Raphaelle Bailhache");
-  metaDataPad->SetBeamPeriod(1);
-  
-  AliCDBId id1Pad("TRD/Calib/LocalT0", startRunNumber, endRunNumber);
-  AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
-  if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
 
+ //________________________________________________________________________________________________
+ void AliTRDPreprocessorOffline::CorrectFromDetGainUsed() {
+   //
+   // Correct from the gas gain used afterwards
+   //
+   AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
+   if(!calDetGain) return;
 
-}
-//_________________________________________________________________________________________________________________
-void AliTRDPreprocessorOffline::UpdateOCDBPRF(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
-  //
-  // Update OCDB entry
-  //
-  
-  AliCDBMetaData *metaData= new AliCDBMetaData();
-  metaData->SetObjectClassName("AliTRDCalPad");
-  metaData->SetResponsible("Raphaelle Bailhache");
-  metaData->SetBeamPeriod(1);
-  
-  AliCDBId id1("TRD/Calib/PRFWidth", startRunNumber, endRunNumber);
-  AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
-  AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
-  if(calPad) gStorage->Put(calPad, id1, metaData);
+   // Calculate mean
+   Double_t mean = 0.0;
+   Int_t nbdet = 0;
 
-}
-//__________________________________________________________________________________________________________________________
-Bool_t AliTRDPreprocessorOffline::ValidateGain() const {
-  //
-  // Validate OCDB entry
-  //
+   for(Int_t det = 0; det < 540; det++) {
 
-  AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
-  if(calDet) {
-    Double_t mean = calDet->GetMean();
-    Double_t rms = calDet->GetRMS();
-    if((mean > 0.2) && (mean < 1.4) && (rms < 0.5)) return kTRUE;
-    else return kFALSE;
-  }
-  else return kFALSE;
-    
+     Float_t gaininit = fCalDetGainUsed->GetValue(det);
+     Float_t gainout = calDetGain->GetValue(det);
 
-}
-//__________________________________________________________________________________________________________________________
-Bool_t AliTRDPreprocessorOffline::ValidateVdrift(){
-  //
-  // Update OCDB entry
-  //
 
-  Int_t detVdrift = kVdriftPHDet;
-  Bool_t ok = kTRUE;
-  
-  if(fMethodSecond) detVdrift = kVdriftLinear;
-  
-  AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
-  if(calDet) {
-    Double_t mean = calDet->GetMean();
-    Double_t rms = calDet->GetRMS();
-    //printf("Vdrift::mean %f, rms %f\n",mean,rms);
-    if(!((mean > 1.0) && (mean < 2.0) && (rms < 0.5))) ok = kFALSE;
-  }
-  else return kFALSE; 
-
-  if(!fMethodSecond) {
-    AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
-    if(calPad) {
-      Double_t mean = calPad->GetMean();
-      Double_t rms = calPad->GetRMS();
-      //printf("Vdrift::meanpad %f, rmspad %f\n",mean,rms);
-      if(!((mean > 0.9) && (mean < 1.1) && (rms < 0.6))) ok = kFALSE;
-    }
-    else return kFALSE;
-  }
+     if(TMath::Abs(gainout-1.0) > 0.000001) {
+       mean += (gaininit*gainout);
+       nbdet++;
+     }  
+   }
+   if(nbdet > 0) mean = mean/nbdet;
 
-  return ok;
+   for(Int_t det = 0; det < 540; det++) {
 
-}
-//__________________________________________________________________________________________________________________________
-Bool_t AliTRDPreprocessorOffline::ValidateT0(){
-  //
-  // Update OCDB entry
-  //
-  
-  AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
-  AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
-  if(calDet && calPad) {
-    Double_t meandet = calDet->GetMean();
-    Double_t rmsdet = calDet->GetRMS();
-    Double_t meanpad = calPad->GetMean();
-    //Double_t rmspad = calPad->GetRMS();
-    //printf("T0::minimum %f, rmsdet %f,meanpad %f, rmspad %f\n",meandet,rmsdet,meanpad,rmspad);
-    if((meandet > -1.5) && (meandet < 5.0) && (rmsdet < 4.0) && (meanpad < 5.0) && (meanpad > -0.5)) return kTRUE;
-    else return kFALSE;
-  }
-  else return kFALSE;
-}
-//__________________________________________________________________________________________________________________________
-Bool_t AliTRDPreprocessorOffline::ValidatePRF() const{
+     Float_t gaininit = fCalDetGainUsed->GetValue(det);
+     Float_t gainout = calDetGain->GetValue(det);
+
+     if(TMath::Abs(gainout-1.0) > 0.000001) calDetGain->SetValue(det,gaininit*gainout);
+     else calDetGain->SetValue(det,mean);
+   }
+
+
+ }
+ //________________________________________________________________________________________________
+ void AliTRDPreprocessorOffline::CorrectFromDetVdriftUsed() {
+   //
+   // Correct from the drift velocity
+   //
+
+   //printf("Correct for vdrift\n");
+
+   AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain);
+   if(!calDetGain) return;
+
+   Int_t detVdrift = kVdriftPHDet;
+   if(fMethodSecond) detVdrift = kVdriftLinear;
+   AliTRDCalDet *calDetVdrift = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
+   if(!calDetVdrift) return;
+
+   // Calculate mean
+
+   for(Int_t det = 0; det < 540; det++) {
+
+     Float_t vdriftinit = fCalDetVdriftUsed->GetValue(det);
+     Float_t vdriftout = calDetVdrift->GetValue(det);
+
+     Float_t gain = calDetGain->GetValue(det);
+     if(vdriftout > 0.0) gain = gain*vdriftinit/vdriftout;
+     calDetGain->SetValue(det,gain);
+
+
+   }
+
+ }
+ //_________________________________________________________________________________________________________________
+ void AliTRDPreprocessorOffline::UpdateOCDBGain(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
+   //
+   // Update OCDB entry
+   //
+
+   AliCDBMetaData *metaData= new AliCDBMetaData();
+   metaData->SetObjectClassName("AliTRDCalDet");
+   metaData->SetResponsible("Raphaelle Bailhache");
+   metaData->SetBeamPeriod(1);
+
+   AliCDBId id1("TRD/Calib/ChamberGainFactor", startRunNumber, endRunNumber);
+   AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
+   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
+   if(calDet) gStorage->Put(calDet, id1, metaData);
+
+
+ }
+ //___________________________________________________________________________________________________________________
+ void AliTRDPreprocessorOffline::UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
+   //
+   // Update OCDB entry
+   //
+
+   Int_t detVdrift = kVdriftPHDet;
+
+   if(fMethodSecond) detVdrift = kVdriftLinear;
+
+   AliCDBMetaData *metaData= new AliCDBMetaData();
+   metaData->SetObjectClassName("AliTRDCalDet");
+   metaData->SetResponsible("Raphaelle Bailhache");
+   metaData->SetBeamPeriod(1);
+
+   AliCDBId id1("TRD/Calib/ChamberVdrift", startRunNumber, endRunNumber);
+   AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
+   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
+   if(calDet) gStorage->Put(calDet, id1, metaData);
+
+   //
+
+   if(!fMethodSecond) {
+
+     AliCDBMetaData *metaDataPad= new AliCDBMetaData();
+     metaDataPad->SetObjectClassName("AliTRDCalPad");
+     metaDataPad->SetResponsible("Raphaelle Bailhache");
+     metaDataPad->SetBeamPeriod(1);
+
+     AliCDBId id1Pad("TRD/Calib/LocalVdrift", startRunNumber, endRunNumber);
+     AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
+     if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
+
+   }
+
+ }
+ //________________________________________________________________________________________________________________________
+ void AliTRDPreprocessorOffline::UpdateOCDBT0(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
+   //
+   // Update OCDB entry
+   //
+
+   AliCDBMetaData *metaData= new AliCDBMetaData();
+   metaData->SetObjectClassName("AliTRDCalDet");
+   metaData->SetResponsible("Raphaelle Bailhache");
+   metaData->SetBeamPeriod(1);
+
+   AliCDBId id1("TRD/Calib/ChamberT0", startRunNumber, endRunNumber);
+   AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
+   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
+   if(calDet) gStorage->Put(calDet, id1, metaData);
+
+   //
+
+   AliCDBMetaData *metaDataPad= new AliCDBMetaData();
+   metaDataPad->SetObjectClassName("AliTRDCalPad");
+   metaDataPad->SetResponsible("Raphaelle Bailhache");
+   metaDataPad->SetBeamPeriod(1);
+
+   AliCDBId id1Pad("TRD/Calib/LocalT0", startRunNumber, endRunNumber);
+   AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
+   if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad);
+
+
+
+ }
+ //_________________________________________________________________________________________________________________
+ void AliTRDPreprocessorOffline::UpdateOCDBPRF(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
+   //
+   // Update OCDB entry
+   //
+
+   AliCDBMetaData *metaData= new AliCDBMetaData();
+   metaData->SetObjectClassName("AliTRDCalPad");
+   metaData->SetResponsible("Raphaelle Bailhache");
+   metaData->SetBeamPeriod(1);
+
+   AliCDBId id1("TRD/Calib/PRFWidth", startRunNumber, endRunNumber);
+   AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
+   AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
+   if(calPad) gStorage->Put(calPad, id1, metaData);
+
+
+ }
+ //_________________________________________________________________________________________________________________
+ void AliTRDPreprocessorOffline::UpdateOCDBChamberStatus(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){
+   //
+   // Update OCDB entry
+   //
+
+   AliCDBMetaData *metaData= new AliCDBMetaData();
+   metaData->SetObjectClassName("AliTRDCalChamberStatus");
+   metaData->SetResponsible("Raphaelle Bailhache");
+   metaData->SetBeamPeriod(1);
+
+   AliCDBId id1("TRD/Calib/ChamberStatus", startRunNumber, endRunNumber);
+   AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath);
+   AliTRDCalChamberStatus *calChamberStatus = (AliTRDCalChamberStatus *) fCalibObjects->At(kChamberStatus);
+   if(calChamberStatus) gStorage->Put(calChamberStatus, id1, metaData);
+
+
+ }
+ //__________________________________________________________________________________________________________________________
+ Bool_t AliTRDPreprocessorOffline::ValidateGain() const {
+   //
+   // Validate OCDB entry
+   //
+
+   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain);
+   if(calDet) {
+     Double_t mean = calDet->GetMean();
+     Double_t rms = calDet->GetRMSRobust();
+     if((mean > 0.2) && (mean < 1.4) && (rms < 0.5)) return kTRUE;
+     //if((mean > 0.2) && (mean < 1.4)) return kTRUE;
+     else return kFALSE;
+   }
+   else return kFALSE;
+
+
+ }
+ //__________________________________________________________________________________________________________________________
+ Bool_t AliTRDPreprocessorOffline::ValidateVdrift(){
+   //
+   // Update OCDB entry
+   //
+
+   Int_t detVdrift = kVdriftPHDet;
+   Bool_t ok = kTRUE;
+
+   if(fMethodSecond) detVdrift = kVdriftLinear;
+
+   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift);
+   if(calDet) {
+     Double_t mean = calDet->GetMean();
+     Double_t rms = calDet->GetRMSRobust();
+     //printf("Vdrift::mean %f, rms %f\n",mean,rms);
+     if(!((mean > 1.0) && (mean < 2.0) && (rms < 0.5))) ok = kFALSE;
+   }
+   else return kFALSE; 
+
+   if(!fMethodSecond) {
+     AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad);
+     if(calPad) {
+       Double_t mean = calPad->GetMean();
+       Double_t rms = calPad->GetRMS();
+       //printf("Vdrift::meanpad %f, rmspad %f\n",mean,rms);
+       if(!((mean > 0.9) && (mean < 1.1) && (rms < 0.6))) ok = kFALSE;
+     }
+     else return kFALSE;
+   }
+
+   return ok;
+
+ }
+ //__________________________________________________________________________________________________________________________
+ Bool_t AliTRDPreprocessorOffline::ValidateT0(){
+   //
+   // Update OCDB entry
+   //
+
+   AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet);
+   AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad);
+   if(calDet && calPad) {
+     Double_t meandet = calDet->GetMean();
+     Double_t rmsdet = calDet->GetRMSRobust();
+     Double_t meanpad = calPad->GetMean();
+     //Double_t rmspad = calPad->GetRMS();
+     //printf("T0::minimum %f, rmsdet %f,meanpad %f, rmspad %f\n",meandet,rmsdet,meanpad,rmspad);
+     if((meandet > -1.5) && (meandet < 5.0) && (rmsdet < 4.0) && (meanpad < 5.0) && (meanpad > -0.5)) return kTRUE;
+     else return kFALSE;
+   }
+   else return kFALSE;
+
+ }
+ //__________________________________________________________________________________________________________________________
+ Bool_t AliTRDPreprocessorOffline::ValidatePRF() const{
+   //
+   // Update OCDB entry
+   //
+
+   AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
+   if(calPad) {
+     Double_t meanpad = calPad->GetMean();
+     Double_t rmspad = calPad->GetRMS();
+     //printf("PRF::meanpad %f, rmspad %f\n",meanpad,rmspad);
+     if((meanpad < 1.0) && (rmspad < 0.8)) return kTRUE;
+     else return kFALSE;
+   }
+   else return kFALSE;
+
+
+ }
+ //__________________________________________________________________________________________________________________________
+Bool_t AliTRDPreprocessorOffline::ValidateChamberStatus() const{
   //
   // Update OCDB entry
   //
   
-  AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF);
-  if(calPad) {
-    Double_t meanpad = calPad->GetMean();
-    Double_t rmspad = calPad->GetRMS();
-    //printf("PRF::meanpad %f, rmspad %f\n",meanpad,rmspad);
-    if((meanpad < 1.0) && (rmspad < 0.8)) return kTRUE;
-    else return kFALSE;
+  AliTRDCalChamberStatus *calChamberStatus = (AliTRDCalChamberStatus *) fCalibObjects->At(kChamberStatus);
+  if(calChamberStatus) {
+    Int_t detectormasked = 0;
+    for(Int_t det = 0; det < 540; det++) {
+      if(calChamberStatus->IsMasked(det)) detectormasked++;
+    }
+    //printf("Number of chambers masked %d\n",detectormasked);
+    if(detectormasked > 29) return kFALSE;
+    else return kTRUE;
   }
   else return kFALSE;
  
-
 }
 //_____________________________________________________________________________
 Int_t AliTRDPreprocessorOffline::GetVersion(TString name) const
@@ -858,56 +1029,4 @@ Int_t AliTRDPreprocessorOffline::GetSubVersion(TString name) const
 
 }
 
-//_____________________________________________________________________________
-AliTRDCalChamberStatus *AliTRDPreprocessorOffline::ProduceChamberStatus()
-{
-  //
-  // Produce AliTRDCalChamberStatus out of calibration results
-  //
-
-  // set up AliTRDCalChamberStatus
-  AliTRDCalChamberStatus *CalChamberStatus = new AliTRDCalChamberStatus();
 
-  // get calibration objects
-  AliTRDCalDet *calDetGain   = (AliTRDCalDet *) fCalibObjects->At(kGain);
-  AliTRDCalDet *calDetVDrift = (AliTRDCalDet *) fCalibObjects->At(kVdriftLinear);
-  
-  // mask chambers with empty gain entries
-  Int_t counter = 0;
-  for (Int_t idet = 0; idet < 540; idet++) {
-
-    // ch2d
-    TH1I *projch =  (TH1I *) fCH2d->ProjectionX("projch",idet+1,idet+1,(Option_t *)"e");
-    if (!projch) continue;
-
-    Int_t entries = static_cast<Int_t>(projch->GetEntries());
-
-    // gain
-    Double_t defaultgain = calDetGain->GetMean();
-    Double_t gain = calDetGain->GetValue(idet);
-
-    // vdrift
-    Double_t defaultvdrift = calDetVDrift->GetMean();
-    Double_t vdrift = calDetVDrift->GetValue(idet);
-
-    if(entries<=0 ||
-       TMath::Abs(defaultgain-gain) < 0.5 ||
-       TMath::Abs(defaultvdrift-vdrift) < 0.1) {
-     
-       printf(" chamber det %03d masked \n",idet);
-       CalChamberStatus->SetStatus(idet,2);
-       counter++;
-    }
-    
-    // installed supermodules+1 -> abort
-    if(counter > (7+1)*30) {
-      printf("ERROR: more than one SM to be masked!! \n Abort...\n");
-      delete projch;
-      return 0x0;
-    }
-
-    delete projch;
-
-  }
-  return CalChamberStatus;
-}
index ae4c0d7..4a2370c 100644 (file)
@@ -32,7 +32,8 @@ public:
       kT0PHPad = 4,
       kVdriftLinear = 5,
       kLorentzLinear = 6,
-      kPRF = 7
+      kChamberStatus = 7,
+      kPRF = 8
       };   
   
   AliTRDPreprocessorOffline();
@@ -53,6 +54,7 @@ public:
   void CalibVdriftT0(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage="");
   void CalibGain(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber,  TString  ocdbStorage="");
   void CalibPRF(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber,  TString  ocdbStorage="");
+  void CalibChamberStatus(Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage="");
 
   Bool_t ReadGainGlobal(const Char_t* fileName="CalibObjects.root");
   Bool_t ReadVdriftT0Global(const Char_t* fileName="CalibObjects.root");
@@ -62,20 +64,23 @@ public:
   Bool_t AnalyzeGain(); 
   Bool_t AnalyzeVdriftT0(); 
   Bool_t AnalyzeVdriftLinearFit(); 
-  Bool_t AnalyzePRF(); 
+  Bool_t AnalyzePRF();
+  Bool_t AnalyzeChamberStatus(); 
   
   void CorrectFromDetGainUsed();
   void CorrectFromDetVdriftUsed();
-
+  
   void UpdateOCDBT0(Int_t startRunNumber, Int_t endRunNumber, const char* storagePath);
   void UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const char* storagePath);
   void UpdateOCDBGain(Int_t  startRunNumber, Int_t endRunNumber, const char* storagePath);
   void UpdateOCDBPRF(Int_t  startRunNumber, Int_t endRunNumber, const char* storagePath);
+  void UpdateOCDBChamberStatus(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath);
 
   Bool_t ValidateGain() const;
   Bool_t ValidateVdrift();
   Bool_t ValidateT0();
   Bool_t ValidatePRF() const;
+  Bool_t ValidateChamberStatus() const;
 
   Int_t    GetVersionGainUsed() const                                { return fVersionGainUsed;        }
   Int_t    GetSubVersionGainUsed() const                             { return fSubVersionGainUsed;     }
@@ -87,7 +92,7 @@ public:
   void     SetMinStatsGain(Int_t minStatsGain)                       { fMinStatsGain = minStatsGain; }  
   void     SetMinStatsPRF(Int_t minStatsPRF)                         { fMinStatsPRF = minStatsPRF; }  
 
-  AliTRDCalChamberStatus *ProduceChamberStatus();
   
  private:
   Bool_t fMethodSecond;                      // Second Method for drift velocity   
@@ -128,3 +133,4 @@ private:
 
 #endif
 
+
index 082181e..37058df 100644 (file)
@@ -171,6 +171,43 @@ Double_t AliTRDCalDet::GetRMS(AliTRDCalDet * const outlierDet) const
   return mean;
 }
 
+//____________________________________________________________________________________________
+Double_t AliTRDCalDet::GetRMSRobust(Double_t robust) const
+{
+  //
+  // Calculate the robust RMS
+  //
+
+  // sorted
+  Int_t *index = new Int_t[kNdet];
+  TMath::Sort((Int_t)kNdet,fData,index);
+  // reject
+  Double_t reject = (Int_t) (kNdet*(1-robust)/2.0);
+  if(reject <= 0.0) reject = 0.0;
+  if(reject >= kNdet) reject = 0.0;
+  //printf("Rejecter %f\n",reject);
+
+  Double_t *ddata = new Double_t[kNdet];
+  Int_t nPoints = 0;
+  for (Int_t i=0;i<kNdet;i++) {
+    Bool_t rej = kFALSE;
+    for(Int_t k = 0; k < reject; k++){
+      if(i==index[k]) rej = kTRUE;
+      if(i==index[kNdet-(k+1)]) rej  = kTRUE;
+    }
+    if(!rej){
+      ddata[nPoints]= fData[i];
+      nPoints++;
+    }
+  }
+  //printf("Number of points %d\n",nPoints);
+  Double_t mean = TMath::RMS(nPoints,ddata);
+  delete [] ddata;
+  delete [] index;
+  return mean;
+}
+
 //______________________________________________________________________________________________
 Double_t AliTRDCalDet::GetLTM(Double_t *sigma
                             , Double_t fraction
@@ -491,3 +528,5 @@ void AliTRDCalDet::Divide(const AliTRDCalDet * calDet)
        }
     }
 }
+
+
index 49bf8e9..5fb1496 100644 (file)
@@ -43,6 +43,7 @@ class AliTRDCalDet : public TNamed {
   // statistic
   Double_t GetMean(AliTRDCalDet * const outlierDet=0) const;
   Double_t GetRMS(AliTRDCalDet * const outlierDet=0) const;
+  Double_t GetRMSRobust(Double_t robust=0.92) const;
   Double_t GetMedian(AliTRDCalDet * const outlierDet=0) const;
   Double_t GetLTM(Double_t * sigma=0, Double_t fraction=0.9, AliTRDCalDet * const outlierDet=0);     
 
@@ -68,3 +69,4 @@ class AliTRDCalDet : public TNamed {
 };
 
 #endif
+