Adding the possibility to histogram at manu level (when channels are disabled), and...
authorlaphecet <laphecet@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 4 Jul 2008 16:09:08 +0000 (16:09 +0000)
committerlaphecet <laphecet@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 4 Jul 2008 16:09:08 +0000 (16:09 +0000)
MUON/AliMUONPainterPlotSelector.cxx
MUON/AliMUONTrackerData.cxx
MUON/AliMUONTrackerData.h
MUON/AliMUONTrackerDataHistogrammer.cxx
MUON/AliMUONVPainter.cxx
MUON/AliMUONVTrackerData.h

index a5bf778..7b54490 100644 (file)
@@ -585,6 +585,13 @@ AliMUONPainterPlotSelector::UpdateTypeButton()
                { 
                        padButton->SetEnabled(fCurrentData->IsChannelLevelEnabled());
                }
+               TGTextButton* manuButton = static_cast<TGTextButton*>
+               (AliMUONPainterInterfaceHelper::FindButtonByName(*fTypes,"MANU"));
+               if (manuButton) 
+               { 
+                       manuButton->SetEnabled(fCurrentData->IsManuLevelEnabled());
+               }
+    
        }
        
   TGTextButton* button = static_cast<TGTextButton*>
index 56c7bf1..9d26be3 100644 (file)
@@ -72,10 +72,11 @@ fDimensionNames(new TObjArray(fDimension+fgkVirtualExtraDimension)),
 fExternalDimensionNames(new TObjArray(dimension)),
 fExternalDimension(dimension),
 fHistogramming(new Int_t[fExternalDimension]),
-fChannelHistos(0x0),
+fHistos(0x0),
 fXmin(0.0),
 fXmax(0.0),
-fIsChannelLevelEnabled(kTRUE)
+fIsChannelLevelEnabled(kTRUE),
+fIsManuLevelEnabled(kTRUE)
 {  
   /// ctor
   memset(fHistogramming,0,sizeof(Int_t)); // histogramming is off by default. Use MakeHistogramForDimension to turn it on.
@@ -100,7 +101,7 @@ AliMUONTrackerData::~AliMUONTrackerData()
   delete fDimensionNames;
   delete fExternalDimensionNames;
   delete[] fHistogramming;
-  delete fChannelHistos;
+  delete fHistos;
 }
 
 //_____________________________________________________________________________
@@ -162,7 +163,10 @@ AliMUONTrackerData::InternalAdd(const AliMUONVStore& store, Bool_t replace)
                {
                        fChannelValues = new AliMUON2DMap(kTRUE);
                }
-    fManuValues = new AliMUON2DMap(kTRUE);
+    if  ( fIsManuLevelEnabled ) 
+    {
+      fManuValues = new AliMUON2DMap(kTRUE);
+    }
     fPCBValues = new AliMUON2DMap(kFALSE);
     fBusPatchValues = new AliMUON1DMap(numberOfBusPatches);
     fDEValues = new AliMUON1DMap(numberOfDEs);
@@ -227,7 +231,7 @@ AliMUONTrackerData::InternalAdd(const AliMUONVStore& store, Bool_t replace)
           
           if ( IsHistogrammed(j) )
           {
-            FillChannel(detElemId,manuId,i,j,vext);
+            FillHisto(detElemId,manuId,i,j,vext);
           }
           
           for ( Int_t k = 0; k < nk; ++k ) 
@@ -239,7 +243,10 @@ AliMUONTrackerData::InternalAdd(const AliMUONVStore& store, Bool_t replace)
                                                        channel->SetValueAsDoubleFast(i,ix+k,channel->ValueAsDoubleFast(i,ix+k)-e+value[k]);
                                                }
                                                
-            manu->SetValueAsDoubleFast(0,ix+k,manu->ValueAsDoubleFast(0,ix+k)-e+value[k]);            
+            if (manu)
+            {
+              manu->SetValueAsDoubleFast(0,ix+k,manu->ValueAsDoubleFast(0,ix+k)-e+value[k]);            
+            }
             
             busPatch->SetValueAsDoubleFast(0,ix+k,busPatch->ValueAsDoubleFast(0,ix+k)-e+value[k]);
             
