PHOS/AliPHOSRawDecoder.cxx

   1 /**************************************************************************
   2  * Copyright(c) 2007, ALICE Experiment at CERN, All rights reserved.      *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 // This class decodes the stream of ALTRO samples to extract
  19 // the PHOS "digits" of current event.
  20 //
  21 // Typical use case:
  22 //     AliRawReader* rf = new AliRawReaderDate("2006run2211.raw");
  23 //     AliPHOSRawDecoder dc(rf);
  24 //     while (rf->NextEvent()) {
  25 //       dc.SetOldRCUFormat(kTRUE);
  26 //       dc.SubtractPedestals(kTRUE);
  27 //       while ( dc.NextDigit() ) {
  28 //         Int_t module = dc.GetModule();
  29 //         Int_t column = dc.GetColumn();
  30 //         Int_t row = dc.GetRow();
  31 //         Double_t amplitude = dc.GetEnergy();
  32 //         Double_t time = dc.GetTime();
  33 //         Bool_t IsLowGain = dc.IsLowGain();
  34 //            ..........
  35 //       }
  36 //     }
  37
  38 // Author: Boris Polichtchouk
  39
  40 // --- ROOT system ---
  41 #include "TArrayI.h"
  42
  43 // --- AliRoot header files ---
  44 #include "AliPHOSRawDecoder.h"
  45 #include <iostream.h>
  46 ClassImp(AliPHOSRawDecoder)
  47
  48 //-----------------------------------------------------------------------------
  49 AliPHOSRawDecoder::AliPHOSRawDecoder():
  50   fRawReader(0),fCaloStream(0),fPedSubtract(kFALSE),fEnergy(-111),fTime(-111),fQuality(0.),
  51   fModule(-1),fColumn(-1),fRow(-1),fNewModule(-1),fNewColumn(-1),fNewRow(-1),fNewAmp(0),fNewTime(0),
  52   fLowGainFlag(kFALSE),fNewLowGainFlag(kFALSE),fOverflow(kFALSE),fSamples(0),fTimes(0)
  53 {
  54   //Default constructor.
  55 }
  56
  57 //-----------------------------------------------------------------------------
  58 AliPHOSRawDecoder::AliPHOSRawDecoder(AliRawReader* rawReader,  AliAltroMapping **mapping):
  59   fRawReader(0),fCaloStream(0),fPedSubtract(kFALSE),fEnergy(-111),fTime(-111),fQuality(0.),
  60   fModule(-1),fColumn(-1),fRow(-1),fNewModule(-1),fNewColumn(-1),fNewRow(-1),fNewAmp(0),fNewTime(0),
  61   fLowGainFlag(kFALSE),fNewLowGainFlag(kFALSE),fOverflow(kFALSE),fSamples(0),fTimes(0)
  62 {
  63   //Construct a decoder object.
  64   //Is is user responsibility to provide next raw event
  65   //using AliRawReader::NextEvent().
  66
  67   fRawReader =  rawReader;
  68   fCaloStream = new AliCaloRawStream(rawReader,"PHOS",mapping);
  69   fCaloStream->SetOldRCUFormat(kFALSE);
  70   fSamples = new TArrayI(100);
  71   fTimes = new TArrayI(100);
  72 }
  73
  74 //-----------------------------------------------------------------------------
  75 AliPHOSRawDecoder::~AliPHOSRawDecoder()
  76 {
  77   //Destructor.
  78
  79   if(fCaloStream){ delete fCaloStream; fCaloStream=0;}
  80   if(fSamples){ delete fSamples; fSamples=0 ;}
  81   if(fTimes){ delete fTimes; fTimes=0 ;}
  82 }
  83
  84 //-----------------------------------------------------------------------------
  85 AliPHOSRawDecoder::AliPHOSRawDecoder(const AliPHOSRawDecoder &phosDecoder ):
  86   fRawReader(phosDecoder.fRawReader),fCaloStream(phosDecoder.fCaloStream),
  87   fPedSubtract(phosDecoder.fPedSubtract),
  88   fEnergy(phosDecoder.fEnergy),fTime(phosDecoder.fTime),fQuality(phosDecoder.fQuality),
  89   fModule(phosDecoder.fModule),fColumn(phosDecoder.fColumn),
  90   fRow(phosDecoder.fRow),fNewModule(phosDecoder.fNewModule),fNewColumn(phosDecoder.fNewColumn),
  91   fNewRow(phosDecoder.fNewRow),fNewAmp(phosDecoder.fNewAmp),fNewTime(phosDecoder.fNewTime),
  92   fLowGainFlag(phosDecoder.fLowGainFlag),fNewLowGainFlag(phosDecoder.fNewLowGainFlag),
  93   fOverflow(phosDecoder.fOverflow),fSamples(phosDecoder.fSamples),
  94   fTimes(phosDecoder.fTimes)
  95 {
  96   //Copy constructor.
  97 }
  98
  99 //-----------------------------------------------------------------------------
 100 AliPHOSRawDecoder& AliPHOSRawDecoder::operator = (const AliPHOSRawDecoder &phosDecode)
 101 {
 102   //Assignment operator.
 103
 104   if(this != &phosDecode) {
 105     fRawReader = phosDecode.fRawReader;
 106
 107     if(fCaloStream) delete fCaloStream;
 108     fCaloStream = phosDecode.fCaloStream;
 109
 110     fEnergy = phosDecode.fEnergy;
 111     fTime = phosDecode.fTime;
 112     fQuality = phosDecode.fQuality ;
 113     fModule = phosDecode.fModule;
 114     fColumn = phosDecode.fColumn;
 115     fRow = phosDecode.fRow;
 116     fNewModule = phosDecode.fNewModule;
 117     fNewColumn = phosDecode.fNewColumn;
 118     fNewRow = phosDecode.fNewRow;
 119     fNewAmp = phosDecode.fNewAmp ;
 120     fNewTime= phosDecode.fNewTime ;
 121     fLowGainFlag = phosDecode.fLowGainFlag;
 122     fNewLowGainFlag = phosDecode.fNewLowGainFlag;
 123     fOverflow = phosDecode.fOverflow ;
 124
 125     if(fSamples) delete fSamples;
 126     fSamples = phosDecode.fSamples;
 127
 128     if(fTimes) delete fTimes;
 129     fTimes = phosDecode.fTimes;
 130   }
 131
 132   return *this;
 133 }
 134
 135 //-----------------------------------------------------------------------------
 136
 137 Bool_t AliPHOSRawDecoder::NextDigit()
 138 {
 139   //Extract an energy deposited in the crystal,
 140   //crystal' position (module,column,row),
 141   //time and gain (high or low).
 142
 143   AliCaloRawStream* in = fCaloStream;
 144
 145   Int_t    iBin     = 0;
 146   Int_t    mxSmps   = fSamples->GetSize();
 147   Int_t    tLength  = 0;
 148   fEnergy = -111;
 149   Float_t pedMean = 0;
 150   Int_t   nPed = 0;
 151   Float_t baseLine = 1.0;
 152   const Int_t nPreSamples = 10;
 153
 154   fSamples->Reset();
 155   while ( in->Next() ) {
 156
 157      if(!tLength) {
 158        tLength = in->GetTimeLength();
 159        if(tLength>mxSmps) {
 160          fSamples->Set(tLength);
 161        }
 162      }
 163
 164      // Fit the full sample
 165      if(in->IsNewHWAddress() && iBin>0) {
 166
 167        iBin=0;
 168        //First remember new sample
 169        fNewLowGainFlag = in->IsLowGain();
 170        fNewModule = in->GetModule()+1;
 171        fNewRow    = in->GetRow()   +1;
 172        fNewColumn = in->GetColumn()+1;
 173        fNewAmp = in->GetSignal() ;
 174        fNewTime=in->GetTime() ;
 175
 176        // Temporarily we take the energy as a maximum amplitude
 177        // and the pedestal from the 0th point (30 Aug 2006).
 178        // Time is not evaluated for the moment (12.01.2007).
 179        // Take is as a first time bin multiplied by the sample tick time
 180
 181        if(fPedSubtract)
 182          if (nPed > 0)
 183            fEnergy -= (Double_t)(pedMean/nPed); // pedestal subtraction
 184          else
 185            return kFALSE;
 186        if (fEnergy < baseLine) fEnergy = 0;
 187
 188        pedMean = 0;
 189        return kTRUE;
 190      }
 191
 192      fLowGainFlag = in->IsLowGain();
 193 //     fTime =   in->GetTime();
 194      fModule = in->GetModule()+1;
 195      fRow    = in->GetRow()   +1;
 196      fColumn = in->GetColumn()+1;
 197
 198     if(fLowGainFlag==fNewLowGainFlag && fModule==fNewModule &&
 199        fRow==fNewRow && fColumn==fNewColumn ){
 200        if(fNewAmp>fEnergy)  fEnergy = (Double_t)fNewAmp ;
 201        fNewModule=-1 ;
 202     }
 203
 204      //Calculate pedestal if necessary
 205      if(fPedSubtract && in->GetTime() < nPreSamples) {
 206        pedMean += in->GetSignal();
 207        nPed++;
 208      }
 209      if((Double_t)in->GetSignal() > fEnergy) fEnergy = (Double_t)in->GetSignal();
 210      iBin++ ;
 211
 212    } // in.Next()
 213
 214    return kFALSE;
 215 }