Fixed a bug which caused a wrong filling of histograms
authorpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 17 Jun 2011 09:41:13 +0000 (09:41 +0000)
committerpulvir <pulvir@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 17 Jun 2011 09:41:13 +0000 (09:41 +0000)
PWG2/RESONANCES/AliRsnMiniAnalysisTask.cxx
PWG2/RESONANCES/AliRsnMiniAnalysisTask.h
PWG2/RESONANCES/AliRsnMiniOutput.cxx
PWG2/RESONANCES/AliRsnMiniOutput.h

index ecbe118..5654323 100644 (file)
@@ -169,6 +169,7 @@ AliRsnMiniAnalysisTask::~AliRsnMiniAnalysisTask()
 // (the list is owner and will clean-up these histograms). Protect in PROOF case.
 //
 
+   cout << "CIAO" << endl;
    if (fOutput && !AliAnalysisManager::GetAnalysisManager()->IsProofMode()) {
       delete fOutput;
    }
@@ -273,11 +274,7 @@ void AliRsnMiniAnalysisTask::UserExec(Option_t *)
    
    // fill a mini-event from current
    // and skip this event if no tracks were accepted
-   Int_t nacc = FillMiniEvent(check);
-   if (nacc < 1) {
-      AliDebugClass(1, Form("Event %d: skipping event with no tracks accepted", fEvNum));
-      return;
-   }
+   FillMiniEvent(check);
    
    // fill MC based histograms on mothers,
    // which do need the original event
@@ -310,15 +307,14 @@ void AliRsnMiniAnalysisTask::FinishTaskOutput()
    
    Int_t ievt, nEvents = (Int_t)fEvBuffer->GetEntries();
    Int_t idef, nDefs   = fHistograms.GetEntries();
-   Int_t imix, iloop;
+   Int_t imix, iloop, ifill;
    AliRsnMiniOutput *def = 0x0;
    AliRsnMiniOutput::EComputation compType;
-   AliRsnMiniEvent evMain;
    
    // initialize mixing counter
    fNMixed.Set(nEvents);
    for (ievt = 0; ievt < nEvents; ievt++) fNMixed[ievt] = 0;
-
+   
    // loop on events, and for each one fill all outputs
    // using the appropriate procedure depending on its type
    // only mother-related histograms are filled in UserExec,
@@ -327,8 +323,8 @@ void AliRsnMiniAnalysisTask::FinishTaskOutput()
       // get next entry
       fEvBuffer->GetEntry(ievt);
       // store in temp variable
-      evMain = (*fMiniEvent);
-      // fill non-mixed histograms
+      AliRsnMiniEvent evMain(*fMiniEvent);
+      // fill
       for (idef = 0; idef < nDefs; idef++) {
          def = (AliRsnMiniOutput*)fHistograms[idef];
          if (!def) continue;
@@ -337,25 +333,27 @@ void AliRsnMiniAnalysisTask::FinishTaskOutput()
          switch (compType) {
             case AliRsnMiniOutput::kEventOnly:
                AliDebugClass(1, Form("Event %d, def %d: event-value histogram filling", ievt, idef));
-               def->Fill(&evMain, &fValues);
+               ifill = 1;
+               def->FillEvent(&evMain, &fValues);
                break;
             case AliRsnMiniOutput::kTruePair:
                AliDebugClass(1, Form("Event %d, def %d: true-pair histogram filling", ievt, idef));
-               ProcessEvents(&evMain, 0x0);
+               ifill = def->FillPair(&evMain, &evMain, &fValues);
                break;
             case AliRsnMiniOutput::kTrackPair:
                AliDebugClass(1, Form("Event %d, def %d: pair-value histogram filling", ievt, idef));
-               ProcessEvents(&evMain, 0x0);
+               ifill = def->FillPair(&evMain, &evMain, &fValues);
                break;
             case AliRsnMiniOutput::kTrackPairRotated1:
                AliDebugClass(1, Form("Event %d, def %d: rotated (1) background histogram filling", ievt, idef));
-               ProcessEvents(&evMain, 0x0);
+               ifill = def->FillPair(&evMain, &evMain, &fValues);
                break;
             case AliRsnMiniOutput::kTrackPairRotated2:
                AliDebugClass(1, Form("Event %d, def %d: rotated (2) background histogram filling", ievt, idef));
-               ProcessEvents(&evMain, 0x0);
+               ifill = def->FillPair(&evMain, &evMain, &fValues);
                break;
             case AliRsnMiniOutput::kTrackPairMix:
+               ifill = 0;
                for (iloop = 1; iloop < nEvents; iloop++) {
                   imix = ievt + iloop;
                   AliDebugClass(1, Form("Event %d, def %d: event mixing (%d with %d)", ievt, idef, ievt, imix));
@@ -375,18 +373,23 @@ void AliRsnMiniAnalysisTask::FinishTaskOutput()
                   fNMixed[ievt]++;
                   fNMixed[imix]++;
                   // process mixing
-                  ProcessEvents(&evMain, fMiniEvent);
+                  ifill += def->FillPair(&evMain, fMiniEvent, &fValues);
                }
                break;
             default:
                // other kinds are processed elsewhere
+               ifill = 0;
                AliDebugClass(2, Form("Computation = %d", (Int_t)compType));
          }
+         // message
+         AliDebugClass(1, Form("Event %6d: def = '%15s' -- fills = %5d", ievt, def->GetName(), ifill));
       }
    }
    
    // print number of mixings done with each event
