Removed old ME classes, since the nex event mixing has been introduced and is integra...

[u/mrichter/AliRoot.git] / PWG2 / RESONANCES / AliRsnTarget.h

//
// *** Class AliRsnTarget ***
//
// Base class used wherever it is needed to check the class type of
// an object (daughter, mother, event) which could be used for
// cut checking or value computing.
// Since most of these operation are implemented into classes that
// operate on any of such objects, then this class helps in making sure
// that the object being processed corresponds to what is expected.
//

#ifndef ALIRSNTARGET_H
#define ALIRSNTARGET_H

#include "TNamed.h"

#include "AliRsnEvent.h"

class AliRsnDaughter;
class AliRsnMother;

class AliRsnTarget : public TNamed {
public:

   enum ETargetType {
      kDaughter,
      kMother,
      kEvent,
      kTargetTypes
   };

   AliRsnTarget() : fTargetType(kTargetTypes), fDaughter(0x0), fMother(0x0), fEvent(0x0) { /*nothing*/ }
   AliRsnTarget(const char *name, ETargetType type) : TNamed(name, ""), fTargetType(type), fDaughter(0x0), fMother(0x0), fEvent(0x0) { /*nothing*/ }
   AliRsnTarget(const AliRsnTarget& copy) : TNamed(copy), fTargetType(copy.fTargetType), fDaughter(0x0), fMother(0x0), fEvent(0x0) { /*nothing*/ }
   AliRsnTarget& operator=(const AliRsnTarget& copy) { TNamed::operator=(copy); fTargetType = copy.fTargetType; fDaughter = 0x0; fMother = 0x0; fEvent = 0x0; return (*this); }
   virtual ~AliRsnTarget() { /*nothing*/ }

   Bool_t           IsTarget(ETargetType targetType)  {return (fTargetType == targetType);}
   ETargetType      GetTargetType() const             {return fTargetType;}
   Char_t           GetTargetTypeChar() const;
   const char*      GetTargetTypeName() const;
   void             SetTargetType(ETargetType type)   {fTargetType = type;}
   Bool_t           TargetOK(TObject *object);
   AliRsnDaughter*  GetTargetDaughter()               {return fDaughter;}
   AliRsnMother*    GetTargetMother()                 {return fMother;}
   AliRsnEvent*     GetTargetEvent()                  {return fEvent;}

   static AliRsnEvent*  GetCurrentEvent()                   {return fgCurrentEvent;}
   static void          SetCurrentEvent(AliRsnEvent *event) {fgCurrentEvent = event;}
   static void          SwitchToFirst()                     {fgCurrentEvent = AliRsnEvent::GetCurrentEvent1();}
   static void          SwitchToSecond()                    {fgCurrentEvent = AliRsnEvent::GetCurrentEvent2();}

protected:

   ETargetType         fTargetType;     //  target type selected for this object
   static AliRsnEvent *fgCurrentEvent;  //! pointer to current event (useful in many cases)

   AliRsnDaughter     *fDaughter;       //  utility pointer to target object (daughter)
   AliRsnMother       *fMother;         //  utility pointer to target object (mother)
   AliRsnEvent        *fEvent;          //  utility pointer to target object (event)

   static const Double_t fgkVeryBig;    //  utility value for very large value
   static const Double_t fgkVerySmall;  //  utility value for very small value

   // ROOT dictionary
   ClassDef(AliRsnTarget, 1)
};

typedef AliRsnTarget::ETargetType RSNTARGET;

#endif