Changes in STEER:
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 7 Jul 2009 14:09:43 +0000 (14:09 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 7 Jul 2009 14:09:43 +0000 (14:09 +0000)
      * If the number of detectors is set to 0 (zero) in AliFMDMap, it
        will assume that the data contained is 51,200 entries -
        corresponding exactly to the number of channels in the FMD.
        This is the default mode of operation for most maps - in
        particular the multiplicity map of AliESDFMD.   Before, one
        would specify 3 detectors, 2 rings, 40 sectors, and 512 strips,
        resulting in 3*2*40*512=122880 entries - or 71680 entries that
        would never be used.  This change will effectively more than
        half the amount of memory used by AliESDFMD.
      * Implemented the member function AliFMDMap::CalcCoords to go from
        array index to detector coordinates
        (detector,ring,sector,strip).
      * Implemented *=, /=, +=, and -= between AliFMDMap objects, and
        *, /, +, and - operators that return an AliFMDFloatMap object.
        The implementation will access the contained arrays sequentially
        for optimal speed (unrolled nested loops).   This would allow us
        to the ADC->Energy conversion like

                energy = (adc - pedestal) * gain

        where energy, adc, pedestal, and gain are all AliFMDFloatMap
        objects.  Special care is taken if the maps do not have the same
        dimensions.
      * Implemented AliFMDMap::ForEach that takes an object of a
        sub-class of AliFMDMap::ForOne and applies the relevant
        functional operator to each element.  The internal array is
        accessed sequentially for optimal speed (unrolled nested
        loops).
      * Define AliESDFMD::ForEach that will loop over all entries and
        apply the functional operator of the supplied object of a
        sub-class of AliESDFMD::ForOne to each element in turn.  The
        loop is unrolled.

Changes in FMD:

      * AliFMD***Map now defaults to construct with exactly 51200
        entries.  Maps with fewer entries can still be made (like
        before) by explicit use of constructor arguments.
      * Calibration and digitizer code constructs AliFMD***Map with
        minimal sizes needed.

These changes committed by Peter HRISTOV on behalf of Christian Holm
Christensen.

19 files changed:
FMD/AliFMDAltroMapping.h
FMD/AliFMDBackgroundCorrection.cxx
FMD/AliFMDBackgroundCorrection.h
FMD/AliFMDBaseDigitizer.cxx
FMD/AliFMDBoolMap.cxx
FMD/AliFMDBoolMap.h
FMD/AliFMDCalibGain.cxx
FMD/AliFMDCalibPedestal.cxx
FMD/AliFMDEdepMap.cxx
FMD/AliFMDEdepMap.h
FMD/AliFMDUShortMap.cxx
FMD/AliFMDUShortMap.h
STEER/AliESDFMD.cxx
STEER/AliESDFMD.h
STEER/AliFMDFloatMap.cxx
STEER/AliFMDFloatMap.h
STEER/AliFMDMap.cxx
STEER/AliFMDMap.h
STEER/ESDLinkDef.h

index 272f35c..83b1a87 100644 (file)
 #ifndef ALIALTROMAPPING_H
 # include <AliAltroMapping.h>
 #endif
-#ifndef ALIFMDUSHORTMAP_H
-# include "AliFMDUShortMap.h"
-#endif
-#ifndef ROOT_TArrayI
-# include <TArrayI.h>
-#endif
 //
 // Map hardware address to detector coordinates. 
 //
@@ -90,44 +84,9 @@ public:
                     UShort_t preSamples, UShort_t  sampleRate, 
                     Short_t& strip,      UShort_t& sample) const;
 
-#if 0  
-  /** Map a hardware address into a detector index. 
-      @param hwaddr Hardware address.  
-      @param ring   On return, the ring ID
-      @param sec    On return, the sector #
-      @param str    On return, the base of strip #
-      @return @c true on success, false otherwise */
-  Bool_t Hardware2Detector(UInt_t    hwaddr, 
-                          Char_t&   ring, UShort_t& sec, Short_t& str) const;
   /** Map a hardware address into a detector index. 
       @param ddl    Hardware DDL number 
       @param hwaddr Hardware address.  
-      @param det    On return, the detector #
-      @param ring   On return, the ring ID
-      @param sec    On return, the sector #
-      @param str    On return, the base of strip #
-      @return @c true on success, false otherwise */
-  Bool_t Hardware2Detector(UInt_t    ddl, UInt_t    hwaddr, 
-                          UShort_t& det, Char_t&   ring, 
-                          UShort_t& sec, Short_t& str) const;
-  /** Map a hardware address into a detector index. 
-      @param ddl     Hardware DDL number 
-      @param board   FEC number
-      @param altro   ALTRO number 
-      @param channel Channel number 
-      @param det     On return, the detector #
-      @param ring    On return, the ring ID
-      @param sec     On return, the sector #
-      @param str     On return, the base of strip #
-      @return @c true on success, false otherwise */
-  Bool_t Hardware2Detector(UInt_t    ddl,   UInt_t    board, 
-                          UInt_t    altro, UInt_t    channel,
-                          UShort_t& det,   Char_t&   ring, 
-                          UShort_t& sec,   Short_t&  str) const;
-#endif
-  /** Map a hardware address into a detector index. 
-      @param ddl        Hardware DDL number 
-      @param hwaddr     Hardware address.  
       @param timebin    Timebin 
       @param preSamples # of pre samples 
       @param sampleRate Over sampling rate 
@@ -198,38 +157,11 @@ public:
                         UShort_t sam, UShort_t preSamples, 
                         UShort_t sampleRate) const;
   
-#if 0  
   /** Map a detector index into a hardware address. 
       @param det     The detector #
       @param ring    The ring ID
       @param sec     The sector #
       @param str     The strip #
-      @param ddl     On return, hardware DDL number 
-      @param board   On return, the FEC board address (local to DDL)
-      @param altro   On return, the ALTRO number (local to FEC)
-      @param channel On return, the channel number (local to ALTRO)
-      @return @c true on success, false otherwise */
-  Bool_t Detector2Hardware(UShort_t  det,   Char_t    ring, 
-                          UShort_t  sec,   UShort_t  str,
-                          UShort_t& ddl,   UShort_t& board, 
-                          UShort_t& altro, UShort_t& channel) const;
-  /** Map a detector index into a hardware address. 
-      @param det    The detector #
-      @param ring   The ring ID
-      @param sec    The sector #
-      @param str    The strip #
-      @param ddl    On return, hardware DDL number 
-      @param hwaddr On return, hardware address.  
-      @return @c true on success, false otherwise */
-  Bool_t Detector2Hardware(UShort_t  det, Char_t    ring, 
-                          UShort_t  sec, UShort_t  str,
-                          UShort_t& ddl, UShort_t&   hwaddr) const;
-#endif
-  /** Map a detector index into a hardware address. 
-      @param det         The detector #
-      @param ring        The ring ID
-      @param sec         The sector #
-      @param str         The strip #
       @param sam         The sample number 
       @param preSamples  Number of pre-samples
       @param sampleRate  The oversampling rate 
index c03de12..906c5e3 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-// Thil class computes background corrections for the FMD. The correction is computed 
-// in eta,phi cells and the objects stored can be put into alien to use with analysis.
-// It is based on the AliFMDInput class that is used to loop over hits and primaries.
+// Thil class computes background corrections for the FMD. The
+// correction is computed in eta,phi cells and the objects stored can
+// be put into alien to use with analysis.  It is based on the
+// AliFMDInput class that is used to loop over hits and primaries.
 //
 // Author: Hans Hjersing Dalsgaard, NBI, hans.dalsgaard@cern.ch
 //
@@ -66,14 +67,14 @@ AliFMDBackgroundCorrection::AliFMDBackgroundCorrection() :
 {} 
 
 //_____________________________________________________________________
-AliFMDBackgroundCorrection::AliFMDInputBG::AliFMDInputBG(Bool_t hits_not_trackref) : 
-  AliFMDInput("galice.root"),
+AliFMDBackgroundCorrection::AliFMDInputBG::AliFMDInputBG(Bool_t hits_not_trackref) 
+  : AliFMDInput("galice.root"),
   fPrimaryArray(),
   fHitArray(),
   fPrimaryMapInner(),
   fPrimaryMapOuter(),
-  fHitMap(),
-  fLastTrackByStrip(),
+    fHitMap(0),           // nDetector=0 means 51200 slots
+    fLastTrackByStrip(0), // nDetector=0 means 51200 slots
   fPrim(0),
   fHits(0),
   fZvtxCut(0),
@@ -84,7 +85,6 @@ AliFMDBackgroundCorrection::AliFMDInputBG::AliFMDInputBG(Bool_t hits_not_trackre
   fPrevSec(-1),
   fNbinsEta(100)
 {
-
   if(hits_not_trackref) {
     AddLoad(kHits);
     AddLoad(kTracks); 
@@ -93,13 +93,12 @@ AliFMDBackgroundCorrection::AliFMDInputBG::AliFMDInputBG(Bool_t hits_not_trackre
     AddLoad(kTrackRefs);
   AddLoad(kKinematics); 
   AddLoad(kHeader);
-  
-  
 }
 
 //_____________________________________________________________________
 
-void AliFMDBackgroundCorrection::GenerateBackgroundCorrection(Bool_t from_hits,
+void 
+AliFMDBackgroundCorrection::GenerateBackgroundCorrection(Bool_t from_hits,
                                                              const Int_t nvtxbins,
                                                              Float_t zvtxcut, 
                                                              const Int_t nBinsEta, 
@@ -110,8 +109,8 @@ void AliFMDBackgroundCorrection::GenerateBackgroundCorrection(Bool_t from_hits,
                                                              Bool_t simulate,
                                                              Int_t nEvents,
                                                              Bool_t inFile,
-                                                             const Char_t* infilename) {
-  
+                                                        const Char_t* infilename) 
+{
   //TGrid::Connect("alien:",0,0,"t");
   if(simulate)
     Simulate(nEvents);
@@ -151,7 +150,8 @@ void AliFMDBackgroundCorrection::GenerateBackgroundCorrection(Bool_t from_hits,
     input.Run();
   }
   
-  AliInfo(Form("Found %d primaries and %d hits.", input.GetNprim(),input.GetNhits()));
+  AliInfo(Form("Found %d primaries and %d hits.", 
+              input.GetNprim(),input.GetNhits()));
   TObjArray* hitArray ;
   TObjArray* primaryArray;
   if(inFile) {
@@ -159,30 +159,27 @@ void AliFMDBackgroundCorrection::GenerateBackgroundCorrection(Bool_t from_hits,
     hitArray     = new TObjArray();
     primaryArray = new TObjArray();
     
-    for(Int_t det =1; det<=3;det++)
-      {
+    for(Int_t det =1; det<=3;det++) {
        TObjArray* detArrayHits = new TObjArray();
        detArrayHits->SetName(Form("FMD%d",det));
        hitArray->AddAtAndExpand(detArrayHits,det);
        Int_t nRings = (det==1 ? 1 : 2);
-       for(Int_t ring = 0;ring<nRings;ring++)
-         {
-           
+      for(Int_t ring = 0;ring<nRings;ring++) {
            Char_t ringChar = (ring == 0 ? 'I' : 'O');
            TObjArray* vtxArrayHits = new TObjArray();
            vtxArrayHits->SetName(Form("FMD%d%c",det,ringChar));
            detArrayHits->AddAtAndExpand(vtxArrayHits,ring);
-           for(Int_t v=0; v<nvtxbins;v++)
-             {
+       for(Int_t v=0; v<nvtxbins;v++) {
              
-               TH2F* hHits          = (TH2F*)infile->Get(Form("hHits_FMD%d%c_vtx%d",det,ringChar,v));
+         TH2F* hHits = 
+           static_cast<TH2F*>(infile->Get(Form("hHits_FMD%d%c_vtx%d",
+                                               det,ringChar,v)));
                
                
              vtxArrayHits->AddAtAndExpand(hHits,v);
                      
            } 
        }
-      
     }
     
     for(Int_t iring = 0; iring<2;iring++) {
@@ -192,7 +189,9 @@ void AliFMDBackgroundCorrection::GenerateBackgroundCorrection(Bool_t from_hits,
       primaryArray->AddAtAndExpand(ringArray,iring);
       for(Int_t v=0; v<nvtxbins;v++) {
        
-       TH2F* hPrimary       = (TH2F*)infile->Get(Form("hPrimary_FMD_%c_vtx%d",ringChar,v));
+       TH2F* hPrimary = 
+         static_cast<TH2F*>(infile->Get(Form("hPrimary_FMD_%c_vtx%d",
+                                             ringChar,v)));
        ringArray->AddAtAndExpand(hPrimary,v);
       }
     }
@@ -214,7 +213,8 @@ void AliFMDBackgroundCorrection::GenerateBackgroundCorrection(Bool_t from_hits,
   TList* corrList    = new TList();
   corrList->SetName("corrections");
   
-  AliFMDAnaCalibBackgroundCorrection* background = new AliFMDAnaCalibBackgroundCorrection();
+  AliFMDAnaCalibBackgroundCorrection* background = 
+    new AliFMDAnaCalibBackgroundCorrection();
   
   for(Int_t det= 1; det <=3; det++) {
     Int_t nRings = (det==1 ? 1 : 2);
@@ -225,7 +225,8 @@ void AliFMDBackgroundCorrection::GenerateBackgroundCorrection(Bool_t from_hits,
     
     
     for(Int_t iring = 0; iring<nRings; iring++) {
-      TObjArray* primRingArray = (TObjArray*)primaryArray->At(iring);
+      TObjArray* primRingArray      = 
+       static_cast<TObjArray*>(primaryArray->At(iring));
       Char_t ringChar = (iring == 0 ? 'I' : 'O');
       TObjArray* vtxArrayCorrection = new TObjArray();
       vtxArrayCorrection->SetName(Form("FMD%d%c",det,ringChar));
@@ -236,16 +237,17 @@ void AliFMDBackgroundCorrection::GenerateBackgroundCorrection(Bool_t from_hits,
        TObjArray* vtxArray  = (TObjArray*)detArray->At(iring);
        TH2F* hHits          = (TH2F*)vtxArray->At(vertexBin);
        hitList->Add(hHits);
-       TH2F* hPrimary  = (TH2F*)primRingArray->At(vertexBin);
+       TH2F* hPrimary  = static_cast<TH2F*>(primRingArray->At(vertexBin));
        primaryList->Add(hPrimary);
-       TH2F* hCorrection = (TH2F*)hHits->Clone(Form("FMD%d%c_vtxbin_%d_correction",det,ringChar,vertexBin));
+       TH2F* hCorrection = 
+         static_cast<TH2F*>(hHits->Clone(Form("FMD%d%c_vtxbin_%d_correction",
+                                              det,ringChar,vertexBin)));
        hCorrection->Divide(hPrimary);
        corrList->Add(hCorrection);
        hCorrection->SetTitle(hCorrection->GetName());
        vtxArrayCorrection->AddAtAndExpand(hCorrection,vertexBin);
        background->SetBgCorrection(det,ringChar,vertexBin,hCorrection);
       }
-      
     }
   }
   
@@ -299,6 +301,7 @@ void AliFMDBackgroundCorrection::Simulate(Int_t nEvents) {
   AliSimulation sim ; 
   sim.SetRunNumber(0);
   TGrid::Connect("alien:",0,0,"t");
+  // FIXME: Do not use a hard-coded path!
   sim.SetDefaultStorage("alien://Folder=/alice/data/2008/LHC08d/OCDB/");
   sim.SetConfigFile("Config.C");
   sim.SetRunQA("FMD:");
@@ -356,7 +359,7 @@ AliFMDBackgroundCorrection::AliFMDInputBG::ProcessEvent(UShort_t det,
                                                        Float_t  charge)
 {
   
-  
+  if (charge == 0) return kTRUE;
   
   /*  if(charge !=  0 && 
      ((nTrack != fPrevTrack) || 
@@ -375,29 +378,26 @@ AliFMDBackgroundCorrection::AliFMDInputBG::ProcessEvent(UShort_t det,
     nextStripTrack = fLastTrackByStrip.operator()(det,ring,sec,strip+1);
   */
   