-   for (ievt = 0; ievt < nEvents; ievt++) cout << Form("Event #%6d mixed %3d times", ievt, fNMixed[ievt]) << endl;
+   for (ievt = 0; ievt < nEvents; ievt++) {
+      AliDebugClass(2, Form("Event %6d: mixed %2d times", ievt, fNMixed[ievt]));
+   }
    
    // post computed data
    PostData(1, fOutput);
@@ -443,7 +446,7 @@ Char_t AliRsnMiniAnalysisTask::CheckCurrentEvent()
       // --> if this is failed, the event is rejected
       isSelected = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kMB);
       if (!isSelected) {
-         AliDebugClass(1, "Event does not pass physics selections");
+         AliDebugClass(2, "Event does not pass physics selections");
          fRsnEvent.SetRef(0x0);
          fRsnEvent.SetRefMC(0x0);
          return 0;
@@ -533,7 +536,7 @@ Char_t AliRsnMiniAnalysisTask::CheckCurrentEvent()
    }
    
    // if the above exit point is not taken, the event is accepted
-   AliDebugClass(1, Form("Stats for event %d: %s", fEvNum, msg.Data()));
+   AliDebugClass(2, Form("Stats for event %d: %s", fEvNum, msg.Data()));
    if (isSelected) {
       fHEventStat->Fill(3.1);
       return output;
@@ -543,7 +546,7 @@ Char_t AliRsnMiniAnalysisTask::CheckCurrentEvent()
 }
 
 //__________________________________________________________________________________________________