@@ -262,8 +269,12 @@ AliMUONTrackerData::InternalAdd(const AliMUONVStore& store, Bool_t replace)
                                                                                                                                                                        channel->ValueAsDoubleFast(i,IndexOfOccupancyDimension())+1.0);
                                        }
                                        
-          manu->SetValueAsDoubleFast(0,IndexOfOccupancyDimension(),
-                                                 manu->ValueAsDoubleFast(0,IndexOfOccupancyDimension())+1.0);        
+          if (manu)
+          {
+            manu->SetValueAsDoubleFast(0,IndexOfOccupancyDimension(),
+                                       manu->ValueAsDoubleFast(0,IndexOfOccupancyDimension())+1.0);        
+          }
+          
           busPatch->SetValueAsDoubleFast(0,IndexOfOccupancyDimension(),
                                                          busPatch->ValueAsDoubleFast(0,IndexOfOccupancyDimension())+1.0);        
           de->SetValueAsDoubleFast(0,IndexOfOccupancyDimension(),
@@ -459,7 +470,7 @@ AliMUONTrackerData::Clear(Option_t*)
   if ( fPCBValues ) fPCBValues->Clear();
   if ( fDEValues) fDEValues->Clear();
   if ( fChamberValues ) fChamberValues->Clear();
-  if ( fChannelHistos ) fChannelHistos->Clear();
+  if ( fHistos ) fHistos->Clear();
   fNevents = 0;
   NumberOfEventsChanged();
 }
@@ -589,6 +600,18 @@ AliMUONTrackerData::DisableChannelLevel()
 }
 
 //_____________________________________________________________________________