-  Float_t thisStripTrack = fLastTrackByStrip.operator()(det,ring,sec,strip);
+  Float_t thisStripTrack = fLastTrackByStrip(det,ring,sec,strip);
   // if(nTrack == fLastTrackByStrip.operator()(det,ring,sec,strip))
   //  std::cout<<"Track # "<<nTrack<<"  failed the cut in "<<det<<"   "<<ring<<"   "<<sec<<"  "<<strip<<std::endl;
   // else
   //  std::cout<<"Track # "<<nTrack<<"  passed the cut in "<<det<<"   "<<ring<<"   "<<sec<<"  "<<strip<<std::endl;
-  if(charge != 0 && nTrack != thisStripTrack) {
+  if(nTrack == thisStripTrack) return kTRUE;
     
-    fHitMap.operator()(det,ring,sec,strip) += 1;
+  fHitMap(det,ring,sec,strip) += 1;
     fHits++;
     Float_t nstrips = (ring =='O' ? 256 : 512);
-    fLastTrackByStrip.operator()(det,ring,sec,strip) = (Float_t)nTrack;
+  fLastTrackByStrip(det,ring,sec,strip)     = Float_t(nTrack);
     if(strip >0)
-      fLastTrackByStrip.operator()(det,ring,sec,strip-1) = (Float_t)nTrack;
+    fLastTrackByStrip(det,ring,sec,strip-1) = Float_t(nTrack);
     if(strip < (nstrips - 1))
-      fLastTrackByStrip.operator()(det,ring,sec,strip+1) = (Float_t)nTrack;
+    fLastTrackByStrip(det,ring,sec,strip+1) = Float_t(nTrack);
     
     fPrevDetector = det;
     fPrevRing     = ring;
     fPrevSec      = sec;
     fPrevTrack    = nTrack;
-  }
-  
-  
   
   return kTRUE;
 
@@ -479,24 +479,23 @@ Bool_t AliFMDBackgroundCorrection::AliFMDInputBG::Begin(Int_t event )
     TDatabasePDG* pdgDB    = TDatabasePDG::Instance();
     TParticlePDG* pdgPart  = pdgDB->GetParticle(p->GetPdgCode());
     Float_t       charge   = (pdgPart ? pdgPart->Charge() : 0);
-    Float_t       phi      = TMath::ATan2(p->Py(),p->Px());
+    if (charge == 0) continue;
     
+    Float_t   phi = TMath::ATan2(p->Py(),p->Px());
     if(phi<0) phi = phi+2*TMath::Pi();
-    // if(p->Theta() == 0) continue;
     Float_t eta   = p->Eta();   
     
     // std::cout<<-1*TMath::Log(TMath::Tan(0.5*p->Theta()))<<std::endl;
     
     Bool_t primary = partStack->IsPhysicalPrimary(j);
     //(charge!=0)&&(TMath::Abs(p->Vx() - vertex.At(0))<0.01)&&(TMath::Abs(p->Vy() - vertex.At(1))<0.01)&&(TMath::Abs(p->Vz() - vertex.At(2))<0.01);
-    if(primary && charge !=0) {
+    if(!primary) continue;
       
       fPrim++;
       
       fPrimaryMapInner.Fill(eta,phi);
       fPrimaryMapOuter.Fill(eta,phi);
     }
-  }
   
   return retVal;
 }
