ROOT logo
// $Id$

//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project        * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
//*                  for The ALICE HLT Project.                            *
//*                                                                        *
//* Permission to use, copy, modify and distribute this software and its   *
//* documentation strictly for non-commercial purposes is hereby granted   *
//* without fee, provided that the above copyright notice appears in all   *
//* copies and that both the copyright notice and this permission notice   *
//* appear in the supporting documentation. The authors make no claims     *
//* about the suitability of this software for any purpose. It is          *
//* provided "as is" without express or implied warranty.                  *
//**************************************************************************

//  @file   AliHLTCTPData.cxx
//  @author Matthias Richter
//  @date   2009-08-20
//  @brief  Container for CTP trigger classes and counters
//  @note

#include "AliHLTCTPData.h"
#include "TClass.h"
#include "TObjString.h"
#include "TFormula.h"
#include "AliHLTComponent.h"
#include "AliHLTCDHWrapper.h"
#include <limits>
#include <sstream>

/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTCTPData)

AliHLTCTPData::AliHLTCTPData()
  : TNamed("AliHLTCTPData", "HLT counters for the CTP")
  , AliHLTLogging()
  , fMask(0)
  , fTriggers(0)
  , fClassIds(AliHLTReadoutList::Class(), gkNCTPTriggerClasses)
  , fCounters(gkNCTPTriggerClasses)
  , fMap()
{
  // constructor
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
}

AliHLTCTPData::AliHLTCTPData(const char* parameter)
  : TNamed("AliHLTCTPData", "HLT counters for the CTP")
  , AliHLTLogging()
  , fMask(0)
  , fTriggers(0)
  , fClassIds(AliHLTReadoutList::Class(), gkNCTPTriggerClasses)
  , fCounters(gkNCTPTriggerClasses)
  , fMap()
{
  // constructor, init the CTP trigger classes
  InitCTPTriggerClasses(parameter);
}

AliHLTCTPData::~AliHLTCTPData()
{
  // destructor
  fClassIds.Delete();
}

AliHLTCTPData::AliHLTCTPData(const AliHLTCTPData& src)
  : TNamed(src.GetName(), src.GetTitle())
  , AliHLTLogging()
  , fMask(src.Mask())
  , fTriggers(src.fTriggers)
  , fClassIds(src.fClassIds)
  , fCounters(src.Counters())
  , fMap()
{
  // copy constructor
  ReadMap();
}

AliHLTCTPData& AliHLTCTPData::operator=(const AliHLTCTPData& src)
{
  // assignment operator, clone content
  if (this!=&src) {
    SetName(src.GetName());
    SetTitle(src.GetTitle());
    fMask=src.Mask();
    fClassIds.Delete();
    fClassIds.ExpandCreate(gkNCTPTriggerClasses);
    for (int i=0; i<gkNCTPTriggerClasses; i++) {
      if (i>src.fClassIds.GetLast()) break;
      ((TNamed*)fClassIds.At(i))->SetName(src.fClassIds.At(i)->GetName());
      ((TNamed*)fClassIds.At(i))->SetTitle(src.fClassIds.At(i)->GetTitle());
    }
    fCounters=src.Counters();
  }

  ReadMap();
  return *this;
}

int AliHLTCTPData::Add(const AliHLTCTPData& src, int factor, int &skipped)
{
  // see header file for class documentation
  
  skipped=0;
  for (int i=0; i<gkNCTPTriggerClasses; i++) {
    TString c;
    c=fClassIds.At(i)->GetName();
    if (c.IsNull()) continue;
    if (c.CompareTo(src.fClassIds.At(i)->GetName())==0) {
      fCounters[i]+=factor*src.Counter(i);
    } else {
      skipped++;
    }
  }
  return 0;
}

AliHLTCTPData& AliHLTCTPData::operator += (const AliHLTCTPData& src)
{
  // see header file for class documentation
  
  int nofInconsistencies=0;
  Add(src, 1, nofInconsistencies);
  if (nofInconsistencies>0) {
    HLTError("Inconsistent operants: skipping %d of %d CTP classes for operation", nofInconsistencies, gkNCTPTriggerClasses);
  }
  return *this;
}

AliHLTCTPData& AliHLTCTPData::operator -= (const AliHLTCTPData& src)
{
  // see header file for class documentation
  
  int nofInconsistencies=0;
  Add(src, -1, nofInconsistencies);
  if (nofInconsistencies>0) {
    HLTError("Inconsistent operants: skipping %d of %d CTP classes for operation", nofInconsistencies, gkNCTPTriggerClasses);
  }
  return *this;
}

AliHLTCTPData AliHLTCTPData::operator + (const AliHLTCTPData& src) const
{
  // see header file for class documentation

  AliHLTCTPData result(*this);
  result+=src;
  return result;
}

AliHLTCTPData AliHLTCTPData::operator - (const AliHLTCTPData& src) const
{
  // see header file for class documentation

  AliHLTCTPData result(*this);
  result-=src;
  return result;
}

