[u/mrichter/AliRoot.git] / STEER / AliRecoParam.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * 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.                  *
 **************************************************************************/


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// ALICE Reconstruction parameterization:                                    //
//                                                                           //
//                                                                           //
// Base Class for Detector reconstruction parameters                         //
// Revision: cvetan.cheshkov@cern.ch 12/06/2008                              //
// Its structure has been revised and it is interfaced to AliEventInfo.      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include "TClass.h"
#include "TObjArray.h"
#include "TMath.h"
#include "AliDetectorRecoParam.h"

#include "AliLog.h"
#include "AliRecoParam.h"
#include "AliRunInfo.h"
#include "AliEventInfo.h"
#include "AliLog.h"

ClassImp(AliRecoParam)

TString AliRecoParam::fkgEventSpecieName[] = {"Default", "LowMultiplicity", "HighMultiplicity", "Cosmic", "Calibration", "Unknown"} ; 

AliRecoParam::AliRecoParam(): 
  TObject(),
  fEventSpecie(kDefault)
{
  // Default constructor
  // ...
  for(Int_t iDet = 0; iDet < kNDetectors; iDet++)
    fDetRecoParams[iDet] = NULL;
  for(Int_t iSpecie = 0; iSpecie < kNSpecies; iSpecie++) {
    for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
      fDetRecoParamsIndex[iSpecie][iDet] = -1;
    }
  }
}

AliRecoParam::AliRecoParam(const AliRecoParam& par) :
  TObject(),
  fEventSpecie(par.fEventSpecie)
{
  // copy constructor
  for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
    if (par.fDetRecoParams[iDet])
      fDetRecoParams[iDet] = (TObjArray*)(par.fDetRecoParams[iDet]->Clone());
    else
      fDetRecoParams[iDet] = NULL;
  }
  for(Int_t iSpecie = 0; iSpecie < kNSpecies; iSpecie++) {
    for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
      fDetRecoParamsIndex[iSpecie][iDet] = par.fDetRecoParamsIndex[iSpecie][iDet];
    }
  }
}

//_____________________________________________________________________________
AliRecoParam& AliRecoParam::operator = (const AliRecoParam& par)
{
  // assignment operator

  if(&par == this) return *this;

  this->~AliRecoParam();
  new(this) AliRecoParam(par);
  return *this;
}

AliRecoParam::~AliRecoParam(){
  // Destructor
  // ...
  // Delete the array with the reco-param objects
  for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
    if (fDetRecoParams[iDet]){
      fDetRecoParams[iDet]->Delete();
      delete fDetRecoParams[iDet];
    }
  }
}

Int_t AliRecoParam::AConvert(EventSpecie_t es)
{
  //Converts EventSpecie_t  into int
  Int_t rv = -1 ; 
  switch (es) {
    case kDefault:
      rv = 0 ; 
      break;
    case kLowMult:
      rv = 1 ; 
      break;
    case kHighMult:
      rv = 2 ; 
      break;
    case kCosmic:
      rv = 3 ; 
      break;
    case kCalib:
      rv = 4 ; 
      break;
    default:
      break;
  }

  if (rv < 0) 
    AliFatalClass(Form("Wrong event specie conversion %d", es)) ; 

  return rv ;
}

AliRecoParam::EventSpecie_t AliRecoParam::Convert(Int_t ies)
{
  //Converts int into EventSpecie_t
  AliRecoParam::EventSpecie_t es = kDefault ; 
  if ( ies >> 1) 
    es = kLowMult ; 
  if ( ies >> 2) 
    es = kHighMult ;   
  if ( ies >> 3) 
    es = kCosmic ;   
  if ( ies >> 4) 
    es = kCalib ;

  return es ;   
}

AliRecoParam::EventSpecie_t AliRecoParam::ConvertIndex(Int_t index)
{
  //Converts index of lists into eventspecie
  EventSpecie_t es = kDefault ; 
  switch (index) {
    case 0:
      es = kDefault ; 
      break;
    case 1:
      es = kLowMult ; 
      break;
    case 2:
      es = kHighMult ;   
      break;
    case 3:
      es = kCosmic ;   
      break;
    case 4:
      es = kCalib ;
      break;
    default:
      break;
  }
  return es ;
}

