ClassImp(AliReconstruction)
//_____________________________________________________________________________
-const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
+const char* AliReconstruction::fgkDetectorName[AliReconstruction::kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
//_____________________________________________________________________________
AliReconstruction::AliReconstruction(const char* gAliceFilename) :
fEquipIdMap(""),
fFirstEvent(0),
fLastEvent(-1),
- fNumberOfEventsPerFile(1),
+ fNumberOfEventsPerFile((UInt_t)-1),
fOptions(),
fLoadAlignFromCDB(kTRUE),
fLoadAlignData("ALL"),
- fESDPar(""),
fUseHLTData(),
fRunInfo(NULL),
fEventInfo(),
fRecoParam(),
- fVertexer(NULL),
fDiamondProfileSPD(NULL),
fDiamondProfile(NULL),
fDiamondProfileTPC(NULL),
// create reconstruction object with default parameters
gGeoManager = NULL;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
fOptions(),
fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
fLoadAlignData(rec.fLoadAlignData),
- fESDPar(rec.fESDPar),
fUseHLTData(rec.fUseHLTData),
fRunInfo(NULL),
fEventInfo(),
fRecoParam(rec.fRecoParam),
- fVertexer(NULL),
fDiamondProfileSPD(rec.fDiamondProfileSPD),
fDiamondProfile(rec.fDiamondProfile),
fDiamondProfileTPC(rec.fDiamondProfileTPC),
for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
}
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
fLoadAlignFromCDB = rec.fLoadAlignFromCDB;
fLoadAlignData = rec.fLoadAlignData;
- fESDPar = rec.fESDPar;
fUseHLTData = rec.fUseHLTData;
delete fRunInfo; fRunInfo = NULL;
fRecoParam = rec.fRecoParam;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
delete fReconstructor[iDet]; fReconstructor[iDet] = NULL;
delete fLoader[iDet]; fLoader[iDet] = NULL;
delete fTracker[iDet]; fTracker[iDet] = NULL;
fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
}
- fVertexer = NULL;
delete fDiamondProfileSPD; fDiamondProfileSPD = NULL;
if (rec.fDiamondProfileSPD) fDiamondProfileSPD = new AliESDVertex(*rec.fDiamondProfileSPD);
delete fDiamondProfile; fDiamondProfile = NULL;
AliCDBPath aPath(calibType);
if(!aPath.IsValid()){
// if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if(!strcmp(calibType, fgkDetectorName[iDet])) {
aPath.SetPath(Form("%s/*", calibType));
AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
// // check that calibType refers to a "valid" detector name
// Bool_t isDetector = kFALSE;
-// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+// for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
// TString detName = fgkDetectorName[iDet];
// if(aPath.GetLevel0() == detName) {
// isDetector = kTRUE;
TString detStr = detectors;
TString loadAlObjsListOfDets = "";
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
- if(fgkDetectorName[iDet]=="HLT") continue;
- if(AliGeomManager::IsModuleInGeom(fgkDetectorName[iDet]))
+ if(!strcmp(fgkDetectorName[iDet],"HLT")) continue;
+
+ if(AliGeomManager::GetNalignable(fgkDetectorName[iDet]) != 0)
{
loadAlObjsListOfDets += fgkDetectorName[iDet];
loadAlObjsListOfDets += " ";
}
} // end loop over detectors
- if(AliGeomManager::IsModuleInGeom("FRAME"))
+
+ if(AliGeomManager::GetNalignable("GRP") != 0)
loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
// First check if the reco-params are global
if(!strcmp(detector, "GRP")) {
par->SetAsDefault();
- fRecoParam.AddDetRecoParam(fgkNDetectors,par);
+ fRecoParam.AddDetRecoParam(kNDetectors,par);
return;
}
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if(!strcmp(detector, fgkDetectorName[iDet])) {
par->SetAsDefault();
fRecoParam.AddDetRecoParam(iDet,par);
// Process the list of active detectors
if (activeDetectors) {
UInt_t detMask = activeDetectors;
+ fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
+ fRunTracking = MatchDetectorList(fRunTracking,detMask);
+ fFillESD = MatchDetectorList(fFillESD,detMask);
+ fQADetectors = MatchDetectorList(fQADetectors,detMask);
fLoadCDB.Form("%s %s %s %s",
fRunLocalReconstruction.Data(),
fRunTracking.Data(),
fFillESD.Data(),
fQADetectors.Data());
- fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
- fRunTracking = MatchDetectorList(fRunTracking,detMask);
- fFillESD = MatchDetectorList(fFillESD,detMask);
- fQADetectors = MatchDetectorList(fQADetectors,detMask);
fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
if (!((detMask >> AliDAQ::DetectorID("ITSSPD")) & 0x1)) {
// switch off the vertexer
AliInfo("SPD is not in the list of active detectors. Vertexer switched off.");
fRunVertexFinder = kFALSE;
}
+ if (!((detMask >> AliDAQ::DetectorID("TRG")) & 0x1)) {
+ // switch off the reading of CTP raw-data payload
+ if (fFillTriggerESD) {
+ AliInfo("CTP is not in the list of active detectors. CTP data reading switched off.");
+ fFillTriggerESD = kFALSE;
+ }
+ }
}
AliInfo("===================================================================================");
AliCDBManager::Instance()->Get("GRP/CTP/Config");
TString detStr = fLoadCDB;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
}
ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
- // get vertexer
- if (fRunVertexFinder && !CreateVertexer()) {
- Abort("CreateVertexer", TSelector::kAbortProcess);
- return;
- }
- AliSysInfo::AddStamp("CreateVertexer");
-
// get trackers
if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
Abort("CreateTrackers", TSelector::kAbortProcess);
ftree = new TTree("esdTree", "Tree with ESD objects");
fesd = new AliESDEvent();
fesd->CreateStdContent();
+
+ fesd->WriteToTree(ftree);
if (fWriteESDfriend) {
+ // careful:
+ // Since we add the branch manually we must
+ // book and add it after WriteToTree
+ // otherwise it is created twice,
+ // once via writetotree and once here.
+ // The case for AliESDfriend is now
+ // caught also in AlIESDEvent::WriteToTree but
+ // be careful when changing the name (AliESDfriend is not
+ // a TNamed so we had to hardwire it)
fesdf = new AliESDfriend();
TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
br->SetFile("AliESDfriends.root");
fesd->AddObject(fesdf);
}
- fesd->WriteToTree(ftree);
ftree->GetUserInfo()->Add(fesd);
fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
fhltesd = new AliESDEvent();
fhltesd->CreateStdContent();
+
+ // read the ESD template from CDB
+ // HLT is allowed to put non-std content to its ESD, the non-std
+ // objects need to be created before invocation of WriteToTree in
+ // order to create all branches. Initialization is done from an
+ // ESD layout template in CDB
+ AliCDBManager* man = AliCDBManager::Instance();
+ AliCDBPath hltESDConfigPath("HLT/ConfigHLT/esdLayout");
+ AliCDBEntry* hltESDConfig=NULL;
+ if (man->GetId(hltESDConfigPath)!=NULL &&
+ (hltESDConfig=man->Get(hltESDConfigPath))!=NULL) {
+ AliESDEvent* pESDLayout=dynamic_cast<AliESDEvent*>(hltESDConfig->GetObject());
+ if (pESDLayout) {
+ // init all internal variables from the list of objects
+ pESDLayout->GetStdContent();
+
+ // copy content and create non-std objects
+ *fhltesd=*pESDLayout;
+ fhltesd->Reset();
+ } else {
+ AliError(Form("error setting hltEsd layout from %s: invalid object type",
+ hltESDConfigPath.GetPath().Data()));
+ }
+ }
+
fhltesd->WriteToTree(fhlttree);
fhlttree->GetUserInfo()->Add(fhltesd);
- ProcInfo_t ProcInfo;
- gSystem->GetProcInfo(&ProcInfo);
- AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
+ ProcInfo_t procInfo;
+ gSystem->GetProcInfo(&procInfo);
+ AliInfo(Form("Current memory usage %d %d", procInfo.fMemResident, procInfo.fMemVirtual));
//QA
//Initialize the QA and start of cycle
// Fill Event-info object
GetEventInfo();
fRecoParam.SetEventSpecie(fRunInfo,fEventInfo);
+ AliInfo(Form("Current event specie: %s",fRecoParam.PrintEventSpecie()));
// Set the reco-params
{
TString detStr = fLoadCDB;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliReconstructor *reconstructor = GetReconstructor(iDet);
if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
// Set most probable pt, for B=0 tracking
// Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
- const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(fgkNDetectors));
+ const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(kNDetectors));
if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
// Fill raw-data error log into the ESD
// Temporary fix to avoid problems with HLT that overwrites the offline ESDs
if (detectors.Contains("ALL")) {
detectors="";
- for (Int_t idet=0; idet<fgkNDetectors; ++idet){
+ for (Int_t idet=0; idet<kNDetectors; ++idet){
detectors += fgkDetectorName[idet];
detectors += " ";
}
ok = kFALSE;
if (tpcTrack)
ok = AliTracker::
- PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE);
+ PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kFALSE);
if (ok) {
Int_t n=trkArray.GetEntriesFast();
if (track->IsOn(AliESDtrack::kITSrefit)) continue;
AliTracker::
- PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
+ PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kFALSE);
track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kVeryBig);
}
AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
if (pvtx) {
if (pvtx->GetStatus()) {
- fesd->SetPrimaryVertex(pvtx);
+ fesd->SetPrimaryVertexTracks(pvtx);
for (Int_t i=0; i<ntracks; i++) {
AliESDtrack *t = fesd->GetTrack(i);
t->RelateToVertex(pvtx, kBz, kVeryBig);
new (fesdf) AliESDfriend(); // Reset...
}
- ProcInfo_t ProcInfo;
- gSystem->GetProcInfo(&ProcInfo);
- AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
+ ProcInfo_t procInfo;
+ gSystem->GetProcInfo(&procInfo);
+ AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, procInfo.fMemResident, procInfo.fMemVirtual));
fEventInfo.Reset();
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (fReconstructor[iDet])
fReconstructor[iDet]->SetRecoParam(NULL);
}
ftree->GetUserInfo()->Add(cdbListCopy);
- if(fESDPar.Contains("ESD.par")){
- AliInfo("Attaching ESD.par to Tree");
- TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par");
- ftree->GetUserInfo()->Add(fn);
- }
-
-
ffile->cd();
if (fWriteESDfriend)
AliCodeTimerAuto("")
TString detStr = detectors;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
AliCodeTimerAuto("")
+ AliVertexer *vertexer = CreateVertexer();
+ if (!vertexer) return kFALSE;
+
+ AliInfo("running the ITS vertex finder");
AliESDVertex* vertex = NULL;
- Double_t vtxPos[3] = {0, 0, 0};
- Double_t vtxErr[3] = {0.07, 0.07, 0.1};
- TArrayF mcVertex(3);
- if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
- fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
- for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
- }
-
- if (fVertexer) {
- AliInfo("running the ITS vertex finder");
- if (fLoader[0]) {
- fLoader[0]->LoadRecPoints();
- TTree* cltree = fLoader[0]->TreeR();
- if (cltree) {
- if(fDiamondProfileSPD) fVertexer->SetVtxStart(fDiamondProfileSPD);
- vertex = fVertexer->FindVertexForCurrentEvent(cltree);
- }
- else {
- AliError("Can't get the ITS cluster tree");
- }
- fLoader[0]->UnloadRecPoints();
- }
- else {
- AliError("Can't get the ITS loader");
- }
- if(!vertex){
- AliWarning("Vertex not found");
- vertex = new AliESDVertex();
- vertex->SetName("default");
+ if (fLoader[0]) {
+ fLoader[0]->LoadRecPoints();
+ TTree* cltree = fLoader[0]->TreeR();
+ if (cltree) {
+ if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD);
+ vertex = vertexer->FindVertexForCurrentEvent(cltree);
}
else {
- vertex->SetName("reconstructed");
+ AliError("Can't get the ITS cluster tree");
}
-
- } else {
- AliInfo("getting the primary vertex from MC");
- vertex = new AliESDVertex(vtxPos, vtxErr);
+ fLoader[0]->UnloadRecPoints();
}
-
- if (vertex) {
- vertex->GetXYZ(vtxPos);
- vertex->GetSigmaXYZ(vtxErr);
- } else {
- AliWarning("no vertex reconstructed");
- vertex = new AliESDVertex(vtxPos, vtxErr);
+ else {
+ AliError("Can't get the ITS loader");
}
+ if(!vertex){
+ AliWarning("Vertex not found");
+ vertex = new AliESDVertex();
+ vertex->SetName("default");
+ }
+ else {
+ vertex->SetName("reconstructed");
+ }
+
+ Double_t vtxPos[3];
+ Double_t vtxErr[3];
+ vertex->GetXYZ(vtxPos);
+ vertex->GetSigmaXYZ(vtxErr);
+
esd->SetPrimaryVertexSPD(vertex);
// if SPD multiplicity has been determined, it is stored in the ESD
- AliMultiplicity *mult = fVertexer->GetMultiplicity();
+ AliMultiplicity *mult = vertexer->GetMultiplicity();
if(mult)esd->SetMultiplicity(mult);
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
}
delete vertex;
+ delete vertexer;
+
return kTRUE;
}
AliInfo("running HLT tracking");
// Get a pointer to the HLT reconstructor
- AliReconstructor *reconstructor = GetReconstructor(fgkNDetectors-1);
+ AliReconstructor *reconstructor = GetReconstructor(kNDetectors-1);
if (!reconstructor) return kFALSE;
// TPC + ITS
if (fReconstructor[11] && fLoader[11]) {
fLoader[11]->LoadRecPoints("READ");
TTree *treeR = fLoader[11]->TreeR();
- GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
+ if (treeR) {
+ GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
+ }
}
// pass 1: TPC + ITS inwards
// pass 2: ALL backwards
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!fTracker[iDet]) continue;
AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
static Int_t eventNr=0;
TString detStr = detectors;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
// load all base libraries to get the loader classes
TString libs = gSystem->GetLibraries();
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
TString detName = fgkDetectorName[iDet];
if (detName == "HLT") continue;
if (libs.Contains("lib" + detName + "base.so")) continue;
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::CreateVertexer()
+AliVertexer* AliReconstruction::CreateVertexer()
{
// create the vertexer
+// Please note that the caller is the owner of the
+// vertexer
- fVertexer = NULL;
+ AliVertexer* vertexer = NULL;
AliReconstructor* itsReconstructor = GetReconstructor(0);
if (itsReconstructor) {
- fVertexer = itsReconstructor->CreateVertexer();
+ vertexer = itsReconstructor->CreateVertexer();
}
- if (!fVertexer) {
+ if (!vertexer) {
AliWarning("couldn't create a vertexer for ITS");
- if (fStopOnError) return kFALSE;
}
- return kTRUE;
+ return vertexer;
}
//_____________________________________________________________________________
AliInfo("Creating trackers");
TString detStr = detectors;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
{
// delete trackers and the run loader and close and delete the file
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
delete fReconstructor[iDet];
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
delete fRunInfo;
fRunInfo = NULL;
- delete fVertexer;
- fVertexer = NULL;
-
delete ftVertexer;
ftVertexer = NULL;
AliESDtrack *track = esd->GetTrack(itrack);
Int_t nsp = 0;
Int_t idx[200];
- for (Int_t iDet = 3; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
+ for (Int_t iDet = 5; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
nsp += track->GetNcls(iDet);
if (iDet==0) { // ITS "extra" clusters
AliTrackPointArray *sp = new AliTrackPointArray(nsp);
track->SetTrackPointArray(sp);
Int_t isptrack = 0;
- for (Int_t iDet = 3; iDet >= 0; iDet--) {
+ for (Int_t iDet = 5; iDet >= 0; iDet--) {
AliTracker *tracker = fTracker[iDet];
if (!tracker) continue;
Int_t nspdet = track->GetClusters(iDet,idx);
}
-TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString pName){
- // Dump a file content into a char in TNamed
- ifstream in;
- in.open(fPath.Data(),ios::in | ios::binary|ios::ate);
- Int_t kBytes = (Int_t)in.tellg();
- printf("Size: %d \n",kBytes);
- TNamed *fn = 0;
- if(in.good()){
- char* memblock = new char [kBytes];
- in.seekg (0, ios::beg);
- in.read (memblock, kBytes);
- in.close();
- TString fData(memblock,kBytes);
- fn = new TNamed(pName,fData);
- printf("fData Size: %d \n",fData.Sizeof());
- printf("pName Size: %d \n",pName.Sizeof());
- printf("fn Size: %d \n",fn->Sizeof());
- delete[] memblock;
- }
- else{
- AliInfo(Form("Could not Open %s\n",fPath.Data()));
- }
-
- return fn;
-}
-
-void AliReconstruction::TNamedToFile(TTree* fTree, TString pName){
- // This is not really needed in AliReconstruction at the moment
- // but can serve as a template
-
- TList *fList = fTree->GetUserInfo();
- TNamed *fn = (TNamed*)fList->FindObject(pName.Data());
- printf("fn Size: %d \n",fn->Sizeof());
-
- TString fTmp(fn->GetName()); // to be 100% sure in principle pName also works
- const char* cdata = fn->GetTitle();
- printf("fTmp Size %d\n",fTmp.Sizeof());
-
- int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()...
- printf("calculated size %d\n",size);
- ofstream out(pName.Data(),ios::out | ios::binary);
- out.write(cdata,size);
- out.close();
-
-}
-
//_____________________________________________________________________________
void AliReconstruction::CheckQA()
{
{
// return the detector index corresponding to detector
Int_t index = -1 ;
- for (index = 0; index < fgkNDetectors ; index++) {
+ for (index = 0; index < kNDetectors ; index++) {
if ( strcmp(detector, fgkDetectorName[index]) == 0 )
break ;
}
// Return: kTRUE if all operations have been done properly, kFALSE otherwise
//
Bool_t ret=kFALSE;
- //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ //for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
//if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
if(fTracker[iDet]) {
Bool_t isOK = kTRUE;
TString detStr = fLoadCDB;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
if (trclass) {
- Int_t trindex = (Int_t)TMath::Log2(trclass->GetMask());
+ Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
fesd->SetTriggerClass(trclass->GetName(),trindex);
+ if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
if (trmask & (1 << trindex)) {
trclasses += " ";
trclasses += trclass->GetName();
if ((detectorMask >> iDet) & 0x1) {
TString det = AliDAQ::OfflineModuleName(iDet);
if ((detList.CompareTo("ALL") == 0) ||
- detList.BeginsWith("ALL ") ||
- detList.EndsWith(" ALL") ||
- detList.Contains(" ALL ") ||
+ ((detList.BeginsWith("ALL ") ||
+ detList.EndsWith(" ALL") ||
+ detList.Contains(" ALL ")) &&
+ !(detList.BeginsWith("-"+det+" ") ||
+ detList.EndsWith(" -"+det) ||
+ detList.Contains(" -"+det+" "))) ||
(detList.CompareTo(det) == 0) ||
- detList.BeginsWith(det) ||
- detList.EndsWith(det) ||
+ detList.BeginsWith(det+" ") ||
+ detList.EndsWith(" "+det) ||
detList.Contains( " "+det+" " )) {
if (!resultList.EndsWith(det + " ")) {
resultList += det;
if ((detectorMask >> AliDAQ::kHLTId) & 0x1) {
TString hltDet = AliDAQ::OfflineModuleName(AliDAQ::kNDetectors-1);
if ((detList.CompareTo("ALL") == 0) ||
- detList.BeginsWith("ALL ") ||
- detList.EndsWith(" ALL") ||
- detList.Contains(" ALL ") ||
+ ((detList.BeginsWith("ALL ") ||
+ detList.EndsWith(" ALL") ||
+ detList.Contains(" ALL ")) &&
+ !(detList.BeginsWith("-"+hltDet+" ") ||
+ detList.EndsWith(" -"+hltDet) ||
+ detList.Contains(" -"+hltDet+" "))) ||
(detList.CompareTo(hltDet) == 0) ||
- detList.BeginsWith(hltDet) ||
- detList.EndsWith(hltDet) ||
+ detList.BeginsWith(hltDet+" ") ||
+ detList.EndsWith(" "+hltDet) ||
detList.Contains( " "+hltDet+" " )) {
resultList += hltDet;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff