Line data    Source code

       1             : /**************************************************************************
       2             :  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
       3             :  *                                                                        *
       4             :  * Author: The ALICE Off-line Project.                                    *
       5             :  * Contributors are mentioned in the code where appropriate.              *
       6             :  *                                                                        *
       7             :  * Permission to use, copy, modify and distribute this software and its   *
       8             :  * documentation strictly for non-commercial purposes is hereby granted   *
       9             :  * without fee, provided that the above copyright notice appears in all   *
      10             :  * copies and that both the copyright notice and this permission notice   *
      11             :  * appear in the supporting documentation. The authors make no claims     *
      12             :  * about the suitability of this software for any purpose. It is          *
      13             :  * provided "as is" without express or implied warranty.                  *
      14             :  **************************************************************************/
      15             : 
      16             : /* $Id$ */
      17             : 
      18             : //
      19             : // Manager class for filter decisions based on cuts
      20             : // The filter contains a list of sets of cuts.
      21             : // A bit field is filled in order to store the decision of each cut-set. 
      22             : // Author: Andreas Morsch
      23             : // andreas.morsch@cern.ch
      24             : 
      25             : #include <TObject.h>
      26             : #include <TList.h>
      27             : #include "AliAnalysisFilter.h"
      28             : #include "AliAnalysisCuts.h"
      29             : 
      30             : 
      31         170 : ClassImp(AliAnalysisFilter)
      32             : 
      33             : 
      34             : ////////////////////////////////////////////////////////////////////////
      35             : 
      36             : AliAnalysisFilter::AliAnalysisFilter():
      37           0 :     TNamed(),
      38           0 :     fCuts(0)
      39           0 : {
      40             :   // Default constructor
      41           0 : }
      42             : 
      43             : AliAnalysisFilter::AliAnalysisFilter(const char* name, const char* title):
      44           4 :     TNamed(name, title),
      45          12 :     fCuts(new TList())
      46          20 : {
      47             :   // Constructor
      48           8 : }
      49             : 
      50             : AliAnalysisFilter::AliAnalysisFilter(const AliAnalysisFilter& obj):
      51           0 :     TNamed(obj),
      52           0 :     fCuts(0)
      53           0 : {
      54             : // Copy constructor
      55           0 :     fCuts = obj.fCuts;
      56           0 : }
      57             : 
      58             : AliAnalysisFilter::~AliAnalysisFilter()
      59          12 : {
      60             : // Destructor
      61           4 :    if (fCuts) fCuts->Delete("slow");
      62           4 :    delete fCuts;
      63           6 : }   
      64             : 
      65             : AliAnalysisFilter& AliAnalysisFilter::operator=(const AliAnalysisFilter& other)
      66             : {
      67             : // Assignment
      68           0 :    if (&other != this) {
      69           0 :            TNamed::operator=(other);
      70           0 :            fCuts = other.fCuts;
      71           0 :    }
      72           0 :    return *this;
      73             :    }
      74             :    
      75             : UInt_t AliAnalysisFilter::IsSelected(TObject* obj)
      76             : {
      77             :     //
      78             :     // Loop over all set of cuts
      79             :     // and store the decision
      80             :     UInt_t result = 0;
      81             :     UInt_t filterMask;
      82             :     
      83         314 :     TIter next(fCuts);
      84             :     AliAnalysisCuts *cuts;
      85             :     Int_t iCutB = 1;
      86             :         
      87        1413 :     while((cuts = (AliAnalysisCuts*)next())) {
      88         628 :         Bool_t acc = cuts->IsSelected(obj);
      89         628 :         if ((filterMask = cuts->GetFilterMask()) > 0) {
      90           0 :             acc = (acc && (filterMask == result));
      91           0 :         }
      92         314 :         cuts->SetSelected(acc);
      93         440 :         if (acc) {result |= iCutB & 0x00ffffff;}
      94         314 :         iCutB *= 2;
      95             :     }  
      96             : 
      97             :     return result;
      98         157 : }
      99             : 
     100             : UInt_t AliAnalysisFilter::IsSelected(TList* list)
     101             : {
     102             :     //
     103             :     // Loop over all set of cuts
     104             :     // and store the decision
     105             :     UInt_t result = 0;
     106             :     UInt_t filterMask;
     107             : 
     108          52 :     TIter next(fCuts);
     109             :     AliAnalysisCuts *cuts;
     110             :     Int_t iCutB = 1;
     111             :         
     112         156 :     while((cuts = (AliAnalysisCuts*)next())) {
     113          52 :         Bool_t acc = cuts->IsSelected(list);
     114          52 :         if ((filterMask = cuts->GetFilterMask()) > 0) {
     115           0 :             acc = (acc && (filterMask & result));
     116           0 :         }
     117          26 :         cuts->SetSelected(acc);
     118          42 :         if (acc) {result |= iCutB & 0x00ffffff;}
     119          26 :         iCutB *= 2;
     120             :     }  
     121             : 
     122             :     return result;
     123          26 : }
     124             : 
     125             : void AliAnalysisFilter::Init()
     126             : {
     127             :     //
     128             :     // Loop over all set of cuts and call Init
     129           0 :     TIter next(fCuts);
     130             :     AliAnalysisCuts *cuts;
     131           0 :     while((cuts = (AliAnalysisCuts*)next())) cuts->Init();
     132           0 : }
     133             : 
     134             : void AliAnalysisFilter::AddCuts(AliAnalysisCuts* cuts)
     135             : {
     136             :     // Add a set of cuts
     137          12 :     fCuts->Add(cuts);
     138           6 : }
     139             : 
     140             : Bool_t AliAnalysisFilter::IsSelected(char* name)
     141             : {
     142             :     //
     143             :     // Returns current result for cut with name
     144         240 :     AliAnalysisCuts* cut = (AliAnalysisCuts*) (fCuts->FindObject(name));
     145         120 :     if (cut) {
     146           0 :       return (cut->Selected());
     147             :     } else  {
     148         120 :       return 0;
     149             :     }
     150         120 : }