void  AliRecoParam::Print(Option_t *option) const {
  //
  // Print reconstruction setup
  //
  for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
    if (fDetRecoParams[iDet]){
      printf("AliDetectorRecoParam objects for detector %d:\n",iDet); 
      Int_t nparam = fDetRecoParams[iDet]->GetEntriesFast();
      for (Int_t iparam=0; iparam<nparam; iparam++){
	AliDetectorRecoParam * param = (AliDetectorRecoParam *)fDetRecoParams[iDet]->At(iparam);
	if (!param) continue;
	param->Print(option);
      }
    }
    else {
      printf("No AliDetectorRecoParam objects specified for detector %d\n",iDet); 
    }
  }
}

void AliRecoParam::SetEventSpecie(const AliRunInfo *runInfo, const AliEventInfo &evInfo)
{
  // To be implemented
  // Here we return always kDefault!!

  fEventSpecie = kDefault;

  if (strcmp(runInfo->GetRunType(),"PHYSICS")) {
    // Not a physics run, the event specie is set to kCalib
    fEventSpecie = kCalib;
    return;
  }

  if (strcmp(runInfo->GetLHCState(),"STABLE_BEAMS") == 0) {
    // In case of stable beams
//    if ((strcmp(runInfo->GetBeamType(),"A-A") == 0) ||
//	(strcmp(runInfo->GetBeamType(),"A-") == 0) ||
//	(strcmp(runInfo->GetBeamType(),"-A") == 0)) {
      // Heavy ion run (any beam tha is not pp, the event specie is set to kHighMult
      fEventSpecie = kHighMult;
//    }
//    else 
    if ((strcmp(runInfo->GetBeamType(),"p-p") == 0) ||
	     (strcmp(runInfo->GetBeamType(),"p-") == 0) ||
	     (strcmp(runInfo->GetBeamType(),"-p") == 0) ||
	     (strcmp(runInfo->GetBeamType(),"P-P") == 0) ||
	     (strcmp(runInfo->GetBeamType(),"P-") == 0) ||
	     (strcmp(runInfo->GetBeamType(),"-P") == 0)) {
      // Proton run, the event specie is set to kLowMult
      fEventSpecie = kLowMult;
    }
    else if (strcmp(runInfo->GetBeamType(),"-") == 0) {
      // No beams, we assume cosmic data
      fEventSpecie = kCosmic;
    }
    else if (strcmp(runInfo->GetBeamType(),"UNKNOWN") == 0) {
      // No LHC beam information is available, we the default
      // event specie
      fEventSpecie = kDefault;
    }

    // Now we look into the trigger type in order to decide
    // on the remaining cases (cosmic event within LHC run,
    // high-mult event based on high-mult SPD trigger
    // within p-p run, laser triggers within physics run,
    // special DAQ events considered as calibration etc...)
    if (evInfo.GetEventType() != 7) {
      // START_OF_*, END_OF_*, CALIBRATION etc events
      fEventSpecie = kCalib;
    }

    TString triggerClasses = evInfo.GetTriggerClasses();
    TObjArray* trClassArray = triggerClasses.Tokenize(" ");
    Int_t nTrClasses = trClassArray->GetEntriesFast();
    Bool_t cosmicTrigger = kFALSE,
      laserTrigger = kFALSE,
      highMultTrigger = kFALSE,
      otherTrigger = kFALSE;
    for( Int_t i=0; i<nTrClasses; ++i ) {
      TString trClass = ((TObjString*)trClassArray->At(i))->String();
      if (trClass.BeginsWith("C0A") ||
	  trClass.BeginsWith("C0SC") ||
	  trClass.BeginsWith("C0OC")) {
      // ACORDE/SPD/TOF cosmic trigger, so we have cosmic event
      // not always true, but we don't have a better idea...
	cosmicTrigger = kTRUE;
      }
      else if (trClass.BeginsWith("C0LSR")) {
	// Laser trigger
	laserTrigger = kTRUE;
      }
      else if (trClass.BeginsWith("C0SH")) {
	// High-multiplicity SPD trugger
	// Have to add other high-mult triggers here...
	highMultTrigger = kTRUE;
      }
      else {
	otherTrigger = kTRUE;
      }
    }

    if (laserTrigger) {
      fEventSpecie = kCalib;
      return;
    }
    if (cosmicTrigger && !highMultTrigger && !otherTrigger) {
      fEventSpecie = kCosmic;
      return;
    }
    if (highMultTrigger) {
      fEventSpecie = kHighMult;
      return;
    }

    // Here we have to add if we have other cases
    // and also HLT info if any...
  }
}

