#include <THashTable.h>
#include <TGrid.h>
#include <TMessage.h>
+#include <TUrl.h>
+#include <TRandom.h>
#include "AliAlignObj.h"
#include "AliCDBEntry.h"
#include "AliTriggerConfiguration.h"
#include "AliV0vertexer.h"
#include "AliVertexer.h"
+#include "AliTrackleter.h"
#include "AliVertexerTracks.h"
#include "AliTriggerRunScalers.h"
#include "AliCTPTimeParams.h"
#include "AliESDHLTDecision.h"
-
+#include "AliTriggerInput.h"
+#include "AliLHCData.h"
ClassImp(AliReconstruction)
//_____________________________________________________________________________
fRunMuonTracking(kFALSE),
fRunV0Finder(kTRUE),
fRunCascadeFinder(kTRUE),
+ fRunMultFinder(kTRUE),
fStopOnError(kTRUE),
fWriteAlignmentData(kFALSE),
fWriteESDfriend(kFALSE),
fFirstEvent(0),
fLastEvent(-1),
fNumberOfEventsPerFile((UInt_t)-1),
+ fFractionFriends(0.04),
fOptions(),
fLoadAlignFromCDB(kTRUE),
fLoadAlignData("ALL"),
fEventInfo(),
fRunScalers(NULL),
fCTPTimeParams(NULL),
+ fCTPTimeAlign(NULL),
fRunLoader(NULL),
fRawReader(NULL),
fhltesd(NULL),
fesdf(NULL),
ffile(NULL),
+ ffileF(NULL),
ftree(NULL),
+ ftreeF(NULL),
fhlttree(NULL),
ftVertexer(NULL),
fIsNewRunLoader(kFALSE),
fRunAliEVE(kFALSE),
- fChain(NULL)
+ fChain(NULL),
+ fNall(0),
+ fNspecie(0),
+ fSspecie(0),
+ fNhighPt(0),
+ fShighPt(0),
+ fUpgradeModule("")
{
// create reconstruction object with default parameters
gGeoManager = NULL;
for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
fReconstructor[iDet] = NULL;
+ fUpgradeMask[iDet]=kFALSE;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
}
fQACycles[iDet] = 999999 ;
fQAWriteExpert[iDet] = kFALSE ;
}
-
+ fBeamInt[0][0]=fBeamInt[0][1]=fBeamInt[1][0]=fBeamInt[1][1] = -1;
+
AliPID pid;
}
fRunMuonTracking(rec.fRunMuonTracking),
fRunV0Finder(rec.fRunV0Finder),
fRunCascadeFinder(rec.fRunCascadeFinder),
+ fRunMultFinder(rec.fRunMultFinder),
fStopOnError(rec.fStopOnError),
fWriteAlignmentData(rec.fWriteAlignmentData),
fWriteESDfriend(rec.fWriteESDfriend),
fFirstEvent(rec.fFirstEvent),
fLastEvent(rec.fLastEvent),
fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
+ fFractionFriends(rec.fFractionFriends),
fOptions(),
fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
fLoadAlignData(rec.fLoadAlignData),
fEventInfo(),
fRunScalers(NULL),
fCTPTimeParams(NULL),
+ fCTPTimeAlign(NULL),
fRunLoader(NULL),
fRawReader(NULL),
fhltesd(NULL),
fesdf(NULL),
ffile(NULL),
+ ffileF(NULL),
ftree(NULL),
+ ftreeF(NULL),
fhlttree(NULL),
ftVertexer(NULL),
fIsNewRunLoader(rec.fIsNewRunLoader),
fRunAliEVE(kFALSE),
- fChain(NULL)
+ fChain(NULL),
+ fNall(0),
+ fNspecie(0),
+ fSspecie(0),
+ fNhighPt(0),
+ fShighPt(0),
+ fUpgradeModule("")
{
// copy constructor
}
for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
fReconstructor[iDet] = NULL;
+ fUpgradeMask[iDet] = kFALSE;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
}
for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
}
+
+ for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
+
}
//_____________________________________________________________________________
fRunMuonTracking = rec.fRunMuonTracking;
fRunV0Finder = rec.fRunV0Finder;
fRunCascadeFinder = rec.fRunCascadeFinder;
+ fRunMultFinder = rec.fRunMultFinder;
fStopOnError = rec.fStopOnError;
fWriteAlignmentData = rec.fWriteAlignmentData;
fWriteESDfriend = rec.fWriteESDfriend;
fFirstEvent = rec.fFirstEvent;
fLastEvent = rec.fLastEvent;
fNumberOfEventsPerFile = rec.fNumberOfEventsPerFile;
+ fFractionFriends = rec.fFractionFriends;
for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
delete fCTPTimeParams; fCTPTimeParams = NULL;
if (rec.fCTPTimeParams) fCTPTimeParams = new AliCTPTimeParams(*rec.fCTPTimeParams);
+ delete fCTPTimeAlign; fCTPTimeAlign = NULL;
+ if (rec.fCTPTimeAlign) fCTPTimeAlign = new AliCTPTimeParams(*rec.fCTPTimeAlign);
fRunLoader = NULL;
fRawReader = NULL;
fRecoParam = rec.fRecoParam;
for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+ fUpgradeMask[iDet] = kFALSE;
delete fReconstructor[iDet]; fReconstructor[iDet] = NULL;
delete fLoader[iDet]; fLoader[iDet] = NULL;
delete fTracker[iDet]; fTracker[iDet] = NULL;
fInitQACalled = rec.fInitQACalled;
fWriteQAExpertData = rec.fWriteQAExpertData;
fRunPlaneEff = rec.fRunPlaneEff;
-
+ for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
fesd = NULL;
fhltesd = NULL;
fesdf = NULL;
ffile = NULL;
+ ffileF = NULL;
ftree = NULL;
+ ftreeF = NULL;
fhlttree = NULL;
ftVertexer = NULL;
fIsNewRunLoader = rec.fIsNewRunLoader;
fRunAliEVE = kFALSE;
fChain = NULL;
+ fNall = 0;
+ fNspecie = 0;
+ fSspecie = 0;
+ fNhighPt = 0;
+ fShighPt = 0;
+ fUpgradeModule="";
return *this;
}
delete fGRPData;
delete fRunScalers;
delete fCTPTimeParams;
+ delete fCTPTimeAlign;
fOptions.Delete();
if (fAlignObjArray) {
fAlignObjArray->Delete();
AliCDBManager::Instance()->SetLock(1);
}
+//_____________________________________________________________________________
+void AliReconstruction::MatchUpgradeDetector() {
+ // Translates detector name in a boolean.
+ // The boolean is used in GetReconstructor to load the
+ // upgrade reconstructor instead of the standard one.
+ for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+ if(fUpgradeModule.Contains(fgkDetectorName[iDet])) fUpgradeMask[iDet]=kTRUE;
+ }
+}
//_____________________________________________________________________________
Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
{
AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
beamEnergy = 0;
}
- // LHC: "multiply by 120 to get the energy in MeV"
- beamEnergy *= 0.120;
TString runType = fGRPData->GetRunType();
if (runType==AliGRPObject::GetInvalidString()) {
!((detMask >> AliDAQ::DetectorID("ITSSDD")) & 0x1) &&
!((detMask >> AliDAQ::DetectorID("ITSSSD")) & 0x1) ) {
// switch off the vertexer
- AliInfo("SPD,SDD,SSD is not in the list of active detectors. Vertexer switched off.");
+ AliInfo("SPD,SDD,SSD is not in the list of active detectors. Vertexer and Trackleter are switched off.");
fRunVertexFinder = kFALSE;
+ fRunMultFinder = kFALSE;
}
if (!((detMask >> AliDAQ::DetectorID("TRG")) & 0x1)) {
// switch off the reading of CTP raw-data payload
//_____________________________________________________________________________
Bool_t AliReconstruction::LoadCDB()
{
+ // Load CDB entries for all active detectors.
+ // By default we load all the entries in <det>/Calib
+ // folder.
+
AliCodeTimerAuto("",0);
AliCDBManager::Instance()->Get("GRP/CTP/Config");
+ AliCDBManager::Instance()->Get("GRP/Calib/LHCClockPhase");
+
TString detStr = fLoadCDB;
for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
//_____________________________________________________________________________
Bool_t AliReconstruction::LoadTriggerScalersCDB()
{
+ // Load CTP scalers from OCDB.
+ // The scalers are checked for consistency.
+
AliCodeTimerAuto("",0);
AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/Scalers");
AliInfo("Found an AliTriggerRunScalers in GRP/CTP/Scalers, reading it");
fRunScalers = dynamic_cast<AliTriggerRunScalers*> (entry->GetObject());
entry->SetOwner(0);
- if (fRunScalers->CorrectScalersOverflow() == 0) AliInfo("32bit Trigger counters corrected for overflow");
+ if (fRunScalers && (fRunScalers->CorrectScalersOverflow() == 0)) AliInfo("32bit Trigger counters corrected for overflow");
}
return kTRUE;
//_____________________________________________________________________________
Bool_t AliReconstruction::LoadCTPTimeParamsCDB()
{
+ // Load CTP timing information (alignment)
+ // from OCDB.
+
AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/CTPtiming");
+ if (!entry) return kFALSE;
- if (entry) {
+ AliInfo("Found an AliCTPTimeParams in GRP/CTP/CTPtiming, reading it");
+ fCTPTimeParams = dynamic_cast<AliCTPTimeParams*> (entry->GetObject());
+ entry->SetOwner(0);
- AliInfo("Found an AliCTPTimeParams in GRP/CTP/CTPtiming, reading it");
- fCTPTimeParams = dynamic_cast<AliCTPTimeParams*> (entry->GetObject());
- entry->SetOwner(0);
- return kTRUE;
+ AliCDBEntry* entry2 = AliCDBManager::Instance()->Get("GRP/CTP/TimeAlign");
+ if (!entry2) return kFALSE;
+
+ AliInfo("Found an AliCTPTimeParams in GRP/CTP/TimeAlign, reading it");
+ fCTPTimeAlign = dynamic_cast<AliCTPTimeParams*> (entry2->GetObject());
+ entry2->SetOwner(0);
+
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::ReadIntensityInfoCDB()
+{
+ // Load LHC DIP data
+ AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/LHCData");
+
+ if (entry) {
+ AliInfo("Found an AliLHCData in GRP/GRP/LHCData, reading it");
+ AliLHCData* dipData = dynamic_cast<AliLHCData*> (entry->GetObject());
+ for (int ib=2;ib--;) {
+ double intI,intNI;
+ if (dipData && (dipData->GetMeanIntensity(ib,intI,intNI)>=0)) {
+ fBeamInt[ib][0] = intI;
+ fBeamInt[ib][1] = intNI;
+ }
+ }
+ return kTRUE;
}
-
- return kFALSE;
+ return kFALSE;
}
+
+
//_____________________________________________________________________________
Bool_t AliReconstruction::Run(const char* input)
{
//_____________________________________________________________________________
void AliReconstruction::InitRawReader(const char* input)
{
- AliCodeTimerAuto("",0);
-
// Init raw-reader and
// set the input in case of raw data
+
+ AliCodeTimerAuto("",0);
+
if (input) fRawInput = input;
fRawReader = AliRawReader::Create(fRawInput.Data());
if (!fRawReader) {
}
AliSysInfo::AddStamp("LoadCTPTimeParamsCDB");
+ if (!ReadIntensityInfoCDB()) {
+ Abort("ReadIntensityInfoCDB", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("ReadIntensityInfoCDB");
+
// Read the reconstruction parameters from OCDB
if (!InitRecoParams()) {
AliWarning("Not all detectors have correct RecoParam objects initialized");
ftree = new TTree("esdTree", "Tree with ESD objects");
fesd = new AliESDEvent();
fesd->CreateStdContent();
-
// add a so far non-std object to the ESD, this will
// become part of the std content
fesd->AddObject(new AliESDHLTDecision);
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");
+ ffileF = TFile::Open("AliESDfriends.root", "RECREATE");
+ ftreeF = new TTree("esdFriendTree", "Tree with ESD Friend objects");
+ fesdf = new AliESDfriend();
+ ftreeF->Branch("ESDfriend.","AliESDfriend", &fesdf);
fesd->AddObject(fesdf);
+ ffile->cd();
}
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
ProcInfo_t procInfo;
gSystem->GetProcInfo(&procInfo);
- AliInfo(Form("Current memory usage %d %d", procInfo.fMemResident, procInfo.fMemVirtual));
+ AliInfo(Form("Current memory usage %ld %ld", procInfo.fMemResident, procInfo.fMemVirtual));
//QA
//Initialize the QA and start of cycle
//_____________________________________________________________________________
void AliReconstruction::Init(TTree *tree)
{
+ // Implementation of TSelector::Init()
+ // method
if (tree == 0) {
AliError("The input tree is not found!");
return;
// run the reconstruction over a single event
// The event loop is steered in Run method
+
+ static Long_t oldMres=0;
+ static Long_t oldMvir=0;
+ static Float_t oldCPU=0;
+ static Long_t aveDMres=0;
+ static Long_t aveDMvir=0;
+ static Float_t aveDCPU=0;
+
AliCodeTimerAuto("",0);
+ AliESDpid pid;
+
if (iEvent >= fRunLoader->GetNumberOfEvents()) {
fRunLoader->SetEventNumber(iEvent);
- fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
- iEvent, iEvent);
+ if (fRawReader)
+ fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
+ iEvent, iEvent);
fRunLoader->TreeE()->Fill();
+
if (fRawReader && fRawReader->UseAutoSaveESD())
fRunLoader->TreeE()->AutoSave("SaveSelf");
}
return kTRUE;
}
- AliInfo(Form("processing event %d", iEvent));
fRunLoader->GetEvent(iEvent);
// Fill Event-info object
GetEventInfo();
fRecoParam.SetEventSpecie(fRunInfo,fEventInfo,fListOfCosmicTriggers);
- AliInfo(Form("Current event specie: %s",fRecoParam.PrintEventSpecie()));
+
+ ProcInfo_t procInfo;
+ if(iEvent==fFirstEvent) {
+ gSystem->GetProcInfo(&procInfo);
+ oldMres=procInfo.fMemResident;
+ oldMvir=procInfo.fMemVirtual;
+ oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
+ }
+ AliInfo(Form("================================= Processing event %d of type %-10s ==================================", iEvent,fRecoParam.PrintEventSpecie()));
// Set the reco-params
{
if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
reconstructor->SetRecoParam(par);
- reconstructor->SetEventInfo(&fEventInfo);
+ reconstructor->GetPidSettings(&pid);
+ reconstructor->SetEventInfo(&fEventInfo);
if (fRunQA) {
AliQAManager::QAManager()->SetRecoParam(iDet, par) ;
- AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(par->GetEventSpecie())) ;
+ if (par) AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(par->GetEventSpecie())) ;
}
}
}
- const AliDetectorRecoParam *grppar = fRecoParam.GetDetRecoParam(kNDetectors);
- AliQAManager::QAManager()->SetRecoParam(AliQAv1::kGLOBAL, grppar) ;
- AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(grppar->GetEventSpecie())) ;
+ if (fRunQA) {
+ const AliDetectorRecoParam *grppar = fRecoParam.GetDetRecoParam(kNDetectors);
+ AliQAManager::QAManager()->SetRecoParam(AliQAv1::kGLOBAL, grppar) ;
+ AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(grppar->GetEventSpecie())) ;
+ }
}
// QA on single raw
}
}
+
+ // fill Event header information from the RawEventHeader
+ if (fRawReader){FillRawEventHeaderESD(fesd);}
+ if (fRawReader){FillRawEventHeaderESD(fhltesd);}
+
fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
+
+ ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
+ ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
+ ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
+ ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
+
fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
fesd->SetMagneticField(AliTracker::GetBz());
fhltesd->SetMagneticField(AliTracker::GetBz());
//
+ AliESDRun *esdRun,*esdRunH;
+ esdRun = (AliESDRun*)fesd->GetESDRun();
+ esdRunH = (AliESDRun*)fhltesd->GetESDRun();
+ esdRun->SetBeamEnergyIsSqrtSHalfGeV();
+ esdRunH->SetBeamEnergyIsSqrtSHalfGeV();
+ //
+ for (int ib=2;ib--;) for (int it=2;it--;) {
+ esdRun->SetMeanIntensity(ib,it, fBeamInt[ib][it]);
+ esdRunH->SetMeanIntensity(ib,it, fBeamInt[ib][it]);
+ }
+ //
AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
if (fld) { // set info needed for field initialization
fesd->SetCurrentL3(fld->GetCurrentSol());
// barrel tracking
if (!fRunTracking.IsNull()) {
- if (!RunTracking(fesd)) {
+ if (!RunTracking(fesd,pid)) {
if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
-
- // fill Event header information from the RawEventHeader
- if (fRawReader){FillRawEventHeaderESD(fesd);}
- if (fRawReader){FillRawEventHeaderESD(fhltesd);}
+
+ // AdC+FN
+ if (fReconstructor[3])
+ GetReconstructor(3)->FillEventTimeWithTOF(fesd,&pid);
// combined PID
- AliESDpid::MakePID(fesd);
+ pid.MakePID(fesd);
if (fFillTriggerESD) {
if (!FillTriggerESD(fesd)) {
ftVertexer->SetITSMode();
ftVertexer->SetConstraintOff();
// get cuts for vertexer from AliGRPRecoParam
+ Bool_t constrSPD=kFALSE;
if (grpRecoParam) {
Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
Double_t *cutsVertexer = new Double_t[nCutsVertexer];
grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer);
ftVertexer->SetCuts(cutsVertexer);
delete [] cutsVertexer; cutsVertexer = NULL;
- if(fDiamondProfile && grpRecoParam->GetVertexerTracksConstraintITS())
- ftVertexer->SetVtxStart(fDiamondProfile);
+ if(grpRecoParam->GetVertexerTracksConstraintITS()) {
+ if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius){
+ ftVertexer->SetVtxStart(fDiamondProfile); // apply constraint only if sigmax is smaller than the beam pipe radius
+ }else{
+ if(fDiamondProfileSPD && fDiamondProfileSPD->GetXRes()<kRadius){
+ ftVertexer->SetVtxStart(fDiamondProfileSPD);
+ constrSPD=kTRUE;
+ }
+ }
+ }
}
AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
if (pvtx) {
+ if(constrSPD){
+ TString title=pvtx->GetTitle();
+ title.Append("SPD");
+ pvtx->SetTitle(title);
+ }
if (pvtx->GetStatus()) {
fesd->SetPrimaryVertexTracks(pvtx);
for (Int_t i=0; i<ntracks; i++) {
grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer);
ftVertexer->SetCuts(cutsVertexer);
delete [] cutsVertexer; cutsVertexer = NULL;
- if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC())
- ftVertexer->SetVtxStart(fDiamondProfileTPC);
+ if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC()) {
+ if(fDiamondProfileTPC->GetXRes()<kRadius) ftVertexer->SetVtxStart(fDiamondProfileTPC); // apply constraint only if sigmax is smaller than the beam pipe radius
+ }
}
pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
if (pvtx) {
}
delete[] selectedIdx;
- if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile);
-
+ if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius) fesd->SetDiamond(fDiamondProfile);
+ else fesd->SetDiamond(fDiamondProfileSPD);
if (fRunV0Finder) {
// V0 finding
AliV0vertexer vtxer;
+ // get cuts for V0vertexer from AliGRPRecoParam
+ if (grpRecoParam) {
+ Int_t nCutsV0vertexer = grpRecoParam->GetVertexerV0NCuts();
+ Double_t *cutsV0vertexer = new Double_t[nCutsV0vertexer];
+ grpRecoParam->GetVertexerV0Cuts(cutsV0vertexer);
+ vtxer.SetCuts(cutsV0vertexer);
+ delete [] cutsV0vertexer; cutsV0vertexer = NULL;
+ }
vtxer.Tracks2V0vertices(fesd);
if (fRunCascadeFinder) {
// Cascade finding
AliCascadeVertexer cvtxer;
+ // get cuts for CascadeVertexer from AliGRPRecoParam
+ if (grpRecoParam) {
+ Int_t nCutsCascadeVertexer = grpRecoParam->GetVertexerCascadeNCuts();
+ Double_t *cutsCascadeVertexer = new Double_t[nCutsCascadeVertexer];
+ grpRecoParam->GetVertexerCascadeCuts(cutsCascadeVertexer);
+ cvtxer.SetCuts(cutsCascadeVertexer);
+ delete [] cutsCascadeVertexer; cutsCascadeVertexer = NULL;
+ }
cvtxer.V0sTracks2CascadeVertices(fesd);
}
}
-
+
// write ESD
if (fCleanESD) CleanESD(fesd);
+ //
+ // RS run updated trackleter: since we want to mark the clusters used by tracks and also mark the
+ // tracks interpreted as primary, this step should be done in the very end, when full
+ // ESD info is available (particulalry, V0s)
+ // vertex finder
+ if (fRunMultFinder) {
+ if (!RunMultFinder(fesd)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
+ }
+ }
if (fRunQA && IsInTasks(AliQAv1::kESDS)) {
AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
}
if (fRunGlobalQA) {
AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
+ if (qadm)
qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
if (qadm && IsInTasks(AliQAv1::kESDS))
qadm->Exec(AliQAv1::kESDS, fesd);
pHLTSrc->Copy(*pHLTTgt);
}
- if (fWriteESDfriend) {
- // fesdf->~AliESDfriend();
- // new (fesdf) AliESDfriend(); // Reset...
+ if (fWriteESDfriend)
fesd->GetESDfriend(fesdf);
- }
+
ftree->Fill();
+ if (fWriteESDfriend) {
+ WriteESDfriend();
+ }
// Auto-save the ESD tree in case of prompt reco @P2
if (fRawReader && fRawReader->UseAutoSaveESD()) {
ftree->AutoSave("SaveSelf");
- TFile *friendfile = (TFile *)(gROOT->GetListOfFiles()->FindObject("AliESDfriends.root"));
- if (friendfile) friendfile->Save();
+ if (fWriteESDfriend) ftreeF->AutoSave("SaveSelf");
}
// write HLT ESD
new (fesdf) AliESDfriend(); // Reset...
}
- ProcInfo_t procInfo;
gSystem->GetProcInfo(&procInfo);
- AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, procInfo.fMemResident, procInfo.fMemVirtual));
+ Long_t dMres=(procInfo.fMemResident-oldMres)/1024;
+ Long_t dMvir=(procInfo.fMemVirtual-oldMvir)/1024;
+ Float_t dCPU=procInfo.fCpuUser+procInfo.fCpuSys-oldCPU;
+ aveDMres+=(dMres-aveDMres)/(iEvent-fFirstEvent+1);
+ aveDMvir+=(dMvir-aveDMvir)/(iEvent-fFirstEvent+1);
+ aveDCPU+=(dCPU-aveDCPU)/(iEvent-fFirstEvent+1);
+ AliInfo(Form("======================= End Event %d: Res %ld(%3ld <%3ld>) Vir %ld(%3ld <%3ld>) CPU %5.2f <%5.2f> ===================",
+ iEvent, procInfo.fMemResident/1024, dMres, aveDMres, procInfo.fMemVirtual/1024, dMvir, aveDMvir, dCPU, aveDCPU));
+ oldMres=procInfo.fMemResident;
+ oldMvir=procInfo.fMemVirtual;
+ oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
fEventInfo.Reset();
for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (fIsNewRunLoader) { // galice.root didn't exist
fRunLoader->WriteHeader("OVERWRITE");
+ fRunLoader->WriteTrigger("OVERWRITE");
fRunLoader->CdGAFile();
fRunLoader->Write(0, TObject::kOverwrite);
}
TPair* pair = 0;
while((pair = dynamic_cast<TPair*> (iter.Next()))){
TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
- TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
- cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
+ TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
+ if (keyStr && valStr)
+ cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
}
TList *cdbListCopy = new TList();
ffile->cd();
- if (fWriteESDfriend)
- ftree->SetBranchStatus("ESDfriend*",0);
// we want to have only one tree version number
ftree->Write(ftree->GetName(),TObject::kOverwrite);
fhlttree->Write(fhlttree->GetName(),TObject::kOverwrite);
+ if (fWriteESDfriend) {
+ ffileF->cd();
+ ftreeF->Write(ftreeF->GetName(),TObject::kOverwrite);
+ }
+
// Finish with Plane Efficiency evaluation: before of CleanUp !!!
if (fRunPlaneEff && !FinishPlaneEff()) {
AliWarning("Finish PlaneEff evaluation failed");
AliCodeTimerAuto("",0)
TString detStr = detectors;
- for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
- AliReconstructor* reconstructor = GetReconstructor(iDet);
- if (!reconstructor) continue;
- AliLoader* loader = fLoader[iDet];
- // Matthias April 2008: temporary fix to run HLT reconstruction
- // although the HLT loader is missing
- if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
+ // execute HLT reconstruction first since other detector reconstruction
+ // might depend on HLT data
+ // key 'HLT' is removed from detStr by IsSelected
+ if (!IsSelected("HLT", detStr)) {
+ AliReconstructor* reconstructor = GetReconstructor(kNDetectors-1);
+ if (reconstructor) {
+ // there is no AliLoader for HLT, see
+ // https://savannah.cern.ch/bugs/?35473
+ AliInfo("running reconstruction for HLT");
if (fRawReader) {
reconstructor->Reconstruct(fRawReader, NULL);
} else {
TTree* dummy=NULL;
reconstructor->Reconstruct(dummy, NULL);
}
- continue;
}
+ }
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+ if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+ AliReconstructor* reconstructor = GetReconstructor(iDet);
+ if (!reconstructor) continue;
+ AliLoader* loader = fLoader[iDet];
if (!loader) {
AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
continue;
loader->UnloadRecPoints();
AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
}
- IsSelected("CTP", detStr);
+ if (!IsSelected("CTP", detStr)) AliDebug(10,"No CTP");
if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
AliError(Form("the following detectors were not found: %s",
detStr.Data()));
fSPDTrackleter->SetVertex(vtxPos, vtxErr);
// run trackleting
if (fSPDTrackleter->Clusters2Tracks(esd) != 0) {
- AliError("AliITSTrackleterSPDEff Clusters2Tracks failed");
+ AliWarning("AliITSTrackleterSPDEff Clusters2Tracks failed");
// fLoader[0]->UnloadRecPoints();
return kFALSE;
}
AliVertexer *vertexer = CreateVertexer();
if (!vertexer) return kFALSE;
- AliInfo("running the ITS vertex finder");
+ AliInfo(Form("running the ITS vertex finder: %s",vertexer->ClassName()));
AliESDVertex* vertex = NULL;
if (fLoader[0]) {
fLoader[0]->LoadRecPoints();
if(novertices>1){
for (Int_t kk=1; kk<novertices; kk++)esd->AddPileupVertexSPD(&vpileup[kk]);
}
+ /*
// if SPD multiplicity has been determined, it is stored in the ESD
AliMultiplicity *mult = vertexer->GetMultiplicity();
if(mult)esd->SetMultiplicity(mult);
-
+ */
for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
}
return kTRUE;
}
+//_____________________________________________________________________________
+Bool_t AliReconstruction::RunMultFinder(AliESDEvent*& esd)
+{
+ // run the trackleter for multiplicity study
+
+ AliCodeTimerAuto("",0)
+
+ AliTrackleter *trackleter = CreateMultFinder();
+ if (!trackleter) return kFALSE;
+
+ AliInfo(Form("running the ITS multiplicity finder: %s",trackleter->ClassName()));
+
+ if (fLoader[0]) {
+ fLoader[0]->LoadRecPoints();
+ TTree* cltree = fLoader[0]->TreeR();
+ if (cltree) {
+ trackleter->Reconstruct(esd,cltree);
+ AliMultiplicity *mult = trackleter->GetMultiplicity();
+ if(mult) esd->SetMultiplicity(mult);
+ }
+ else {
+ AliError("Can't get the ITS cluster tree");
+ }
+ fLoader[0]->UnloadRecPoints();
+ }
+ else {
+ AliError("Can't get the ITS loader");
+ }
+
+ delete trackleter;
+
+ return kTRUE;
+}
+
//_____________________________________________________________________________
Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
{
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
+Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd,AliESDpid &PID)
{
// run the barrel tracking
static Int_t eventNr=0;
// preliminary PID in TPC needed by the ITS tracker
if (iDet == 1) {
GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
- AliESDpid::MakePID(esd);
+ PID.MakePID(esd,kTRUE);
}
AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
}
}
// updated PID in TPC needed by the ITS tracker -MI
if (iDet == 1) {
- GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
- AliESDpid::MakePID(esd);
+ //GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
+ //AliESDpid::MakePID(esd);
+ PID.MakePID(esd,kTRUE);
}
AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
}
static Int_t eventNr=0;
TString detStr = detectors;
+ AliSysInfo::AddStamp(Form("FillESDb%d",eventNr), -19,-19, eventNr);
for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliReconstructor* reconstructor = GetReconstructor(iDet);
}
}
- IsSelected("CTP", detStr);
+ if (!IsSelected("CTP", detStr)) AliDebug(10,"No CTP");
if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
AliError(Form("the following detectors were not found: %s",
detStr.Data()));
if (fStopOnError) return kFALSE;
}
- AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
+ AliSysInfo::AddStamp(Form("FillESDe%d",eventNr), -20,-20, eventNr);
eventNr++;
return kTRUE;
}
if(TMath::Abs(Int_t(orbit-(input.GetIR(i))->GetOrbit()))<=1){
esdheader->AddTriggerIR(input.GetIR(i));
}
+ AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
+ rlCTP->SetL0TriggerInputs(input.GetL0Inputs());
+ rlCTP->SetL1TriggerInputs(input.GetL1Inputs());
+ rlCTP->SetL2TriggerInputs(input.GetL2Inputs());
}
+ if (fIsNewRunLoader) fRunLoader->TreeCT()->Fill();
}
return kTRUE;
}
}
fIsNewRunLoader = kTRUE;
fRunLoader->MakeTree("E");
+ fRunLoader->MakeTree("GG");
if (fNumberOfEventsPerFile > 0)
fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
}
+
+ // check if the upgrade reconstructor should be used instead of the standard one
+ if(fUpgradeMask[iDet]) {
+ if(reconstructor) delete reconstructor;
+ TClass *cl = new TClass(Form("Ali%sUpgradeReconstructor",fgkDetectorName[iDet]));
+ reconstructor = (AliReconstructor*)(cl->New());
+ }
+
if (reconstructor) {
TObject* obj = fOptions.FindObject(detName.Data());
if (obj) reconstructor->SetOption(obj->GetTitle());
if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
- reconstructor->SetRecoParam(par);
- reconstructor->SetRunInfo(fRunInfo);
+ if (reconstructor) {
+ reconstructor->SetRecoParam(par);
+ reconstructor->SetRunInfo(fRunInfo);
+ }
}
return reconstructor;
}
AliVertexer* vertexer = NULL;
AliReconstructor* itsReconstructor = GetReconstructor(0);
- if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) || fRunTracking.Contains("ITS"))) {
+ if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) ||
+ fRunTracking.Contains("ITS") || fFillESD.Contains("ITS") )) {
vertexer = itsReconstructor->CreateVertexer();
}
if (!vertexer) {
return vertexer;
}
+//_____________________________________________________________________________
+AliTrackleter* AliReconstruction::CreateMultFinder()
+{
+// create the ITS trackleter for mult. estimation
+// Please note that the caller is the owner of the
+// trackleter
+
+ AliTrackleter* trackleter = NULL;
+ AliReconstructor* itsReconstructor = GetReconstructor(0);
+ if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) ||
+ fRunTracking.Contains("ITS") || fFillESD.Contains("ITS") )) {
+ trackleter = itsReconstructor->CreateMultFinder();
+ }
+ else {
+ AliWarning("ITS is not in reconstruction, switching off RunMultFinder");
+ fRunMultFinder = kFALSE;
+ }
+
+ return trackleter;
+}
+
//_____________________________________________________________________________
Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
{
continue;
}
-
fTracker[iDet] = reconstructor->CreateTracker();
if (!fTracker[iDet] && (iDet < 7)) {
AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
}
//_____________________________________________________________________________
-void AliReconstruction::CheckQA()
-{
+// void AliReconstruction::CheckQA()
+// {
// check the QA of SIM for this run and remove the detectors
// with status Fatal
// fRunLocalReconstruction = newRunLocalReconstruction ;
// fRunTracking = newRunTracking ;
// fFillESD = newFillESD ;
-}
+// }
//_____________________________________________________________________________
Int_t AliReconstruction::GetDetIndex(const char* detector)
// Input: none
// Return: kTRUE if all operations have been done properly, kFALSE otherwise
//
- AliWarning(Form("Implementation of this method not yet completed !! Method return kTRUE"));
fSPDTrackleter = NULL;
TString detStr = fLoadCDB;
// The return flag shows whenever the
// AliEVE initialization was successful or not.
- TString macroStr;
- macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
+ TString macroStr(gSystem->Getenv("ALIEVE_ONLINE_MACRO"));
+
+ if (macroStr.IsNull())
+ macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
+
AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
+
if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
gROOT->ProcessLine("if (!AliEveEventManager::GetMaster()){new AliEveEventManager();AliEveEventManager::GetMaster()->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(AliEveEventManager::GetMaster());};");
// successful initialization of AliEVE.
AliInfo("Running AliEVE...");
- gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)0x%lx,(AliRawReader*)0x%lx,(AliESDEvent*)0x%lx,(AliESDfriend*)0x%lx);",fRunLoader,fRawReader,fesd,fesdf));
+ gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p,(AliESDfriend*)%p);",fRunLoader,fRawReader,fesd,fesdf));
gSystem->Run();
}
}
aCTP->SetClassMask(mask);
aCTP->SetClusterMask(clmask);
+
+ AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
+ rlCTP->SetClassMask(mask);
+ rlCTP->SetClusterMask(clmask);
}
else {
fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
Int_t nclasses = classesArray.GetEntriesFast();
for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
- if (trclass) {
+ if (trclass && trclass->GetMask()>0) {
Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
fesd->SetTriggerClass(trclass->GetName(),trindex);
if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
}
fEventInfo.SetTriggerClasses(trclasses);
+ // Write names of active trigger inputs in ESD Header
+ const TObjArray& inputsArray = config->GetInputs();
+ Int_t ninputs = inputsArray.GetEntriesFast();
+ for( Int_t iinput=0; iinput < ninputs; iinput++ ) {
+ AliTriggerInput* trginput = (AliTriggerInput*)inputsArray.At(iinput);
+ if (trginput && trginput->GetMask()>0) {
+ Int_t inputIndex = (Int_t)TMath::Nint(TMath::Log2(trginput->GetMask()));
+ AliESDHeader* headeresd = fesd->GetHeader();
+ Int_t trglevel = (Int_t)trginput->GetLevel();
+ if (trglevel == 0) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex);
+ if (trglevel == 1) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex+24);
+ if (trglevel == 2) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex+48);
+ }
+ }
+
// Set the information in ESD
fesd->SetTriggerMask(trmask);
fesd->SetTriggerCluster(clustmask);
return kTRUE;
}
+
+//______________________________________________________________________________
+Bool_t AliReconstruction::IsHighPt() const {
+ // Selection of events containing "high" pT tracks
+ // If at least one track is found within 1.5 and 100 GeV (pT)
+ // that was reconstructed by both ITS and TPC, the event is accepted
+
+ // Track cuts
+ const Double_t pTmin = 1.5;
+ const Double_t pTmax = 100;
+ ULong_t mask = 0;
+ mask |= (AliESDtrack::kITSrefit);
+ mask |= (AliESDtrack::kTPCrefit);
+ const Double_t pTminCosmic = 5.;
+ const Double_t pTmaxCosmic = 100;
+ ULong_t maskCosmic = 0;
+ Int_t cosmicCount=0;
+ maskCosmic |= (AliESDtrack::kTPCrefit);
+
+ Bool_t isOK = kFALSE;
+
+ if (fesd && fesd->GetEventType()==AliRawEventHeaderBase::kPhysicsEvent) {
+ // Check if this ia a physics event (code 7)
+ Int_t ntrk = fesd->GetNumberOfTracks();
+ for (Int_t itrk=0; itrk<ntrk; ++itrk) {
+
+ AliESDtrack * trk = fesd->GetTrack(itrk);
+ if (trk
+ && trk->Pt() > pTmin
+ && trk->Pt() < pTmax
+ && (trk->GetStatus() & mask) == mask ) {
+
+ isOK = kTRUE;
+ break;
+ }
+ if (trk
+ && trk->GetInnerParam()
+ && trk->GetInnerParam()->Pt() > pTminCosmic
+ && trk->GetInnerParam()->Pt() < pTmaxCosmic
+ && (trk->GetStatus() & maskCosmic) == maskCosmic ) {
+
+ cosmicCount++;
+ break;
+ }
+ }
+ if (cosmicCount>1) isOK=kTRUE;
+ }
+ return isOK;
+}
+
+//______________________________________________________________________________
+Bool_t AliReconstruction::IsCosmicOrCalibSpecie() const {
+ // Select cosmic or calibration events
+
+ Bool_t isOK = kFALSE;
+
+ if (fesd && fesd->GetEventType()==AliRawEventHeaderBase::kPhysicsEvent) {
+ // Check if this ia a physics event (code 7)
+
+ UInt_t specie = fesd->GetEventSpecie();
+ if (specie==AliRecoParam::kCosmic || specie==AliRecoParam::kCalib) {
+ isOK = kTRUE;
+ }
+ }
+ return isOK;
+}
+
+//______________________________________________________________________________
+void AliReconstruction::WriteESDfriend() {
+ // Fill the ESD friend in the tree. The required fraction of ESD friends is stored
+ // in fFractionFriends. We select events where we store the ESD friends according
+ // to the following algorithm:
+ // 1. Store all Cosmic or Calibration events within the required fraction
+ // 2. Sample "high Pt" events within the remaining fraction after step 1.
+ // 3. Sample randomly events if we still have remaining slot
+
+ fNall++;
+ Bool_t isSelected = kFALSE;
+ //
+ // Store all friends for B field OFF
+ if (TMath::Abs(AliTrackerBase::GetBz())<0.5) isSelected=kTRUE;
+
+ if (IsCosmicOrCalibSpecie()) { // Selection of calib or cosmic events
+ fNspecie++;
+ Double_t curentSpecieFraction = ((Double_t)(fNspecie+1))/((Double_t)(fNall+1));
+ // "Bayesian" estimate supposing that without events all the events are of the required type
+
+ Double_t rnd = gRandom->Rndm()*curentSpecieFraction;
+ if (rnd<fFractionFriends) {
+ isSelected = kTRUE;
+ fSspecie++;
+ }
+ }
+
+ Double_t remainingFraction = fFractionFriends;
+ remainingFraction -= ((Double_t)(fSspecie)/(Double_t)(fNall));
+
+ if (IsHighPt()) { // Selection of "high Pt" events
+ fNhighPt++;
+ Double_t curentHighPtFraction = ((Double_t)(fNhighPt+1))/((Double_t)(fNall+1));
+ // "Bayesian" estimate supposing that without events all the events are of the required type
+
+ if (!isSelected) {
+ Double_t rnd = gRandom->Rndm()*curentHighPtFraction;
+ if (rnd<remainingFraction) {
+ isSelected = kTRUE;
+ fShighPt++;
+ }
+ }
+ }
+ remainingFraction -= ((Double_t)(fShighPt)/(Double_t)(fNall));
+
+ // Random selection to fill the remaining fraction (if any)
+ if (!isSelected) {
+ Double_t rnd = gRandom->Rndm();
+ if (rnd<remainingFraction) {
+ isSelected = kTRUE;
+ }
+ }
+
+ if (!isSelected) {
+ fesdf->~AliESDfriend();
+ new (fesdf) AliESDfriend(); // Reset...
+ fesdf->SetSkipBit(kTRUE);
+ }
+
+ ftreeF->Fill();
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff