Implementation of DeadMap
authorcheynis <cheynis@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 23 Oct 2009 09:55:12 +0000 (09:55 +0000)
committercheynis <cheynis@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 23 Oct 2009 09:55:12 +0000 (09:55 +0000)
VZERO/AliVZEROCalibData.cxx
VZERO/AliVZEROCalibData.h
VZERO/AliVZERODataDCS.cxx
VZERO/AliVZERODataDCS.h
VZERO/AliVZEROPreprocessor.cxx
VZERO/AliVZEROReconstructor.cxx
VZERO/AliVZEROReconstructor.h
VZERO/DBStorageCalib.C
VZERO/VZEROTestPreprocessor.C

index 135faf4..be76d17 100644 (file)
@@ -146,6 +146,13 @@ void AliVZEROCalibData::SetWidthHV(Float_t* WidthHV)
   else for(int t=0; t<64; t++) fWidthHV[t] = 0.0;
 }
 
+//________________________________________________________________
+void AliVZEROCalibData::SetDeadMap(Bool_t* deadMap) 
+{
+  if(deadMap) for(int t=0; t<64; t++) fDeadChannel[t] = deadMap[t];
+  else for(int t=0; t<64; t++) fDeadChannel[t] = kFALSE;
+}
+
 //________________________________________________________________
 void AliVZEROCalibData::SetGain(Float_t* Gain) 
 {
index a5ae1e0..7b3ff73 100644 (file)
@@ -35,6 +35,8 @@ class AliVZEROCalibData: public TNamed {
   Float_t* GetMeanHV()   const {return (float*)fMeanHV;} 
   Float_t  GetWidthHV(Int_t channel)   const {return fWidthHV[channel];}
   Float_t* GetWidthHV()   const {return (float*)fWidthHV;}
+  Bool_t   IsChannelDead(Int_t channel)        const {return fDeadChannel[channel];}
+  Bool_t*  GetDeadMap()   const {return (bool*)fDeadChannel;} 
    
   Float_t  GetGain(Int_t channel)      const {return fGain[channel];}
   Float_t* GetGain()   const {return (float*)fGain;}  
@@ -55,6 +57,8 @@ class AliVZEROCalibData: public TNamed {
   void     SetMeanHV(Float_t* MeanHV);  
   void     SetWidthHV(Float_t val, Int_t channel) {fWidthHV[channel]=val;}
   void     SetWidthHV(Float_t* WidthHV); 
+  void     SetDeadChannel(Bool_t val, Int_t channel) {fDeadChannel[channel]=val;}
+  void     SetDeadMap(Bool_t* deadMap);  
    
   void            SetGain(Float_t val, Int_t channel) {fGain[channel]=val;}
   void            SetGain(Float_t* Gain);  
@@ -76,8 +80,9 @@ class AliVZEROCalibData: public TNamed {
   Float_t  fGain[128];        // Gain factor used in digitization only  
   Float_t  fTimeOffset[64];
   Float_t  fTimeGain[64];
+  Bool_t   fDeadChannel[64];
 
-  ClassDef(AliVZEROCalibData,2)    // VZERO Calibration data
+  ClassDef(AliVZEROCalibData,3)    // VZERO Calibration data
 };
 
 #endif
index c9113cc..2e41d0d 100644 (file)
@@ -49,6 +49,7 @@ AliVZERODataDCS::AliVZERODataDCS():
        fIsProcessed(kFALSE)
 {
   // Default constructor
+  for(int i=0;i<kNHvChannel;i++) fDeadChannel[i] = kFALSE;
 }
 
 //_____________________________________________________________________________
@@ -62,6 +63,7 @@ AliVZERODataDCS::AliVZERODataDCS(Int_t nRun, UInt_t startTime, UInt_t endTime):
 {
 
   // constructor with arguments
+       for(int i=0;i<kNHvChannel;i++) fDeadChannel[i] = kFALSE;
 
        AliInfo(Form("\n\tRun %d \n\tStartTime %s \n\tEndTime %s", nRun,
        TTimeStamp(startTime).AsString(),
@@ -116,9 +118,14 @@ void AliVZERODataDCS::ProcessData(TMap& aliasMap){
     UInt_t iValue=0;
     while((aValue = (AliDCSValue*) iterarray.Next())) {
                values[iValue] = aValue->GetFloat();
+               if(iValue>0) {
+                       Float_t variation ;
+                       if(values[iValue-1]>0.) variation = TMath::Abs(values[iValue]-values[iValue-1])/values[iValue-1];
+                       if(variation > 0.10) fDeadChannel[GetOfflineChannel(iAlias)] = kTRUE;
+               }
                times[iValue] = (Double_t) (aValue->GetTimeStamp());
                fHv[iAlias]->Fill(values[iValue]);
-               printf("%s %f\n",fAliasNames[iAlias].Data(),values[iValue]);
+               printf("%s %f Dead=%d\n",fAliasNames[iAlias].Data(),values[iValue],fDeadChannel[GetOfflineChannel(iAlias)]);
                iValue++;
     }      
     CreateGraph(iAlias, aliasArr->GetEntries(), times, values); // fill graphs 
index 578ba76..b0b2c3f 100644 (file)
@@ -20,7 +20,7 @@ class TH1F;
 
 class AliVZERODataDCS : public TObject {
 public:
-  enum {kNAliases=64,kNGraphs=64};
+  enum {kNAliases=64,kNGraphs=64,kNHvChannel=64,kNLvChannel=16};
   enum {kHvMin=0, kHvMax=2000};
   
   AliVZERODataDCS();
@@ -43,6 +43,7 @@ public:
   
   Float_t* GetMeanHV()    const {return (float*)fMeanHV;}
   Float_t* GetWidthHV()   const {return (float*)fWidthHV;}
+  Bool_t * GetDeadMap()   const {return (bool*)fDeadChannel;}
 
 // Getter of Offline Channel number as used in aliroot (defined by aliroot 
 // numbering convention) from DCS Channel number
@@ -73,13 +74,14 @@ private:
   
   TString fAliasNames[kNAliases];        // aliases for DCS data
   TClonesArray fGraphs;                         // Array containing  graphics
-  TH1F *fHv[kNAliases];                  // High Voltage histograms
-  Float_t fMeanHV[kNAliases];            // High Voltage mean values
-  Float_t fWidthHV[kNAliases];           // High Voltage widths
+  TH1F *fHv[kNHvChannel];                  // High Voltage histograms
+  Float_t fMeanHV[kNHvChannel];            // High Voltage mean values
+  Float_t fWidthHV[kNHvChannel];           // High Voltage widths
+  Bool_t  fDeadChannel[kNHvChannel];       // Dead Map 
+  
   Bool_t fIsProcessed;                   // bool to know processing status
   
-  ClassDef(AliVZERODataDCS, 2);
+  ClassDef(AliVZERODataDCS, 3);
 };
 
 #endif
index 379c66c..d18258f 100644 (file)
@@ -105,7 +105,8 @@ UInt_t AliVZEROPreprocessor::Process(TMap* dcsAliasMap)
        // Writes VZERO PMs HV values into VZERO calibration object
        calibData->SetMeanHV(fData->GetMeanHV());
        calibData->SetWidthHV(fData->GetWidthHV());
-    
+       calibData->SetDeadMap(fData->GetDeadMap());
+          
    // *************** From DAQ ******************
    
        TString sourcesId = "V00da_results";
index ef21723..0e57b4b 100644 (file)
@@ -160,9 +160,14 @@ void AliVZEROReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digits
 
      // Channels(aliroot numbering) will be ordered in the tree
      for(Int_t iChannel = 0; iChannel < 64; iChannel++) {
+         if(fCalibData->IsChannelDead(iChannel)){
+           adc[iChannel]  = (Float_t) kInvalidADC; 
+           time[iChannel] = (Float_t) kInvalidTime;     
+         }
          new ((*digitsArray)[digitsArray->GetEntriesFast()])
              AliVZEROdigit(iChannel, adc[iChannel], time[iChannel],
                           width[iChannel], BBFlag[iChannel], BGFlag[iChannel],integrator[iChannel]);
+        
      }          
      digitsTree->Fill();
   }
index 0ee2c61..59a03c9 100644 (file)
@@ -51,6 +51,9 @@ public:
   AliVZEROCalibData *GetCalibData() const; 
   AliVZEROTriggerData *GetTriggerData() const; 
 
+  enum {kInvalidADC   =  -1024,
+        kInvalidTime  =  -1};
+
 protected:
   AliESDVZERO*        fESDVZERO;       // ESD output object  
   AliESDEvent*             fESD;       // ESD object
@@ -65,7 +68,7 @@ private:
 
   Int_t              fCollisionMode;  // =0->p-p, =1->A-A
   Float_t            fBeamEnergy;     // beam energy
-  
+    
   ClassDef(AliVZEROReconstructor, 0)  // class for the VZERO reconstruction
 };
 
index a7f02c4..91b2b15 100644 (file)
@@ -100,6 +100,17 @@ Float_t WidthHVs[64] =
   
 calibda->SetWidthHV(WidthHVs);
 
+Bool_t DeadChannels[64] =  
+{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0 };
+  
+calibda->SetDeadMap(DeadChannels);
+
 Float_t GainFactors[128] =
 { 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0,
   50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 50.0, 
@@ -151,7 +162,7 @@ AliCDBId id("VZERO/Calib/Data",0,9999999);
 //set to AliVZEROCalibData by the CDB classes during storage 
 md->SetResponsible("Brigitte Cheynis");
 md->SetBeamPeriod(0);
-md->SetAliRootVersion("August 2008");
+md->SetAliRootVersion("October 2009");
 md->SetComment("Prototype");
 md->PrintMetaData();
 
index 5ac778d..09890d3 100644 (file)
@@ -163,7 +163,7 @@ TMap* CreateDCSAliasMap()
                valueSet->Add(dcsVal);
                
                if(aliasName.Contains("HV")) {
-                       dcsVal = new AliDCSValue((Float_t) (val+random.Gaus(0,10)), timeStamp+10);
+                       dcsVal = new AliDCSValue((Float_t) (val+random.Gaus(0,100)), timeStamp+10);
                        valueSet->Add(dcsVal);
                }