class AliAnalysisMuMuCutElement: public TObject

 Default ctor, leading to an invalid cut object

   * Construct a cut, which is a proxy to another method of (most probably) another object
   *
   * \param expectedType the type of cut which is expected (this cut will be invalidated if
   * the actual method does not comply with this type)
   * \param cutObject the object which has the cut method
   * \param cutMethodName the name of the method of cutObject that should do the cut work
   * \param cutMethodPrototype the prototype (i.e. list of arguments) of cutMethod
   * \param defaultParameters values of the default parameters (if any) of the cutMethod
   *
   * See the \ref Init method for details.

 Dtor

 Call the cut method with one parameter

 Call the cut method with two parameters

 Count the number of times "search" is found in prototype

 Convert the enum into a string

 Return the cut method name

 Return the cut method prototype

 Build the non-persistent members (TMethodCalls)
    *
    * Each cut method XXXX must have
    * a companion method, called NameOfXXXX(TString& nameOfCut) which fills the nameOfCut
    * string with the name of cut (using the default parameter values if need be to distinguish
    * different cuts using the same method).
    * The cut method we're proxy-ing can not be of any kind. We basically only recognize the
    * following prototypes (more or less based on the Pass() method prototypes). The checks
    * performed below to ensure that are far from being bullet-proof though... You've been
    * warned !
    *
    * For event cutters (3 or them instead of just one because of the, imo,
    * improper event/eventhandler interfaces we currently have in AliRoot)
    *
    * Bool_t XXXX(const AliVEvent&, ...)
    * Bool_t XXXX(const AliVEventHandler&, ...)
    * Bool_t XXXX(const AliInputEventHandler&, ...)
    *
    * For track cutters :
    *
    * Bool_t XXXX(const AliVParticle&, ...)
    *
    * For track pairs cutters :
    *
    * Bool_t XXXX(const AliVParticle&, const AliVParticle&, ...)
    *
    * For trigger class cutters :
    *
    * Bool_t XXXX(const TString& firedTriggerClasses, TString& acceptedTriggerClasses)
    *
    * where ... stands for optional arguments (different from VEvent VParticle, etc...),
    * which can have default values
    *
    * Note that Root reflexion does not allow (yet?) to check for constness of the arguments,
    * so AliVEvent& and const AliVEvent& will be the same.
    *
    *

 Whether we're the same cut as obj

 Whether the event pass this cut

 Whether the eventHandler pass this cut

 Whether the particle pass this cut

 Whether the particle pair pass this cut

 Whether the firedTriggerClasses pass the cut.
   * \param firedTriggerClasses (input) list of fired trigger classes (separated by space)
   * \param acceptedTriggerClasses (output) list of accepted classes
   * \param L0 (input, optional) level 0 trigger mask
   * \param L1 (input, optional) level 1 trigger mask
   * \param L2 (input, optional) level 2 trigger mask

 Printout of the cut information

 not implemented on purpose