@@ -514,13 +513,13 @@ Bool_t AliFMDBackgroundCorrection::AliFMDInputBG::End()  {
   
   Double_t delta           = 2*fZvtxCut/fNvtxBins;
   Double_t vertexBinDouble = (vertex.At(2) + fZvtxCut) / delta;
-  Int_t    vertexBin       = (Int_t)vertexBinDouble;
+  Int_t    vertexBin       = Int_t(vertexBinDouble);
   //Primaries
-  TObjArray* innerArray = (TObjArray*)fPrimaryArray.At(0);
-  TObjArray* outerArray = (TObjArray*)fPrimaryArray.At(1);
+  TObjArray* innerArray = static_cast<TObjArray*>(fPrimaryArray.At(0));
+  TObjArray* outerArray = static_cast<TObjArray*>(fPrimaryArray.At(1));
   
-  TH2F* hPrimaryInner  = (TH2F*)innerArray->At(vertexBin);
-  TH2F* hPrimaryOuter  = (TH2F*)outerArray->At(vertexBin);
+  TH2F* hPrimaryInner  = static_cast<TH2F*>(innerArray->At(vertexBin));
+  TH2F* hPrimaryOuter  = static_cast<TH2F*>(outerArray->At(vertexBin));
   
   hPrimaryInner->Add(&fPrimaryMapInner);
   hPrimaryOuter->Add(&fPrimaryMapOuter);
@@ -537,7 +536,7 @@ Bool_t AliFMDBackgroundCorrection::AliFMDInputBG::End()  {
        
        for(UShort_t strip = 0; strip < nstr; strip++) {
          
-         if(fHitMap.operator()(det,ring,sec,strip) > 0) {
+         if(fHitMap(det,ring,sec,strip) > 0) {
            //std::cout<<fHitMap.operator()(det,ring,sec,strip)<<std::endl;
            Double_t x,y,z;
            AliFMDGeometry* fmdgeo = AliFMDGeometry::Instance();
@@ -545,9 +544,9 @@ Bool_t AliFMDBackgroundCorrection::AliFMDInputBG::End()  {
            
            Int_t iring = (ring == 'I' ? 0 : 1);
            
-           TObjArray* detArray  = (TObjArray*)fHitArray.At(det);
-           TObjArray* vtxArray  = (TObjArray*)detArray->At(iring);
-           TH2F* hHits          = (TH2F*)vtxArray->At(vertexBin);
+           TObjArray* detArray  = static_cast<TObjArray*>(fHitArray.At(det));
+           TObjArray* vtxArray  = static_cast<TObjArray*>(detArray->At(iring));
+           TH2F* hHits          = static_cast<TH2F*>(vtxArray->At(vertexBin));
            
            Float_t   phi   = TMath::ATan2(y,x);
            if(phi<0) phi   = phi+2*TMath::Pi();
index f30fee8..c9e80bd 100644 (file)
@@ -5,8 +5,9 @@
  *
  * See cxx source for full Copyright notice                               
  */
-// Thil class computes background corrections for the FMD. The correction is computed 
-// in eta,phi cells and the objects stored can be put into alien to use with analysis.
+// This class computes background corrections for the FMD. The
+// correction is computed in eta,phi cells and the objects stored can
+// be put into alien to use with analysis.
 //
 // Author: Hans Hjersing Dalsgaard, NBI, hans.dalsgaard@cern.ch
 //
 #define ALIFMDBACKGROUNDCORRECTION_H
 
 #include "AliFMDInput.h"
-#include "TObjArray.h"
-#include "AliRunLoader.h"
-#include "AliFMDFloatMap.h"
-#include "TH2F.h"
+#include <TObjArray.h>
+#include <AliRunLoader.h>
+#include <AliFMDFloatMap.h>
+#include <TH2F.h>
 class AliTrackReference;
 
-class AliFMDBackgroundCorrection : public TNamed {
-  
+/**
+ * Background correction map.
+ * 
+ */
+class AliFMDBackgroundCorrection : public TNamed 
+{
 public:
-  
+  /** 
+   * Constructor
+   */
   AliFMDBackgroundCorrection() ;
-  ~AliFMDBackgroundCorrection() {};
+  /** 
+   * Destructor
+   */
+  virtual ~AliFMDBackgroundCorrection() {};
+  /** 
+   * Generate the background correction
+   * 
+   * @param from_hits     Whether we run over hits
+   * @param nvtxbins      Number of vertex bins
+   * @param zvtxcut       Outer cut on interaction point Z coordinate
+   * @param nBinsEta      Number of psuedo-rapidity bins
+   * @param storeInAlien  Whether to store the result in AliEn
+   * @param runNo         Run number 
+   * @param endRunNo      End validity 
+   * @param filename      The output file name 
+   * @param simulate      Whether to run the simulation or not
+   * @param nEvents       Number of events to analyse 
+   * @param inFile        Whether an input file is specified
+   * @param infilename    Input file name
+   */
   void GenerateBackgroundCorrection(Bool_t from_hits=kFALSE,
                                    Int_t nvtxbins=10,
                                    Float_t zvtxcut=10,
@@ -40,60 +66,163 @@ public:
                                    Int_t nEvents=10,
                                    Bool_t inFile = kFALSE,
                                    const Char_t* infilename="");
+  /** 
+   * Nested class that derives from AliFMDInput to do the actual
+   * processing  
+   */  
+  class AliFMDInputBG : public AliFMDInput 
+  {
   
-  class AliFMDInputBG : public AliFMDInput {
-    
   public :
     //AliFMDInputBG() ; 
+    /** 
+     * Constructo
+     * 
+     * @param hits_not_trackrefs Use hits rather than track references
+     */
     AliFMDInputBG(Bool_t hits_not_trackrefs);
+    /** 
+     * Initialize the object
+     * 
+     * 
+     * @return @c true on success.
+     */
     Bool_t Init();
     
+    /** 
+     * Get number of primaries seen
+     * 
+     * 
+     * @return Number of primaries seen 
+     */    
     Int_t GetNprim() {return fPrim;}
+    /** 
+     * Get number of hits (total number of particles seen)
+     * 
+     * 
+     * @return Total number of particles seen
+     */
     Int_t GetNhits() {return fHits;}
+    /** 
+     * Set the interaction point Z coordinate cut 
+     * 
+     * @param vtxCut The Z coordinate cut 
+     */
     void  SetVtxCutZ(Double_t vtxCut) { fZvtxCut = vtxCut;}
+    /** 
+     * Set the number of vertex bins
+     * 
+     * @param nBins Number of vertex bins 
+     */
     void  SetNvtxBins(Int_t nBins) { fNvtxBins = nBins;}
+    /** 
+     * Set the number of eta bins
+     * 
+     * @param nBins Number of eta bins
+     */
     void  SetNbinsEta(Int_t nBins) { fNbinsEta = nBins;}
+    /** 
+     * Get a list of hits i.e., the particles that hit the FMD
+     * 
+     * @return List of particles
+     */
     TObjArray*  GetHits() {return &fHitArray;}
+    /** 
+     * Get a list of primaries i.e., the primary particles that hit the FMD
+     * 
+     * @return List of particles
+     */
     TObjArray*  GetPrimaries() {return &fPrimaryArray;}
+    /** 
+     * Get the run loader used
+     * 
+     * @return Run loader used 
+     */
     AliRunLoader* GetRunLoader() {return fLoader; }
   private:
+    /** 
+     * Process a single hit
+     * 
+     * @param h Hit data
+     * @param p Particle that made the hit
+     * 
+     * @return @c false on failure
+     */    
     Bool_t ProcessHit(AliFMDHit* h, TParticle* p );
+    /** 
+     * Process a track reference 
+     * 
+     * @param tr Track reference
+     * @param p  Particle that made the track reference
+     * 
+     * @return  @c false on failure
+     */
     Bool_t ProcessTrackRef(AliTrackReference* tr, TParticle* p );
+    /** 
+     * Process a single event
+     * 
+     * @param det     Detector
+     * @param ring    Ring
+     * @param sector  Sector 
+     * @param strip   Strip
+     * @param nTrack  Track number
+     * @param charge  Charge 
+     * 
+     * @return @c false on failure
+     */
     Bool_t ProcessEvent(UShort_t det,
                        Char_t ring, 
                        UShort_t sector, 
                        UShort_t strip,
                        Int_t nTrack,
                        Float_t charge);
-               
+    /** 
+     * Called at start of event
+     * 
+     * @param event Event number
+     * 
+     * @return @c false on failure
+     */                
     Bool_t Begin(Int_t event );
+    /** 
+     * Called at end of event 
+     * 
+     * @return @c false on failure
+     */
     Bool_t End();
-    TObjArray fPrimaryArray;
-    TObjArray fHitArray;
-    TH2F    fPrimaryMapInner;
-    TH2F    fPrimaryMapOuter;
-    AliFMDFloatMap fHitMap;
-    AliFMDFloatMap fLastTrackByStrip;
-    Int_t fPrim;
-    Int_t fHits;
-    Double_t fZvtxCut;
-    Int_t fNvtxBins;
-    Int_t fPrevTrack;
-    Int_t fPrevDetector;
-    Char_t fPrevRing;
-    Int_t fPrevSec;
-    Int_t fNbinsEta;
+    TObjArray      fPrimaryArray;     // List of primaries
+    TObjArray      fHitArray;         // List of all particles
+    TH2F           fPrimaryMapInner;  // Histogram for inners
+    TH2F           fPrimaryMapOuter;  // Histogram for outers
+    // FIXME: Consider using AliFMDUShortMap, or maybe new class AliFMDIntMap
+    AliFMDFloatMap fHitMap;           // A map of hits
+    AliFMDFloatMap fLastTrackByStrip; // A map of last track 
+    Int_t          fPrim;             // Number of primaries
+    Int_t          fHits;             // Number of hits
+    Double_t       fZvtxCut;          // Vertex cut
+    Int_t          fNvtxBins;         // Number of vertex bins
+    Int_t          fPrevTrack;        // Previous track number
+    Int_t          fPrevDetector;     // Previous detector number
+    Char_t         fPrevRing;         // Previous ring number
+    Int_t          fPrevSec;          // Previous sector number
+    Int_t          fNbinsEta;         // Number of eta bins
   };
   
 private:
-  
-  void Simulate(Int_t);
-  void ProcessPrimaries(AliRunLoader*);
-  TObjArray fCorrectionArray;
-  TList     fPrimaryList;
-  //Double_t fZvtxCut;
-  // Int_t fNvtxBins;
-  //Int_t fNbinsEta;
+  /** 
+   * Run a simulation
+   * 
+   * @param e_t Not used
+   */  
+  void Simulate(Int_t e);
+  /** 
+   * Process all primaries from the run loader
+   * 
+   * @param rl Run loader
+   */
+  void ProcessPrimaries(AliRunLoader* rl);
+  TObjArray fCorrectionArray; // Array of corrections
+  TList     fPrimaryList;     // List of primaries
   ClassDef(AliFMDBackgroundCorrection,0)
   
 };
index cf88ee2..1970eb3 100644 (file)
@@ -242,10 +242,7 @@ AliFMDBaseDigitizer::AliFMDBaseDigitizer(AliRunDigitizer* manager)
   : AliDigitizer(manager, "AliFMDBaseDigitizer", "FMD Digitizer base class"), 
     fFMD(0),
     fRunLoader(0),
-    fEdep(AliFMDMap::kMaxDetectors, 
-         AliFMDMap::kMaxRings, 
-         AliFMDMap::kMaxSectors, 
-         AliFMDMap::kMaxStrips), 
+    fEdep(0),        // nDet==0 means 51200 slots
     fShapingTime(6),
     fStoreTrackRefs(kTRUE)
 {
@@ -260,10 +257,7 @@ AliFMDBaseDigitizer::AliFMDBaseDigitizer(const Char_t* name,
   : AliDigitizer(name, title),
     fFMD(0),
     fRunLoader(0),
-    fEdep(AliFMDMap::kMaxDetectors, 
-         AliFMDMap::kMaxRings, 
-         AliFMDMap::kMaxSectors, 
-         AliFMDMap::kMaxStrips),
+    fEdep(0),        // nDet==0 means 51200 slots
     fShapingTime(6),
     fStoreTrackRefs(kTRUE)
 {
index 218a078..f2fd938 100644 (file)
@@ -40,22 +40,33 @@ AliFMDBoolMap::AliFMDBoolMap(const AliFMDBoolMap& other)
               other.fMaxRings,
               other.fMaxSectors,
               other.fMaxStrips),
-    fTotal(0),
+    fTotal(fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips),
     fData(0)
 {
   // Copy constructor
-  fTotal = fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips;
+  if (fTotal == 0) fTotal = 51200;
   fData  = new Bool_t[fTotal];
   for (Int_t i = 0; i < fTotal; i++) fData[i] = other.fData[i];
 }
 
 //__________________________________________________________
+AliFMDBoolMap::AliFMDBoolMap()
+  : AliFMDMap(),
+    fTotal(0),
+    fData(0)
+{
+  // Constructor.
+  // Parameters:
+  //   None
+}
+
+//__________________________________________________________
 AliFMDBoolMap::AliFMDBoolMap(UShort_t maxDet,
                          UShort_t maxRing,
                          UShort_t maxSec,
                          UShort_t maxStr)
   : AliFMDMap(maxDet, maxRing, maxSec, maxStr),
-    fTotal(0),
+    fTotal(fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips),
     fData(0)
 {
   // Constructor.
@@ -64,7 +75,7 @@ AliFMDBoolMap::AliFMDBoolMap(UShort_t maxDet,
   //   maxRing Maximum number of rings per detector
   //   maxSec  Maximum number of sectors per ring
   //   maxStr  Maximum number of strips per sector
-  fTotal = fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips;
+  if (fTotal == 0) fTotal = 51200;
   fData  = new Bool_t[fTotal];
   Reset();
 }
@@ -80,6 +91,7 @@ AliFMDBoolMap::operator=(const AliFMDBoolMap& other)
   fMaxStrips    = other.fMaxStrips;
   if (fData) delete [] fData;
   fTotal = fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips;
+  if (fTotal == 0) fTotal = 51200;
   fData  = new Bool_t[fTotal];
   for (Int_t i = 0; i < fTotal; i++) fData[i] = other.fData[i];
   return *this;
index c039a80..abb9858 100644 (file)
@@ -32,17 +32,21 @@ public:
   /** Copy constructor 
       @param other Object to copy from. */
   AliFMDBoolMap(const AliFMDBoolMap& other);
+  /** 
+   * Constructor 
+   */
+  AliFMDBoolMap();
   /** Constructor 
       @param maxDet  Number of detectors (3)
       @param maxRing Number of rings (2)
       @param maxSec  Number of sectors (40)
       @param maxStr  Number of strips (20) */
-  AliFMDBoolMap(UShort_t maxDet  = kMaxDetectors,
-               UShort_t maxRing = kMaxRings,
-               UShort_t maxSec  = kMaxSectors,
-               UShort_t maxStr  = kMaxStrips);
+  AliFMDBoolMap(UShort_t maxDet,
+               UShort_t maxRing = 0,
+               UShort_t maxSec  = 0,
+               UShort_t maxStr  = 0);
   /** Destructor */
-  virtual ~AliFMDBoolMap() { delete [] fData; }
+  virtual ~AliFMDBoolMap() { if (fData) delete [] fData; }
   /** Assignment operator 
       @param other Object to assign from 
       @return reference to this object.  */
@@ -71,6 +75,16 @@ public:
                                   UShort_t sec,
                                   UShort_t str) const;
 protected:
+  Int_t     MaxIndex()            const { return fTotal; }
+  Bool_t    AtAsBool(Int_t idx)   const { return fData[idx]; }
+  Bool_t&   AtAsBool(Int_t idx)         { return fData[idx]; }
+  Bool_t    IsBool()              const { return kTRUE; }  
+  Int_t     AtAsInt(Int_t idx)    const { return fData[idx] ? 1   : 0;   }
+  Float_t   AtAsFloat(Int_t idx)  const { return fData[idx] ? 1.F : 0.F; }
+  UShort_t  AtAsUShort(Int_t idx) const { return fData[idx] ? 1   : 0;   }
+  Int_t&    AtAsInt(Int_t idx)          { return AliFMDMap::AtAsInt(idx);    }
+  Float_t&  AtAsFloat(Int_t idx)        { return AliFMDMap::AtAsFloat(idx);  }
+  UShort_t& AtAsUShort(Int_t idx)       { return AliFMDMap::AtAsUShort(idx); }
   Int_t  fTotal; // Total number of entries 
   Bool_t* fData;  // [fTotal] The Data
   ClassDef(AliFMDBoolMap,3) // Map of Bool_t data per strip
index de18b4a..aee7030 100644 (file)
@@ -35,7 +35,7 @@ ClassImp(AliFMDCalibGain)
 
 //____________________________________________________________________
 AliFMDCalibGain::AliFMDCalibGain()
-  : fValue(),
+  : fValue(0), // nDet == 0 mean 51200 slots
     fThreshold(-1.)
 {
   // CTOR
index 8795c02..cefeca5 100644 (file)
@@ -36,8 +36,8 @@ ClassImp(AliFMDCalibPedestal)
 
 //____________________________________________________________________
 AliFMDCalibPedestal::AliFMDCalibPedestal()
-  : fValue(), 
-    fWidth()
+  : fValue(0), // nDet == 0 mean 51200 entries 
+    fWidth(0)  // nDet == 0 mean 51200 entries
 {
   // CTOR 
   fValue.Reset(-1.);
index 1de27cc..6341619 100644 (file)
@@ -40,16 +40,27 @@ ClassImp(AliFMDEdepMap)
 AliFMDEdepMap::AliFMDEdepMap(const AliFMDEdepMap& other)
   : AliFMDMap(other.fMaxDetectors, other.fMaxRings, other.fMaxSectors, 
              other.fMaxStrips), 
-    fTotal(0),
+    fTotal(fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips),
     fData(0)
 {
   // Copy constructor 
-  fTotal = fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips;
+  if (fTotal == 0) fTotal = 51200;
   fData  = new AliFMDEdepHitPair[fTotal];
   for (Int_t i = 0; i < fTotal; i++) fData[i] = other.fData[i];
 }
 
   
+//____________________________________________________________________
+AliFMDEdepMap::AliFMDEdepMap()
+  : AliFMDMap(), 
+    fTotal(0),
+    fData(0)
+{
+  // Construct a map
+  //
+  // Parameters:
+  //   None
+}
 
 //____________________________________________________________________
 AliFMDEdepMap::AliFMDEdepMap(UShort_t maxDet, 
@@ -57,7 +68,7 @@ AliFMDEdepMap::AliFMDEdepMap(UShort_t maxDet,
                             UShort_t maxSec, 
                             UShort_t maxStr)
   : AliFMDMap(maxDet, maxRing, maxSec, maxStr), 
-    fTotal(0),
+    fTotal(fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips),
     fData(0)
 {
   // Construct a map
@@ -67,7 +78,7 @@ AliFMDEdepMap::AliFMDEdepMap(UShort_t maxDet,
   //     maxRinf      Maximum # of rings
   //     maxSec       Maximum # of sectors
   //     maxStr       Maximum # of strips
-  fTotal = fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips;
+  if (fTotal == 0) fTotal = 51200;
   fData  = new AliFMDEdepHitPair[fTotal];
 }
 
@@ -82,6 +93,7 @@ AliFMDEdepMap::operator=(const AliFMDEdepMap& other)
   fMaxStrips    = other.fMaxStrips;
   if (fData) delete [] fData;
   fTotal = fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips;
+  if (fTotal == 0) fTotal = 51200;
   fData  = new AliFMDEdepHitPair[fTotal];
   for (Int_t i = 0; i < fTotal; i++) fData[i] = other.fData[i];
   return *this;
index 522de6f..f586d13 100644 (file)
@@ -37,15 +37,17 @@ public:
       @param other Object to copy from. 
       @return  */
   AliFMDEdepMap(const AliFMDEdepMap& other);
+  /** Constructor */
+  AliFMDEdepMap();
   /** Constructor 
       @param maxDet  Number of detectors (3)
       @param maxRing Number of rings (2)
       @param maxSec  Number of sectors (40)
       @param maxStr  Number of strips (20) */
-  AliFMDEdepMap(UShort_t maxDet = kMaxDetectors, 
-               UShort_t maxRing= kMaxRings, 
-               UShort_t maxSec = kMaxSectors, 
-               UShort_t maxStr = kMaxStrips);
+  AliFMDEdepMap(UShort_t maxDet, 
+               UShort_t maxRing= 0, 
+               UShort_t maxSec = 0, 
+               UShort_t maxStr = 0);
   /** DTOR */
   virtual ~AliFMDEdepMap() { delete [] fData; }
   AliFMDEdepMap& operator=(const AliFMDEdepMap& other);
@@ -75,6 +77,17 @@ public:
                                              UShort_t sector, 
                                              UShort_t strip) const;
 protected:
+  Int_t     MaxIndex()            const { return fTotal; }
+  Int_t     AtAsInt(Int_t idx)    const { return fData[idx].fN; }
+  Int_t&    AtAsInt(Int_t idx)          { return AliFMDMap::AtAsInt(idx); }
+  Bool_t    AtAsBool(Int_t idx)   const { return fData[idx].fEdep > 0; }
+  Bool_t&   AtAsBool(Int_t idx)         { return AliFMDMap::AtAsBool(idx); }
+  Float_t   AtAsFloat(Int_t idx)  const { return fData[idx].fEdep; }
+  Float_t&  AtAsFloat(Int_t idx)        { return fData[idx].fEdep; }
+  UShort_t  AtAsUShort(Int_t idx) const { return fData[idx].fN; }
+  UShort_t& AtAsUShort(Int_t idx)       { return fData[idx].fN; }
+  Bool_t    IsUShort()            const { return kTRUE; }  
+  Bool_t    IsFloat()             const { return kTRUE; }  
   Int_t             fTotal; //  Total number of entries
   AliFMDEdepHitPair* fData;  //[fTotal] The data 
   ClassDef(AliFMDEdepMap, 3) // Cache of edep,hit information per strip
index e026ebb..b688651 100644 (file)
@@ -55,7 +55,7 @@ AliFMDUShortMap::AliFMDUShortMap(UShort_t maxDet,
                                 UShort_t maxSec, 
                                 UShort_t maxStr)
   : AliFMDMap(maxDet, maxRing, maxSec, maxStr), 
-    fTotal(0),
+    fTotal(fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips),
     fData(0)
 {
   // Construct a map
@@ -65,11 +65,23 @@ AliFMDUShortMap::AliFMDUShortMap(UShort_t maxDet,
   //     maxRinf      Maximum # of rings
   //     maxSec       Maximum # of sectors
   //     maxStr       Maximum # of strips
-  fTotal = fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips;
+  if (fTotal == 0) fTotal = 51200;
   fData  = new UShort_t[fTotal];
 }
 
 //____________________________________________________________________
+AliFMDUShortMap::AliFMDUShortMap()
+  : AliFMDMap(), 
+    fTotal(0),
+    fData(0)
+{
+  // Construct a map
+  //
+  // Parameters:
+  //     None
+}
+
+//____________________________________________________________________
 AliFMDUShortMap&
 AliFMDUShortMap::operator=(const AliFMDUShortMap& other) 
 {
index 0c10d6e..48d4398 100644 (file)
@@ -27,12 +27,14 @@ public:
   /** Copy constructor 
       @param other Object to copy from.  */
   AliFMDUShortMap(const AliFMDUShortMap& other);
+  /** Constructor */
+  AliFMDUShortMap();
   /** Constructor 
       @param maxDet  Number of detectors (3)
       @param maxRing Number of rings (2)
       @param maxSec  Number of sectors (40)
       @param maxStr  Number of strips (20) */
-  AliFMDUShortMap(UShort_t maxDet = kMaxDetectors, 
+  AliFMDUShortMap(UShort_t maxDet,
                  UShort_t maxRing= kMaxRings, 
                  UShort_t maxSec = kMaxSectors, 
                  UShort_t maxStr = kMaxStrips);
@@ -66,6 +68,16 @@ public:
                                     UShort_t sector, 
                                     UShort_t strip) const;
  protected:
+  Int_t     MaxIndex()            const { return fTotal; }
+  UShort_t  AtAsUShort(Int_t idx) const { return fData[idx]; }
+  UShort_t& AtAsUShort(Int_t idx)       { return fData[idx]; }
+  Int_t     AtAsInt(Int_t idx)    const { return fData[idx]; }
+  Float_t   AtAsFloat(Int_t idx)  const { return fData[idx]; }
+  Bool_t    AtAsBool(Int_t idx)   const { return fData[idx]!=0?kTRUE:kFALSE; }
+  Int_t&    AtAsInt(Int_t idx)          { return AliFMDMap::AtAsInt(idx);    }
+  Float_t&  AtAsFloat(Int_t idx)        { return AliFMDMap::AtAsFloat(idx);  }
+  Bool_t&   AtAsBool(Int_t idx)         { return AliFMDMap::AtAsBool(idx); }
+  Bool_t    IsUShort()            const { return kTRUE; }  
   Int_t     fTotal; // Total number of entries 
   UShort_t* fData;  // [fTotal] The data 
   ClassDef(AliFMDUShortMap, 3) // Cache of edep,hit information per strip
index 9709396..3d092a0 100755 (executable)
@@ -26,6 +26,7 @@
 #include "AliESDFMD.h"         // ALIFMDESD_H
 #include "AliLog.h"            // ALILOG_H
 #include "Riostream.h"         // ROOT_Riostream
+#include <TMath.h>
 
 //____________________________________________________________________
 ClassImp(AliESDFMD)
@@ -35,11 +36,80 @@ ClassImp(AliESDFMD)
 
 
 //____________________________________________________________________
+namespace {
+  // Private implementation of a AliFMDMap::ForOne to use in
+  // forwarding to AliESDFMD::ForOne
+  class ForMultiplicity : public AliFMDMap::ForOne 
+  {
+  public:
+    ForMultiplicity(const AliESDFMD& o, AliESDFMD::ForOne& a)
+      : fObject(o), fAlgo(a) 
+    {}
+    Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t, 
+                     Float_t m)
+    {
+      Float_t e = fObject.Eta(d, r, 0, t);
+      return fAlgo.operator()(d, r, s, t, m, e);
+    }
+    Bool_t operator()(UShort_t, Char_t, UShort_t, UShort_t, Int_t)
+    {
+      return kTRUE;
+    }
+    Bool_t operator()(UShort_t, Char_t, UShort_t, UShort_t, UShort_t)
+    {
+      return kTRUE;
+    }
+    Bool_t operator()(UShort_t, Char_t, UShort_t, UShort_t, Bool_t)
+    {
+      return kTRUE;
+    }
+  protected:
+    const AliESDFMD&   fObject;
+    AliESDFMD::ForOne& fAlgo;
+  };
+
+  // Private implementation of AliESDFMD::ForOne to print an 
+  // object 
+  class Printer : public AliESDFMD::ForOne
+  {
+  public:
+    Printer() : fOldD(0), fOldR('-'), fOldS(1024) {}
+    Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t, 
+                     Float_t m, Float_t e)
+    {
+      if (d != fOldD) { 
+       if (fOldD != 0) printf("\n");
+       fOldD = d;
+       fOldR = '-';
+       printf("FMD%d", fOldD);
+      }
+      if (r != fOldR) { 
+       fOldR = r;
+       fOldS = 1024;
+       printf("\n %s ring", (r == 'I' ? "Inner" : "Outer"));
+      }
+      if (s != fOldS) { 
+       fOldS = s;
+       printf("\n  Sector %d", fOldS);
+      }
+      if (t % 4 == 0)                   printf("\n   %3d-%3d ", t, t+3);
+      if (m == AliESDFMD::kInvalidMult) printf("------/");
+      else                              printf("%6.3f/", m);
+      if (e == AliESDFMD::kInvalidEta)  printf("------ ");
+      else                              printf("%6.3f ", e);
+
+      return kTRUE;
+    }
+  private:
+    UShort_t fOldD;
+    Char_t   fOldR;
+    UShort_t fOldS;
+  };
+}
+
+//____________________________________________________________________
 AliESDFMD::AliESDFMD()
-  : fMultiplicity(AliFMDFloatMap::kMaxDetectors, 
-                 AliFMDFloatMap::kMaxRings, 
-                 AliFMDFloatMap::kMaxSectors, 
-                 AliFMDFloatMap::kMaxStrips), 
+  : fMultiplicity(0, 0, 0, 0),
     fEta(AliFMDFloatMap::kMaxDetectors, 
         AliFMDFloatMap::kMaxRings, 
         1,
@@ -74,7 +144,10 @@ AliESDFMD::operator=(const AliESDFMD& other)
   return *this;
 }
 
-void AliESDFMD::Copy(TObject &obj) const{
+//____________________________________________________________________
+void 
+AliESDFMD::Copy(TObject &obj) const
+{
   // this overwrites the virtual TOBject::Copy()
   // to allow run time copying without casting
   // in AliESDEvent
@@ -130,6 +203,62 @@ AliESDFMD::Eta(UShort_t detector, Char_t ring, UShort_t /* sector */,
 }
 
 //____________________________________________________________________
+Float_t
+AliESDFMD::Phi(UShort_t detector, Char_t ring, UShort_t sector, UShort_t) const
+{
+  // Return azimuthal angle (in degrees) of the strip
+  // FMD<detector><ring>[<sector>,<strip>].  
+  // 
+  Float_t baseAng = (detector == 1 ? 90 : 
+                    detector == 2 ?  0 : 180);
+  Float_t dAng    = ((detector == 3 ? -1 : 1) * 360 / 
+                    (ring == 'I' || ring == 'i' ? 
+                     AliFMDMap::kNSectorInner : 
+                     AliFMDMap::kNSectorOuter));
+  Float_t ret =  baseAng + dAng * (sector + .5);
+  if (ret > 360) ret -= 360;
+  if (ret <   0) ret += 360;
+  return ret;
+  
+}
+
+//____________________________________________________________________
+Float_t
+AliESDFMD::Theta(UShort_t detector, Char_t ring, UShort_t, UShort_t strip) const
+{
+  // Return polar angle from beam line (in degrees) of the strip
+  // FMD<detector><ring>[<sector>,<strip>].  
+  // 
+  // This value is calculated from eta and therefor takes into account
+  // the Z position of the interaction point. 
+  Float_t eta   = Eta(detector, ring, 0, strip);
+  Float_t theta = TMath::ATan(2 * TMath::Exp(-eta));
+  if (theta < 0) theta += TMath::Pi();
+  theta *= 180. / TMath::Pi();
+  return theta;
+}
+
+//____________________________________________________________________
+Float_t
+AliESDFMD::R(UShort_t, Char_t ring, UShort_t, UShort_t strip) const
+{
+  // Return radial distance from beam line (in cm) of the strip
+  // FMD<detector><ring>[<sector>,<strip>].  
+  // 
+  
+  // Numbers are from AliFMDRing
+  Float_t  lR  = (ring == 'I' || ring == 'i' ?  4.522 : 15.4);
+  Float_t  hR  = (ring == 'I' || ring == 'i' ? 17.2   : 28.0);
+  UShort_t nS  = (ring == 'I' || ring == 'i' ? 
+                 AliFMDMap::kNStripInner : 
+                 AliFMDMap::kNStripOuter);
+  Float_t  dR  = (hR - lR) / nS;
+  Float_t  ret = lR + dR * (strip + .5);
+  return ret;
+  
+}
+
+//____________________________________________________________________
 void
 AliESDFMD::SetMultiplicity(UShort_t detector, Char_t ring, UShort_t sector, 
                           UShort_t strip, Float_t mult)
@@ -157,11 +286,23 @@ AliESDFMD::SetEta(UShort_t detector, Char_t ring, UShort_t /* sector */,
 }
 
 //____________________________________________________________________
+Bool_t
+AliESDFMD::ForEach(AliESDFMD::ForOne& a) const
+{
+  ForMultiplicity i(*this, a);
+  return fMultiplicity.ForEach(i);
+}
+
+//____________________________________________________________________
 void
 AliESDFMD::Print(Option_t* /* option*/) const
 {
   // Print all information to standard output. 
   std::cout << "AliESDFMD:" << std::endl;
+  Printer p;
+  ForEach(p);
+  printf("\n");
+#if 0
   for (UShort_t det = 1; det <= fMultiplicity.MaxDetectors(); det++) {
     for (UShort_t ir = 0; ir < fMultiplicity.MaxRings(); ir++) {
       Char_t ring = (ir == 0 ? 'I' : 'O');
@@ -184,6 +325,7 @@ AliESDFMD::Print(Option_t* /* option*/) const
       }
     }
   }
+#endif
 }
 
 
index 564b206..7e76361 100755 (executable)
 class AliESDFMD : public TObject
 {
 public:
-  /** Default constructor */
+  /** 
+   * Base class of looping over the FMD ESD object 
+   *
+   * A simple example could be 
+   * 
+   * @code 
+   * struct ESDFMDPrinter : AliESDFMD::ForOne
+   * { 
+   *   Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t,
+   *                     Float_t m, Float_t e) 
+   *   { 
+   *     Printf("FMD%d%c[%2d,%3d]=%7.4f @ %7.4f", d, r, s, t, m, e);
+   *     return kTRUE;
+   *   }
+   * };
+   * @endcode
+   */
+  class ForOne 
+  {
+  public:
+    /** 
+     * Destructor
+     */    
+    virtual ~ForOne() {}
+    /** 
+     * Functional operator called for each entry 
+     * 
+     * @param d Detector number
+     * @param r Ring identifier 
+     * @param s Sector number
+     * @param t Strip number
+     * @param m 'Bare' multiplicity of this strip
+     * @param e Pseudo-rapidity of this strip
+     * 
+     * @return @c kTRUE in case of success, @c kFALSE in case of failure.
+     *         If the method returns @c kFALSE, the loop stops. 
+     */    
+    virtual bool operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t, 
+                             Float_t m, Float_t e) = 0;
+  };
+  /** 
+   * Default constructor 
+   */
   AliESDFMD();
-  /** Copy constructor 
-      @param other Object to construct from */
+  /** 
+   * Copy constructor 
+   * 
+   * @param other Object to construct from 
+   */
   AliESDFMD(const AliESDFMD& other);
-  /** Assignment operator 
-      @param other Object to assign from
-      @return  reference to this object */
+  /** 
+   * Assignment operator 
+   * 
+   * @param other Object to assign from
+   *
+   * @return  reference to this object 
+   */
   AliESDFMD& operator=(const AliESDFMD& other);
-  /** Destructor - does nothing */
+  /** 
+   * Destructor - does nothing 
+   */
   virtual ~AliESDFMD() {}
+  /** 
+   * Copy the content of this object to @a obj which must have been 
+   * preallocated
+   *
+   * @param obj Object to copy to
+   */
   virtual void Copy(TObject &obj) const;
 
-
+  /**
+   * Reset the object 
+   */
   void Clear(Option_t *option="");
-  /** Get the pseudo-multiplicity of 
-      @f$ \text{FMD}\langle detector\rangle\lange ring\rangle_{\langle
-      sector\rangle\langle strip\rangle}@f$ 
-      @param detector Detector number (1-3)
-      @param ring     Ring identifier ('I' or 'O')
-      @param sector   Sector number (0-511, or 0-255)
-      @param strip    Strip number (0-19, or 0-39)
-      @return Psuedo multiplicity */
+  /** 
+   * Get the pseudo-multiplicity of 
+   * @f$ \text{FMD}\langle detector\rangle\lange ring\rangle_{\langle
+   * sector\rangle\langle strip\rangle}@f$ 
+   * 
+   * @param detector Detector number (1-3)
+   * @param ring     Ring identifier ('I' or 'O')
+   * @param sector   Sector number (0-511, or 0-255)
+   * @param strip    Strip number (0-19, or 0-39)
+   *
+   * @return Psuedo multiplicity 
+   */
   Float_t Multiplicity(UShort_t detector, Char_t ring, 
                       UShort_t sector, UShort_t strip) const;
-  /** Get the pseudo-rapidity of 
-      @f$ \text{FMD}\langle detector\rangle\lange ring\rangle_{\langle
-      sector\rangle\langle strip\rangle}@f$ 
-      @param detector Detector number (1-3)
-      @param ring     Ring identifier ('I' or 'O')
-      @param sector   Sector number (0-511, or 0-255)
-      @param strip    Strip number (0-19, or 0-39)
-      @return Psuedo rapidity */
+  /** 
+   * Get the pseudo-rapidity of 
+   * @f$ \text{FMD}\langle detector\rangle\lange ring\rangle_{\langle
+   * sector\rangle\langle strip\rangle}@f$ 
+   *
+   * @param detector Detector number (1-3)
+   * @param ring     Ring identifier ('I' or 'O')
+   * @param sector   Sector number (0-511, or 0-255)
+   * @param strip    Strip number (0-19, or 0-39)
+   *
+   * @return Psuedo rapidity 
+   */
   Float_t Eta(UShort_t detector, Char_t ring, 
              UShort_t sector, UShort_t strip) const;
-  /** Set the pseudo-multiplicity of 
-      @f$ \text{FMD}\langle detector\rangle\lange ring\rangle_{\langle
-      sector\rangle\langle strip\rangle}@f$ 
-      @param detector Detector number (1-3)
-      @param ring     Ring identifier ('I' or 'O')
-      @param sector   Sector number (0-511, or 0-255)
-      @param strip    Strip number (0-19, or 0-39)
-      @param mult     Psuedo multiplicity */
+  /** 
+   * Get the azimuthal angle of 
+   * @f$ \text{FMD}\langle detector\rangle\lange ring\rangle_{\langle
+   * sector\rangle\langle strip\rangle}@f$ 
+   *
+   * @param detector Detector number (1-3)
+   * @param ring     Ring identifier ('I' or 'O')
+   * @param sector   Sector number (0-511, or 0-255)
+   * @param strip    Strip number (0-19, or 0-39)
+   *
+   * @return Azimuthal angle 
+   */
+  Float_t Phi(UShort_t detector, Char_t ring, 
+             UShort_t sector, UShort_t strip) const;
+  /** 
+   * Get the polar angle (in degrees) from beam line of 
+   * @f$ \text{FMD}\langle detector\rangle\lange ring\rangle_{\langle
+   * sector\rangle\langle strip\rangle}@f$ 
+   *
+   * @param detector Detector number (1-3)
+   * @param ring     Ring identifier ('I' or 'O')
+   * @param sector   Sector number (0-511, or 0-255)
+   * @param strip    Strip number (0-19, or 0-39)
+   *
+   * @return Polar angle
+   */
+  Float_t Theta(UShort_t detector, Char_t ring, 
+               UShort_t sector, UShort_t strip) const;
+  /** 
+   * Get the radial distance (in cm) from beam line of 
+   * @f$ \text{FMD}\langle detector\rangle\lange ring\rangle_{\langle
+   * sector\rangle\langle strip\rangle}@f$ 
+   *
+   * @param detector Detector number (1-3)
+   * @param ring     Ring identifier ('I' or 'O')
+   * @param sector   Sector number (0-511, or 0-255)
+   * @param strip    Strip number (0-19, or 0-39)
+   *
+   * @return Radial distance
+   */
+  Float_t R(UShort_t detector, Char_t ring, 
+           UShort_t sector, UShort_t strip) const;
+  /** 
+   * Set the pseudo-multiplicity of 
+   * @f$ \text{FMD}\langle detector\rangle\lange ring\rangle_{\langle
+   * sector\rangle\langle strip\rangle}@f$ 
+   * 
+   * @param detector Detector number (1-3)
+   * @param ring     Ring identifier ('I' or 'O')
+   * @param sector   Sector number (0-511, or 0-255)
+   * @param strip    Strip number (0-19, or 0-39)
+   * @param mult     Psuedo multiplicity 
+   */
   void SetMultiplicity(UShort_t detector, Char_t ring, 
                       UShort_t sector, UShort_t strip, 
                       Float_t mult);
-  /** Set the pseudo-rapidity of 
-      @f$ \text{FMD}\langle detector\rangle\lange ring\rangle_{\langle
-      sector\rangle\langle strip\rangle}@f$ 
-      @param detector Detector number (1-3)
-      @param ring     Ring identifier ('I' or 'O')
-      @param sector   Sector number (0-511, or 0-255)
-      @param strip    Strip number (0-19, or 0-39)
-      @param eta      Psuedo rapidity */
+  /** 
+   * Set the pseudo-rapidity of 
+   * @f$ \text{FMD}\langle detector\rangle\lange ring\rangle_{\langle
+   * sector\rangle\langle strip\rangle}@f$ 
+   * 
+   * @param detector Detector number (1-3)
+   * @param ring     Ring identifier ('I' or 'O')
+   * @param sector   Sector number (0-511, or 0-255)
+   * @param strip    Strip number (0-19, or 0-39)
+   * @param eta      Psuedo rapidity 
+   */
   void SetEta(UShort_t detector, Char_t ring, 
              UShort_t sector, UShort_t strip, 
              Float_t eta);
-  /** @param f the factor for noise suppression */
+  /** 
+   * @param f the factor for noise suppression 
+   */
   void SetNoiseFactor(Float_t f) { fNoiseFactor = f; }
-  /** @param done Whether we've done angle correction or not */
+  /** 
+   * @param done Whether we've done angle correction or not 
+   */
   void SetAngleCorrected(Bool_t done) { fAngleCorrected = done; }
-  /** @return Whether we've done angle correction or not */
+  /** 
+   * @return Whether we've done angle correction or not 
+   */
   Bool_t IsAngleCorrected() const { return fAngleCorrected; }
-  /** @return the  factor for noise suppression */
+  /** 
+   * @return the  factor for noise suppression 
+   */
   Float_t GetNoiseFactor() const { return fNoiseFactor; }
-  /** @return maximum number of detectors */
+  /** 
+   * @return maximum number of detectors 
+   */
   UShort_t MaxDetectors() const { return fMultiplicity.MaxDetectors(); }
-  /** @return maximum number of rings */
+  /** 
+   * @return maximum number of rings 
+   */
   UShort_t MaxRings()     const { return fMultiplicity.MaxRings(); }
-  /** @return maximum number of sectors */
+  /** 
+   * @return maximum number of sectors 
+   */
   UShort_t MaxSectors()   const { return fMultiplicity.MaxSectors(); }
-  /** @return Maximum number of strips */
+  /** 
+   * @return Maximum number of strips 
+   */
   UShort_t MaxStrips()    const { return fMultiplicity.MaxStrips(); }
-  /** Print this object to standard out. 
-      @param option Options */
+  /** 
+   * Print this object to standard out. 
+   * 
+   * @param option Options 
+   */
   void Print(Option_t* option="") const;
-  /** Check if we need the @c UShort_t fix 
-      @param file File this object was read from */
+  /** 
+   * Check if we need the @c UShort_t fix 
+   * 
+   * @param file File this object was read from 
+   */
   void CheckNeedUShort(TFile* file);
+  /** 
+   * Call the function operator of the passed object @a algo for each
+   * entry in this object
+   * 
+   * @param algo Algorithm
+   * 
+   * @return @c kTRUE on success, @c kFALSE if the passed object
+   * failed at any entry.  It will return immediately on error. 
+   */
+  Bool_t ForEach(ForOne& algo) const;
   enum {
     /** Value used for undefined multiplicity */
     kInvalidMult = 1024
@@ -117,9 +264,13 @@ public:
     /** Value used for undefined pseudo rapidity */
     kInvalidEta = 1024
   };
-  /** @return constant reference to multiplicity map */
+  /** 
+   * @return constant reference to multiplicity map 
+   */
   const AliFMDFloatMap& MultiplicityMap() const { return fMultiplicity; }
-  /** @return constant reference to pseudo-rapidity map */
+  /** 
+   * @return constant reference to pseudo-rapidity map 
+   */
   const AliFMDFloatMap& EtaMap() const { return fMultiplicity; }
 protected:
   AliFMDFloatMap fMultiplicity;   // Psuedo multplicity per strip
index 8696766..4615328 100755 (executable)
 // Created Mon Nov  8 12:51:51 2004 by Christian Holm Christensen
 // 
 #include "AliFMDFloatMap.h"    //ALIFMDFLOATMAP_H
+namespace {
+  class Printer : public AliFMDMap::ForOne
+  {
+  public:
+    Printer(const char* format) 
+      : fFormat(format), fOldD(0), fOldR('-'), fOldS(1024) {}
+    Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t, 
+                     Float_t m)
+    {
+      if (d != fOldD) { 
+       fOldD = d;
+       fOldR = '-';
+       if (d != 0) printf("\n");
+       printf("FMD%d", fOldD);
+      }
+      if (r != fOldR) {
+       fOldR = r;
+       fOldS = 1024;
+       printf("\n %s ring", (r == 'I' ? "Inner" : "Outer"));
+      }
+      if (s != fOldS) { 
+       fOldS = s;
+       printf("\n  Sector %2d", fOldS);
+      }
+      if (t % 4 == 0) printf("\n   %3d-%3d ", t, t+3);
+      printf(fFormat, m);
+      // if (t % 4 == 3) printf("\n");
+
+      return kTRUE;
+    }
+    Bool_t operator()(UShort_t, Char_t, UShort_t, UShort_t, Int_t)
+    {
+      return kTRUE;
+    }
+    Bool_t operator()(UShort_t, Char_t, UShort_t, UShort_t, UShort_t)
+    {
+      return kTRUE;
+    }
+    Bool_t operator()(UShort_t, Char_t, UShort_t, UShort_t, Bool_t)
+    {
+      return kTRUE;
+    }
+  private:
+    Printer(const Printer& p) 
+      : fFormat(p.fFormat), 
+       fOldD(p.fOldD), 
+       fOldR(p.fOldR), 
+       fOldS(p.fOldS) 
+    {}
+    Printer& operator=(const Printer&) { return *this; }
+    const char* fFormat;
+    UShort_t    fOldD;
+    Char_t      fOldR;
+    UShort_t    fOldS;
+  };
+}
 //__________________________________________________________
 ClassImp(AliFMDFloatMap)
 #if 0
   ; // This is here to keep Emacs for indenting the next line
 #endif
+
+//__________________________________________________________
+AliFMDFloatMap::AliFMDFloatMap(const AliFMDMap& other)
+  : AliFMDMap(other),
+    fTotal(fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips),
+    fData(0)
+{
+  if (fTotal == 0) fTotal = 51200;
+  fData = new Float_t[fTotal];
+  // Copy constructor
+  if (!other.IsFloat()) return;
+  for (Int_t i = 0; i < fTotal; i++) fData[i] = other.AtAsFloat(i);
+}
+
 //__________________________________________________________
 AliFMDFloatMap::AliFMDFloatMap(const AliFMDFloatMap& other)
   : AliFMDMap(other.fMaxDetectors,
@@ -40,21 +110,34 @@ AliFMDFloatMap::AliFMDFloatMap(const AliFMDFloatMap& other)
               other.fMaxSectors,
               other.fMaxStrips),
     fTotal(fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips),
-    fData(new Float_t[fTotal])
+    fData(0)
 {
+  if (fTotal == 0) fTotal = 51200;
+  fData = new Float_t[fTotal];
   // Copy constructor
   for (Int_t i = 0; i < fTotal; i++)
     fData[i] = other.fData[i];
 }
 
 //__________________________________________________________
+AliFMDFloatMap::AliFMDFloatMap()
+  : AliFMDMap(),
+    fTotal(0),
+    fData(0)
+{
+  // Constructor.
+  // Parameters:
+  //   None
+}
+
+//__________________________________________________________
 AliFMDFloatMap::AliFMDFloatMap(Int_t maxDet,
                               Int_t maxRing,
                               Int_t maxSec,
                               Int_t maxStr)
   : AliFMDMap(maxDet, maxRing, maxSec, maxStr),
     fTotal(fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips),
-    fData(new Float_t[fTotal])
+    fData(0)
 {
   // Constructor.
   // Parameters:
@@ -62,6 +145,8 @@ AliFMDFloatMap::AliFMDFloatMap(Int_t maxDet,
   //   maxRing Maximum number of rings per detector
   //   maxSec  Maximum number of sectors per ring
   //   maxStr  Maximum number of strips per sector
+  if (fTotal == 0) fTotal = 51200;
+  fData = new Float_t[fTotal];
   Reset(0);
 }
 
@@ -81,6 +166,7 @@ AliFMDFloatMap::operator=(const AliFMDFloatMap& other)
       fMaxSectors   = other.fMaxSectors;
       fMaxStrips    = other.fMaxStrips;
       fTotal        = fMaxDetectors * fMaxRings * fMaxSectors * fMaxStrips;
+      if (fTotal == 0) fTotal = 51200;
       if (fData) delete [] fData;
       fData = new Float_t[fTotal];
     }
@@ -89,6 +175,7 @@ AliFMDFloatMap::operator=(const AliFMDFloatMap& other)
   return *this;
 }
 
+
 //__________________________________________________________
 void
 AliFMDFloatMap::Reset(const Float_t& val)
@@ -98,6 +185,16 @@ AliFMDFloatMap::Reset(const Float_t& val)
 }
 
 //__________________________________________________________
+void
+AliFMDFloatMap::Print(Option_t* option) const
+{
+  // Print contents of map
+  if (!option || option[0] == '\0') TObject::Print();
+  Printer p(option);
+  ForEach(p);
+  printf("\n");
+}
+//__________________________________________________________
 Float_t&
 AliFMDFloatMap::operator()(UShort_t det, 
                           Char_t   ring, 
index e9e235f..c9a772f 100755 (executable)
 class AliFMDFloatMap : public AliFMDMap
 {
 public:
-  AliFMDFloatMap(Int_t  maxDet = kMaxDetectors, 
-                Int_t  maxRing= kMaxRings, 
-                Int_t  maxSec = kMaxSectors, 
-                Int_t  maxStr = kMaxStrips);
+  AliFMDFloatMap();
+  AliFMDFloatMap(Int_t  maxDet, 
+                Int_t  maxRing= 0, 
+                Int_t  maxSec = 0, 
+                Int_t  maxStr = 0);
+  AliFMDFloatMap(const AliFMDMap& o);
   AliFMDFloatMap(const AliFMDFloatMap& o);
   virtual ~AliFMDFloatMap() { delete [] fData;fData = 0; }
   AliFMDFloatMap& operator=(const AliFMDFloatMap& o);
@@ -37,12 +39,47 @@ public:
                                    UShort_t sec,
                                    UShort_t str) const;
   Float_t* Data() const { return fData; }
+  void Print(Option_t* option="%8.4f") const;
 protected:
+  Int_t    MaxIndex() const { return fTotal; }
+  Float_t  AtAsFloat(Int_t i) const { return fData[i]; } 
+  Float_t& AtAsFloat(Int_t i)       { return fData[i]; } 
+  Bool_t   IsFloat() const { return kTRUE; }
+
   Int_t   fTotal;  // Total number of entries
   Float_t* fData;   //[fTotal]
-  ClassDef(AliFMDFloatMap,2) // Map of floats
+  ClassDef(AliFMDFloatMap,3) // Map of floats
 };
 
+inline AliFMDFloatMap
+operator*(const AliFMDMap& lhs, const AliFMDMap& rhs)
+{
+  AliFMDFloatMap r(lhs);
+  r *= rhs;
+  return r;
+}
+inline AliFMDFloatMap
+operator/(const AliFMDMap& lhs, const AliFMDMap& rhs)
+{
+  AliFMDFloatMap r(lhs);
+  r /= rhs;
+  return r;
+}
+inline AliFMDFloatMap
+operator+(const AliFMDMap& lhs, const AliFMDMap& rhs)
+{
+  AliFMDFloatMap r(lhs);
+  r += rhs;
+  return r;
+}
+inline AliFMDFloatMap
+operator-(const AliFMDMap& lhs, const AliFMDMap& rhs)
+{
+  AliFMDFloatMap r(lhs);
+  r -= rhs;
+  return r;
+}
+
 #endif
 //____________________________________________________________________
 //
index 1b8ce2a..8e7a2a0 100755 (executable)
@@ -58,6 +58,17 @@ AliFMDMap::AliFMDMap(UShort_t maxDet,
 }
 
 //____________________________________________________________________
+AliFMDMap::AliFMDMap(const AliFMDMap& other)
+  : TObject(other), 
+    fMaxDetectors(other.fMaxDetectors), 
+    fMaxRings(other.fMaxRings),
+    fMaxSectors(other.fMaxSectors),
+    fMaxStrips(other.fMaxStrips)
+{
+  SetBit(kNeedUShort, other.TestBit(kNeedUShort));
+}
+
+//____________________________________________________________________
 void
 AliFMDMap::CheckNeedUShort(TFile* file) 
 {
@@ -68,8 +79,60 @@ AliFMDMap::CheckNeedUShort(TFile* file)
   if (info->GetClassVersion() == 2) SetBit(kNeedUShort);
 }
 //____________________________________________________________________
+void
+AliFMDMap::Index2CoordsOld(Int_t     idx, 
+                          UShort_t& det, 
+                          Char_t&   ring, 
+                          UShort_t& sec, 
+                          UShort_t& str) const
+{
+  UShort_t rng;
+  str  = idx % fMaxStrips;
+  sec  = (idx / fMaxStrips) % fMaxSectors;
+  rng  = (idx / fMaxStrips / fMaxSectors) % fMaxRings;
+  det  = (idx / fMaxStrips / fMaxSectors / fMaxRings) % fMaxDetectors + 1;
+  ring = (rng == 0 ? 'I' : 'O');
+}
+
+//____________________________________________________________________
+void
+AliFMDMap::Index2Coords(Int_t     idx, 
+                       UShort_t& det, 
+                       Char_t&   ring, 
+                       UShort_t& sec, 
+                       UShort_t& str) const
+{
+  UShort_t nStr;
+  Int_t    i   = idx;
+  if      (i >= kFMD3Base)  { det  = 3;  i -= kFMD3Base; }
+  else if (i >= kFMD2Base)  { det  = 2;  i -= kFMD2Base; }
+  else                      { det  = 1;  i -= kFMD1Base; } 
+  if      (i >= kBaseOuter) { ring = 'O';i -= kBaseOuter; nStr = kNStripOuter; }
+  else                      { ring = 'I';                 nStr = kNStripInner; }
+  sec  = i / nStr;
+  str  = i % nStr;
+}
+
+//____________________________________________________________________
+void
+AliFMDMap::CalcCoords(Int_t     idx, 
+                     UShort_t& det, 
+                     Char_t&   ring, 
+                     UShort_t& sec, 
+                     UShort_t& str) const
+{
+  if (fMaxDetectors == 0) {
+    Index2Coords(idx, det, ring, sec, str);
+  }
+  else {
+    Index2CoordsOld(idx, det, ring, sec, str);
+  }
+}
+
+//____________________________________________________________________
 Int_t 
-AliFMDMap::CheckIndex(UShort_t det, Char_t ring, UShort_t sec, UShort_t str) const
+AliFMDMap::Coords2IndexOld(UShort_t det, Char_t ring, UShort_t sec, 
+                          UShort_t str) const
 {
   // Check that the index supplied is OK.   Returns true index, or -1
   // on error. 
@@ -83,6 +146,46 @@ AliFMDMap::CheckIndex(UShort_t det, Char_t ring, UShort_t sec, UShort_t str) con
   return idx;
 }
 
+//____________________________________________________________________
+Int_t 
+AliFMDMap::Coords2Index(UShort_t det, Char_t ring, UShort_t sec, 
+                       UShort_t str) const
+{
+  // Check that the index supplied is OK.   Returns true index, or -1
+  // on error. 
+  UShort_t irg  = (ring == 'I' || ring == 'i' ? kInner : 
+                  (ring == 'O' || ring == 'o' ? kOuter  : kOuter+1));
+  if (irg > kOuter) return -1;
+    
+  Int_t idx = 0;
+  switch (det) { 
+  case 1: idx = kFMD1Base;  if (irg > 0) return -1; break;
+  case 2: idx = kFMD2Base + irg * kBaseOuter; break;
+  case 3: idx = kFMD3Base + irg * kBaseOuter; break;
+  default: return -1;
+  }
+  UShort_t nSec = (irg == 0 ?  kNSectorInner :  kNSectorOuter);
+  if (sec >= nSec) return -1;
+  UShort_t nStr = (irg == 0 ? kNStripInner : kNStripOuter);
+  if (str >= nStr) return -1;
+  idx += nStr * sec + str;
+
+  return idx;
+}
+
+//____________________________________________________________________
+Int_t 
+AliFMDMap::CheckIndex(UShort_t det, Char_t ring, UShort_t sec, 
+                     UShort_t str) const
+{
+  // Check that the index supplied is OK.   Returns true index, or -1
+  // on error. 
+  if (fMaxDetectors == 0)
+    return Coords2Index(det, ring, sec, str);
+  return Coords2IndexOld(det, ring, sec, str);
+}
+
+
     
 //____________________________________________________________________
 Int_t 
@@ -100,8 +203,9 @@ AliFMDMap::CalcIndex(UShort_t det, Char_t ring, UShort_t sec, UShort_t str) cons
   //
   Int_t idx = CheckIndex(det, ring, sec, str);
   if (idx < 0) {
-    UShort_t ringi = (ring == 'I' ||  ring == 'i' ? 0 : 1);
-    AliFatal(Form("Index (%d,'%c',%d,%d) out of bounds, "
+    UShort_t ringi = (ring == 'I' ||  ring == 'i' ? 0 : 
+                     (ring == 'O' || ring == 'o' ? 1 : 2));
+    AliFatal(Form("Index FMD%d%c[%2d,%3d] out of bounds, "
                  "in particular the %s index ", 
                  det, ring, sec, str, 
                  (det > fMaxDetectors ? "Detector" : 
@@ -112,6 +216,147 @@ AliFMDMap::CalcIndex(UShort_t det, Char_t ring, UShort_t sec, UShort_t str) cons
   return idx;
 }
 
+#define INCOMP_OP(self, other, OP) do {                                        \
+  AliWarning("Incompatible sized AliFMDMap");                          \
+  UShort_t maxDet = TMath::Min(self->MaxDetectors(), other.MaxDetectors()); \
+  UShort_t maxRng = TMath::Min(self->MaxRings(),     other.MaxRings());        \
+  UShort_t maxSec = TMath::Min(self->MaxSectors(),   other.MaxSectors()); \
+  UShort_t maxStr = TMath::Min(self->MaxStrips(),    other.MaxStrips()); \
+  for (UShort_t d = 1; d <= maxDet; d++) {                             \
+    UShort_t nRng = TMath::Min(UShort_t(d == 1 ? 1 : 2), maxRng);      \
+    for (UShort_t q = 0; q < nRng; q++) {                               \
+      Char_t   r    = (q == 0 ? 'I' : 'O');                             \
+      UShort_t nSec = TMath::Min(UShort_t(q == 0 ?  20 :  40), maxSec);        \
+      UShort_t nStr = TMath::Min(UShort_t(q == 0 ? 512 : 256), maxStr);        \
+      for (UShort_t s = 0; s < nSec; s++) {                            \
+        for (UShort_t t = 0; t < nStr; t++) {                          \
+         Int_t idx1 = self->CalcIndex(d, r, s, t);                     \
+         Int_t idx2 = other.CalcIndex(d, r, s, t);                     \
+         if (idx1 < 0 || idx2 < 0) {                                   \
+           AliWarning("Index out of bounds");                          \
+           continue;                                                   \
+         }                                                             \
+         if (self->IsFloat())                                          \
+           self->AtAsFloat(idx1) OP other.AtAsFloat(idx2);             \
+         else if (self->IsInt())                                       \
+           self->AtAsInt(idx1) OP other.AtAsInt(idx2);                 \
+         else if (self->IsUShort())                                    \
+           self->AtAsUShort(idx1) OP other.AtAsUShort(idx2);           \
+         else if (self->IsBool())                                      \
+           self->AtAsBool(idx1) OP other.AtAsBool(idx2);               \
+       }                                                               \
+      }                                                                        \
+    }                                                                  \
+  }                                                                    \
+  } while (false)
+
+#define COMP_OP(self,other,OP) do {                                    \
+    for (Int_t i = 0; i < self->MaxIndex(); i++) {                     \
+      if (self->IsFloat())                                             \
+       self->AtAsFloat(i) OP other.AtAsFloat(i);                       \
+      else if (self->IsInt())                                          \
+       self->AtAsInt(i) OP other.AtAsInt(i);                           \
+      else if (self->IsUShort())                                       \
+       self->AtAsUShort(i) OP other.AtAsUShort(i);                     \
+      else if (self->IsBool())                                         \
+       self->AtAsBool(i) OP other.AtAsBool(i);                         \
+    } } while (false)
+
+//__________________________________________________________
+AliFMDMap&
+AliFMDMap::operator*=(const AliFMDMap& other)
+{
+  // Right multiplication assignment operator 
+  if(fMaxDetectors!= other.fMaxDetectors||
+     fMaxRings    != other.fMaxRings    ||
+     fMaxSectors  != other.fMaxSectors  ||
+     fMaxStrips   != other.fMaxStrips   ||
+     MaxIndex()   != other.MaxIndex()) {
+    INCOMP_OP(this, other, *=);
+    return *this;
+  }
+  COMP_OP(this, other, *=);
+  return *this;
+}
+
+//__________________________________________________________
+AliFMDMap&
+AliFMDMap::operator/=(const AliFMDMap& other)
+{
+  // Right division assignment operator 
+  if(fMaxDetectors!= other.fMaxDetectors||
+     fMaxRings    != other.fMaxRings    ||
+     fMaxSectors  != other.fMaxSectors  ||
+     fMaxStrips   != other.fMaxStrips   ||
+     MaxIndex()   != other.MaxIndex()) {
+    INCOMP_OP(this, other, /=);
+    return *this;
+  }
+  COMP_OP(this, other, /=);
+  return *this;
+}
+
+//__________________________________________________________
+AliFMDMap&
+AliFMDMap::operator+=(const AliFMDMap& other)
+{
+  // Right addition assignment operator 
+  if(fMaxDetectors!= other.fMaxDetectors||
+     fMaxRings    != other.fMaxRings    ||
+     fMaxSectors  != other.fMaxSectors  ||
+     fMaxStrips   != other.fMaxStrips   ||
+     MaxIndex()   != other.MaxIndex()) {
+    INCOMP_OP(this, other, +=);
+    return *this;
+  }
+  COMP_OP(this, other, +=);
+  return *this;
+}
+
+//__________________________________________________________
+AliFMDMap&
+AliFMDMap::operator-=(const AliFMDMap& other)
+{
+  // Right subtraction assignment operator 
+  if(fMaxDetectors!= other.fMaxDetectors||
+     fMaxRings    != other.fMaxRings    ||
+     fMaxSectors  != other.fMaxSectors  ||
+     fMaxStrips   != other.fMaxStrips   ||
+     MaxIndex()   != other.MaxIndex()) {
+    INCOMP_OP(this, other, +=);
+    return *this;
+  }
+  COMP_OP(this, other, +=);
+  return *this;
+}
+
+//__________________________________________________________
+Bool_t
+AliFMDMap::ForEach(ForOne& algo) const
+{
+  // Assignment operator 
+  Bool_t ret = kTRUE;
+  for (Int_t i = 0; i < this->MaxIndex(); i++) { 
+    UShort_t d, s, t;
+    Char_t r;
+    CalcCoords(i, d, r, s, t);
+    Bool_t rr = kTRUE;
+    if (IsFloat()) 
+      rr = algo.operator()(d, r, s, t, this->AtAsFloat(i));
+    else if (IsInt()) 
+      rr = algo.operator()(d, r, s, t, this->AtAsInt(i));
+    else if (IsUShort()) 
+      rr = algo.operator()(d, r, s, t, this->AtAsUShort(i));
+    else if (IsBool()) 
+      rr = algo.operator()(d, r, s, t, this->AtAsBool(i));
+    if (!rr) {
+      ret = kFALSE;
+      break;
+    }
+  }
+  return ret;
+}
+
 #if 0
 //___________________________________________________________________
 void AliFMDMap::Streamer(TBuffer &R__b)
index 6ffdc68..f25f736 100755 (executable)
@@ -29,59 +29,504 @@ public:
     /** Default maximum number of strips */
     kMaxStrips    = 512
   };
-  /** Constructor 
-      @param maxDet  Maximum allowed detector number
-      @param maxRing Maximum number of rings
-      @param maxSec  Maximum number of sectors
-      @param maxStr  Maximum number of strips
-      @return  */
-  AliFMDMap(UShort_t maxDet = kMaxDetectors, 
-           UShort_t maxRing= kMaxRings, 
-           UShort_t maxSec = kMaxSectors, 
-           UShort_t maxStr = kMaxStrips);
+  enum { 
+    /** Number used for inner rings */
+    kInner = 0, 
+    /** Number used for outer rings */
+    kOuter
+  };
+  enum { 
+    /** Number of strips in outer rings */ 
+    kNStripOuter = 256, 
+    /** Number of strips in the inner rings */ 
+    kNStripInner = 512
+  };
+  enum { 
+    /** Number of sectors in the inner rings */ 
+    kNSectorInner = 20, 
+    /** Number of sectorts in the outer rings */ 
+    kNSectorOuter = 40
+ };
+  enum { 
+    /** Base index for inner rings */ 
+    kBaseInner = 0, 
+    /** Base index for outer rings */
+    kBaseOuter = kNSectorInner * kNStripInner
+  };
+  enum { 
+    /** Base for FMD1 index */ 
+    kFMD1Base = 0, 
+    /** Base for FMD2 index */ 
+    kFMD2Base = kNSectorInner * kNStripInner, 
+    /** Base for FMD3 index */ 
+    kFMD3Base = (kBaseOuter + kNSectorOuter * kNStripOuter + kFMD2Base)
+  };
+  /** 
+   * Class to do stuff on each element of a map in an efficient
+   * way. 
+   */ 
+  class ForOne 
+  {
+  public:
+  /** Destructor */
+    virtual ~ForOne() { }
+    /** 
+     * Called for each element considered a floating point number 
+     *
+     * @param d   Detector number
+     * @param r   Ring identifier 
+     * @param s   Sector number
+     * @param t   Strip number
+     * @param v   Value (as a floating point number)
+     * 
+     * @return Should return @c true on success, @c false otherwise
+     */
+    virtual Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t, 
+                             Float_t v);
+    /** 
+     * Called for each element considered an integer
+     *
+     * @param d   Detector number
+     * @param r   Ring identifier 
+     * @param s   Sector number
+     * @param t   Strip number
+     * @param v   Value (as an integer)
+     * 
+     * @return Should return @c true on success, @c false otherwise
+     */
+    virtual Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t, 
+                             Int_t v);
+    /** 
+     * Called for each element considered an integer
+     *
+     * @param d   Detector number
+     * @param r   Ring identifier 
+     * @param s   Sector number
+     * @param t   Strip number
+     * @param v   Value (as an unsigned short integer)
+     * 
+     * @return Should return @c true on success, @c false otherwise
+     */
+    virtual Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t, 
+                             UShort_t v);
+    /** 
+     * Called for each element considered an integer
+     *
+     * @param d   Detector number
+     * @param r   Ring identifier 
+     * @param s   Sector number
+     * @param t   Strip number
+     * @param v   Value (as a boolean)
+     * 
+     * @return Should return @c true on success, @c false otherwise
+     */
+    virtual Bool_t operator()(UShort_t d, Char_t r, UShort_t s, UShort_t t, 
+                             Bool_t v);
+  };
+
+  /** 
+   * Constructor 
+   * 
+   * @param maxDet  Maximum allowed detector number
+   * @param maxRing Maximum number of rings
+   * @param maxSec  Maximum number of sectors
+   * @param maxStr  Maximum number of strips
+   */
+  AliFMDMap(UShort_t maxDet = 0, 
+           UShort_t maxRing= 0, 
+           UShort_t maxSec = 0, 
+           UShort_t maxStr = 0);
+  /** 
+   * Copy constructor
+   * 
+   * @param other Object to construct from
+   */  
+  AliFMDMap(const AliFMDMap& other);
   /** Destructor */
   virtual ~AliFMDMap() {}
   /** @return  Maximum detector number */
-  UShort_t MaxDetectors() const { return fMaxDetectors; }
+  UShort_t MaxDetectors() const { return fMaxDetectors==0 ?   3 :fMaxDetectors;}
   /** @return  Maximum number of rings */
-  UShort_t MaxRings()     const { return fMaxRings; }
+  UShort_t MaxRings()     const { return fMaxRings    ==0 ?   2 :fMaxRings; }
   /** @return  Maximum number of sectors */
-  UShort_t MaxSectors()   const { return fMaxSectors; }
+  UShort_t MaxSectors()   const { return fMaxSectors  ==0 ?  40 :fMaxSectors; }
   /** @return  Maximum number of strip */
-  UShort_t MaxStrips()    const { return fMaxStrips; }
-  /** Calculate, check, and return index for strip.  If the index is
-      invalid, -1 is returned
-      @param det   Detector number
-      @param ring  Ring identifier
-      @param sec   Sector number 
-      @param str   Strip number
-      @return  Unique index, or -1 in case of errors */
+  UShort_t MaxStrips()    const { return fMaxStrips   ==0 ? 512 :fMaxStrips; }
+  /** 
+   * Calculate the detector coordinates for a given index number
+   * 
+   * @param idx  Index to find cooresponding detector coordinates for
+   * @param det  On return, contain the detector number 
+   * @param ring On return, contain the ring identifier
+   * @param sec  On return, contain the sector number
+   * @param str  On return, contain the strip number 
+   */
+  void CalcCoords(Int_t     idx, 
+                 UShort_t& det, 
+                 Char_t&   ring, 
+                 UShort_t& sec, 
+                 UShort_t& str) const;
+  /** 
+   * Calculate index and return 
+   *
+   * @param det  Detector number
+   * @param ring Ring identifier 
+   * @param sec  Sector number 
+   * @param str  Strip number 
+   * 
+   * @return  Index (not checked) 
+   */
+  Int_t CalcIndex(UShort_t det, Char_t ring, 
+                 UShort_t sec, UShort_t str) const;
+  /** 
+   * Calculate index and return 
+   *
+   * @param det  Detector number
+   * @param ring Ring identifier 
+   * @param sec  Sector number 
+   * @param str  Strip number 
+   * 
+   * @return  Index or -1 if the coordinates are invalid
+   */
   Int_t  CheckIndex(UShort_t det, Char_t ring, 
                    UShort_t sec, UShort_t str) const;
-  /** Check if we need UShort_t hack 
-      @param file File this object was read from */
+  /** 
+   * Check if we need UShort_t hack 
+   * 
+   * @param file File this object was read from 
+   */
   void CheckNeedUShort(TFile* file);
+  /** 
+   * Right multiplication operator
+   * 
+   * @param o Other map to multuiply with
+   * 
+   * @return Reference to this object
+   */
+  AliFMDMap& operator*=(const AliFMDMap& o);
+  /** 
+   * Right division operator
+   * 
+   * @param o Other map to divide with
+   * 
+   * @return Reference to this object
+   */
+  AliFMDMap& operator/=(const AliFMDMap& o);
+  /** 
+   * Right addision operator
+   * 
+   * @param o Other map to add to this
+   * 
+   * @return Reference to this object
+   */
+  AliFMDMap& operator+=(const AliFMDMap& o);
+  /** 
+   * Right subtraction operator
+   * 
+   * @param o Other map to substract from this
+   * 
+   * @return Reference to this object
+   */
+  AliFMDMap& operator-=(const AliFMDMap& o);
+  /** 
+   * For each element of the map, call the user defined overloaded
+   * @c ForOne::operator() 
+   * 
+   * @param algo Algorithm to use
+   * 
+   * @return @c true on success, @c false if for any element, @c
+   * algo(d,r,s,t,v) returns false. 
+   */
+  virtual Bool_t  ForEach(ForOne& algo) const;
+  /** 
+   * Get the total size of the internal array - that is the maximum
+   * index possible plus one. 
+   * 
+   * @return maximum index, plus 1
+   */
+  virtual Int_t MaxIndex() const = 0;
+  /** 
+   * Virtal function to get the value at index @a idx as a floating
+   * point number.  
+   * 
+   * @note 
+   * Even if the map is not floating point valued the
+   * sub-class can define this member function to allow non l-value
+   * usage of the data in the map.   That is, if @c a is a floating
+   * point valued map, and @c b is not, then if the class @c B of @c b 
+   * implements this member function, expression like 
+   *
+   * @verbatim
+   *   a += b;
+   * @endverbatim 
+   *
+   * multiplies each element of @c a (floating points) with each
+   * element of @c c according to the definition of @c B::AtAsFloat
+   * (@c const version).   
+   *
+   * @param idx Index number
+   * 
+   * @return Value at index as a floating point number 
+   */
+  virtual Float_t AtAsFloat(Int_t idx) const;
+  /** 
+   * Virtal function to get the value at index @a idx as a floating
+   * point number.  
+   * 
+   * This member function should only be defined if the map is a
+   * floating point valued, and can be assigned floating point valued
+   * values.  That is, if the map's elements are anything but @c
+   * float then this member function should not be defined in the
+   * derived class.  That will prevent expressions like 
+   *
+   * @code 
+   *   a += b;
+   * @endcode
+   * 
+   * where @c a is non-floating point valued, and @c b is floating
+   * point valued (only).
+   *
+   * @param idx Index number
+   * 
+   * @return Value at index as a floating point number 
+   */
+  virtual Float_t& AtAsFloat(Int_t idx);
+  /** 
+   * Virtal function to get the value at index @a idx as an integer
+   * 
+   * @see Float_t AliFMDMap::AtAsFloat(Int_t) const
+   *
+   * @param idx Index number
+   * 
+   * @return Value at index as an integer
+   */
+  virtual Int_t   AtAsInt(Int_t idx) const;
+  /** 
+   * Virtal function to get the value at index @a idx as an integer
+   * 
+   * @see Float_t& AliFMDMap::AtAsFloat(Int_t)
+   *
+   * @param idx Index number
+   * 
+   * @return Value at index as an integer
+   */
+  virtual Int_t&   AtAsInt(Int_t idx);
+  /** 
+   * Virtal function to get the value at index @a idx as an boolean  
+   * 
+   * @see Float_t AliFMDMap::AtAsFloat(Int_t) const
+   *
+   * @param idx Index number
+   * 
+   * @return Value at index as a boolean
+   */
+  virtual UShort_t   AtAsUShort(Int_t idx) const;
+  /** 
+   * Virtal function to get the value at index @a idx as an boolean
+   * 
+   * @see Float_t& AliFMDMap::AtAsFloat(Int_t)
+   *
+   * @param idx Index number
+   * 
+   * @return Value at index as a boolean
+   */
+  virtual UShort_t&   AtAsUShort(Int_t idx);
+  /** 
+   * Virtal function to get the value at index @a idx as an unsigned
+   * short integer  
+   * 
+   * @see Float_t AliFMDMap::AtAsFloat(Int_t) const
+   *
+   * @param idx Index number
+   * 
+   * @return Value at index as an unsigned short integer
+   */
+  virtual Bool_t   AtAsBool(Int_t idx) const;
+  /** 
+   * Virtal function to get the value at index @a idx as an unsigned
+   * short integer
+   * 
+   * @see Float_t& AliFMDMap::AtAsFloat(Int_t)
+   *
+   * @param idx Index number
+   * 
+   * @return Value at index as an unsigned short integer
+   */
+  virtual Bool_t&   AtAsBool(Int_t idx);
+  /**
+   * Whether this map is floating point valued - that is, it can be
+   * assigned floating point valued values.
+   * 
+   * @return @c true if the map is floating point valued 
+   */
+  virtual Bool_t IsFloat() const { return kFALSE; }
+  /**
+   * Whether this map is floating point valued or integer valued -
+   * that is, it can be assigned integer valued values
+   * 
+   * @return @c true if the map is integer valued 
+   */
+  virtual Bool_t IsInt() const { return kFALSE; }
+  /**
+   * Whether this map is unsigned short integer valued - that is it
+   * can be assigned unsigned short integer values
+   * 
+   * @return @c true if the map is unsigned short integer valued 
+   */
+  virtual Bool_t IsUShort() const { return kFALSE; }
+  /**
+   * Whether this map is boolean valued - that is it can be assigned
+   * boolean values
+   * 
+   * @return @c true if the map is boolean valued 
+   */
+  virtual Bool_t IsBool() const { return kFALSE; }
+
   enum {
     /** In case of version 2 of this class, this bit should be set. */
     kNeedUShort = 14
   };
 protected:
-  /** Calculate index and return 
-      @param det  Detector number
-      @param ring Ring identifier 
-      @param sec  Sector number 
-      @param str  Strip number 
-      @return  Index (not checked) */
-  Int_t CalcIndex(UShort_t det, Char_t ring, 
+  /** 
+   * Calculate, check, and return index for strip.  If the index is
+   * invalid, -1 is returned
+   * 
+   * This is only used when a full map is used, signalled by
+   * fMaxDetector = 0
+   * 
+   * @param det   Detector number
+   * @param ring  Ring identifier
+   * @param sec   Sector number 
+   * @param str   Strip number
+   * 
+   * @return  Unique index, or -1 in case of errors 
+   */
+  Int_t  Coords2Index(UShort_t det, Char_t ring, 
                  UShort_t sec, UShort_t str) const;
+  /** 
+   * Calculate, check, and return index for strip.  If the index is
+   * invalid, -1 is returned
+   * 
+   * This is for back-ward compatibility and for when a map does not
+   * cover all of the FMD strips
+   * 
+   * @param det   Detector number
+   * @param ring  Ring identifier
+   * @param sec   Sector number 
+   * @param str   Strip number
+   *
+   * @return  Unique index, or -1 in case of errors 
+   */
+  Int_t  Coords2IndexOld(UShort_t det, Char_t ring, 
+                        UShort_t sec, UShort_t str) const;
+  /** 
+   * Calculate the detector coordinates from an array index. 
+   * 
+   * This is used for backward compatibility and for when a map does not
+   * cover all of the FMD strips
+   * 
+   * @param idx  Index to convert
+   * @param det  Detector number on return
+   * @param ring Ring identifier on return
+   * @param sec  Sector number on return
+   * @param str  Strip number on return
+   */
+  void Index2CoordsOld(Int_t     idx, 
+                      UShort_t& det, 
+                      Char_t&   ring, 
+                      UShort_t& sec, 
+                      UShort_t& str) const;
+  /** 
+   * Calculate the detector coordinates from an array index. 
+   * 
+   * This is used for a full map only, signalled by fMaxDetector = 0
+   * 
+   * @param idx  Index to convert
+   * @param det  Detector number on return
+   * @param ring Ring identifier on return
+   * @param sec  Sector number on return
+   * @param str  Strip number on return
+   */
+  void Index2Coords(Int_t     idx, 
+                   UShort_t& det, 
+                   Char_t&   ring, 
+                   UShort_t& sec, 
+                   UShort_t& str) const;
   UShort_t fMaxDetectors;             // Maximum # of detectors
   UShort_t fMaxRings;                 // Maximum # of rings
   UShort_t fMaxSectors;               // Maximum # of sectors
   UShort_t fMaxStrips;                // Maximum # of strips
 
-  ClassDef(AliFMDMap, 3) // Cache of per strip information
+  ClassDef(AliFMDMap, 4) // Cache of per strip information
 };
 
+inline Float_t
+AliFMDMap::AtAsFloat(Int_t) const
+{
+  return 0;
+}
+inline Float_t&
+AliFMDMap::AtAsFloat(Int_t)
+{
+  static Float_t d;
+  return d;
+}
+inline Int_t
+AliFMDMap::AtAsInt(Int_t) const
+{
+  return 0;
+}
+inline Int_t&
+AliFMDMap::AtAsInt(Int_t)
+{
+  static Int_t d;
+  return d;
+}
+inline UShort_t
+AliFMDMap::AtAsUShort(Int_t) const
+{
+  return 0;
+}
+inline UShort_t&
+AliFMDMap::AtAsUShort(Int_t)
+{
+  static UShort_t d;
+  return d;
+}
+inline Bool_t
+AliFMDMap::AtAsBool(Int_t) const
+{
+  return kFALSE;
+}
+inline Bool_t&
+AliFMDMap::AtAsBool(Int_t)
+{
+  static Bool_t d;
+  return d;
+}
+inline Bool_t
+AliFMDMap::ForOne::operator()(UShort_t, Char_t, UShort_t, UShort_t, Float_t)
+{
+  return kTRUE;
+}
+inline Bool_t
+AliFMDMap::ForOne::operator()(UShort_t, Char_t, UShort_t, UShort_t, Int_t)
+{
+  return kTRUE;
+}
+inline Bool_t
+AliFMDMap::ForOne::operator()(UShort_t, Char_t, UShort_t, UShort_t, UShort_t)
+{
+  return kTRUE;
+}
+inline Bool_t
+AliFMDMap::ForOne::operator()(UShort_t, Char_t, UShort_t, UShort_t, Bool_t)
+{
+  return kTRUE;
+}
+
+
+
 #endif 
 //____________________________________________________________________
 //
index e363119..98aba41 100644 (file)
 #pragma link C++ class  AliTriggerScalersESD+;
 #pragma link C++ class  AliTriggerScalersRecordESD+;
 #pragma link C++ class  AliESDZDCScalers+;
+
+#pragma link C++ function operator*(const AliFMDMap&,const AliFMDMap&);
+#pragma link C++ function operator/(const AliFMDMap&,const AliFMDMap&);
+#pragma link C++ function operator+(const AliFMDMap&,const AliFMDMap&);
+#pragma link C++ function operator-(const AliFMDMap&,const AliFMDMap&);
   
 #endif