HLT/trigger/AliHLTMuonSpectroScalars.cxx

   1 // $Id: $
   2 /**************************************************************************
   3  * This file is property of and copyright by the ALICE HLT Project        *
   4  * All rights reserved.                                                   *
   5  *                                                                        *
   6  * Primary Authors:                                                       *
   7  *   Artur Szostak <artursz@iafrica.com>                                  *
   8  *                                                                        *
   9  * Permission to use, copy, modify and distribute this software and its   *
  10  * documentation strictly for non-commercial purposes is hereby granted   *
  11  * without fee, provided that the above copyright notice appears in all   *
  12  * copies and that both the copyright notice and this permission notice   *
  13  * appear in the supporting documentation. The authors make no claims     *
  14  * about the suitability of this software for any purpose. It is          *
  15  * provided "as is" without express or implied warranty.                  *
  16  **************************************************************************/
  17
  18 ///  @file   AliHLTMuonSpectroScalars.cxx
  19 ///  @author Artur Szostak <artursz@iafrica.com>
  20 ///  @date   9 Nov 2009
  21 ///  @brief  Implementation of the muon spectrometer trigger scalars.
  22 ///
  23 /// This implements the trigger scalars for the muon spectrometer that can be used
  24 /// in the HLT global trigger and/or added to the AliESDEvent.
  25
  26 #include "AliHLTMuonSpectroScalars.h"
  27 #include "AliLog.h"
  28 #include "TObjArray.h"
  29 #include "TObjString.h"
  30 #include "TString.h"
  31 #include "Riostream.h"
  32
  33 using std::cout;
  34 using std::endl;
  35 using std::setw;
  36 ClassImp(AliHLTMuonSpectroScalars);
  37 ClassImp(AliHLTMuonSpectroScalars::AliScalar);
  38
  39
  40 AliHLTMuonSpectroScalars::AliHLTMuonSpectroScalars() :
  41         TObject(),
  42         fScalars(AliHLTMuonSpectroScalars::AliScalar::Class(), 128),
  43         fIndex(128),
  44         fIndexValid(false)
  45 {
  46         // Default constructor.
  47
  48         fIndex.SetOwner(kFALSE);
  49 }
  50
  51
  52 AliHLTMuonSpectroScalars::AliHLTMuonSpectroScalars(const AliHLTMuonSpectroScalars& obj) :
  53         TObject(obj),
  54         fScalars(obj.fScalars),
  55         fIndex(obj.fIndex),
  56         fIndexValid(obj.fIndexValid)
  57 {
  58         // Copy constructor performs a deep copy.
  59
  60         fIndex.SetOwner(kFALSE);
  61 }
  62
  63
  64 AliHLTMuonSpectroScalars::~AliHLTMuonSpectroScalars()
  65 {
  66         // Default destructor.
  67
  68         Clear();
  69 }
  70
  71
  72 void AliHLTMuonSpectroScalars::Add(const char* name, const char* description, Double_t value)
  73 {
  74         // Adds a new scalar.
  75
  76         new (fScalars[fScalars.GetEntriesFast()]) AliScalar(value, name, description);
  77         fIndexValid = false; // Invalidate the index.
  78 }
  79
  80
  81 bool AliHLTMuonSpectroScalars::Exists(const char* name) const
  82 {
  83         // Checks if the scalar exists or not.
  84
  85         if (not fIndexValid) MakeIndex();
  86         AliScalar tmpobj(0, name, "");
  87         Int_t n = fIndex.BinarySearch(&tmpobj);
  88         if (n == -1) return false;
  89         return true;
  90 }
  91
  92
  93 AliHLTMuonSpectroScalars::AliScalar* AliHLTMuonSpectroScalars::GetScalarN(UInt_t n)
  94 {
  95         // Fetch the n'th scalar object.
  96
  97         if (n >= NumberOfScalars())
  98         {
  99                 AliError(Form("Value 'n' is out of bounds. Should be in the range [0..%d].", NumberOfScalars()-1));
 100                 return NULL;
 101         }
 102         return static_cast<AliScalar*>( fScalars.UncheckedAt(Int_t(n)) );
 103 }
 104
 105
 106 const AliHLTMuonSpectroScalars::AliScalar* AliHLTMuonSpectroScalars::GetScalarN(UInt_t n) const
 107 {
 108         // Fetch the n'th scalar object.
 109
 110         if (n >= NumberOfScalars())
 111         {
 112                 AliError(Form("Value 'n' is out of bounds. Should be in the range [0..%d].", NumberOfScalars()-1));
 113                 return NULL;
 114         }
 115         return static_cast<const AliScalar*>( fScalars.UncheckedAt(Int_t(n)) );
 116 }
 117
 118
 119 AliHLTMuonSpectroScalars::AliScalar* AliHLTMuonSpectroScalars::GetScalar(const char* name)
 120 {
 121         // Fetch the named scalar object.
 122
 123         if (not fIndexValid) MakeIndex();
 124         AliScalar tmpobj(0, name, "");
 125         Int_t n = fIndex.BinarySearch(&tmpobj);
 126         if (n == -1)
 127         {
 128                 AliError(Form("Scalar '%s' could not be found.", name));
 129                 return NULL;
 130         }
 131         return static_cast<AliScalar*>( fIndex.UncheckedAt(n) );
 132 }
 133
 134
 135 const AliHLTMuonSpectroScalars::AliScalar* AliHLTMuonSpectroScalars::GetScalar(const char* name) const
 136 {
 137         // Fetch the named scalar object.
 138
 139         if (not fIndexValid) MakeIndex();
 140         AliScalar tmpobj(0, name, "");
 141         Int_t n = fIndex.BinarySearch(&tmpobj);
 142         if (n == -1)
 143         {
 144                 AliError(Form("Scalar '%s' could not be found.", name));
 145                 return NULL;
 146         }
 147         return static_cast<const AliScalar*>( fIndex.UncheckedAt(n) );
 148 }
 149
 150
 151 Double_t AliHLTMuonSpectroScalars::GetN(UInt_t n) const
 152 {
 153         // Fetches the n'th scalar value.
 154
 155         const AliScalar* scalar = GetScalarN(n);
 156         if (scalar == NULL) return 0;
 157         return scalar->Value();
 158 }
 159
 160
 161 Double_t AliHLTMuonSpectroScalars::Get(const char* name) const
 162 {
 163         // Fetches the n'th scalar value.
 164
 165         const AliScalar* scalar = GetScalar(name);
 166         if (scalar == NULL) return 0;
 167         return scalar->Value();
 168 }
 169
 170
 171 bool AliHLTMuonSpectroScalars::SetN(UInt_t n, Double_t value)
 172 {
 173         // Sets the n'th scalar value.
 174
 175         AliScalar* scalar = GetScalarN(n);
 176         if (scalar == NULL) return false;
 177         scalar->Value(value);
 178         return true;
 179 }
 180
 181
 182 bool AliHLTMuonSpectroScalars::Set(const char* name, Double_t value)
 183 {
 184         // Sets the named scalar value.
 185
 186         AliScalar* scalar = GetScalar(name);
 187         if (scalar == NULL) return false;
 188         scalar->Value(value);
 189         return true;
 190 }
 191
 192
 193 bool AliHLTMuonSpectroScalars::IncrementN(UInt_t n, UInt_t count)
 194 {
 195         // Increments the n'th scalar by a value of 'count'.
 196
 197         AliScalar* scalar = GetScalarN(n);
 198         if (scalar == NULL) return false;
 199         scalar->Increment(count);
 200         return true;
 201 }
 202
 203
 204 bool AliHLTMuonSpectroScalars::Increment(const char* name, UInt_t count)
 205 {
 206         // Increments the named scalar by a value of 'count'.
 207
 208         AliScalar* scalar = GetScalar(name);
 209         if (scalar == NULL) return false;
 210         scalar->Increment(count);
 211         return true;
 212 }
 213
 214
 215 const char* AliHLTMuonSpectroScalars::Name(UInt_t n) const
 216 {
 217         // Fetches the n'th scalar's name.
 218
 219         const AliScalar* scalar = GetScalarN(n);
 220         if (scalar == NULL) return NULL;
 221         return scalar->Name();
 222 }
 223
 224
 225 const char* AliHLTMuonSpectroScalars::Description(UInt_t n) const
 226 {
 227         // Fetches the n'th scalar's description.
 228
 229         const AliScalar* scalar = GetScalarN(n);
 230         if (scalar == NULL) return NULL;
 231         return scalar->Description();
 232 }
 233
 234
 235 void AliHLTMuonSpectroScalars::Reset()
 236 {
 237         // Sets all the scalar values to zero.
 238
 239         for (Int_t i = 0; i < fScalars.GetEntriesFast(); ++i)
 240         {
 241                 AliScalar* scalar = static_cast<AliScalar*>( fScalars.UncheckedAt(i) );
 242                 scalar->Value(0);
 243         }
 244 }
 245
 246
 247 void AliHLTMuonSpectroScalars::Clear(Option_t* option)
 248 {
 249         // Clears the array of scalars.
 250
 251         fScalars.Delete(option);
 252         fIndex.Clear();
 253 }
 254
 255
 256 void AliHLTMuonSpectroScalars::Copy(TObject& object) const
 257 {
 258         // Performs a deep copy.
 259
 260         if (object.IsA() != AliHLTMuonSpectroScalars::Class())
 261         {
 262                 AliError(Form("Cannot copy to an object of type '%s'.", object.ClassName()));
 263                 return;
 264         }
 265         AliHLTMuonSpectroScalars* obj = static_cast<AliHLTMuonSpectroScalars*>(&object);
 266         *obj = *this;
 267 }
 268
 269
 270 TObject* AliHLTMuonSpectroScalars::FindObject(const char* name) const
 271 {
 272         // Finds the scalar object by name.
 273
 274         if (fIndexValid)
 275         {
 276                 AliScalar tmpobj(0, name, "");
 277                 Int_t n = fIndex.BinarySearch(&tmpobj);
 278                 if (n != -1) return fIndex.UncheckedAt(n);
 279         }
 280         else
 281         {
 282                 return fScalars.FindObject(name);
 283         }
 284         return NULL;
 285 }
 286
 287
 288 TObject* AliHLTMuonSpectroScalars::FindObject(const TObject* obj) const
 289 {
 290         // Finds the scalar object with the same name as obj->GetName().
 291
 292         return FindObject(obj->GetName());
 293 }
 294
 295
 296 void AliHLTMuonSpectroScalars::Print(Option_t* option) const
 297 {
 298         // Prints the muon spectrometer's HLT trigger scalars.
 299
 300         TString opt = option;
 301         if (opt == "compact")
 302         {
 303                 if (NumberOfScalars() > 0)
 304                 cout << GetN(0);
 305                 for (UInt_t i = 1; i < NumberOfScalars(); ++i) cout << ", " << GetN(i);
 306                 cout << endl;
 307                 return;
 308         }
 309
 310         // Calculate the maximum field width required to keep things aligned.
 311         int fieldwidth = 0;
 312         for (Int_t i = 0; i < fScalars.GetEntriesFast(); ++i)
 313         {
 314                 AliScalar* scalar = static_cast<AliScalar*>( fScalars.UncheckedAt(i) );
 315                 int length = strlen(scalar->Description());
 316                 if (length > fieldwidth) fieldwidth = length;
 317         }
 318         if (fieldwidth > 80) fieldwidth = 80;
 319
 320         cout << "HLT muon spectrometer trigger scalars:" << endl;
 321         for (Int_t i = 0; i < fScalars.GetEntriesFast(); ++i)
 322         {
 323                 AliScalar* scalar = static_cast<AliScalar*>( fScalars.UncheckedAt(i) );
 324                 cout << setw(fieldwidth) << scalar->Description() << setw(0)
 325                      << " = " << scalar->Value() << endl;
 326         }
 327         if (fScalars.GetEntriesFast() == 0) cout << "(none)" << endl;
 328 }
 329
 330
 331 AliHLTMuonSpectroScalars& AliHLTMuonSpectroScalars::operator = (const AliHLTMuonSpectroScalars& obj)
 332 {
 333         // Performs a deep copy.
 334
 335         if (this == &obj) return *this;
 336         fScalars.Delete();
 337         for (Int_t i = 0; i < obj.fScalars.GetEntriesFast(); ++i)
 338         {
 339                 AliScalar* scalar = static_cast<AliScalar*>( obj.fScalars.UncheckedAt(i) );
 340                 Add(scalar->Name(), scalar->Description(), scalar->Value());
 341         }
 342         MakeIndex();
 343         return *this;
 344 }
 345
 346
 347 bool AliHLTMuonSpectroScalars::operator == (const AliHLTMuonSpectroScalars& obj) const
 348 {
 349         // Compares two scalar objects.
 350
 351         if (not fIndexValid) MakeIndex();
 352         if (fScalars.GetEntriesFast() != obj.fScalars.GetEntriesFast()) return false;
 353         for (Int_t i = 0; i < obj.fScalars.GetEntriesFast(); ++i)
 354         {
 355                 AliScalar* scalar1 = static_cast<AliScalar*>( obj.fScalars.UncheckedAt(i) );
 356                 Int_t n = fIndex.BinarySearch(scalar1);
 357                 if (n == -1) return false;
 358                 AliScalar* scalar2 = static_cast<AliScalar*>( fIndex.UncheckedAt(n) );
 359                 if (scalar1->Value() != scalar2->Value()) return false;
 360         }
 361         return true;
 362 }
 363
 364
 365 void AliHLTMuonSpectroScalars::MakeIndex() const
 366 {
 367         // Makes the index fIndex required for faster searching in fScalars.
 368
 369         fIndex.Clear();
 370         for (Int_t i = 0; i < fScalars.GetEntriesFast(); ++i)
 371         {
 372                 fIndex.Add(fScalars.UncheckedAt(i));
 373         }
 374         fIndex.Sort();
 375         fIndexValid = true;
 376 }
 377
 378
 379 void AliHLTMuonSpectroScalars::AliScalar::Copy(TObject& object) const
 380 {
 381         // Performs a deep copy.
 382
 383         if (object.IsA() != AliHLTMuonSpectroScalars::AliScalar::Class())
 384         {
 385                 AliError(Form("Cannot copy to an object of type '%s'.", object.ClassName()));
 386                 return;
 387         }
 388         AliHLTMuonSpectroScalars::AliScalar* obj = static_cast<AliHLTMuonSpectroScalars::AliScalar*>(&object);
 389         *obj = *this;
 390 }