const AliDetectorRecoParam *AliRecoParam::GetDetRecoParam(Int_t iDet) const
{
  // Return AliDetectorRecoParam object for a given detector
  // according to the event specie provided as an argument
  if ( iDet >= kNDetectors) return NULL;
  if (!fDetRecoParams[iDet]) return NULL;
  if (fDetRecoParams[iDet]->GetEntries() == 0) return NULL;

  for(Int_t iBit = 0; iBit < kNSpecies; iBit++) {
    if (fEventSpecie & (1 << iBit)) {
      if (fDetRecoParamsIndex[iBit][iDet] >= 0)
	return (AliDetectorRecoParam *)fDetRecoParams[iDet]->At(fDetRecoParamsIndex[iBit][iDet]);
      else
	return (AliDetectorRecoParam *)fDetRecoParams[iDet]->At(fDetRecoParamsIndex[0][iDet]);
    }
  }

  // Default one
  AliError(Form("Invalid event specie: %d!",fEventSpecie));
  return (AliDetectorRecoParam *)fDetRecoParams[iDet]->At(fDetRecoParamsIndex[0][iDet]);
}

void  AliRecoParam::AddDetRecoParam(Int_t iDet, AliDetectorRecoParam* param)
{
  // Add an instance of reco params object into
  // the fDetRecoParams for detector iDet
  // Updates the fDetRecoParams index
  if (!fDetRecoParams[iDet]) fDetRecoParams[iDet] = new TObjArray;
  fDetRecoParams[iDet]->AddLast(param);
  Int_t index = fDetRecoParams[iDet]->GetLast();

  // Index
  Int_t specie = param->GetEventSpecie();
  for(Int_t iBit = 0; iBit < kNSpecies; iBit++) {
    if (specie & (1 << iBit)) {
      fDetRecoParamsIndex[iBit][iDet] = index;
    }
  }
}

Bool_t AliRecoParam::AddDetRecoParamArray(Int_t iDet, TObjArray* parArray)
{
  // Add an array of reconstruction parameter objects
  // for a given detector
  // Basic check on the consistency of the array
  Bool_t defaultFound = kFALSE;
  for(Int_t i = 0; i < parArray->GetEntriesFast(); i++) {
    AliDetectorRecoParam *par = (AliDetectorRecoParam*)parArray->At(i);
    if (!par) continue;
    if (par->IsDefault()) defaultFound = kTRUE;

    Int_t specie = par->GetEventSpecie();
    for(Int_t iBit = 0; iBit < kNSpecies; iBit++) {
      if (specie & (1 << iBit)) {
	fDetRecoParamsIndex[iBit][iDet] = i;
      }
    }
 }
   
  fDetRecoParams[iDet] = parArray;

  return defaultFound;
}

const char*  AliRecoParam::PrintEventSpecie() const
{
  // Print the current
  // event specie
  switch (fEventSpecie) {
  case kDefault:
    return fkgEventSpecieName[0].Data() ;
    break;
  case kLowMult:
    return fkgEventSpecieName[1].Data() ;
    break;
  case kHighMult:
    return fkgEventSpecieName[2].Data() ;
    break;
  case kCosmic:
    return fkgEventSpecieName[3].Data() ;
    break;
  case kCalib:
    return fkgEventSpecieName[4].Data() ;
    break;
  default:
    return fkgEventSpecieName[5].Data() ;
    break;
  }
}