int AliHLTCTPData::InitCTPTriggerClasses(const char* ctpString)
{
  // see header file for function documentation
  if (!ctpString) return -EINVAL;

  HLTImportant("Parameter: %s", ctpString);

  fMask=0;
  fClassIds.Delete();
  fClassIds.ExpandCreate(gkNCTPTriggerClasses);

  // general format of the CTP_TRIGGER_CLASS parameter
  // <bit position>:<Trigger class identifier string>:<detector-id-nr>-<detector-id-nr>-...,<bit position>:<Trigger class identifier string>:<detector-id-nr>-<detector-id-nr>-...,...
  HLTDebug(": %s", ctpString);
  TString string=ctpString;
  if (string.BeginsWith("CTP_TRIGGER_CLASS=")) string.ReplaceAll("CTP_TRIGGER_CLASS=", "");
  TObjArray* classEntries=string.Tokenize(",");
  if (classEntries) {
    enum {kBit=0, kName, kDetectors};
    for (int i=0; i<classEntries->GetEntriesFast(); i++) {
      TString entry=((TObjString*)classEntries->At(i))->GetString();
      TObjArray* entryParams=entry.Tokenize(":");
      if (entryParams) {
	if (entryParams->GetEntriesFast()==3 &&
	    (((TObjString*)entryParams->At(kBit))->GetString()).IsDigit()) {
	  int index=(((TObjString*)entryParams->At(kBit))->GetString()).Atoi();
	  if (index<gkNCTPTriggerClasses) {
	    AliHLTReadoutList* pCTPClass=dynamic_cast<AliHLTReadoutList*>(fClassIds.At(index));
	    if (pCTPClass) {
	      fMask.set(index);
	      pCTPClass->SetTitle("CTP Class");
	      pCTPClass->SetName((((TObjString*)entryParams->At(kName))->GetString()).Data());
	      TObjArray* detectors=(((TObjString*)entryParams->At(kDetectors))->GetString()).Tokenize("-");
	      if (detectors) {
		for (int dix=0; dix<detectors->GetEntriesFast(); dix++) {
		  if (!(((TObjString*)detectors->At(dix))->GetString()).IsDigit()) {
		    HLTError("invalid detector list format: trigger class entry %s", entry.Data());
		    break;
		  }
		  // see AliHLTReadoutList::EDetectorId for defines of detectors
		  pCTPClass->Enable(0x1<<(((TObjString*)detectors->At(dix))->GetString()).Atoi());
		}
		delete detectors;
	      }
	    } else {
	    }
	  } else {
	    // the trigger bitfield is fixed to 100 bits (gkNCTPTriggerClasses)
	    HLTError("invalid trigger class entry %s, index width of trigger bitfield exceeded (%d)", entry.Data(), gkNCTPTriggerClasses);
	  }
	} else {
	  HLTError("invalid trigger class entry %s", entry.Data());
	}
	delete entryParams;
      }
    }
    delete classEntries;
  }

  ResetCounters();
  ReadMap();

  return 0;
}

AliHLTTriggerMask_t AliHLTCTPData::ActiveTriggers(const AliHLTComponentTriggerData& trigData)
{
  // extract active triggers from the trigger data
  AliHLTCDHWrapper cdh;
  if (AliHLTComponent::ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL) != 0) return 0x0;
  if ((cdh.GetL1TriggerMessage() & 0x1) == 0x1) return 0x0;  // invalid for software triggers.

  AliHLTTriggerMask_t triggerLow(cdh.GetTriggerClasses()); //low bits
  AliHLTTriggerMask_t triggerHigh(cdh.GetTriggerClassesNext50()); // high bits

  return triggerLow | (triggerHigh << 50);
}

bool AliHLTCTPData::EvaluateCTPTriggerClass(const char* expression, const AliHLTComponentTriggerData& trigData) const
{
  // see header file for function documentation
  
  AliHLTCDHWrapper cdh;
  if (AliHLTComponent::ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL, true) != 0) return false;
  if ((cdh.GetL1TriggerMessage() & 0x1) == 0x1) return false;  // invalid for software triggers.

  AliHLTTriggerMask_t triggerMask(cdh.GetTriggerClasses());
  AliHLTTriggerMask_t triggerHigh(cdh.GetTriggerClassesNext50());
  triggerMask |= (triggerHigh << 50);

  if (fMask!=0 && (triggerMask & fMask)==0) {
    AliHLTEventTriggerData* evtData=reinterpret_cast<AliHLTEventTriggerData*>(trigData.fData);
    HLTWarning("invalid trigger mask %s, unknown CTP trigger, initialized %s", 
	       TriggerMaskToString(triggerMask).c_str(), TriggerMaskToString(fMask).c_str() );
    for (int i=0; i<gkAliHLTCommonHeaderCount; i++) HLTWarning("\t CDH[%d]=0x%lx", i, evtData->fCommonHeader[i]);
    return false;
  }

  return EvaluateCTPTriggerClass(expression, triggerMask);
}

