class PDecayManager: public TObject

  PDecayManager

  Author:   Volker Hejny
  Written:  Sep. 99
  Revised:  21.03.05 RH (writing parent indices to ascii file implemented)
  Revised:  10.12.04 RH (beam smearing/skewing implemented)
  Revised:  28.08.03 RH (random decays implemented)
  Revised:  04.07.03 RH (adjusted for multiple Root files: 1.9Gb limit!)
  Revised:  15.12.00 RH (adjustments for Pythia decay routines)
  Revised:  26.09.00 R. Holzmann (adjusted to gcc 2.95.2 20000220)
  Revised:  08.08.00 R. Holzmann (weight treatment fixed)
  Revised:  21.06.00 MK (adjustments for decay modes from PData)
  Revised:  14.04.00 R. Holzmann (minor adjustments for
                                  PFireball and HGeant operation)
  Revised:  27.07.07 IF: Changes for the new framework,
                         Removed beam smearing as covered by the Distr.Manager

  The purpose of PDecayManager is to produce a set of possible
  decay branches of a initial particle using a list of particle
  decay modes. The list of decay modes is empty by default. The
  user has to take care about the filling of this list. This can
  be done using the defaults supplied by this file (at end) or
  by hand.



  The following templates and the class PReactionList are
  private members of PDecayManager, but I due to problems using
  ClassImp() and ClassDef() with nested classes, they are not
  derived from TObject and not known inside ROOT. The members are
  all public for better use inside PDecayManager.

  template<class T> class PNextList
    It implements a linked list of pointers to object T. All elements
    of this templates are public. The destructor does not imply a
    delete of the object T itself. If this is wanted -> use member
    function Delete().

    T 	 *Curr;		// pointer to object T
    PNextList  *Next;		// pointer to next list node

    PNextList();		// standard constructor
    PNextList(T*);		// initalized with object T
    ~PNextList();		// standard destructor

    void Add(T*);		// add object T to list
    void Delete();            // delete the objects T in the list


  template<class T> class PStack
    It implements a last-in-first-out standard stack via a single linked
    list. Additionally the number of objects is counted. All elements
    are public.

    PNextList<T>	*top;	// pointer to top node
    Int_t		Count;	// number of elements in the stack

    PStack();			// standarad constructor
    ~PStack();		// the destructor deletes the nodes
				// starting at top node, but not the
				// objects T itself.

    void Push(T*);
    T *Pop();			// standard stack operators

    PStack<T> *Clone(PStack<T> *UseThis);
				// returns a pointer to a clone of the stack.
 				// either an existing, empty stack is used
				// (giving UseThis as an optional argument)
				// or a new stack is constructed internally.


  class PReactionList
    It implements two connected stacks of PChannel objects to organize
    the already processed decay channels and the work to do.
    'Processed' means that all possible decay channels of the daughter
    particles have been put on the ToDo stack.
    The variable ReactionWeight contains the overall weight of
    this specific channel. All elements of this class are public.

    PStack<PChannel> 	*Finished;	// channels already looked at
    PStack<PChannel> 	*ToDo;		// decays to be done
    Double_t		ReactionWeight;	// overall branching ratio
    Int_t		ID;		// serial number of this object
    static Int_t	maxID;		// maximum serial number

    PReactionList();
    ~PReactionList(); 		// again: deletes only the stacks,
					// not the objects in it.
    PReactionList *Clone(); 		// doubles the whole PReactionList
					// returning a pointer to the
					// new one.