-Int_t AliRsnMiniAnalysisTask::FillMiniEvent(Char_t evType)
+void AliRsnMiniAnalysisTask::FillMiniEvent(Char_t evType)
 {
 //
 // Refresh cursor mini-event data member to fill with current event.
@@ -551,15 +554,18 @@ Int_t AliRsnMiniAnalysisTask::FillMiniEvent(Char_t evType)
 //
 
    // assign event-related values
+   if (fMiniEvent) delete fMiniEvent;
    fMiniEvent = new AliRsnMiniEvent;
+   fMiniEvent->ID()    = fEvNum;
    fMiniEvent->Vz()    = fInputEvent->GetPrimaryVertex()->GetZ();
    fMiniEvent->Angle() = ComputeAngle();
    fMiniEvent->Mult()  = ComputeCentrality((evType == 'E'));
-   AliDebugClass(1, Form("Event %d: type = %c -- vz = %f -- mult = %f -- angle = %f", fEvNum, evType, fMiniEvent->Vz(), fMiniEvent->Mult(), fMiniEvent->Angle()));
+   AliDebugClass(2, Form("Event %d: type = %c -- vz = %f -- mult = %f -- angle = %f", fEvNum, evType, fMiniEvent->Vz(), fMiniEvent->Mult(), fMiniEvent->Angle()));
    
    // loop on daughters and assign track-related values
    Int_t ic, ncuts = fTrackCuts.GetEntries();
    Int_t ip, npart = fRsnEvent.GetAbsoluteSum();
+   Int_t npos = 0, nneg = 0, nneu = 0;
    AliRsnDaughter cursor;
    AliRsnMiniParticle miniParticle;
    for (ip = 0; ip < npart; ip++) {
@@ -567,19 +573,23 @@ Int_t AliRsnMiniAnalysisTask::FillMiniEvent(Char_t evType)
       fRsnEvent.SetDaughter(cursor, ip);
       // copy momentum and MC info if present
       miniParticle.CopyDaughter(&cursor);
+      miniParticle.Index() = ip;
       // switch on the bits corresponding to passed cuts
       for (ic = 0; ic < ncuts; ic++) {
          AliRsnCutSet *cuts = (AliRsnCutSet*)fTrackCuts[ic];
          if (cuts->IsSelected(&cursor)) miniParticle.SetCutBit(ic);
       }
       // if a track passes at least one track cut, it is added to the pool
-      if (miniParticle.CutBits()) fMiniEvent->AddParticle(miniParticle);
+      if (miniParticle.CutBits()) {
+         fMiniEvent->AddParticle(miniParticle);
+         if (miniParticle.Charge() == '+') npos++;
+         else if (miniParticle.Charge() == '-') nneg++;
+         else nneu++;
+      }
    }
    
    // get number of accepted tracks
-   Int_t nacc = (Int_t)fMiniEvent->Particles().GetEntriesFast();
-   AliDebugClass(1, Form("Event %d: total = %d, accepted = %d", fEvNum, npart, nacc));
-   return nacc;
+   AliDebugClass(1, Form("Event %6d: total = %5d, accepted = %4d (pos %4d, neg %4d, neu %4d)", fEvNum, npart, (Int_t)fMiniEvent->Particles().GetEntriesFast(), npos, nneg, nneu));
 }
 
 //__________________________________________________________________________________________________
@@ -692,7 +702,7 @@ void AliRsnMiniAnalysisTask::FillTrueMotherESD(AliRsnMiniEvent *miniEvent)
          miniPair.Sum(0) = miniPair.Sum(1) = (p1 + p2);
          miniPair.FillRef(def->GetMotherMass());
          // do computations
-         def->Fill(&miniPair, miniEvent, &fValues);
+         def->FillMother(&miniPair, miniEvent, &fValues);
       }
    }
 }
@@ -741,55 +751,7 @@ void AliRsnMiniAnalysisTask::FillTrueMotherAOD(AliRsnMiniEvent *miniEvent)
          miniPair.Sum(0) = miniPair.Sum(1) = (p1 + p2);
          miniPair.FillRef(def->GetMotherMass());
          // do computations
-         def->Fill(&miniPair, miniEvent, &fValues);
+         def->FillMother(&miniPair, miniEvent, &fValues);
       }
    }
 }