+void 
+AliMUONTrackerData::DisableManuLevel()
+{ 
+  /// Disable the storing of data at manu level (and below)
+  
+  DisableChannelLevel();
+  delete fManuValues;
+  fManuValues = 0x0;
+  fIsManuLevelEnabled = kFALSE; 
+}
+
+//_____________________________________________________________________________
 Int_t 
 AliMUONTrackerData::External2Internal(Int_t index) const 
 {
@@ -615,28 +638,86 @@ AliMUONTrackerData::ExternalDimensionName(Int_t dim) const
 
 //_____________________________________________________________________________
 void
-AliMUONTrackerData::FillChannel(Int_t detElemId, Int_t manuId, Int_t manuChannel,
-                                Int_t dim, Double_t value)
+AliMUONTrackerData::FillHisto(Int_t detElemId, Int_t manuId, Int_t manuChannel,
+                              Int_t dim, Double_t value)
 {
   /// Fill histogram of a given channel
   
+  AliMUONSparseHisto* h(0x0);
+  
        if ( fIsChannelLevelEnabled ) 
        {
-               AliMUONSparseHisto* h = GetChannelSparseHisto(detElemId, manuId, manuChannel,dim);
+               h = GetChannelSparseHisto(detElemId, manuId, manuChannel,dim);
+  }
+  else if ( fIsManuLevelEnabled ) 
+  {
+    h = GetManuSparseHisto(detElemId,manuId,dim);
+  }
+  
+  AliDebug(1,Form("DE %04d MANU %04d CH %02d dim %d value %e h %p",detElemId,manuId,manuChannel,dim,value,h));
+  
+  if (h)
+  {
                h->Fill(static_cast<Int_t>(TMath::Nint(value)));
        }
 }
 
 //_____________________________________________________________________________
 AliMUONSparseHisto*
+AliMUONTrackerData::GetManuSparseHisto(Int_t detElemId, Int_t manuId, 
+                                       Int_t dim) const
+{
+  /// Get histogram of a given manu
+  
+  if (!fHistos) return 0x0;
+  
+  AliMUON1DArray* m = static_cast<AliMUON1DArray*>(fHistos->FindObject(detElemId,manuId));
+  if (!m) return 0x0;
+  
+  AliMUONSparseHisto* h = static_cast<AliMUONSparseHisto*>(m->FindObject(dim));
+  
+  return h;
+}
+
+//_____________________________________________________________________________
+AliMUONSparseHisto*
+AliMUONTrackerData::GetManuSparseHisto(Int_t detElemId, Int_t manuId, Int_t dim)
+{
+  /// Get histogram of a given manu. Create it if necessary
+  
+  if (!fHistos) fHistos = new AliMUON2DMap(kTRUE);
+  
+  AliMUON1DArray* m = static_cast<AliMUON1DArray*>(fHistos->FindObject(detElemId,manuId));
+  if (!m)
+  {
+    m = new AliMUON1DArray(NumberOfDimensions());
+    m->SetUniqueID( ( manuId << 16 ) | detElemId );
+    fHistos->Add(m);
+  }
+    
+  AliMUONSparseHisto* h = static_cast<AliMUONSparseHisto*>(m->FindObject(dim));
+  if (!h)
+  {
+    h = new AliMUONSparseHisto(fXmin,fXmax);
+    
+    h->SetUniqueID(dim);
+    
+    m->Add(h);
+  }
+  
+   return h;
+}
+
+//_____________________________________________________________________________
+AliMUONSparseHisto*
 AliMUONTrackerData::GetChannelSparseHisto(Int_t detElemId, Int_t manuId, 
                                           Int_t manuChannel, Int_t dim) const
 {
   /// Get histogram of a given channel
   
-  if (!fChannelHistos) return 0x0;
+  if (!fHistos) return 0x0;
   
-  AliMUON1DMap* m = static_cast<AliMUON1DMap*>(fChannelHistos->FindObject(detElemId,manuId));
+  AliMUON1DMap* m = static_cast<AliMUON1DMap*>(fHistos->FindObject(detElemId,manuId));
   if (!m) return 0x0;
   
   UInt_t uid = ( manuChannel << 16 ) | dim;
@@ -653,14 +734,14 @@ AliMUONTrackerData::GetChannelSparseHisto(Int_t detElemId, Int_t manuId,
 {
   /// Get histogram of a given channel. Create it if necessary
   
-  if (!fChannelHistos) fChannelHistos = new AliMUON2DMap(kTRUE);
+  if (!fHistos) fHistos = new AliMUON2DMap(kTRUE);
   
-  AliMUON1DMap* m = static_cast<AliMUON1DMap*>(fChannelHistos->FindObject(detElemId,manuId));
+  AliMUON1DMap* m = static_cast<AliMUON1DMap*>(fHistos->FindObject(detElemId,manuId));
   if (!m)
   {
     m = new AliMUON1DMap(AliMpConstants::ManuNofChannels()); // start with only 1 dim
     m->SetUniqueID( ( manuId << 16 ) | detElemId );
-    fChannelHistos->Add(m);
+    fHistos->Add(m);
   }
   
   UInt_t uid = ( manuChannel << 16 ) | dim;
@@ -920,11 +1001,16 @@ AliMUONTrackerData::Print(Option_t* wildcard, Option_t* opt) const
     cout << " Nevents=" << fNevents << endl;
   }
 
-       if ( fIsChannelLevelEnabled ) 
+       if ( !fIsChannelLevelEnabled ) 
+       {
+               cout << "Is not storing data at the channel level" << endl;
+       }
+
+  if ( !fIsManuLevelEnabled ) 
        {
-               cout << "Is storing (accumulated) data at the channel level" << endl;
+               cout << "Is not storing data at the manu level" << endl;
        }
-       
+  
   for ( Int_t i = 0; i <= fExternalDimensionNames->GetLast(); ++i ) 
   {
     TObjString* name = static_cast<TObjString*>(fExternalDimensionNames->At(i));
@@ -943,14 +1029,28 @@ AliMUONTrackerData::Print(Option_t* wildcard, Option_t* opt) const
   TString sopt(opt);
   sopt.ToUpper();
   
-  if ( sopt.Contains("CHANNEL") && fChannelValues ) 
+  if ( sopt.Contains("CHANNEL") )
   {
-    fChannelValues->Print(wildcard,opt);
+    if ( fIsChannelLevelEnabled ) 
+    {      
+      if ( fChannelValues ) fChannelValues->Print(wildcard,opt);
+    }
+    else
+    {
+      AliWarning("You requested channel values, but they were not stored !");
+    }
   }
 
-  if ( sopt.Contains("MANU") && fManuValues ) 
+  if ( sopt.Contains("MANU") )
   {
-    fManuValues->Print(wildcard,opt);
+    if ( fIsManuLevelEnabled ) 
+    {
+      if ( fManuValues ) fManuValues->Print(wildcard,opt);
+    }
+    else
+    {
+      AliWarning("You requested manu values, but they were not stored !");
+    }
   }
 
   if ( sopt.Contains("BUSPATCH") && fBusPatchValues ) 
index fac0d53..66e0498 100644 (file)
@@ -92,6 +92,12 @@ public:
   
   virtual void HistogramRange(Double_t& xmin, Double_t& xmax) const { xmin = fXmin; xmax = fXmax; }
 
+  AliMUONSparseHisto* GetManuSparseHisto(Int_t detElemId, Int_t manuId, 
+                                         Int_t dim=0);
+
+  AliMUONSparseHisto* GetManuSparseHisto(Int_t detElemId, Int_t manuId, 
+                                         Int_t dim=0) const;
+  
   AliMUONSparseHisto* GetChannelSparseHisto(Int_t detElemId, Int_t manuId, 
                                             Int_t manuChannel, Int_t dim=0);
   
@@ -104,10 +110,16 @@ public:
        /// Whether we store values at the channel level or not
        virtual Bool_t IsChannelLevelEnabled() const { return fIsChannelLevelEnabled; }
 
+  /// Disable storing values at the manu level
+       virtual void DisableManuLevel();
+       
+       /// Whether we store values at the manu level or not
+       virtual Bool_t IsManuLevelEnabled() const { return fIsManuLevelEnabled; }
+  
 private:
     
-  void FillChannel(Int_t detElemId, Int_t manuId, Int_t manuChannel,
-                   Int_t dim, Double_t value);
+  void FillHisto(Int_t detElemId, Int_t manuId, Int_t manuChannel,
+                 Int_t dim, Double_t value);
 
   AliMUONVCalibParam* BusPatchParam(Int_t busPatch, Bool_t create=kFALSE) const;
 
@@ -191,14 +203,15 @@ private:
   Int_t fExternalDimension; ///< number of interface values per item 
   /// whether we should histogram the dimension(s)
   Int_t* fHistogramming; //[fExternalDimension] whether we should histogram the dimension(s)
-  AliMUONVStore* fChannelHistos; ///< the channel histograms
+  AliMUONVStore* fHistos; ///< the lowest histograms we have
   Double_t fXmin; ///< min x value for histograms
   Double_t fXmax; ///< max x value for histograms
   static const Int_t fgkExtraDimension; ///< to hold extra information
   static const Int_t fgkVirtualExtraDimension; ///< to give access to information not stored, but computed on the fly
   Bool_t fIsChannelLevelEnabled; //< whether we allow storing of channel (fChannelValues) values
+  Bool_t fIsManuLevelEnabled; //< whether we allow storing of manu (fManuValues) values
        
-  ClassDef(AliMUONTrackerData,5) // Implementation of AliMUONVTrackerData
+  ClassDef(AliMUONTrackerData,6) // Implementation of AliMUONVTrackerData
 };
 
 #endif
index 734a99d..5079b4e 100644 (file)
@@ -128,22 +128,40 @@ AliMUONTrackerDataHistogrammer::AddManuHisto(TH1& h, Int_t detElemId, Int_t manu
   
   if ( fData.HasManu(detElemId,manuId) )
   {
-    for ( Int_t i = 0; i < AliMpConstants::ManuNofChannels(); ++i ) 
+    if ( fData.IsChannelLevelEnabled() )
     {
-      if ( fData.HasChannel(detElemId,manuId,i) )
+      for ( Int_t i = 0; i < AliMpConstants::ManuNofChannels(); ++i ) 
       {
-        if ( IsInternalMode() ) 
+        if ( fData.HasChannel(detElemId,manuId,i) )
         {
-          h.Fill(fData.Channel(detElemId,manuId,i,fInternalDim));
+          if ( IsInternalMode() ) 
+          {
+            h.Fill(fData.Channel(detElemId,manuId,i,fInternalDim));
+          }
+          else
+          {
+            AliMUONSparseHisto* sh = fData.GetChannelSparseHisto(detElemId,manuId,i,fExternalDim);
+            
+            if ( sh ) 
+            {       
+              Add(h,*sh);
+            }
+          }
         }
-        else
+      }
+    }
+    else
+    {
+      if ( IsInternalMode() ) 
+      {
+        h.Fill(fData.Manu(detElemId,manuId,fInternalDim));
+      }
+      else
+      {
+        AliMUONSparseHisto* sh = fData.GetManuSparseHisto(detElemId,manuId,fExternalDim);
+        if (sh)
         {
-          AliMUONSparseHisto* sh = fData.GetChannelSparseHisto(detElemId,manuId,i);
-        
-          if ( sh ) 
-          {       
-            Add(h,*sh);
-          }
+          Add(h,*sh);
         }
       }
     }
@@ -287,10 +305,13 @@ AliMUONTrackerDataHistogrammer::CreateHisto(const AliMUONVPainter& painter,
   }
   else
   {
-    AliErrorClass(Form("Could not create histo for painter %s external dim %d internal dim %d",
-                       painter.PathName().Data(),externalDim,internalDim));
+    AliErrorClass(Form("Could not create histo for painter %s (%p) data %s (%p) external dim %d internal dim %d",
+                       painter.PathName().Data(),&painter,
+                       data->GetName(),data,externalDim,internalDim));
   }
   
+  if (histo) histo->SetDirectory(gROOT);
+  
   return histo;
 }
 
index 807b2af..cdfe4c0 100644 (file)
@@ -933,7 +933,6 @@ AliMUONVPainter::SetData(const char* pattern, AliMUONVTrackerData* data,
   {
     TList* l = p->IsA()->GetMenuList();
   
-//    l->Clear();
     l->Delete();
   
     TClassMenuItem* n(0x0);
@@ -945,21 +944,22 @@ AliMUONVPainter::SetData(const char* pattern, AliMUONVTrackerData* data,
     
     if ( group )  
     {
-      Int_t dim = group->Data()->InternalToExternal(group->DataIndex());
-      if ( dim < group->Data()->ExternalDimension() )
-      {      
-        if ( data && data->IsHistogrammed(dim) ) 
-        {
-          // Add histo drawing to the popup menu
-          n = new TClassMenuItem(TClassMenuItem::kPopupUserFunction,p->IsA(),
-                                                 "Draw histogram","DrawHistogram0",p,"",-1,kTRUE);
-          l->Add(n);
-          
-          n = new TClassMenuItem(TClassMenuItem::kPopupUserFunction,p->IsA(),
-                                 "Draw histogram clone","DrawHistogramClone0",p,"",-1,kTRUE);
-          l->Add(n);
-        }
+      if ( data && data->IsHistogrammed(0) ) 
+      {
+        // Add histo drawing to the popup menu
+        TString name("Draw histogram of ");
+        
+        name += data->ExternalDimensionName(0);
+        
+        n = new TClassMenuItem(TClassMenuItem::kPopupUserFunction,p->IsA(),
+                               name.Data(),"DrawHistogram0",p,"",-1,kTRUE);
+        l->Add(n);
+        
+        name += " clone";
         
+        n = new TClassMenuItem(TClassMenuItem::kPopupUserFunction,p->IsA(),
+                               name.Data(),"DrawHistogramClone0",p,"",-1,kTRUE);
+        l->Add(n);
       }
       
       Int_t nd = data->IsSingleEvent() ? data->ExternalDimension() : data->ExternalDimension()*2;
index 469822e..19d4e35 100644 (file)
@@ -137,6 +137,10 @@ public:
   virtual AliMUONSparseHisto* GetChannelSparseHisto(Int_t detElemId, Int_t manuId, 
                                                     Int_t manuChannel, Int_t dim=0) const = 0;
 
+  /// Get sparse histogram for a given manu (valid only if IsChannelLevelEnabled()==kFALSE and IsManuLevelEnabled()==kTRUE)
+  virtual AliMUONSparseHisto* GetManuSparseHisto(Int_t detElemId, Int_t manuId, 
+                                                 Int_t dim=0) const = 0;
+  
   /// To allow merging of different objects
   virtual Long64_t Merge(TCollection* list) = 0;
 
@@ -145,7 +149,13 @@ public:
        
        /// Whether we store values at the channel level
        virtual Bool_t IsChannelLevelEnabled() const = 0;
+
+  /// Disable recording of information at the manu level (and below)
+       virtual void DisableManuLevel() = 0;
        
+       /// Whether we store values at the channel level
+       virtual Bool_t IsManuLevelEnabled() const = 0;
+  
 private:
   /// not implemented
   AliMUONVTrackerData(const AliMUONVTrackerData& rhs);