bool AliHLTCTPData::EvaluateCTPTriggerClass(const char* expression, AliHLTTriggerMask_t triggerMask) const
{
  // see header file for function documentation

  // use a TFormula to interprete the expression
  // all classname are replaced by '[n]' which means the n'th parameter in the formula
  // the parameters are set to 0 or 1 depending on the bit in the trigger mask
  const vector<unsigned> *pMap=&fMap;
  vector<unsigned> tmp;
  if (fMap.size()==0 && fClassIds.GetLast()>=0) {
    // read map into temporary array and use it
    ReadMap(tmp);
    pMap=&tmp;
    static bool suppressWarning=false;
    if (!suppressWarning) HLTWarning("map not yet initialized, creating local map (slow), suppressing further warnings");
    suppressWarning=true;
  }
  vector<Double_t> par;
  TString condition=expression;
  for (unsigned index=0; index<pMap->size(); index++) {
    const char* className=Name((*pMap)[index]);
    if (className && strlen(className)>0) {
      //HLTDebug("checking trigger class %s", className.Data());
      if (condition.Contains(className)) {
	TString replace; replace.Form("[%d]", (int)par.size());
	//HLTDebug("replacing %s with %s in \"%s\"", className.Data(), replace.Data(), condition.Data());
	condition.ReplaceAll(className, replace);
	if ( triggerMask.test((*pMap)[index]) ) par.push_back(1.0);
	else par.push_back(0.0);
      }
    }
  }

  TFormula form("trigger expression", condition);
  if (form.Compile()!=0) {
    HLTError("invalid expression %s", expression);
    return false;
  }
  if (form.EvalPar(&par[0], &par[0])>0.5) return true;
  return false;
}

void AliHLTCTPData::ResetCounters()
{
  // see header file for function documentation
  fCounters.Set(gkNCTPTriggerClasses);
  fCounters.Reset();
}

int AliHLTCTPData::Index(const char* name) const
{
  // see header file for function documentation
  TObject* obj=fClassIds.FindObject(name);
  return obj!=NULL?fClassIds.IndexOf(obj):-1;
}

int AliHLTCTPData::CheckTrigger(const char* name) const
{
  // check status of a trigger class
  int index=Index(name);
  if (index<0) return index;
  return ( fTriggers.test(index) ? 1 : 0 );
}

void AliHLTCTPData::Increment(const char* classIds)
{
  // see header file for function documentation
  TString string=classIds;
  TObjArray* classEntries=string.Tokenize(",");
  if (classEntries) {
    for (int i=0; i<classEntries->GetEntriesFast(); i++) {
      int index=Index(((TObjString*)classEntries->At(i))->GetString().Data());
      if (index>=0 && index<fCounters.GetSize()) fCounters[index]++;
    }
    delete classEntries;
  }
}

void AliHLTCTPData::Increment(AliHLTTriggerMask_t triggerPattern)
{
  // see header file for function documentation
  AliHLTTriggerMask_t pattern=triggerPattern&fMask;
  for (int i=0; i<fCounters.GetSize(); i++) {
    if (!pattern.test(i)) continue;
    fCounters[i]++;    
  }
}

void AliHLTCTPData::Increment(int classIdx)
{
  // see header file for function documentation
  if (classIdx<fCounters.GetSize() &&
      fMask.test(classIdx)) {
    fCounters[classIdx]++;    
  }
  
}

int AliHLTCTPData::Increment(AliHLTComponentTriggerData& trigData)
{
  // see header file for function documentation
  AliHLTCDHWrapper cdh;
  int result = AliHLTComponent::ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL, true);
  if (result != 0) return result;
  if ((cdh.GetL1TriggerMessage() & 0x1) == 0x1) return 0;  // invalid for software triggers.

  AliHLTTriggerMask_t triggerMask(cdh.GetTriggerClasses());
  AliHLTTriggerMask_t triggerHigh(cdh.GetTriggerClassesNext50());
  triggerMask |= (triggerHigh << 50);

  if (fMask.any() && (triggerMask & fMask).none()) {
    AliHLTEventTriggerData* evtData=reinterpret_cast<AliHLTEventTriggerData*>(trigData.fData);
    HLTWarning("invalid trigger mask %s, unknown CTP trigger, initialized %s", 
	       TriggerMaskToString(triggerMask).c_str(), TriggerMaskToString(fMask).c_str());
    for (int i=0; i<gkAliHLTCommonHeaderCount; i++) 
      HLTWarning("\t CDH[%d]=0x%lx", i, evtData->fCommonHeader[i]);
  }
  Increment(triggerMask);
  return 0;
}

AliHLTUInt64_t AliHLTCTPData::Counter(int index) const
{
  // see header file for function documentation
  if (index>=0 && index<Counters().GetSize()) return Counters()[index];
  return 0;
}

AliHLTUInt64_t AliHLTCTPData::Counter(const char* classId) const
{
  // see header file for function documentation
  return Counter(Index(classId));
}

const char* AliHLTCTPData::Name(int index) const
{
  // see header file for function documentation
  if (index>fClassIds.GetLast()) return NULL;
  return fClassIds.At(index)->GetName();
}