-
-//________________________________________________________________________
-void AliRsnMiniAnalysisTask::ProcessEvents(AliRsnMiniEvent *evMain, AliRsnMiniEvent *evMix)
-{
-//
-// This function processes all single tracks.
-// Loops on the daughters defined in current event
-// and on all of them which pass the single-track cuts defined, computes what needed
-//
-
-   // check if it is mixed
-   Bool_t isMix;
-   if (evMix) {
-      isMix = kTRUE;
-   } else {
-      evMix = evMain;
-      isMix = kFALSE;
-   }
-   
-   // 2 nested loops on tracks
-   // inner starts from next track or from first, depending if is mixing or not
-   Int_t i1, i2, idef, start;
-   Int_t n1 = evMain->Particles().GetEntries();
-   Int_t n2 = evMix ->Particles().GetEntries();
-   Int_t ndef = fHistograms.GetEntries();
-   AliRsnMiniParticle *daughter1 = 0x0, *daughter2 = 0x0;
-   AliRsnMiniOutput *def = 0x0;
-   for (i1 = 0; i1 < n1; i1++) {
-      daughter1 = (AliRsnMiniParticle*)evMain->Particles()[i1];
-      if (!daughter1) continue;
-      if (isMix) start = 0; else start = i1 + 1;
-      for (i2 = start; i2 < n2; i2++) {
-         daughter2 = (AliRsnMiniParticle*)evMix->Particles()[i2];
-         if (!daughter2) continue;
-         // loop on definitions
-         for (idef = 0; idef < ndef; idef++) {
-            def = (AliRsnMiniOutput*)fHistograms[idef];
-            if (!def) continue;
-            if (def->IsEventOnly()) continue;
-            if (def->IsMother()) continue;
-            if (isMix && !def->IsTrackPairMix()) continue;
-            if (!isMix && def->IsTrackPairMix()) continue;
-            // check if definitions here match the current pair
-            def->Fill(daughter1, daughter2, evMain, &fValues);
-         } // end loop on definitions
-      } // end loop on daughter #2
-   } // end loop on daughter #1
-}
index 03fe30e..acc7248 100644 (file)
@@ -60,13 +60,12 @@ public:
 private:
 
    Char_t   CheckCurrentEvent();
-   Int_t    FillMiniEvent(Char_t evType);
+   void     FillMiniEvent(Char_t evType);
    Double_t ComputeAngle();
    Double_t ComputeCentrality(Bool_t isESD);
    void     FillTrueMotherESD(AliRsnMiniEvent *event);
    void     FillTrueMotherAOD(AliRsnMiniEvent *event);
    void     StoreTrueMother(AliRsnMiniPair *pair, AliRsnMiniEvent *event);
-   void     ProcessEvents(AliRsnMiniEvent *evMain, AliRsnMiniEvent *evMix = 0x0);
 
    Bool_t               fUseMC;           //  use or not MC info
    Int_t                fEvNum;           //! absolute event counter
index f7050d1..7411c36 100644 (file)
@@ -13,6 +13,7 @@
 #include "TH2.h"
 #include "TH3.h"
 #include "TList.h"
+#include "TMath.h"
 #include "THnSparse.h"
 #include "TString.h"
 #include "TClonesArray.h"
@@ -244,10 +245,21 @@ Bool_t AliRsnMiniOutput::Init(const char *prefix, TList *list)
    }
    
    fList = list;
+   Int_t size = fAxes.GetEntries();
+   if (size < 1) {
+      AliWarning(Form("[%s] Cannot initialize histogram with less than 1 axis", GetName()));
+      return kFALSE;
+   }
 
    switch (fOutputType) {
       case kHistogram:
-         CreateHistogram(Form("%s_%s", prefix, GetName()));
+         if (size <= 3) {
+            CreateHistogram(Form("%s_%s", prefix, GetName()));
+         } else {
+            AliInfo(Form("[%s] Added %d > 3 axes. Creating a sparse histogram", GetName(), size));
+            fOutputType = kHistogramSparse;
+            CreateHistogramSparse(Form("%s_%s", prefix, GetName()));
+         }
          return kTRUE;
       case kHistogramSparse:
          CreateHistogramSparse(Form("%s_%s", prefix, GetName()));
@@ -335,7 +347,7 @@ void AliRsnMiniOutput::CreateHistogramSparse(const char *name)
 }
 
 //________________________________________________________________________________________
-Bool_t AliRsnMiniOutput::Fill(AliRsnMiniEvent *event, TClonesArray *valueList)
+Bool_t AliRsnMiniOutput::FillEvent(AliRsnMiniEvent *event, TClonesArray *valueList)
 {
 //
 // Compute values for event-based computations (does not use the pair)
@@ -347,15 +359,14 @@ Bool_t AliRsnMiniOutput::Fill(AliRsnMiniEvent *event, TClonesArray *valueList)
       return kFALSE;
    }
 
-   // get computed values
-   if (!ComputeValues(event, valueList)) return kFALSE;
-   
-   // call filling method
-   return FillHistogram();
+   // compute & fill
+   ComputeValues(event, valueList);
+   FillHistogram();
+   return kTRUE;
 }
 
 //________________________________________________________________________________________
