#include "TClass.h"
#include "TObjArray.h"
#include "TMath.h"
#include "THashTable.h"
#include "TString.h"
#include "TRegexp.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", "Calib", "Unknown"} ;
AliRecoParam::AliRecoParam():
TObject(),
fEventSpecie(kDefault)
{
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)
{
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)
{
if(&par == this) return *this;
this->~AliRecoParam();
new(this) AliRecoParam(par);
return *this;
}
AliRecoParam::~AliRecoParam(){
for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (fDetRecoParams[iDet]){
fDetRecoParams[iDet]->Delete();
delete fDetRecoParams[iDet];
}
}
}
Int_t AliRecoParam::AConvert(EventSpecie_t es)
{
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)
{
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)
{
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 {
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,
const THashTable *cosmicTriggersList)
{
fEventSpecie = kDefault;
if (strcmp(runInfo->GetRunType(),"PHYSICS")) {
fEventSpecie = kCalib;
return;
}
if (evInfo.GetEventType() != 7) {
fEventSpecie = kCalib;
return;
}
TString lhcState(runInfo->GetLHCState());
TString beamType(runInfo->GetBeamType());
TRegexp reStable("^STABLE[_ ]BEAMS$");
TRegexp reASthg("^A-");
TRegexp reSthgA(".*-A$");
TRegexp repSthg("^[pP]-.*");
TRegexp reSthgp(".*-[pP]$");
if(lhcState.Index(reStable)==0){
if(beamType.Index(repSthg)==0 || beamType.Index(reSthgp)==0){
fEventSpecie = kLowMult;
}else if(beamType.Index(reASthg)==0 || beamType.Index(reSthgA)==0){
fEventSpecie = kHighMult;
}
}
if(beamType==TString("-")){
fEventSpecie = kCosmic;
}
TString triggerClasses = evInfo.GetTriggerClasses();
TObjArray* trClassArray = triggerClasses.Tokenize(" ");
Int_t nTrClasses = trClassArray->GetEntriesFast();
Bool_t cosmicTrigger = kFALSE,
calibTrigger = kFALSE,
otherTrigger = kFALSE;
for( Int_t i=0; i<nTrClasses; ++i ) {
TString trClass = ((TObjString*)trClassArray->At(i))->String();
if (trClass.BeginsWith("C0L")) {
calibTrigger = kTRUE;
continue;
}
if (cosmicTriggersList) {
if (cosmicTriggersList->FindObject(trClass.Data())) {
cosmicTrigger = kTRUE;
AliDebug(1,Form("Trigger %s identified as cosmic according to the list defined in OCDB.",
trClass.Data()));
continue;
}
}
else {
AliDebug(1,"Cosmic trigger list is not provided, cosmic event specie is effectively disabled!");
}
otherTrigger = kTRUE;
}
delete trClassArray;
if (calibTrigger) {
fEventSpecie = kCalib;
return;
}
if (cosmicTrigger && !otherTrigger) {
fEventSpecie = kCosmic;
return;
}
}
const AliDetectorRecoParam *AliRecoParam::GetDetRecoParam(Int_t iDet) const
{
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 if (fDetRecoParamsIndex[0][iDet] >= 0)
return (AliDetectorRecoParam *)fDetRecoParams[iDet]->At(fDetRecoParamsIndex[0][iDet]);
else {
AliError(Form("no RecoParam set for detector %d", iDet));
return NULL;
}
}
}
AliError(Form("Invalid event specie: %d!",fEventSpecie));
if (fDetRecoParamsIndex[0][iDet] >= 0)
return (AliDetectorRecoParam *)fDetRecoParams[iDet]->At(fDetRecoParamsIndex[0][iDet]);
AliError(Form("no RecoParam set for detector %d", iDet));
return NULL;
}
void AliRecoParam::AddDetRecoParam(Int_t iDet, AliDetectorRecoParam* param)
{
if (!fDetRecoParams[iDet]) fDetRecoParams[iDet] = new TObjArray;
fDetRecoParams[iDet]->AddLast(param);
Int_t index = fDetRecoParams[iDet]->GetLast();
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)
{
Bool_t defaultFound = kFALSE;
if (!parArray) return defaultFound;
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
{
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() ;
}