const char * AliRecoParam::GetEventSpecieName(EventSpecie_t es)
{
  switch (es) {
    case kDefault:
      return fkgEventSpecieName[0].Data() ;
      break;
    case kLowMult:
      return fkgEventSpecieName[1].Data() ;
      break;
    case kHighMult:
      return fkgEventSpecieName[2].Data() ;
      break;
    case kCosmic:
      return fkgEventSpecieName[3].Data() ;
      break;
    case kCalib:
      return fkgEventSpecieName[4].Data() ;
      break;
    default:
      return fkgEventSpecieName[5].Data() ;
      break;
  }
}

const char * AliRecoParam::GetEventSpecieName(Int_t esIndex)
{
  if ( esIndex >= 0 && esIndex < kNSpecies) 
    return fkgEventSpecieName[esIndex].Data() ;
  else 
    return fkgEventSpecieName[kNSpecies].Data() ;
}
Commit	Line	Data
	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, 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	///////////////////////////////////////////////////////////////////////////////
	18	// //
	19	// ALICE Reconstruction parameterization: //
	20	// //
	21	// //
	22	// Base Class for Detector reconstruction parameters //
	23	// Revision: cvetan.cheshkov@cern.ch 12/06/2008 //
	24	// Its structure has been revised and it is interfaced to AliEventInfo. //
	25	// //
	26	///////////////////////////////////////////////////////////////////////////////
	27
	28	#include "TClass.h"
	29	#include "TObjArray.h"
	30	#include "TMath.h"
	31	#include "AliDetectorRecoParam.h"
	32
	33	#include "AliLog.h"
	34	#include "AliRecoParam.h"
	35	#include "AliRunInfo.h"
	36	#include "AliEventInfo.h"
	37	#include "AliLog.h"
	38
	39	ClassImp(AliRecoParam)
	40
	41	TString AliRecoParam::fkgEventSpecieName[] = {"Default", "LowMultiplicity", "HighMultiplicity", "Cosmic", "Calibration", "Unknown"} ;
	42
	43	AliRecoParam::AliRecoParam():
	44	TObject(),
	45	fEventSpecie(kDefault)
	46	{
	47	// Default constructor
	48	// ...
	49	for(Int_t iDet = 0; iDet < kNDetectors; iDet++)
	50	fDetRecoParams[iDet] = NULL;
	51	for(Int_t iSpecie = 0; iSpecie < kNSpecies; iSpecie++) {
	52	for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
	53	fDetRecoParamsIndex[iSpecie][iDet] = -1;
	54	}
	55	}
	56	}
	57
	58	AliRecoParam::AliRecoParam(const AliRecoParam& par) :
	59	TObject(),
	60	fEventSpecie(par.fEventSpecie)
	61	{
	62	// copy constructor
	63	for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
	64	if (par.fDetRecoParams[iDet])
	65	fDetRecoParams[iDet] = (TObjArray*)(par.fDetRecoParams[iDet]->Clone());
	66	else
	67	fDetRecoParams[iDet] = NULL;
	68	}
	69	for(Int_t iSpecie = 0; iSpecie < kNSpecies; iSpecie++) {
	70	for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
	71	fDetRecoParamsIndex[iSpecie][iDet] = par.fDetRecoParamsIndex[iSpecie][iDet];
	72	}
	73	}
	74	}
	75
	76	//_____________________________________________________________________________
	77	AliRecoParam& AliRecoParam::operator = (const AliRecoParam& par)
	78	{
	79	// assignment operator
	80
	81	if(&par == this) return *this;
	82
	83	this->~AliRecoParam();
	84	new(this) AliRecoParam(par);
	85	return *this;
	86	}
	87
	88	AliRecoParam::~AliRecoParam(){
	89	// Destructor
	90	// ...
	91	// Delete the array with the reco-param objects
	92	for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
	93	if (fDetRecoParams[iDet]){
	94	fDetRecoParams[iDet]->Delete();
	95	delete fDetRecoParams[iDet];
	96	}
	97	}
	98	}
	99
	100	Int_t AliRecoParam::AConvert(EventSpecie_t es)
	101	{
	102	//Converts EventSpecie_t into int
	103	Int_t rv = -1 ;
	104	switch (es) {
	105	case kDefault:
	106	rv = 0 ;
	107	break;
	108	case kLowMult:
	109	rv = 1 ;
	110	break;
	111	case kHighMult:
	112	rv = 2 ;
	113	break;
	114	case kCosmic:
	115	rv = 3 ;
	116	break;
	117	case kCalib:
	118	rv = 4 ;
	119	break;
	120	default:
	121	break;
	122	}
	123
	124	if (rv < 0)
	125	AliFatalClass(Form("Wrong event specie conversion %d", es)) ;
	126
	127	return rv ;
	128	}
	129
	130	AliRecoParam::EventSpecie_t AliRecoParam::Convert(Int_t ies)
	131	{
	132	//Converts int into EventSpecie_t
	133	AliRecoParam::EventSpecie_t es = kDefault ;
	134	if ( ies >> 1)
	135	es = kLowMult ;
	136	if ( ies >> 2)
	137	es = kHighMult ;
	138	if ( ies >> 3)
	139	es = kCosmic ;
	140	if ( ies >> 4)
	141	es = kCalib ;
	142
	143	return es ;
	144	}
	145
	146	AliRecoParam::EventSpecie_t AliRecoParam::ConvertIndex(Int_t index)
	147	{
	148	//Converts index of lists into eventspecie
	149	EventSpecie_t es = kDefault ;
	150	switch (index) {
	151	case 0:
	152	es = kDefault ;
	153	break;
	154	case 1:
	155	es = kLowMult ;
	156	break;
	157	case 2:
	158	es = kHighMult ;
	159	break;
	160	case 3:
	161	es = kCosmic ;
	162	break;
	163	case 4:
	164	es = kCalib ;
	165	break;
	166	default:
	167	break;
	168	}
	169	return es ;
	170	}
	171
	172	void AliRecoParam::Print(Option_t *option) const {
	173	//
	174	// Print reconstruction setup
	175	//
	176	for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
	177	if (fDetRecoParams[iDet]){
	178	printf("AliDetectorRecoParam objects for detector %d:\n",iDet);
	179	Int_t nparam = fDetRecoParams[iDet]->GetEntriesFast();
	180	for (Int_t iparam=0; iparam<nparam; iparam++){
	181	AliDetectorRecoParam * param = (AliDetectorRecoParam *)fDetRecoParams[iDet]->At(iparam);
	182	if (!param) continue;
	183	param->Print(option);
	184	}
	185	}
	186	else {
	187	printf("No AliDetectorRecoParam objects specified for detector %d\n",iDet);
	188	}
	189	}
	190	}
	191
	192	void AliRecoParam::SetEventSpecie(const AliRunInfo *runInfo, const AliEventInfo &evInfo)
	193	{
	194	// To be implemented
	195	// Here we return always kDefault!!
	196
	197	fEventSpecie = kDefault;
	198
	199	if (strcmp(runInfo->GetRunType(),"PHYSICS")) {
	200	// Not a physics run, the event specie is set to kCalib
	201	fEventSpecie = kCalib;
	202	return;
	203	}
	204
	205	if (strcmp(runInfo->GetLHCState(),"STABLE_BEAMS") == 0) {
	206	// In case of stable beams
	207	// if ((strcmp(runInfo->GetBeamType(),"A-A") == 0) \|\|
	208	// (strcmp(runInfo->GetBeamType(),"A-") == 0) \|\|
	209	// (strcmp(runInfo->GetBeamType(),"-A") == 0)) {
	210	// Heavy ion run (any beam tha is not pp, the event specie is set to kHighMult
	211	fEventSpecie = kHighMult;
	212	// }
	213	// else
	214	if ((strcmp(runInfo->GetBeamType(),"p-p") == 0) \|\|
	215	(strcmp(runInfo->GetBeamType(),"p-") == 0) \|\|
	216	(strcmp(runInfo->GetBeamType(),"-p") == 0) \|\|
	217	(strcmp(runInfo->GetBeamType(),"P-P") == 0) \|\|
	218	(strcmp(runInfo->GetBeamType(),"P-") == 0) \|\|
	219	(strcmp(runInfo->GetBeamType(),"-P") == 0)) {
	220	// Proton run, the event specie is set to kLowMult
	221	fEventSpecie = kLowMult;
	222	}
	223	else if (strcmp(runInfo->GetBeamType(),"-") == 0) {
	224	// No beams, we assume cosmic data
	225	fEventSpecie = kCosmic;
	226	}
	227	else if (strcmp(runInfo->GetBeamType(),"UNKNOWN") == 0) {
	228	// No LHC beam information is available, we the default
	229	// event specie
	230	fEventSpecie = kDefault;
	231	}
	232
	233	// Now we look into the trigger type in order to decide
	234	// on the remaining cases (cosmic event within LHC run,
	235	// high-mult event based on high-mult SPD trigger
	236	// within p-p run, laser triggers within physics run,
	237	// special DAQ events considered as calibration etc...)
	238	if (evInfo.GetEventType() != 7) {
	239	// START_OF_, END_OF_, CALIBRATION etc events
	240	fEventSpecie = kCalib;
	241	}
	242
	243	TString triggerClasses = evInfo.GetTriggerClasses();
	244	TObjArray* trClassArray = triggerClasses.Tokenize(" ");
	245	Int_t nTrClasses = trClassArray->GetEntriesFast();
	246	Bool_t cosmicTrigger = kFALSE,
	247	laserTrigger = kFALSE,
	248	highMultTrigger = kFALSE,
	249	otherTrigger = kFALSE;
	250	for( Int_t i=0; i<nTrClasses; ++i ) {
	251	TString trClass = ((TObjString*)trClassArray->At(i))->String();
	252	if (trClass.BeginsWith("C0A") \|\|
	253	trClass.BeginsWith("C0SC") \|\|
	254	trClass.BeginsWith("C0OC")) {
	255	// ACORDE/SPD/TOF cosmic trigger, so we have cosmic event
	256	// not always true, but we don't have a better idea...
	257	cosmicTrigger = kTRUE;
	258	}
	259	else if (trClass.BeginsWith("C0LSR")) {
	260	// Laser trigger
	261	laserTrigger = kTRUE;
	262	}
	263	else if (trClass.BeginsWith("C0SH")) {
	264	// High-multiplicity SPD trugger
	265	// Have to add other high-mult triggers here...
	266	highMultTrigger = kTRUE;
	267	}
	268	else {
	269	otherTrigger = kTRUE;
	270	}
	271	}
	272
	273	if (laserTrigger) {
	274	fEventSpecie = kCalib;
	275	return;
	276	}
	277	if (cosmicTrigger && !highMultTrigger && !otherTrigger) {
	278	fEventSpecie = kCosmic;
	279	return;
	280	}
	281	if (highMultTrigger) {
	282	fEventSpecie = kHighMult;
	283	return;
	284	}
	285
	286	// Here we have to add if we have other cases
	287	// and also HLT info if any...
	288	}
	289	}
	290
	291	const AliDetectorRecoParam *AliRecoParam::GetDetRecoParam(Int_t iDet) const
	292	{
	293	// Return AliDetectorRecoParam object for a given detector
	294	// according to the event specie provided as an argument
	295	if ( iDet >= kNDetectors) return NULL;
	296	if (!fDetRecoParams[iDet]) return NULL;
	297	if (fDetRecoParams[iDet]->GetEntries() == 0) return NULL;
	298
	299	for(Int_t iBit = 0; iBit < kNSpecies; iBit++) {
	300	if (fEventSpecie & (1 << iBit)) {
	301	if (fDetRecoParamsIndex[iBit][iDet] >= 0)
	302	return (AliDetectorRecoParam *)fDetRecoParams[iDet]->At(fDetRecoParamsIndex[iBit][iDet]);
	303	else
	304	return (AliDetectorRecoParam *)fDetRecoParams[iDet]->At(fDetRecoParamsIndex[0][iDet]);
	305	}
	306	}
	307
	308	// Default one
	309	AliError(Form("Invalid event specie: %d!",fEventSpecie));
	310	return (AliDetectorRecoParam *)fDetRecoParams[iDet]->At(fDetRecoParamsIndex[0][iDet]);
	311	}
	312
	313	void AliRecoParam::AddDetRecoParam(Int_t iDet, AliDetectorRecoParam* param)
	314	{
	315	// Add an instance of reco params object into
	316	// the fDetRecoParams for detector iDet
	317	// Updates the fDetRecoParams index
	318	if (!fDetRecoParams[iDet]) fDetRecoParams[iDet] = new TObjArray;
	319	fDetRecoParams[iDet]->AddLast(param);
	320	Int_t index = fDetRecoParams[iDet]->GetLast();
	321
	322	// Index
	323	Int_t specie = param->GetEventSpecie();
	324	for(Int_t iBit = 0; iBit < kNSpecies; iBit++) {
	325	if (specie & (1 << iBit)) {
	326	fDetRecoParamsIndex[iBit][iDet] = index;
	327	}
	328	}
	329	}
	330
	331	Bool_t AliRecoParam::AddDetRecoParamArray(Int_t iDet, TObjArray* parArray)
	332	{
	333	// Add an array of reconstruction parameter objects
	334	// for a given detector
	335	// Basic check on the consistency of the array
	336	Bool_t defaultFound = kFALSE;
	337	for(Int_t i = 0; i < parArray->GetEntriesFast(); i++) {
	338	AliDetectorRecoParam par = (AliDetectorRecoParam)parArray->At(i);
	339	if (!par) continue;
	340	if (par->IsDefault()) defaultFound = kTRUE;
	341
	342	Int_t specie = par->GetEventSpecie();
	343	for(Int_t iBit = 0; iBit < kNSpecies; iBit++) {
	344	if (specie & (1 << iBit)) {
	345	fDetRecoParamsIndex[iBit][iDet] = i;
	346	}
	347	}
	348	}
	349
	350	fDetRecoParams[iDet] = parArray;
	351
	352	return defaultFound;
	353	}
	354
	355	const char* AliRecoParam::PrintEventSpecie() const
	356	{
	357	// Print the current
	358	// event specie
	359	switch (fEventSpecie) {
	360	case kDefault:
	361	return fkgEventSpecieName[0].Data() ;
	362	break;
	363	case kLowMult:
	364	return fkgEventSpecieName[1].Data() ;
	365	break;
	366	case kHighMult:
	367	return fkgEventSpecieName[2].Data() ;
	368	break;
	369	case kCosmic:
	370	return fkgEventSpecieName[3].Data() ;
	371	break;
	372	case kCalib:
	373	return fkgEventSpecieName[4].Data() ;
	374	break;
	375	default:
	376	return fkgEventSpecieName[5].Data() ;
	377	break;
	378	}
	379	}
	380
	381	const char * AliRecoParam::GetEventSpecieName(EventSpecie_t es)
	382	{
	383	switch (es) {
	384	case kDefault:
	385	return fkgEventSpecieName[0].Data() ;
	386	break;
	387	case kLowMult:
	388	return fkgEventSpecieName[1].Data() ;
	389	break;
	390	case kHighMult:
	391	return fkgEventSpecieName[2].Data() ;
	392	break;
	393	case kCosmic:
	394	return fkgEventSpecieName[3].Data() ;
	395	break;
	396	case kCalib:
	397	return fkgEventSpecieName[4].Data() ;
	398	break;
	399	default:
	400	return fkgEventSpecieName[5].Data() ;
	401	break;
	402	}
	403	}
	404
	405	const char * AliRecoParam::GetEventSpecieName(Int_t esIndex)
	406	{
	407	if ( esIndex >= 0 && esIndex < kNSpecies)
	408	return fkgEventSpecieName[esIndex].Data() ;
	409	else
	410	return fkgEventSpecieName[kNSpecies].Data() ;
	411	}