-Bool_t AliRsnMiniOutput::Fill(const AliRsnMiniPair *pair, AliRsnMiniEvent *event, TClonesArray *valueList)
+Bool_t AliRsnMiniOutput::FillMother(const AliRsnMiniPair *pair, AliRsnMiniEvent *event, TClonesArray *valueList)
 {
 //
 // Compute values for mother-based computations
@@ -373,89 +384,113 @@ Bool_t AliRsnMiniOutput::Fill(const AliRsnMiniPair *pair, AliRsnMiniEvent *event
    // check pair against cuts
    if (fPairCuts) if (!fPairCuts->IsSelected(&fPair)) return kFALSE;
 
-   // get computed values
-   if (!ComputeValues(event, valueList)) return kFALSE;
-   
-   // call filling method
-   return FillHistogram();
+   // compute & fill
+   ComputeValues(event, valueList);
+   FillHistogram();
+   return kTRUE;
 }
 
 //________________________________________________________________________________________
-Bool_t AliRsnMiniOutput::Fill
-(AliRsnMiniParticle *p1, AliRsnMiniParticle *p2, AliRsnMiniEvent *event, TClonesArray *valueList)
+Int_t AliRsnMiniOutput::FillPair(AliRsnMiniEvent *event1, AliRsnMiniEvent *event2, TClonesArray *valueList)
 {
 //
-// Compute values for pair-based comptuations
+// Loops on the passed mini-event, and for each pair of particles
+// which satisfy the charge and cut requirements defined here, add an entry.
+// Returns the number of successful fillings.
 //
 
    // check computation type
    Bool_t okComp = kFALSE;
-   if (fComputation == kTrackPair) okComp = kTRUE;
-   if (fComputation == kTrackPairMix) okComp = kTRUE;
-   if (fComputation == kTrackPairRotated1)  okComp = kTRUE;
-   if (fComputation == kTrackPairRotated2)  okComp = kTRUE;
+   if (fComputation == kTrackPair)         okComp = kTRUE;
+   if (fComputation == kTrackPairMix)      okComp = kTRUE;
+   if (fComputation == kTrackPairRotated1) okComp = kTRUE;
+   if (fComputation == kTrackPairRotated2) okComp = kTRUE;
+   if (fComputation == kTruePair)          okComp = kTRUE;
    if (!okComp) {
-      AliError("This method can be called only for pair-based computations");
-      return kFALSE;
-   }
-
-   // require that the two particles are well defined
-   if (!p1 || !p2) {
-      AliError("Required two particles");
+      AliError(Form("[%s] This method can be called only for pair-based computations", GetName()));
       return kFALSE;
    }
    
-   // match check #1: first particle with first def, second particle with second def
-   // match check #2: first particle with second def, second particle with first def
-   if (p1->Charge() == fCharge[0] && p1->HasCutBit(fCutID[0]) && p2->Charge() == fCharge[1] && p2->HasCutBit(fCutID[1])) {
-      fPair.Fill(p1, p2, GetMass(0), GetMass(1), fMotherMass);
-   } else if (p1->Charge() == fCharge[1] && p1->HasCutBit(fCutID[1]) && p2->Charge() == fCharge[0] && p2->HasCutBit(fCutID[0])) {
-      fPair.Fill(p2, p1, GetMass(0), GetMass(1), fMotherMass);
-   } else {
-      AliDebugClass(1, "Pair does not match definition in any order");
-      return kFALSE;
-   }
+   // loop variables
+   Int_t i1, i2, start, nadded = 0;
+   Int_t n1 = event1->Particles().GetEntriesFast();
+   Int_t n2 = event2->Particles().GetEntriesFast();
+   AliRsnMiniParticle *p1, *p2;
    
-   // if required, rotate one of the two backgrounds
-   if (fComputation == kTrackPairRotated1) {
-      fPair.InvertP(kTRUE);
-   }
-   else if (fComputation == kTrackPairRotated2){
-      fPair.InvertP(kFALSE);
-   }
+   // it is necessary to know if criteria for the two daughters are the same
+   // and if the two events are the same or not (mixing)
+   Bool_t sameCriteria = ((fCharge[0] == fCharge[1]) && (fCutID[0] == fCutID[1]));
+   Bool_t sameEvent = (event1->ID() == event2->ID());
    
-   // if required, check that this is a true pair
-   if (fComputation == kTruePair) {
-      //cout << fPair.Mother() << ' ' << fPair.MotherPDG() << ' ';
-      //cout << p1->PDG() << " (" << p1->Mother() << ") ";
-      //cout << p2->PDG() << " (" << p2->Mother() << ")" << endl;
-      if (fPair.Mother() < 0)  {
-         return kFALSE;
-      } else if (TMath::Abs(fPair.MotherPDG()) != fMotherPDG) {
-         return kFALSE;
-      }
-      //cout << fPair.Mother() << ' ' << fPair.MotherPDG() << ' ' << p1->PDG() << ' ' << p2->PDG() << endl;
-      Bool_t decayMatch = kFALSE;
-      if (p1->PDGAbs() == AliRsnDaughter::SpeciesPDG(fDaughter[0]) && p2->PDGAbs() == AliRsnDaughter::SpeciesPDG(fDaughter[1]))
-         decayMatch = kTRUE;
-      if (p2->PDGAbs() == AliRsnDaughter::SpeciesPDG(fDaughter[0]) && p1->PDGAbs() == AliRsnDaughter::SpeciesPDG(fDaughter[1]))
-         decayMatch = kTRUE;
-      //cout << " DECAY MATCH = " << (decayMatch ? " OK " : " NO ") << endl;
-      if (!decayMatch) return kFALSE;
-   }
-   
-   // check pair against cuts
-   if (fPairCuts) if (!fPairCuts->IsSelected(&fPair)) return kFALSE;
+   //Int_t nsel1 = event1->CountParticles(fCharge[0], fCutID[0]);
+   //Int_t nsel2 = event2->CountParticles(fCharge[1], fCutID[1]);
+   //cout << "Charge #1 = " << fCharge[0] << " cut bit #1 = " << fCutID[0] << ", tracks = " << nsel1 << endl;
+   //cout << "Charge #2 = " << fCharge[1] << " cut bit #2 = " << fCutID[1] << ", tracks = " << nsel2 << endl;
+   //if (!nsel1 || !nsel2) {
+   //   cout << "Nothing to mix" << endl;
+   //   return 0;
+   //}
    
-   // get computed values
-   if (!ComputeValues(event, valueList)) return kFALSE;
+   // external loop
+   for (i1 = 0; i1 < n1; i1++) {
+      p1 = event1->GetParticle(i1);
+      if (p1->Charge() != fCharge[0]) continue;
+      if (!p1->HasCutBit(fCutID[0])) continue;
+      // define starting point for inner loop
+      // if daughter selection criteria (charge, cuts) are the same
+      // and the two events coincide, internal loop must start from
+      // the first track *after* current one;
+      // otherwise it starts from the beginning
+      start = ((sameEvent && sameCriteria) ? i1 + 1 : 0);
+      // internal loop
+      for (i2 = start; i2 < n2; i2++) {
+         p2 = event2->GetParticle(i2);
+         if (p2->Charge() != fCharge[1]) continue;
+         if (!p2->HasCutBit(fCutID[1])) continue;
+         //cout << "Matching: " << i1 << ' ' << i2 << endl;
+         // avoid to mix a particle with itself
+         if (sameEvent && (p1->Index() == p2->Index())) {
+            //cout << "-- skipping same index" << endl;
+            continue;
+         }
+         // sum momenta
+         fPair.Fill(p1, p2, GetMass(0), GetMass(1), fMotherMass);
+         // do rotation if needed
+         if (fComputation == kTrackPairRotated1) fPair.InvertP(kTRUE);
+         if (fComputation == kTrackPairRotated2) fPair.InvertP(kFALSE);
+         // if required, check that this is a true pair
+         if (fComputation == kTruePair) {
+            if (fPair.Mother() < 0)  {
+               continue;
+            } else if (TMath::Abs(fPair.MotherPDG()) != fMotherPDG) {
+               continue;
+            }
+            Bool_t decayMatch = kFALSE;
+            if (p1->PDGAbs() == AliRsnDaughter::SpeciesPDG(fDaughter[0]) && p2->PDGAbs() == AliRsnDaughter::SpeciesPDG(fDaughter[1]))
+               decayMatch = kTRUE;
+            if (p2->PDGAbs() == AliRsnDaughter::SpeciesPDG(fDaughter[0]) && p1->PDGAbs() == AliRsnDaughter::SpeciesPDG(fDaughter[1]))
+               decayMatch = kTRUE;
+            if (!decayMatch) continue;
+         }
+         // check pair against cuts
+         if (fPairCuts) {
+            if (!fPairCuts->IsSelected(&fPair)) {
+               //cout << "-- cuts not passed: Y = " << TMath::Abs(fPair.Y(0)) << endl;
+               continue;
+            }
+         }
+         // get computed values & fill histogram
+         ComputeValues(event1, valueList);
+         FillHistogram();
+         nadded++;
+      } // end internal loop
+   } // end external loop
    
-   // call filling method
-   return FillHistogram();
+   return nadded;
 }
 
 //________________________________________________________________________________________
-Bool_t AliRsnMiniOutput::ComputeValues(AliRsnMiniEvent *event, TClonesArray *valueList)
+void AliRsnMiniOutput::ComputeValues(AliRsnMiniEvent *event, TClonesArray *valueList)
 {
 //
 // Using the arguments and the internal 'fPair' data member,
@@ -488,12 +523,10 @@ Bool_t AliRsnMiniOutput::ComputeValues(AliRsnMiniEvent *event, TClonesArray *val
       // if none of the above exit points is taken, compute value
       fComputed[i] = val->Eval(&fPair, event);
    }
-   
-   return kTRUE;
 }
 
 //________________________________________________________________________________________
-Bool_t AliRsnMiniOutput::FillHistogram()
+void AliRsnMiniOutput::FillHistogram()
 {
 //
 // Fills the internal histogram using the current values stored in the
@@ -504,7 +537,7 @@ Bool_t AliRsnMiniOutput::FillHistogram()
    // retrieve object from list
    if (!fList) {
       AliError("List pointer is NULL");
-      return kFALSE;
+      return;
    }
    TObject *obj = fList->At(fOutputID);
 
@@ -518,8 +551,5 @@ Bool_t AliRsnMiniOutput::FillHistogram()
       ((THnSparseF*)obj)->Fill(fComputed.GetArray());
    } else {
       AliError("No output initialized");
-      return kFALSE;
    }
-   
-   return kTRUE;
 }
