STEER/STEERBase/AliTOFHeader.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-2003, 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 //-----------------------------------------------------------------
  17 //           Implementation of the Event Time class
  18 //           for the Event Data Summary class
  19 //           This class contains the Event Time
  20 //           as estimated by the TOF combinatorial algorithm
  21 // Origin: A.De Caro, decaro@sa.infn.it
  22 //-----------------------------------------------------------------
  23
  24 //---- standard headers ----
  25 #include "Riostream.h"
  26 //---- Root headers --------
  27 #include "TArrayF.h"
  28 #include "TArrayI.h"
  29 //---- AliRoot headers -----
  30 #include "AliTOFHeader.h"
  31
  32
  33 ClassImp(AliTOFHeader)
  34
  35 //--------------------------------------------------------------------------
  36 AliTOFHeader::AliTOFHeader() :
  37   TObject(),
  38   fDefaultEventTimeValue(0.),
  39   fDefaultEventTimeRes(0.),
  40   fNbins(0),
  41   fEventTimeValues(0),
  42   fEventTimeRes(0),
  43   fNvalues(0),
  44   fTOFtimeResolution(0.),
  45   fT0spread(0.),
  46   fNumberOfTOFclusters(-1),
  47   fNumberOfTOFtrgPads(-1),
  48   fTrigMask(new AliTOFTriggerMask())
  49 {
  50   //
  51   // Default Constructor
  52   //
  53
  54 }
  55
  56 //--------------------------------------------------------------------------
  57 AliTOFHeader::AliTOFHeader(Float_t defEvTime, Float_t defResEvTime,
  58                            Int_t nDifPbins, Float_t *times, Float_t *res,
  59                            Int_t *nPbin, Float_t tofTimeRes, Float_t t0spread) :
  60   TObject(),
  61   fDefaultEventTimeValue(defEvTime),
  62   fDefaultEventTimeRes(defResEvTime),
  63   fNbins(nDifPbins),
  64   fEventTimeValues(0),
  65   fEventTimeRes(0),
  66   fNvalues(0),
  67   fTOFtimeResolution(tofTimeRes),
  68   fT0spread(t0spread),
  69   fNumberOfTOFclusters(-1),
  70   fNumberOfTOFtrgPads(-1),
  71   fTrigMask(new AliTOFTriggerMask())
  72 {
  73   //
  74   // Constructor for TOF header
  75   //
  76
  77   if (fNbins>0) {
  78     fEventTimeValues = new TArrayF(fNbins);
  79     fEventTimeRes = new TArrayF(fNbins);
  80     fNvalues = new TArrayI(fNbins);
  81     for (Int_t ii=0; ii<fNbins; ii++) {
  82       fEventTimeValues->SetAt(times[ii],ii);
  83       fEventTimeRes->SetAt(res[ii],ii);
  84       fNvalues->SetAt(nPbin[ii],ii);
  85     }
  86   }
  87
  88 }
  89
  90 //--------------------------------------------------------------------------
  91 AliTOFHeader::AliTOFHeader(const AliTOFHeader &source):
  92   TObject(source),
  93   fDefaultEventTimeValue(source.fDefaultEventTimeValue),
  94   fDefaultEventTimeRes(source.fDefaultEventTimeRes),
  95   fNbins(source.fNbins),
  96   fEventTimeValues(0),
  97   fEventTimeRes(0),
  98   fNvalues(0),
  99   fTOFtimeResolution(source.fTOFtimeResolution),
 100   fT0spread(source.fT0spread),
 101   fNumberOfTOFclusters(source.fNumberOfTOFclusters),
 102   fNumberOfTOFtrgPads(source.fNumberOfTOFtrgPads),
 103   fTrigMask(NULL)
 104 {
 105   //
 106   // Copy constructor
 107   //
 108
 109   if (fNbins>0) {
 110     fEventTimeValues = new TArrayF(fNbins);
 111     fEventTimeRes = new TArrayF(fNbins);
 112     fNvalues = new TArrayI(fNbins);
 113     for(Int_t i=0;i<fNbins;i++) {
 114       (*fEventTimeValues)[i]=source.fEventTimeValues->At(i);
 115       (*fEventTimeRes)[i]=source.fEventTimeRes->At(i);
 116       (*fNvalues)[i]=source.fNvalues->At(i);
 117     }
 118   }
 119
 120   if(source.fTrigMask) fTrigMask = new AliTOFTriggerMask(*(source.fTrigMask));
 121   else fTrigMask = new AliTOFTriggerMask();
 122 }
 123 //--------------------------------------------------------------------------
 124 AliTOFHeader &AliTOFHeader::operator=(const AliTOFHeader &source){
 125   //
 126   // assignment operator
 127   //
 128   if(&source != this){
 129     TObject::operator=(source);
 130
 131     fDefaultEventTimeValue=source.fDefaultEventTimeValue;
 132     fDefaultEventTimeRes=source.fDefaultEventTimeRes;
 133     fNbins=source.fNbins;
 134     fTOFtimeResolution=source.fTOFtimeResolution;
 135     fT0spread=source.fT0spread;
 136     fNumberOfTOFclusters=source.fNumberOfTOFclusters;
 137     fNumberOfTOFtrgPads=source.fNumberOfTOFtrgPads;
 138
 139     if (fNbins>0) {
 140       fEventTimeValues = new TArrayF(fNbins);
 141       fEventTimeRes = new TArrayF(fNbins);
 142       fNvalues = new TArrayI(fNbins);
 143       for(Int_t i=0;i<fNbins;i++) {
 144         (*fEventTimeValues)[i]=source.fEventTimeValues->At(i);
 145         (*fEventTimeRes)[i]=source.fEventTimeRes->At(i);
 146         (*fNvalues)[i]=source.fNvalues->At(i);
 147       }
 148     } else {
 149       fEventTimeValues = 0;
 150       fEventTimeRes = 0;
 151       fNvalues = 0;
 152     }
 153
 154     if(source.fTrigMask && fTrigMask) *fTrigMask = *(source.fTrigMask);
 155     else if(! fTrigMask) fTrigMask = new AliTOFTriggerMask();
 156   }
 157   return *this;
 158 }
 159 //--------------------------------------------------------------------------
 160 void AliTOFHeader::Copy(TObject &obj) const {
 161
 162   // this overwrites the virtual TOBject::Copy()
 163   // to allow run time copying without casting
 164   // in AliESDEvent
 165
 166   if (this==&obj) return;
 167   AliTOFHeader *robj = dynamic_cast<AliTOFHeader*>(&obj);
 168   if (!robj) return; // not an AliTOFHeader
 169   *robj = *this;
 170
 171 }
 172
 173 //--------------------------------------------------------------------------
 174 AliTOFHeader::~AliTOFHeader()
 175 {
 176
 177   fNbins = 0;
 178   if (fEventTimeValues) {
 179     delete fEventTimeValues;
 180     fEventTimeValues=0;
 181   }
 182   if (fEventTimeRes) {
 183     delete fEventTimeRes;
 184     fEventTimeRes=0;
 185   }
 186   if (fNvalues) {
 187     delete fNvalues;
 188     fNvalues=0;
 189   }
 190   if(fTrigMask){
 191     delete fTrigMask;
 192     fTrigMask=NULL;
 193   }
 194
 195 }
 196
 197 //--------------------------------------------------------------------------
 198 void AliTOFHeader::SetNbins(Int_t nbins)
 199 {
 200   //
 201   //
 202   //
 203
 204   fNbins=nbins;
 205   if (!fEventTimeValues)
 206     fEventTimeValues = new TArrayF(nbins);
 207   else
 208     fEventTimeValues->Set(nbins);
 209
 210   if (!fEventTimeRes)
 211     fEventTimeRes = new TArrayF(nbins);
 212   else
 213     fEventTimeRes->Set(nbins);
 214
 215   if (!fNvalues)
 216     fNvalues = new TArrayI(nbins);
 217   else
 218     fNvalues->Set(nbins);
 219
 220 }
 221 //--------------------------------------------------------------------------
 222 void AliTOFHeader::SetEventTimeValues(TArrayF *arr)
 223 {
 224   //
 225   //
 226   //
 227
 228   fNbins=arr->GetSize();
 229
 230   if (!fEventTimeValues)
 231     fEventTimeValues = new TArrayF(fNbins);
 232   else
 233     fEventTimeValues->Set(fNbins);
 234
 235   for (Int_t ii=0; ii<fNbins; ii++)
 236     fEventTimeValues->SetAt(arr->GetAt(ii),ii);
 237
 238 }
 239 //--------------------------------------------------------------------------
 240 void AliTOFHeader::SetEventTimeRes(TArrayF *arr)
 241 {
 242   //
 243   //
 244   //
 245
 246   fNbins=arr->GetSize();
 247
 248   if (!fEventTimeRes)
 249     fEventTimeRes = new TArrayF(fNbins);
 250   else
 251     fEventTimeRes->Set(fNbins);
 252
 253   for (Int_t ii=0; ii<fNbins; ii++)
 254     fEventTimeRes->SetAt(arr->GetAt(ii),ii);
 255
 256 }
 257 //--------------------------------------------------------------------------
 258 void AliTOFHeader::SetNvalues(TArrayI *arr)
 259 {
 260   //
 261   //
 262   //
 263
 264   fNbins=arr->GetSize();
 265
 266   if (!fNvalues)
 267     fNvalues = new TArrayI(fNbins);
 268   else
 269     fNvalues->Set(fNbins);
 270
 271   for (Int_t ii=0; ii<fNbins; ii++)
 272     fNvalues->SetAt(arr->GetAt(ii),ii);
 273
 274 }