int AliHLTCTPData::ReadMap(vector<unsigned> &map) const
{
  // read the index map for class names
  // for nested class names (e.g. 'myclass' is contained in
  // 'myclassA') the longer names is added first to the map.
  for (int index=0; index<=fClassIds.GetLast(); index++) {
    vector<unsigned>::iterator element=map.begin();
    for (; element!=map.end(); element++) {
      TString name=Name(index);
      if (name.Contains(Name(*element))) {
	// current name contains another one already in the map
	// -> add before and go to next entry
	element=map.insert(element, index);
	break;
      }
    }

    if (element==map.end()) {
      // unique class name, append to map
      map.push_back(index);
    }
  }
  return 0;
}


AliHLTReadoutList AliHLTCTPData::ReadoutList(const AliHLTComponentTriggerData& trigData) const
{
  // see header file for function documentation

  AliHLTCDHWrapper cdh;
  if (AliHLTComponent::ExtractTriggerData(trigData, NULL, NULL, &cdh, NULL, true) != 0) return AliHLTReadoutList();
  // Check if we are dealing with a software trigger. If so then we need to return
  // a readout list with everything set because the CTP trigger bits are invalid.
  // Thus we assume that everything should be read out.
  if ((cdh.GetL1TriggerMessage() & 0x1) == 0x1) return ~ AliHLTReadoutList();

  AliHLTTriggerMask_t triggerMask(cdh.GetTriggerClasses());
  AliHLTTriggerMask_t triggerHigh(cdh.GetTriggerClassesNext50());
  triggerMask |= (triggerHigh << 50);

  if (fMask.any() && (triggerMask & fMask).none()) {
    AliHLTEventTriggerData* evtData=reinterpret_cast<AliHLTEventTriggerData*>(trigData.fData);
    HLTWarning("invalid trigger mask %s, unknown CTP trigger, initialized %s",
               TriggerMaskToString(triggerMask).c_str(), TriggerMaskToString(fMask).c_str());
    for (int i=0; i<gkAliHLTCommonHeaderCount; i++)
      HLTWarning("\t CDH[%d]=0x%lx", i, evtData->fCommonHeader[i]);
  }

  return ReadoutList(triggerMask);
}

AliHLTReadoutList AliHLTCTPData::ReadoutList(AliHLTTriggerMask_t  triggerMask) const
{
  // take an 'OR' of all active trigger classes 
  AliHLTReadoutList list;
  for (int i=0; i<gkNCTPTriggerClasses; i++) {
    if (i>fClassIds.GetLast()) break;
    if (! triggerMask.test(i)) continue;
    AliHLTReadoutList* tcrl=(AliHLTReadoutList*)fClassIds.At(i);
    list.OrEq(*tcrl);
  }

  return list;
}


void AliHLTCTPData::Print(Option_t* /*option*/) const
{
  // see header file for function documentation
  cout << GetTitle() << endl;
  cout << "\tactive trigger mask: 0x" << hex << fTriggers << dec << endl;
  int count=0;
  for (int i=0; i<gkNCTPTriggerClasses; i++) {
    if (i>=Counters().GetSize()) break;
    if (i>fClassIds.GetLast()) break;
    if (! fMask.test(i)) continue;
    count++;
    cout << "\t" << i << "\t" << Name(i) << "\t" << Counter(i) << endl;
  }
  if (count==0) cout << "\t(none)" << endl;
}