index 7ea67d2..959e8fc 100644 (file)
@@ -85,16 +85,16 @@ public:
    
    AliRsnMiniPair& Pair() {return fPair;}
    Bool_t          Init(const char *prefix, TList *list);
-   Bool_t          Fill(AliRsnMiniParticle *p1, AliRsnMiniParticle *p2, AliRsnMiniEvent *event, TClonesArray *valueList);
-   Bool_t          Fill(const AliRsnMiniPair *pair, AliRsnMiniEvent *event, TClonesArray *valueList);
-   Bool_t          Fill(AliRsnMiniEvent *event, TClonesArray *valueList);
+   Bool_t          FillMother(const AliRsnMiniPair *pair, AliRsnMiniEvent *event, TClonesArray *valueList);
+   Bool_t          FillEvent(AliRsnMiniEvent *event, TClonesArray *valueList);
+   Int_t           FillPair(AliRsnMiniEvent *event1, AliRsnMiniEvent *event2, TClonesArray *valueList);
                   
 private:
 
    void   CreateHistogram(const char *name);
    void   CreateHistogramSparse(const char *name);
-   Bool_t ComputeValues(AliRsnMiniEvent *event, TClonesArray *valueList);
-   Bool_t FillHistogram();
+   void   ComputeValues(AliRsnMiniEvent *event, TClonesArray *valueList);
+   void   FillHistogram();
 
    EOutputType      fOutputType;       //  type of output
    EComputation     fComputation;      //  type of computation