+//______________________________________________________________________________
+void AliAODHandler::Print(Option_t* opt) const
+{
+ // Print info about this object
+
+ cout << opt << Form("IsStandard %d filename=%s",fIsStandard,fFileName.Data()) << endl;
+
+ if ( fExtensions )
+ {
+ cout << opt << fExtensions->GetEntries() << " extensions :" << endl;
+ PrintExtensions(*fExtensions);
+ }
+ if ( fFilters )
+ {
+ cout << opt << fFilters->GetEntries() << " filters :" << endl;
+ PrintExtensions(*fFilters);
+ }
+}
+
+//______________________________________________________________________________
+void AliAODHandler::PrintExtensions(const TObjArray& array) const
+{
+ // Show the list of aod extensions
+ TIter next(&array);
+ AliAODExtension* ext(0x0);
+ while ( ( ext = static_cast<AliAODExtension*>(next()) ) )
+ {
+ ext->Print(" ");
+ }
+}
+
+//______________________________________________________________________________
+void AliAODHandler::StoreMCParticles(){
+
+ //
+ // Remap the labels from ESD stack and store
+ // the AODMCParticles, makes only sense if we have
+ // the mcparticles branch
+ // has to be done here since we cannot know in advance
+ // which particles are needed (e.g. by the tracks etc.)
+ //
+ // Particles have been selected by AliMCEventhanlder->SelectParticle()
+ // To use the MCEventhandler here we need to set it from the outside
+ // can vanish when Handler go to the ANALYSISalice library
+ //
+ // The Branch booking for mcParticles and mcHeader has to happen
+ // in an external task for now since the AODHandler does not have access
+ // the AnalysisManager. For the same reason the pointer t o the MCEventH
+ // 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;
+
+ AliAODMCHeader *mcHeader = (AliAODMCHeader*)fAODEvent->FindListObject(AliAODMCHeader::StdBranchName());
+ if(!mcHeader)return;
+
+ // 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
+
+ if(!fMCEventH)return;
+ if(!fMCEventH->MCEvent())return;
+ AliStack *pStack = fMCEventH->MCEvent()->Stack();
+ if(!pStack)return;
+
+ fMCEventH->CreateLabelMap();
+
+ //
+ // Get the Event Header
+ //
+
+ AliHeader* header = fMCEventH->MCEvent()->Header();
+ // get the MC vertex
+ AliGenEventHeader* genHeader = 0;
+ if (header) genHeader = header->GenEventHeader();
+ if (genHeader) {
+ TArrayF vtxMC(3);
+ genHeader->PrimaryVertex(vtxMC);
+ mcHeader->SetVertex(vtxMC[0],vtxMC[1],vtxMC[2]);
+
+ // we search the MCEventHeaders first
+ // Two cases, cocktail or not...
+ AliGenCocktailEventHeader* genCocktailHeader = dynamic_cast<AliGenCocktailEventHeader*>(genHeader);
+ if(genCocktailHeader){
+ // we have a coktail header
+ mcHeader->AddGeneratorName(genHeader->GetName());
+ // Loop from the back so that the first one sets the process type
+ TList* headerList = genCocktailHeader->GetHeaders();
+ for(int i = headerList->GetEntries()-1;i>=0;--i){
+ AliGenEventHeader *headerEntry = dynamic_cast<AliGenEventHeader*>(headerList->At(i));
+ SetMCHeaderInfo(mcHeader,headerEntry);
+ }
+ }
+ else{
+ // No Cocktail just take the first one
+ SetMCHeaderInfo(mcHeader,genHeader);
+ }
+ }
+
+
+
+
+
+ // Store the AliAODParticlesMC
+ AliMCEvent* mcEvent = fMCEventH->MCEvent();
+
+ Int_t np = mcEvent->GetNumberOfTracks();
+ Int_t nprim = mcEvent->GetNumberOfPrimaries();
+
+
+ Int_t j = 0;
+ TClonesArray& l = *mcarray;
+
+ for(int i = 0; i < np; ++i){
+ if(fMCEventH->IsParticleSelected(i)){
+ Int_t flag = 0;
+ AliMCParticle* mcpart = (AliMCParticle*) mcEvent->GetTrack(i);
+ if(i<nprim)flag |= AliAODMCParticle::kPrimary;
+
+ if(mcEvent->IsPhysicalPrimary(i))flag |= AliAODMCParticle::kPhysicalPrim;
+
+ if(fMCEventH->GetNewLabel(i)!=j){
+ AliError(Form("MISMATCH New label %d j: %d",fMCEventH->GetNewLabel(i),j));
+ }
+
+ 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);
+ Int_t m = mcpart_tmp.GetMother();
+
+ // other than for the track labels, negative values mean
+ // no daughter/mother so preserve it
+
+ if(d0<0 && d1<0){
+ // no first daughter -> no second daughter
+ // nothing to be done
+ // second condition not needed just for sanity check at the end
+ mcpart_tmp.SetDaughter(0,d0);
+ mcpart_tmp.SetDaughter(1,d1);
+ } else if(d1 < 0 && d0 >= 0) {
+ // Only one daughter
+ // second condition not needed just for sanity check at the end
+ if(fMCEventH->IsParticleSelected(d0)){
+ mcpart_tmp.SetDaughter(0,fMCEventH->GetNewLabel(d0));
+ } else {
+ mcpart_tmp.SetDaughter(0,-1);
+ }
+ mcpart_tmp.SetDaughter(1,d1);
+ }
+ else if (d0 > 0 && d1 > 0 ){
+ // we have two or more daughters loop on the stack to see if they are
+ // selected
+ Int_t d0_tmp = -1;
+ Int_t d1_tmp = -1;
+ for(int id = d0; id<=d1;++id){
+ if(fMCEventH->IsParticleSelected(id)){
+ if(d0_tmp==-1){
+ // first time
+ d0_tmp = fMCEventH->GetNewLabel(id);
+ d1_tmp = d0_tmp; // this is to have the same schema as on the stack i.e. with one daugther d0 and d1 are the same
+ }
+ else d1_tmp = fMCEventH->GetNewLabel(id);
+ }
+ }
+ mcpart_tmp.SetDaughter(0,d0_tmp);
+ mcpart_tmp.SetDaughter(1,d1_tmp);
+ } else {
+ AliError(Form("Unxpected indices %d %d",d0,d1));
+ }
+
+ if(m<0){
+ mcpart_tmp.SetMother(m);
+ } else {
+ 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);
+
+ }
+ }
+ AliInfo(Form("AliAODHandler::StoreMCParticles: Selected %d (Primaries %d / total %d) after validation \n",
+ j,nprim,np));
+
+ // Set the labels in the AOD output...
+ // Remapping
+
+ // AODTracks
+ TClonesArray* tracks = fAODEvent->GetTracks();
+ if(tracks){
+ for(int it = 0; it < fAODEvent->GetNTracks();++it){
+ AliAODTrack *track = fAODEvent->GetTrack(it);
+
+ 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(sign*fMCEventH->GetNewLabel(label));
+ }
+ }
+
+ // AOD calo cluster
+ TClonesArray *clusters = fAODEvent->GetCaloClusters();
+ if(clusters){
+ for (Int_t iClust = 0;iClust < fAODEvent->GetNumberOfCaloClusters(); ++iClust) {
+ AliAODCaloCluster * cluster = fAODEvent->GetCaloCluster(iClust);
+ UInt_t nLabel = cluster->GetNLabels();
+ // Ugly but do not want to fragment memory by creating
+ // new Int_t (nLabel)
+ Int_t* labels = const_cast<Int_t*>(cluster->GetLabels());
+ if (labels){
+ for(UInt_t i = 0;i < nLabel;++i){
+ labels[i] = fMCEventH->GetNewLabel(cluster->GetLabelAt(i));
+ }
+ }
+ // cluster->SetLabels(labels,nLabel);
+ }// iClust
+ }// clusters
+
+ // AOD tracklets
+ AliAODTracklets *tracklets = fAODEvent->GetTracklets();
+ if(tracklets){
+ for(int it = 0;it < tracklets->GetNumberOfTracklets();++it){
+ int label0 = tracklets->GetLabel(it,0);
+ int label1 = tracklets->GetLabel(it,1);
+ if(label0>=0)label0 = fMCEventH->GetNewLabel(label0);
+ if(label1>=0)label1 = fMCEventH->GetNewLabel(label1);
+ tracklets->SetLabel(it,0,label0);
+ tracklets->SetLabel(it,1,label1);
+ }
+ }
+
+}
+
+//______________________________________________________________________________