std::string AliHLTCTPData::TriggerMaskToString(AliHLTTriggerMask_t mask) const
{
  AliHLTTriggerMask_t max(std::numeric_limits<unsigned long>::max());
  int digits = std::numeric_limits<unsigned long>::digits;
  int numberOfWords = (mask.size() + digits - 1)/digits;
  std::stringstream stream;
  stream << "0x";
  stream << std::hex << std::right;
  for(int i=numberOfWords-1; i>=0; --i){
    stream.width(digits/4);
    stream.fill('0');
    stream << ((mask >> (digits*i)) & max).to_ulong() << " ";
  }
  return stream.str();
}

 AliHLTCTPData.cxx:1
 AliHLTCTPData.cxx:2
 AliHLTCTPData.cxx:3
 AliHLTCTPData.cxx:4
 AliHLTCTPData.cxx:5
 AliHLTCTPData.cxx:6
 AliHLTCTPData.cxx:7
 AliHLTCTPData.cxx:8
 AliHLTCTPData.cxx:9
 AliHLTCTPData.cxx:10
 AliHLTCTPData.cxx:11
 AliHLTCTPData.cxx:12
 AliHLTCTPData.cxx:13
 AliHLTCTPData.cxx:14
 AliHLTCTPData.cxx:15
 AliHLTCTPData.cxx:16
 AliHLTCTPData.cxx:17
 AliHLTCTPData.cxx:18
 AliHLTCTPData.cxx:19
 AliHLTCTPData.cxx:20
 AliHLTCTPData.cxx:21
 AliHLTCTPData.cxx:22
 AliHLTCTPData.cxx:23
 AliHLTCTPData.cxx:24
 AliHLTCTPData.cxx:25
 AliHLTCTPData.cxx:26
 AliHLTCTPData.cxx:27
 AliHLTCTPData.cxx:28
 AliHLTCTPData.cxx:29
 AliHLTCTPData.cxx:30
 AliHLTCTPData.cxx:31
 AliHLTCTPData.cxx:32
 AliHLTCTPData.cxx:33
 AliHLTCTPData.cxx:34
 AliHLTCTPData.cxx:35
 AliHLTCTPData.cxx:36
 AliHLTCTPData.cxx:37
 AliHLTCTPData.cxx:38
 AliHLTCTPData.cxx:39
 AliHLTCTPData.cxx:40
 AliHLTCTPData.cxx:41
 AliHLTCTPData.cxx:42
 AliHLTCTPData.cxx:43
 AliHLTCTPData.cxx:44
 AliHLTCTPData.cxx:45
 AliHLTCTPData.cxx:46
 AliHLTCTPData.cxx:47
 AliHLTCTPData.cxx:48
 AliHLTCTPData.cxx:49
 AliHLTCTPData.cxx:50
 AliHLTCTPData.cxx:51
 AliHLTCTPData.cxx:52
 AliHLTCTPData.cxx:53
 AliHLTCTPData.cxx:54
 AliHLTCTPData.cxx:55
 AliHLTCTPData.cxx:56
 AliHLTCTPData.cxx:57
 AliHLTCTPData.cxx:58
 AliHLTCTPData.cxx:59
 AliHLTCTPData.cxx:60
 AliHLTCTPData.cxx:61
 AliHLTCTPData.cxx:62
 AliHLTCTPData.cxx:63
 AliHLTCTPData.cxx:64
 AliHLTCTPData.cxx:65
 AliHLTCTPData.cxx:66
 AliHLTCTPData.cxx:67
 AliHLTCTPData.cxx:68
 AliHLTCTPData.cxx:69
 AliHLTCTPData.cxx:70
 AliHLTCTPData.cxx:71
 AliHLTCTPData.cxx:72
 AliHLTCTPData.cxx:73
 AliHLTCTPData.cxx:74
 AliHLTCTPData.cxx:75
 AliHLTCTPData.cxx:76
 AliHLTCTPData.cxx:77
 AliHLTCTPData.cxx:78
 AliHLTCTPData.cxx:79
 AliHLTCTPData.cxx:80
 AliHLTCTPData.cxx:81
 AliHLTCTPData.cxx:82
 AliHLTCTPData.cxx:83
 AliHLTCTPData.cxx:84
 AliHLTCTPData.cxx:85
 AliHLTCTPData.cxx:86
 AliHLTCTPData.cxx:87
 AliHLTCTPData.cxx:88
 AliHLTCTPData.cxx:89
 AliHLTCTPData.cxx:90
 AliHLTCTPData.cxx:91
 AliHLTCTPData.cxx:92
 AliHLTCTPData.cxx:93
 AliHLTCTPData.cxx:94
 AliHLTCTPData.cxx:95
 AliHLTCTPData.cxx:96
 AliHLTCTPData.cxx:97
 AliHLTCTPData.cxx:98
 AliHLTCTPData.cxx:99
 AliHLTCTPData.cxx:100
 AliHLTCTPData.cxx:101
 AliHLTCTPData.cxx:102
 AliHLTCTPData.cxx:103
 AliHLTCTPData.cxx:104
 AliHLTCTPData.cxx:105
 AliHLTCTPData.cxx:106
 AliHLTCTPData.cxx:107
 AliHLTCTPData.cxx:108
 AliHLTCTPData.cxx:109
 AliHLTCTPData.cxx:110
 AliHLTCTPData.cxx:111
 AliHLTCTPData.cxx:112
 AliHLTCTPData.cxx:113
 AliHLTCTPData.cxx:114
 AliHLTCTPData.cxx:115
 AliHLTCTPData.cxx:116
 AliHLTCTPData.cxx:117
 AliHLTCTPData.cxx:118
 AliHLTCTPData.cxx:119
 AliHLTCTPData.cxx:120
 AliHLTCTPData.cxx:121
 AliHLTCTPData.cxx:122
 AliHLTCTPData.cxx:123
 AliHLTCTPData.cxx:124
 AliHLTCTPData.cxx:125
 AliHLTCTPData.cxx:126
 AliHLTCTPData.cxx:127
 AliHLTCTPData.cxx:128
 AliHLTCTPData.cxx:129
 AliHLTCTPData.cxx:130
 AliHLTCTPData.cxx:131
 AliHLTCTPData.cxx:132
 AliHLTCTPData.cxx:133
 AliHLTCTPData.cxx:134
 AliHLTCTPData.cxx:135
 AliHLTCTPData.cxx:136
 AliHLTCTPData.cxx:137
 AliHLTCTPData.cxx:138
 AliHLTCTPData.cxx:139
 AliHLTCTPData.cxx:140
 AliHLTCTPData.cxx:141
 AliHLTCTPData.cxx:142
 AliHLTCTPData.cxx:143
 AliHLTCTPData.cxx:144
 AliHLTCTPData.cxx:145
 AliHLTCTPData.cxx:146
 AliHLTCTPData.cxx:147
 AliHLTCTPData.cxx:148
 AliHLTCTPData.cxx:149
 AliHLTCTPData.cxx:150
 AliHLTCTPData.cxx:151
 AliHLTCTPData.cxx:152
 AliHLTCTPData.cxx:153
 AliHLTCTPData.cxx:154
 AliHLTCTPData.cxx:155
 AliHLTCTPData.cxx:156
 AliHLTCTPData.cxx:157
 AliHLTCTPData.cxx:158
 AliHLTCTPData.cxx:159
 AliHLTCTPData.cxx:160
 AliHLTCTPData.cxx:161
 AliHLTCTPData.cxx:162
 AliHLTCTPData.cxx:163
 AliHLTCTPData.cxx:164
 AliHLTCTPData.cxx:165
 AliHLTCTPData.cxx:166
 AliHLTCTPData.cxx:167
 AliHLTCTPData.cxx:168
 AliHLTCTPData.cxx:169
 AliHLTCTPData.cxx:170
 AliHLTCTPData.cxx:171
 AliHLTCTPData.cxx:172
 AliHLTCTPData.cxx:173
 AliHLTCTPData.cxx:174
 AliHLTCTPData.cxx:175
 AliHLTCTPData.cxx:176
 AliHLTCTPData.cxx:177
 AliHLTCTPData.cxx:178
 AliHLTCTPData.cxx:179
 AliHLTCTPData.cxx:180
 AliHLTCTPData.cxx:181
 AliHLTCTPData.cxx:182
 AliHLTCTPData.cxx:183
 AliHLTCTPData.cxx:184
 AliHLTCTPData.cxx:185
 AliHLTCTPData.cxx:186
 AliHLTCTPData.cxx:187
 AliHLTCTPData.cxx:188
 AliHLTCTPData.cxx:189
 AliHLTCTPData.cxx:190
 AliHLTCTPData.cxx:191
 AliHLTCTPData.cxx:192
 AliHLTCTPData.cxx:193
 AliHLTCTPData.cxx:194
 AliHLTCTPData.cxx:195
 AliHLTCTPData.cxx:196
 AliHLTCTPData.cxx:197
 AliHLTCTPData.cxx:198
 AliHLTCTPData.cxx:199
 AliHLTCTPData.cxx:200
 AliHLTCTPData.cxx:201
 AliHLTCTPData.cxx:202
 AliHLTCTPData.cxx:203
 AliHLTCTPData.cxx:204
 AliHLTCTPData.cxx:205
 AliHLTCTPData.cxx:206
 AliHLTCTPData.cxx:207
 AliHLTCTPData.cxx:208
 AliHLTCTPData.cxx:209
 AliHLTCTPData.cxx:210
 AliHLTCTPData.cxx:211
 AliHLTCTPData.cxx:212
 AliHLTCTPData.cxx:213
 AliHLTCTPData.cxx:214
 AliHLTCTPData.cxx:215
 AliHLTCTPData.cxx:216
 AliHLTCTPData.cxx:217
 AliHLTCTPData.cxx:218
 AliHLTCTPData.cxx:219
 AliHLTCTPData.cxx:220
 AliHLTCTPData.cxx:221
 AliHLTCTPData.cxx:222
 AliHLTCTPData.cxx:223
 AliHLTCTPData.cxx:224
 AliHLTCTPData.cxx:225
 AliHLTCTPData.cxx:226
 AliHLTCTPData.cxx:227
 AliHLTCTPData.cxx:228
 AliHLTCTPData.cxx:229
 AliHLTCTPData.cxx:230
 AliHLTCTPData.cxx:231
 AliHLTCTPData.cxx:232
 AliHLTCTPData.cxx:233
 AliHLTCTPData.cxx:234
 AliHLTCTPData.cxx:235
 AliHLTCTPData.cxx:236
 AliHLTCTPData.cxx:237
 AliHLTCTPData.cxx:238
 AliHLTCTPData.cxx:239
 AliHLTCTPData.cxx:240
 AliHLTCTPData.cxx:241
 AliHLTCTPData.cxx:242
 AliHLTCTPData.cxx:243
 AliHLTCTPData.cxx:244
 AliHLTCTPData.cxx:245
 AliHLTCTPData.cxx:246
 AliHLTCTPData.cxx:247
 AliHLTCTPData.cxx:248
 AliHLTCTPData.cxx:249
 AliHLTCTPData.cxx:250
 AliHLTCTPData.cxx:251
 AliHLTCTPData.cxx:252
 AliHLTCTPData.cxx:253
 AliHLTCTPData.cxx:254
 AliHLTCTPData.cxx:255
 AliHLTCTPData.cxx:256
 AliHLTCTPData.cxx:257
 AliHLTCTPData.cxx:258
 AliHLTCTPData.cxx:259
 AliHLTCTPData.cxx:260
 AliHLTCTPData.cxx:261
 AliHLTCTPData.cxx:262
 AliHLTCTPData.cxx:263
 AliHLTCTPData.cxx:264
 AliHLTCTPData.cxx:265
 AliHLTCTPData.cxx:266
 AliHLTCTPData.cxx:267
 AliHLTCTPData.cxx:268
 AliHLTCTPData.cxx:269
 AliHLTCTPData.cxx:270
 AliHLTCTPData.cxx:271
 AliHLTCTPData.cxx:272
 AliHLTCTPData.cxx:273
 AliHLTCTPData.cxx:274
 AliHLTCTPData.cxx:275
 AliHLTCTPData.cxx:276
 AliHLTCTPData.cxx:277
 AliHLTCTPData.cxx:278
 AliHLTCTPData.cxx:279
 AliHLTCTPData.cxx:280
 AliHLTCTPData.cxx:281
 AliHLTCTPData.cxx:282
 AliHLTCTPData.cxx:283
 AliHLTCTPData.cxx:284
 AliHLTCTPData.cxx:285
 AliHLTCTPData.cxx:286
 AliHLTCTPData.cxx:287
 AliHLTCTPData.cxx:288
 AliHLTCTPData.cxx:289
 AliHLTCTPData.cxx:290
 AliHLTCTPData.cxx:291
 AliHLTCTPData.cxx:292
 AliHLTCTPData.cxx:293
 AliHLTCTPData.cxx:294
 AliHLTCTPData.cxx:295
 AliHLTCTPData.cxx:296
 AliHLTCTPData.cxx:297
 AliHLTCTPData.cxx:298
 AliHLTCTPData.cxx:299
 AliHLTCTPData.cxx:300
 AliHLTCTPData.cxx:301
 AliHLTCTPData.cxx:302
 AliHLTCTPData.cxx:303
 AliHLTCTPData.cxx:304
 AliHLTCTPData.cxx:305
 AliHLTCTPData.cxx:306
 AliHLTCTPData.cxx:307
 AliHLTCTPData.cxx:308
 AliHLTCTPData.cxx:309
 AliHLTCTPData.cxx:310
 AliHLTCTPData.cxx:311
 AliHLTCTPData.cxx:312
 AliHLTCTPData.cxx:313
 AliHLTCTPData.cxx:314
 AliHLTCTPData.cxx:315
 AliHLTCTPData.cxx:316
 AliHLTCTPData.cxx:317
 AliHLTCTPData.cxx:318
 AliHLTCTPData.cxx:319
 AliHLTCTPData.cxx:320
 AliHLTCTPData.cxx:321
 AliHLTCTPData.cxx:322
 AliHLTCTPData.cxx:323
 AliHLTCTPData.cxx:324
 AliHLTCTPData.cxx:325
 AliHLTCTPData.cxx:326
 AliHLTCTPData.cxx:327
 AliHLTCTPData.cxx:328
 AliHLTCTPData.cxx:329
 AliHLTCTPData.cxx:330
 AliHLTCTPData.cxx:331
 AliHLTCTPData.cxx:332
 AliHLTCTPData.cxx:333
 AliHLTCTPData.cxx:334
 AliHLTCTPData.cxx:335
 AliHLTCTPData.cxx:336
 AliHLTCTPData.cxx:337
 AliHLTCTPData.cxx:338
 AliHLTCTPData.cxx:339
 AliHLTCTPData.cxx:340
 AliHLTCTPData.cxx:341
 AliHLTCTPData.cxx:342
 AliHLTCTPData.cxx:343
 AliHLTCTPData.cxx:344
 AliHLTCTPData.cxx:345
 AliHLTCTPData.cxx:346
 AliHLTCTPData.cxx:347
 AliHLTCTPData.cxx:348
 AliHLTCTPData.cxx:349
 AliHLTCTPData.cxx:350
 AliHLTCTPData.cxx:351
 AliHLTCTPData.cxx:352
 AliHLTCTPData.cxx:353
 AliHLTCTPData.cxx:354
 AliHLTCTPData.cxx:355
 AliHLTCTPData.cxx:356
 AliHLTCTPData.cxx:357
 AliHLTCTPData.cxx:358
 AliHLTCTPData.cxx:359
 AliHLTCTPData.cxx:360
 AliHLTCTPData.cxx:361
 AliHLTCTPData.cxx:362
 AliHLTCTPData.cxx:363
 AliHLTCTPData.cxx:364
 AliHLTCTPData.cxx:365
 AliHLTCTPData.cxx:366
 AliHLTCTPData.cxx:367
 AliHLTCTPData.cxx:368
 AliHLTCTPData.cxx:369
 AliHLTCTPData.cxx:370
 AliHLTCTPData.cxx:371
 AliHLTCTPData.cxx:372
 AliHLTCTPData.cxx:373
 AliHLTCTPData.cxx:374
 AliHLTCTPData.cxx:375
 AliHLTCTPData.cxx:376
 AliHLTCTPData.cxx:377
 AliHLTCTPData.cxx:378
 AliHLTCTPData.cxx:379
 AliHLTCTPData.cxx:380
 AliHLTCTPData.cxx:381
 AliHLTCTPData.cxx:382
 AliHLTCTPData.cxx:383
 AliHLTCTPData.cxx:384
 AliHLTCTPData.cxx:385
 AliHLTCTPData.cxx:386
 AliHLTCTPData.cxx:387
 AliHLTCTPData.cxx:388
 AliHLTCTPData.cxx:389
 AliHLTCTPData.cxx:390
 AliHLTCTPData.cxx:391
 AliHLTCTPData.cxx:392
 AliHLTCTPData.cxx:393
 AliHLTCTPData.cxx:394
 AliHLTCTPData.cxx:395
 AliHLTCTPData.cxx:396
 AliHLTCTPData.cxx:397
 AliHLTCTPData.cxx:398
 AliHLTCTPData.cxx:399
 AliHLTCTPData.cxx:400
 AliHLTCTPData.cxx:401
 AliHLTCTPData.cxx:402
 AliHLTCTPData.cxx:403
 AliHLTCTPData.cxx:404
 AliHLTCTPData.cxx:405
 AliHLTCTPData.cxx:406
 AliHLTCTPData.cxx:407
 AliHLTCTPData.cxx:408
 AliHLTCTPData.cxx:409
 AliHLTCTPData.cxx:410
 AliHLTCTPData.cxx:411
 AliHLTCTPData.cxx:412
 AliHLTCTPData.cxx:413
 AliHLTCTPData.cxx:414
 AliHLTCTPData.cxx:415
 AliHLTCTPData.cxx:416
 AliHLTCTPData.cxx:417
 AliHLTCTPData.cxx:418
 AliHLTCTPData.cxx:419
 AliHLTCTPData.cxx:420
 AliHLTCTPData.cxx:421
 AliHLTCTPData.cxx:422
 AliHLTCTPData.cxx:423
 AliHLTCTPData.cxx:424
 AliHLTCTPData.cxx:425
 AliHLTCTPData.cxx:426
 AliHLTCTPData.cxx:427
 AliHLTCTPData.cxx:428
 AliHLTCTPData.cxx:429
 AliHLTCTPData.cxx:430
 AliHLTCTPData.cxx:431
 AliHLTCTPData.cxx:432
 AliHLTCTPData.cxx:433
 AliHLTCTPData.cxx:434
 AliHLTCTPData.cxx:435
 AliHLTCTPData.cxx:436
 AliHLTCTPData.cxx:437
 AliHLTCTPData.cxx:438
 AliHLTCTPData.cxx:439
 AliHLTCTPData.cxx:440
 AliHLTCTPData.cxx:441
 AliHLTCTPData.cxx:442
 AliHLTCTPData.cxx:443
 AliHLTCTPData.cxx:444
 AliHLTCTPData.cxx:445
 AliHLTCTPData.cxx:446
 AliHLTCTPData.cxx:447
 AliHLTCTPData.cxx:448
 AliHLTCTPData.cxx:449
 AliHLTCTPData.cxx:450
 AliHLTCTPData.cxx:451
 AliHLTCTPData.cxx:452
 AliHLTCTPData.cxx:453
 AliHLTCTPData.cxx:454
 AliHLTCTPData.cxx:455
 AliHLTCTPData.cxx:456
 AliHLTCTPData.cxx:457
 AliHLTCTPData.cxx:458
 AliHLTCTPData.cxx:459
 AliHLTCTPData.cxx:460
 AliHLTCTPData.cxx:461
 AliHLTCTPData.cxx:462
 AliHLTCTPData.cxx:463
 AliHLTCTPData.cxx:464
 AliHLTCTPData.cxx:465
 AliHLTCTPData.cxx:466
 AliHLTCTPData.cxx:467
 AliHLTCTPData.cxx:468
 AliHLTCTPData.cxx:469
 AliHLTCTPData.cxx:470
 AliHLTCTPData.cxx:471
 AliHLTCTPData.cxx:472
 AliHLTCTPData.cxx:473
 AliHLTCTPData.cxx:474
 AliHLTCTPData.cxx:475
 AliHLTCTPData.cxx:476
 AliHLTCTPData.cxx:477
 AliHLTCTPData.cxx:478
 AliHLTCTPData.cxx:479
 AliHLTCTPData.cxx:480
 AliHLTCTPData.cxx:481
 AliHLTCTPData.cxx:482
 AliHLTCTPData.cxx:483
 AliHLTCTPData.cxx:484
 AliHLTCTPData.cxx:485
 AliHLTCTPData.cxx:486
 AliHLTCTPData.cxx:487
 AliHLTCTPData.cxx:488
 AliHLTCTPData.cxx:489
 AliHLTCTPData.cxx:490
 AliHLTCTPData.cxx:491
 AliHLTCTPData.cxx:492
 AliHLTCTPData.cxx:493
 AliHLTCTPData.cxx:494
 AliHLTCTPData.cxx:495
 AliHLTCTPData.cxx:496
 AliHLTCTPData.cxx:497
 AliHLTCTPData.cxx:498
 AliHLTCTPData.cxx:499
 AliHLTCTPData.cxx:500
 AliHLTCTPData.cxx:501
 AliHLTCTPData.cxx:502
 AliHLTCTPData.cxx:503
 AliHLTCTPData.cxx:504
 AliHLTCTPData.cxx:505
 AliHLTCTPData.cxx:506
 AliHLTCTPData.cxx:507
 AliHLTCTPData.cxx:508