AliVEventHandler(),
fIsStandard(kTRUE),
fFillAOD(kTRUE),
+ fFillAODRun(kTRUE),
fNeedsHeaderReplication(kFALSE),
fNeedsTracksBranchReplication(kFALSE),
fNeedsVerticesBranchReplication(kFALSE),
fNeedsV0sBranchReplication(kFALSE),
+ fNeedsCascadesBranchReplication(kFALSE),
fNeedsTrackletsBranchReplication(kFALSE),
fNeedsPMDClustersBranchReplication(kFALSE),
fNeedsJetsBranchReplication(kFALSE),
fNeedsFMDClustersBranchReplication(kFALSE),
fNeedsCaloClustersBranchReplication(kFALSE),
fNeedsMCParticlesBranchReplication(kFALSE),
+ fNeedsDimuonsBranchReplication(kFALSE),
fAODIsReplicated(kFALSE),
fAODEvent(NULL),
fMCEventH(NULL),
fTreeA(NULL),
fFileA(NULL),
fFileName(""),
- fExtensions(NULL)
+ fExtensions(NULL),
+ fFilters(NULL)
{
// default constructor
}
AliVEventHandler(name, title),
fIsStandard(kTRUE),
fFillAOD(kTRUE),
+ fFillAODRun(kTRUE),
fNeedsHeaderReplication(kFALSE),
fNeedsTracksBranchReplication(kFALSE),
fNeedsVerticesBranchReplication(kFALSE),
fNeedsV0sBranchReplication(kFALSE),
+ fNeedsCascadesBranchReplication(kFALSE),
fNeedsTrackletsBranchReplication(kFALSE),
fNeedsPMDClustersBranchReplication(kFALSE),
fNeedsJetsBranchReplication(kFALSE),
fNeedsFMDClustersBranchReplication(kFALSE),
fNeedsCaloClustersBranchReplication(kFALSE),
fNeedsMCParticlesBranchReplication(kFALSE),
+ fNeedsDimuonsBranchReplication(kFALSE),
fAODIsReplicated(kFALSE),
fAODEvent(NULL),
fMCEventH(NULL),
fTreeA(NULL),
fFileA(NULL),
fFileName(""),
- fExtensions(NULL)
+ fExtensions(NULL),
+ fFilters(NULL)
{
+// Normal constructor.
}
//______________________________________________________________________________
AliAODHandler::~AliAODHandler()
{
// Destructor.
- delete fAODEvent;
+ if (fAODEvent) delete fAODEvent;
if(fFileA){
// is already handled in TerminateIO
fFileA->Close();
delete fFileA;
+ fTreeA = 0;
}
- delete fTreeA;
- if (fExtensions) delete fExtensions;
+ if (fTreeA) delete fTreeA;
+ if (fExtensions) {fExtensions->Delete(); delete fExtensions;}
+ if (fFilters) {fFilters->Delete(); delete fFilters;}
}
//______________________________________________________________________________
// Initialize IO
//
// Create the AODevent object
- if(!fAODEvent){
+
+ Bool_t createStdAOD = fIsStandard || fFillAOD;
+ if(!fAODEvent && createStdAOD){
fAODEvent = new AliAODEvent();
if (fIsStandard) fAODEvent->CreateStdContent();
}
// File opening according to execution mode
TString option(opt);
option.ToLower();
- TDirectory *owd = gDirectory;
- if (option.Contains("proof")) {
- // proof
- // Merging via files. Need to access analysis manager via interpreter.
- gROOT->ProcessLine(Form("AliAnalysisManager::GetAnalysisManager()->OpenProofFile(\"%s\", \"RECREATE\");", fFileName.Data()));
- gROOT->ProcessLine(Form("AliAnalysisManager::GetAnalysisManager()->GetCommonOutputContainer()->SetFile((TFile*)0x%lx);", gFile));
- fFileA = gFile;
- } else {
- // local and grid
- fFileA = new TFile(fFileName.Data(), "RECREATE");
- }
- CreateTree(1);
- owd->cd();
+ if (createStdAOD) {
+ TDirectory *owd = gDirectory;
+ if (option.Contains("proof")) {
+ // proof
+ // Merging via files. Need to access analysis manager via interpreter.
+ gROOT->ProcessLine(Form("AliAnalysisDataContainer *c_common_out = AliAnalysisManager::GetAnalysisManager()->GetCommonOutputContainer();"));
+ gROOT->ProcessLine(Form("AliAnalysisManager::GetAnalysisManager()->OpenProofFile(c_common_out, \"RECREATE\");"));
+ fFileA = gFile;
+ } else {
+ // local and grid
+ fFileA = new TFile(fFileName.Data(), "RECREATE");
+ }
+ CreateTree(1);
+ owd->cd();
+ }
if (fExtensions) {
TIter next(fExtensions);
AliAODExtension *ext;
while ((ext=(AliAODExtension*)next())) ext->Init(option);
}
+ if (fFilters) {
+ TIter nextf(fFilters);
+ AliAODExtension *filteredAOD;
+ while ((filteredAOD=(AliAODExtension*)nextf())) {
+ filteredAOD->SetEvent(fAODEvent);
+ filteredAOD->Init(option);
+ }
+ }
return kTRUE;
}
// has to passed to the AOD Handler by this task
// (doing this in the steering macro would not work on PROOF)
+ if (!fAODEvent) return;
TClonesArray *mcarray = (TClonesArray*)fAODEvent->FindListObject(AliAODMCParticle::StdBranchName());
if(!mcarray)return;
- mcarray->Delete();
AliAODMCHeader *mcHeader = (AliAODMCHeader*)fAODEvent->FindListObject(AliAODMCHeader::StdBranchName());
if(!mcHeader)return;
- mcHeader->Reset();
-
// Get the MC Infos.. Handler needs to be set before
// while adding the branch
// This needs to be done, not to depend on the AnalysisManager
AliAODMCParticle mcpart_tmp(mcpart,i,flag);
+ mcpart_tmp.SetStatus(mcpart->Particle()->GetStatusCode());
//
Int_t d0 = mcpart_tmp.GetDaughter(0);
Int_t d1 = mcpart_tmp.GetDaughter(1);
if(fMCEventH->IsParticleSelected(m))mcpart_tmp.SetMother(fMCEventH->GetNewLabel(m));
else AliError(Form("PROBLEM Mother not selected %d \n", m));
}
-
+
new (l[j++]) AliAODMCParticle(mcpart_tmp);
}
for(int it = 0; it < fAODEvent->GetNTracks();++it){
AliAODTrack *track = fAODEvent->GetTrack(it);
- Int_t label = TMath::Abs(track->GetLabel());
+ Int_t sign = 1;
+ Int_t label = track->GetLabel();
+ if(label<0){ // preserve the sign for later usage
+ label *= -1;
+ sign = -1;
+ }
+
if (label >= AliMCEvent::BgLabelOffset()) label = mcEvent->BgLabelToIndex(label);
-
-
if(label > np || track->GetLabel() == 0){
AliWarning(Form("Wrong ESD track label %5d (%5d)",track->GetLabel(), label));
}
if(fMCEventH->GetNewLabel(label) == 0){
AliWarning(Form("New label not found for %5d (%5d)",track->GetLabel(), label));
}
- track->SetLabel(fMCEventH->GetNewLabel(label));
+ track->SetLabel(sign*fMCEventH->GetNewLabel(label));
}
}
Bool_t AliAODHandler::FinishEvent()
{
// Fill data structures
- if(fFillAOD){
- fAODEvent->MakeEntriesReferencable();
- StoreMCParticles();
- FillTree();
- if (fExtensions) {
- TIter next(fExtensions);
- AliAODExtension *ext;
- while ((ext=(AliAODExtension*)next())) {
- ext->GetAOD()->MakeEntriesReferencable();
- ext->GetTree()->Fill();
- }
- }
+ if(fFillAOD && fFillAODRun && fAODEvent){
+ fAODEvent->MakeEntriesReferencable();
+ fTreeA->BranchRef();
+ FillTree();
}
+ if (fFillAOD) {
+ if (fExtensions) {
+ TIter next(fExtensions);
+ AliAODExtension *ext;
+ while ((ext=(AliAODExtension*)next())) ext->FinishEvent();
+ }
+ if (fFilters) {
+ TIter nextf(fFilters);
+ AliAODExtension *ext;
+ while ((ext=(AliAODExtension*)nextf())) {
+ ext->FinishEvent();
+ }
+ }
+ }
if (fIsStandard) fAODEvent->ResetStd();
+ TClonesArray *mcarray = (TClonesArray*)fAODEvent->FindListObject(AliAODMCParticle::StdBranchName());
+ if(mcarray) mcarray->Delete();
+
+ AliAODMCHeader *mcHeader = (AliAODMCHeader*)fAODEvent->FindListObject(AliAODMCHeader::StdBranchName());
+ if(mcHeader) mcHeader->Reset();
+
// Reset AOD replication flag
fAODIsReplicated = kFALSE;
return kTRUE;
{
// Terminate IO
if (fFileA) {
+ fFileA->Write();
fFileA->Close();
delete fFileA;
fFileA = 0;
+ // When closing the file, the tree is also deleted.
+ fTreeA = 0;
}
if (fExtensions) {
TIter next(fExtensions);
AliAODExtension *ext;
while ((ext=(AliAODExtension*)next())) ext->TerminateIO();
}
+ if (fFilters) {
+ TIter nextf(fFilters);
+ AliAODExtension *ext;
+ while ((ext=(AliAODExtension*)nextf())) ext->TerminateIO();
+ }
return kTRUE;
}
//______________________________________________________________________________
void AliAODHandler::FillTree()
{
+
// Fill the AOD Tree
- fTreeA->Fill();
+ fTreeA->Fill();
}
//______________________________________________________________________________
void AliAODHandler::AddAODtoTreeUserInfo()
{
// Add aod event to tree user info
- fTreeA->GetUserInfo()->Add(fAODEvent);
+ if (fTreeA) fTreeA->GetUserInfo()->Add(fAODEvent);
+ // Now the tree owns our fAODEvent...
+ fAODEvent = 0;
}
//______________________________________________________________________________
fTreeA->Bronch(obj->GetName(), cname, fAODEvent->GetList()->GetObjectRef(obj),
kBufsize, kSplitlevel - 1);
- // fTreeA->Branch(obj->GetName(), cname, addobj);
}
owd->cd();
}
}
return ext;
}
+
+//______________________________________________________________________________
+AliAODExtension *AliAODHandler::GetExtension(const char *filename) const
+{
+// Getter for AOD extensions via file name.
+ if (!fExtensions) return NULL;
+ return (AliAODExtension*)fExtensions->FindObject(filename);
+}
+
+//______________________________________________________________________________
+AliAODExtension *AliAODHandler::AddFilteredAOD(const char *filename, const char *filtername)
+{
+// Add an AOD extension that can write only AOD events that pass a user filter.
+ if (!fFilters) {
+ fFilters = new TObjArray();
+ fFilters->SetOwner();
+ }
+ AliAODExtension *filter = (AliAODExtension*)fFilters->FindObject(filename);
+ if (!filter) {
+ filter = new AliAODExtension(filename, filtername, kTRUE);
+ fFilters->Add(filter);
+ }
+ return filter;
+}
+
+//______________________________________________________________________________
+AliAODExtension *AliAODHandler::GetFilteredAOD(const char *filename) const
+{
+// Getter for AOD filters via file name.
+ if (!fFilters) return NULL;
+ return (AliAODExtension*)fFilters->FindObject(filename);
+}
//______________________________________________________________________________
void AliAODHandler::SetOutputFileName(const char* fname)
// stored.
//-------------------------------------------------------------------------
+//______________________________________________________________________________
+AliAODExtension::AliAODExtension(const char* name, const char* title, Bool_t isfilter)
+ :TNamed(name,title),
+ fAODEvent(0),
+ fTreeE(0),
+ fFileE(0),
+ fNtotal(0),
+ fNpassed(0),
+ fSelected(kFALSE)
+{
+// Constructor.
+ if (isfilter) {
+ TObject::SetBit(kFilteredAOD);
+ printf("####### Added AOD filter %s\n", name);
+ } else printf("####### Added AOD extension %s\n", name);
+}
+
//______________________________________________________________________________
AliAODExtension::~AliAODExtension()
{
// Destructor.
- delete fAODEvent;
if(fFileE){
// is already handled in TerminateIO
fFileE->Close();
delete fFileE;
+ fTreeE = 0;
+ fAODEvent = 0;
}
- delete fTreeE;
+ if (fTreeE) delete fTreeE;
}
//______________________________________________________________________________
void AliAODExtension::AddBranch(const char* cname, void* addobj)
{
// Add a new branch to the aod
+ if (IsFilteredAOD()) {
+ Error("AddBranch", "Not allowed to add branched to filtered AOD's.");
+ return;
+ }
if (!fAODEvent) {
char type[20];
gROOT->ProcessLine(Form("TString s_tmp; AliAnalysisManager::GetAnalysisManager()->GetAnalysisTypeString(s_tmp); sprintf((char*)0x%lx, \"%%s\", s_tmp.Data());", type));
if (!fTreeE->FindBranch(obj->GetName())) {
// Do the same as if we book via
// TTree::Branch(TCollection*)
-
fTreeE->Bronch(obj->GetName(), cname, fAODEvent->GetList()->GetObjectRef(obj),
kBufsize, kSplitlevel - 1);
- // fTreeA->Branch(obj->GetName(), cname, addobj);
}
owd->cd();
}
+//______________________________________________________________________________
+Bool_t AliAODExtension::FinishEvent()
+{
+// Fill current event.
+ fNtotal++;
+ if (!IsFilteredAOD()) {
+ fAODEvent->MakeEntriesReferencable();
+ fTreeE->Fill();
+ return kTRUE;
+ }
+ // Filtered AOD. Fill only if event is selected.
+ if (!fSelected) return kTRUE;
+ fNpassed++;
+ fTreeE->Fill();
+ fSelected = kFALSE; // so that next event will not be selected unless demanded
+ return kTRUE;
+}
+
//______________________________________________________________________________
Bool_t AliAODExtension::Init(Option_t *option)
{
}
fTreeE = new TTree("aodTree", "AliAOD tree");
fTreeE->Branch(fAODEvent->GetList());
+ fTreeE->BranchRef();
owd->cd();
return kTRUE;
}
+//______________________________________________________________________________
+void AliAODExtension::SetEvent(AliAODEvent *event)
+{
+// Connects to an external event
+ if (!IsFilteredAOD()) {
+ Error("SetEvent", "Not allowed to set external event for filtered AOD's");
+ return;
+ }
+ // Use the copy constructor or assignment operator to synchronize with external event.
+// AliAODEvent &other = *event;
+// if (!fAODEvent) fAODEvent = new AliAODEvent(other);
+// else if (fSelected) *fAODEvent = other;
+ fAODEvent = event;
+}
+
//______________________________________________________________________________
Bool_t AliAODExtension::TerminateIO()
{
// Terminate IO
+ if (TObject::TestBit(kFilteredAOD))
+ printf("AOD Filter %s: events processed: %d passed: %d\n", GetName(), fNtotal, fNpassed);
+ else
+ printf("AOD extension %s: events processed: %d\n", GetName(), fNtotal);
if (fFileE) {
fFileE->Write();
fFileE->Close();
delete fFileE;
fFileE = 0;
+ fTreeE = 0;
+ fAODEvent = 0;
}
return kTRUE;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff