/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Event/DecayChain/DecayChain-00-00-03-slc6tag/DecayChain/List/Template/CombinatoricList.cc

Go to the documentation of this file.

#ifndef DCHAIN_COMBINATORICLIST_CC
#define DCHAIN_COMBINATORICLIST_CC
// -*- C++ -*-
//
// Package:     DChain
// Module:      CombinatoricList
// 
// Description: container used to build Decay subclass objects
//
// Implimentation:
//     <Notes on implimentation>
//
// Author:      Simon Patton
// Created:     Sat Oct  5 17:18:02 EDT 1996
// $Id: CombinatoricList.cc,v 1.1.1.1 2009/03/03 06:06:56 maqm Exp $
//
// Revision history
//
// $Log: CombinatoricList.cc,v $
// Revision 1.1.1.1  2009/03/03 06:06:56  maqm
// first import of DecayChain
//
// Revision 1.1  2006/01/11 20:28:35  cdj
// massive class renaming, addition of [] for selection and unit tests
//
// Revision 1.10  2003/05/15 19:56:12  cdj
// revamped memory handling so always use a ReferenceHolder to deal with the reference counting
//
// Revision 1.9  2003/03/13 20:19:16  cleo3
// now compiles under Linux
//
// Revision 1.8  2002/06/21 14:20:51  cdj
// previous changes now compile under OSF1
//
// Revision 1.7  2002/06/19 20:37:10  cleo3
// added missing typename and create a copy constructor
//
// Revision 1.6  2002/06/18 20:52:04  cdj
// fixed bug that occurred when mulitplying 3 or more of the same list and conjugation where one of the list was the first list of the combination
//
// Revision 1.5  2001/04/20 14:02:09  ajm36
// plug memory leak associated with makeDecay
//
// Revision 1.4  2001/04/10 13:56:48  urner
// bug fixes
//
// Revision 1.3  2001/03/30 19:41:12  cdj
// improved memory usage when doing combinatorics
//
// Revision 1.2  2001/03/29 21:33:38  cdj
// initial try at bug fix for selfCongugateList*nonSelfCongugateList
//
// Revision 1.1.1.1  2000/12/18 22:16:55  cdj
// imported DChain
//
// Revision 1.13  1998/08/21 00:51:54  sjp
// Modifier to no longer use typedefs
//
// Revision 1.12  1998/08/20 20:00:09  sjp
// Modified to use DChainBoolean
//
// Revision 1.11  1998/08/19 20:46:21  sjp
// Fixed comments and removed report references
//
// Revision 1.10  1998/04/17 19:14:49  sjp
// Modified to use latest type
//
// Revision 1.9  1997/09/03 14:58:22  sjp
// Use new report.h and TBParticlePoint
//
// Revision 1.8  1997/08/28 07:00:35  sjp
// Modified files to handle complete templating
//
// Revision 1.7  1997/08/19 23:03:14  sjp
// Restructured package to be independent of Rock
//
// Revision 1.6  1997/08/19 16:19:03  sjp
// Improved handling of STL containers
//
// Revision 1.5  1997/08/15 21:33:35  sjp
// Updated to use <package>/<file>.h include structure.
// Updated to use bug flags specified in Experiement.h
//
// Revision 1.4  1997/01/31 20:16:24  sjp
// Modified to use the new `bug' include files
//
// Revision 1.3  1997/01/21 20:31:34  sjp
// Changed CPP flags and include because of library reorganization
//
// Revision 1.2  1996/12/20 21:14:01  sjp
// Changed aPossible to Possible and added dropLink where nec.
//
// Revision 1.1  1996/11/04 17:17:12  sjp
// New file for new `List' module
//

// system include files
#include <stdlib.h>  // For 'exit'

// user include files
#include "DecayChain/Element/conjugation.h"
#include "DecayChain/Element/LabeledParticle.h"
#include "DecayChain/Iterator/MuteWholeCandidateItr.h"
#include "DecayChain/Iterator/WholeCandidateItr.h"
#include "DecayChain/Iterator/PartialCandidateItr.h"
#include "DecayChain/Iterator/MuteWholeItr.h"
#include "DecayChain/Iterator/WholeItr.h"
#include "DecayChain/Iterator/PartialItr.h"
#include "DecayChain/List/CombinatoricLoop.h"

#include "DecayChain/List/CombinatoricList.h"

//
// constants, enums and typedefs
//
namespace dchain {
static const conjugation::Label kBaseLabel = conjugation::kHeads ;

//
// local functions
//

// The follwing function is local rather than a member of CombinatoricList
//   as that would require the file <vector> to be included in
//   CombinatoricList.h, and thus in many other parts of the code.  That
//   inclusion can sieverly slow down compliation and also cause many
//   local copies of the code to be generated.  It is best to avoid this.
//
// Now, you may ask why make this a static function in a class.  The simple
//   answer is it works!  I tried this as a simple, normal static
//   (i.e. file-scope) function and my compilers barfed.  Why do it work
//   in a class? I don't know, but it does so lets just get one with it!

template < class DecayClass, class CandidateClass >
class FillDecayList {
public:
   class ChildList  {
      public:

         ChildList() {
            m_list.reserve(4);
         }

         ChildList(const DecayClass* decay) {
            //fill the m_list with decay
            uint32_t n = decay->numberChildren();
            for ( uint32_t i = 0; i < n; i++) m_list.push_back(&(decay->child(i)));
         }

         void push_back( const CandidateClass* iCandidate ) {
            m_list.push_back( iCandidate );
         }
         void pop_back() {
            m_list.pop_back();
         }
         void eraseAll() {
            m_list.erase(m_list.begin(), m_list.end());
         }

         bool overlap( const CandidateClass& iCandidate ) const {
            for( typename std::vector<const CandidateClass*>::const_iterator itChild =
                  m_list.begin();
                  itChild != m_list.end();
                  ++itChild ) {
               if( iCandidate.overlap( *(*itChild) ) ) {
                  return true;
               }
            }
            return false;
         }

         DecayClass* makeDecay() {
            DecayClass* returnValue = new DecayClass( *(m_list.front()) );
            for( typename std::vector<const CandidateClass*>::iterator itChild = m_list.begin()+1;
                  itChild != m_list.end();
                  ++itChild ) {
               returnValue->addChild( *(*itChild) );
            }
            return returnValue;
         }
      private:
         std::vector<const CandidateClass*> m_list;
   };

   static void fill( CombinatoricLoop<CandidateClass >& iLoop,
         const typename _combinatoricloop_vector_::iterator& aBegin ,
         const typename _combinatoricloop_vector_::iterator& aEnd ,
         const conjugation::Label aLabel ,
         dchain::LabeledParticleList< DecayClass , CandidateClass >& aDecayList )
   {
      ChildList childList;

      typename dchain::CandidateList<CandidateClass >::const_partial_iterator itEnd = iLoop.partial_end();
      for( typename dchain::CandidateList<CandidateClass >::const_partial_iterator entry = iLoop.partial_begin();
            entry != itEnd;
            ++entry ) {

         iLoop.setCurrentIterator( entry ) ;

         childList.push_back( & (*entry).labeledClass() );

         //
         // Note: need to cast way `const' to make sure a non-const LabeledParticleList
         //         is returned 
         //
         doIt( aBegin,
               aEnd,
               childList ,
               aLabel,
               aDecayList );
         childList.eraseAll();
      }
   }

   static void doIt( const typename _combinatoricloop_vector_::iterator& aBegin ,
         const typename _combinatoricloop_vector_::iterator& aEnd ,
         ChildList& iList ,
         const conjugation::Label aLabel ,
         dchain::LabeledParticleList< DecayClass, CandidateClass >& aDecayList )
   {
      if ( aBegin == aEnd ) {
         //
         // if all ConjuagetLists have been used add Decay to the final list
         //
         DecayClass* ptr = iList.makeDecay();
         ReferenceHolder<DecayClass> pHolder(ptr);
         aDecayList.push_back(dchain::LabeledParticle< DecayClass >( 
                  ptr,
                  aLabel ) ) ;
      }
      else {
         //
         // make iterator for next ConjugateList loop
         //
         const typename _combinatoricloop_vector_::iterator newBegin( aBegin + 1 ) ;
         //
         // loop over each entry in the current ConjugateList
         //
         typename dchain::CandidateList< CandidateClass >::const_partial_iterator finished( (*(*aBegin)).partial_end() ) ;
         for ( typename dchain::CandidateList< CandidateClass >::const_partial_iterator entry( (*(*aBegin)).partial_begin() ) ;
               entry != finished ;
               ++entry ) {
            if ( !( iList.overlap( (*entry)() ) ) ) {
               //
               // If baseDecay does not overlap current element in the this ConjugateList,
               //   record the current element of this Loop
               //
               (*(*aBegin)).setCurrentIterator( entry ) ;
               //
               // build new baseDecay with old baseDecay plus the current element
               //
               iList.push_back( & (*entry).labeledClass() );
               //
               // do all successive ConjugateList loops
               //
               doIt( newBegin ,
                     aEnd ,
                     iList ,
                     aLabel ,
                     aDecayList ) ;

               iList.pop_back();

            }
         }
      }
   }
} ;

//
// static data member definitions
//

//
// constructors and destructor
//

//the copy constructor is only used for the return value of operator* so
// we can make things faster by swapping the data stored in the vector
template < class CandidateClass >
CombinatoricList< CandidateClass >::CombinatoricList( const CombinatoricList<CandidateClass >& iRHS) :
   m_listOfLists( *(new _combinatoriclist_vector_() ) ),
   m_listFilled( iRHS.m_listFilled ) ,
   m_conjugationKnown( iRHS.m_conjugationKnown )
{
   m_listOfLists.swap(const_cast<CombinatoricList<CandidateClass>&>(iRHS).m_listOfLists);
}

template < class CandidateClass >
CombinatoricList< CandidateClass >::CombinatoricList( const ConjugateList< CandidateClass >& aList ) :
   m_listOfLists( *(new _combinatoriclist_vector_( 1 ,
                                                   &aList ) ) ) ,
   m_listFilled( false ) ,
   m_conjugationKnown( false )
{
}

template < class CandidateClass >
CombinatoricList< CandidateClass >::CombinatoricList( const ConjugateList< CandidateClass >& lhs ,
                                    const ConjugateList< CandidateClass >& rhs ) :
   m_listOfLists( *(new _combinatoriclist_vector_( 1 ,
                                                   &lhs ) ) ) ,
   m_listFilled( false ) ,
   m_conjugationKnown( false )
{
   //std::cout << "@CombinatoricList::CombinatoricList() 11" << std::endl;
   //typedef typename ConjugateList< CandidateClass >::const_partial_iterator test_it;
   //std::cout << "lhs ...................... : " << std::endl;
   //for ( test_it it = lhs.partial_begin(); it != lhs.partial_end(); it++ ) {
   //   std::cout << (*it)().footPrint() << std::endl;
   //}
   //std::cout << "rhs ...................... : " << std::endl;
   //for ( test_it it = rhs.partial_begin(); it != rhs.partial_end(); it++ ) {
   //   std::cout << (*it)().footPrint() << std::endl;
   //}
   m_listOfLists.push_back( &rhs ) ;
}

template < class CandidateClass >
CombinatoricList< CandidateClass >::CombinatoricList( const CombinatoricList< CandidateClass >& lhs ,
                                    const ConjugateList< CandidateClass >& rhs ) :
   m_listOfLists( *(new _combinatoriclist_vector_( lhs.m_listOfLists ) ) ) ,
   m_listFilled( false ) ,
   m_conjugationKnown( false )
{
   m_listOfLists.push_back( &rhs ) ;
}

template < class CandidateClass >
CombinatoricList< CandidateClass >::CombinatoricList( const ConjugateList< CandidateClass >& lhs ,
                                    const CombinatoricList< CandidateClass >& rhs ) :
   m_listOfLists( *(new _combinatoriclist_vector_( 1 ,
                                                   &lhs ) ) ) ,
   m_listFilled( false ) ,
   m_conjugationKnown( false )
{
   m_listOfLists.insert( m_listOfLists.end() ,
                         (rhs.m_listOfLists).begin() ,
                         (rhs.m_listOfLists).end() ) ;
}

template < class CandidateClass >
CombinatoricList< CandidateClass >::CombinatoricList( const CombinatoricList< CandidateClass >& lhs ,
                                    const CombinatoricList< CandidateClass >& rhs ) :
   m_listOfLists( *(new _combinatoriclist_vector_( lhs.m_listOfLists ) ) ) ,
   m_listFilled( false ) ,
   m_conjugationKnown( false )
{
   m_listOfLists.insert( m_listOfLists.end() ,
                         (rhs.m_listOfLists).begin() ,
                         (rhs.m_listOfLists).end() ) ;
}

template < class CandidateClass >
CombinatoricList< CandidateClass >::~CombinatoricList()
{
   delete &m_listOfLists ;
}

//
// assignment operators
//
// const CombinatoricList< CandidateClass >& CombinatoricList< CandidateClass >::operator=( const CombinatoricList< CandidateClass >& )
// {
// }

//
// member functions
//

template < class CandidateClass >
typename dchain::CandidateList< CandidateClass >::iterator CombinatoricList< CandidateClass >::begin()
{
   fill() ;
   return ( dchain::DecayList< DecayClass , CandidateClass >::begin() ) ;
}

template < class CandidateClass >
typename dchain::CandidateList< CandidateClass >::iterator CombinatoricList< CandidateClass >::end()
{
   fill() ;
   return ( dchain::DecayList< DecayClass , CandidateClass >::end() ) ;
}

template < class CandidateClass >
typename dchain::DecayList< typename DCCandidateTraits<CandidateClass>::DecayClass , CandidateClass >::iterator CombinatoricList< CandidateClass >::particle_begin()
{
   //std::cout << "@CombinatoricList::particle_begin() -- iterator" << std::endl;
   fill() ;
   return ( dchain::DecayList< DecayClass , CandidateClass >::particle_begin() ) ;
}

template < class CandidateClass >
typename dchain::DecayList< typename DCCandidateTraits<CandidateClass>::DecayClass , CandidateClass >::iterator CombinatoricList< CandidateClass >::particle_end() {
   //std::cout << "@CombinatoricList::particle_end() -- iterator" << std::endl;
   fill() ;
   return ( dchain::DecayList< DecayClass , CandidateClass >::particle_end() ) ;
}

template < class CandidateClass >
dchain::LabeledCandidateList< CandidateClass >& CombinatoricList< CandidateClass >::labeledCandidateList()
{
   fill() ;
   return ( dchain::DecayList< DecayClass , CandidateClass >::labeledCandidateList() ) ;
}

//
// const member functions
//

template < class CandidateClass >
const dchain::DecayList< typename CombinatoricList<CandidateClass>::DecayClass , CandidateClass >
CombinatoricList< CandidateClass >::bar() const
{
   fill() ;
// Need to cast away 'const' to get the right type of LabelList returned
   return ( dchain::DecayList< DecayClass , CandidateClass >(
      (*(CombinatoricList< CandidateClass >*)this).labeledParticleList() ,
      otherLabel( label() ) ) ) ;
}

template < class CandidateClass >
const dchain::DecayList< typename CombinatoricList<CandidateClass>::DecayClass , CandidateClass >& 
CombinatoricList< CandidateClass >::operator()() const
{
   fill() ;
// // Need to cast away 'const' to get the right type of LabelList returned
//    return ( dchain::DecayList< DecayClass , CandidateClass >( (*(CombinatoricList< CandidateClass >*)this).labeledDecayList() ,
//                                 label() ) ) ;
   return ( *this ) ;
}

template < class CandidateClass >
bool 
CombinatoricList< CandidateClass >::isSelfConjugate() const
{
   determineConjugation() ;
   return ( dchain::DecayList< DecayClass , CandidateClass >::isSelfConjugate() ) ;
}

template < class CandidateClass >
typename dchain::CandidateList< CandidateClass >::const_iterator CombinatoricList< CandidateClass >::begin() const
{
   fill() ;
   return ( dchain::DecayList< DecayClass , CandidateClass >::begin() ) ;
}

template < class CandidateClass >
typename dchain::CandidateList< CandidateClass >::const_iterator CombinatoricList< CandidateClass >::end() const
{
   fill() ;
   return ( dchain::DecayList< DecayClass , CandidateClass >::end() ) ;
}

template < class CandidateClass >
typename dchain::CandidateList< CandidateClass >::const_partial_iterator CombinatoricList< CandidateClass >::partial_begin() const
{
   fill() ;
   return ( dchain::DecayList< DecayClass , CandidateClass >::partial_begin() ) ;
}

template < class CandidateClass >
typename dchain::CandidateList< CandidateClass >::const_partial_iterator CombinatoricList< CandidateClass >::partial_end() const
{
   fill() ;
   return ( dchain::DecayList< DecayClass , CandidateClass >::partial_end() ) ;
}

template < class CandidateClass >
typename dchain::DecayList< typename DCCandidateTraits<CandidateClass>::DecayClass , CandidateClass >::const_iterator 
CombinatoricList< CandidateClass >::particle_begin() const
{
   //std::cout << "@CombinatoricList::particle_begin() -- iterator" << std::endl;
   fill() ;
   return ( dchain::DecayList< DecayClass , CandidateClass >::particle_begin() ) ;
}

template < class CandidateClass >
typename dchain::DecayList< typename DCCandidateTraits<CandidateClass>::DecayClass , CandidateClass >::const_iterator 
CombinatoricList< CandidateClass >::particle_end() const
{
   //std::cout << "@CombinatoricList::particle_end() -- const_iterator" << std::endl;
   fill() ;
   return ( dchain::DecayList< DecayClass , CandidateClass >::particle_end() ) ;
}

template < class CandidateClass >
typename dchain::DecayList< typename DCCandidateTraits<CandidateClass>::DecayClass , CandidateClass >::const_partial_iterator 
CombinatoricList< CandidateClass >::partial_particle_begin() const
{
   fill() ;
   return ( dchain::DecayList< DecayClass , CandidateClass >::partial_particle_begin() ) ;
}

template < class CandidateClass >
typename dchain::DecayList< typename DCCandidateTraits<CandidateClass>::DecayClass , CandidateClass >::const_partial_iterator 
CombinatoricList< CandidateClass >::partial_particle_end() const
{
   fill() ;
   return ( dchain::DecayList< DecayClass , CandidateClass >::partial_particle_end() ) ;
}


template < class CandidateClass >
conjugation::Label CombinatoricList< CandidateClass >::label() const
{
   determineConjugation() ;
   return ( dchain::DecayList< DecayClass , CandidateClass >::label() ) ;
}

template < class CandidateClass >
const dchain::LabeledCandidateList< CandidateClass >& CombinatoricList< CandidateClass >::labeledCandidateList() const
{
   fill() ;
   return ( dchain::DecayList< DecayClass , CandidateClass >::labeledCandidateList() ) ;
}

template < class CandidateClass >
void CombinatoricList< CandidateClass >::determineConjugation() const
{
   if ( m_conjugationKnown ) {
      return ;
   }
   _combinatoriclist_vector_ unConjugatedLists ;
   typename _combinatoriclist_vector_::const_iterator finishedTesting ( m_listOfLists.end() ) ;
   for ( typename _combinatoriclist_vector_::const_iterator list( m_listOfLists.begin() ) ;
         list != finishedTesting ;
         ++list ) {
      if ( ! (*(*list)).isSelfConjugate() ) {
         bool noMatchFound( !false ) ;
         typename _combinatoriclist_vector_::iterator matchToCheck( unConjugatedLists.begin() ) ;
         typename _combinatoriclist_vector_::iterator finishedMatching ( unConjugatedLists.end() ) ;
         while ( noMatchFound &&
                 ( matchToCheck != finishedMatching ) ) {
            if ( (*(*list)).isConjugateOf( (*(*matchToCheck)) ) ) {
               unConjugatedLists.erase( matchToCheck ) ;
               noMatchFound = false ;
            }
            ++matchToCheck ;
         }
         if ( noMatchFound ) {
            unConjugatedLists.push_back( *list ) ;
         }
      }
   }
   if ( 0 == unConjugatedLists.size() ) {
// have to cast away 'const' to set the real value of the label
      (*(CombinatoricList< CandidateClass >*)this).setLabel( conjugation::kNone ) ;
   }
   else {
// have to cast away 'const' to set the real value of the label
      (*(CombinatoricList< CandidateClass >*)this).setLabel( kBaseLabel ) ;
   }
// have to cast away 'const' to set the real value of the flag
   (*(CombinatoricList< CandidateClass >*)this).m_conjugationKnown = !false ;
}

template < class CandidateClass >
void CombinatoricList< CandidateClass >::fill() const
{
   //std::cout << "@CombinatoricList::fill(), filled = " << m_listFilled << std::endl;
   if ( m_listFilled ) {
      return ;
   }
//
// Create CombinatoricLoop lists for `primary' half of the list.
// If list is not self-conjugate, fill CombinatoricLoop lists for `conjugate'
//   half of the list as well.
//
   const short kPrimary = 0 ;
   const short kConjugate = 1 ;
   const short kEndLoopType = 2 ;
   _combinatoricloop_vector_ loopList[ 2 ] ;
   typename _combinatoricloop_vector_::iterator initialLoop[ 2 ] ;
   typename _combinatoricloop_vector_::iterator secondLoop[ 2 ] ;
   typename _combinatoricloop_vector_::iterator endLoop[ 2 ] ;
   for ( short loopType( kPrimary ) ;
         loopType != kEndLoopType ;
         ++loopType ) {
      if ( ( kConjugate != loopType ) ||
           ( ! isSelfConjugate() ) ) {
         loopList[ loopType ].reserve( m_listOfLists.size() ) ;
         typename _combinatoriclist_vector_::const_iterator finishedBuilding( m_listOfLists.end() ) ;
         for ( typename _combinatoriclist_vector_::const_iterator listForLoop( m_listOfLists.begin() ) ;
               listForLoop != finishedBuilding ;
               ++listForLoop ) {
            CombinatoricLoop< CandidateClass >* newLoop ;
            if ( kPrimary == loopType ) {
               newLoop = new CombinatoricLoop< CandidateClass >( (*(*listForLoop)).partial_begin() ,
                                                             (*(*listForLoop)).partial_end() ,
                                                             loopList[ loopType ] ) ;
            }
            else {
               newLoop = new CombinatoricLoop< CandidateClass >( (*(*listForLoop)).conjugate_partial_begin() ,
                                                             (*(*listForLoop)).conjugate_partial_end() ,
                                                             loopList[ loopType ] ) ;
            }
            loopList[ loopType ].push_back( newLoop ) ;
         }
         initialLoop[ loopType ] = loopList[ loopType ].begin() ;
         secondLoop[ loopType ] = initialLoop[ loopType ] + 1 ;
         endLoop[ loopType ] = loopList[ loopType ].end() ;
      }
   }
//
// do loop through initial ConjugateList
//
   conjugation::Label conjugationLabel = kBaseLabel;
   if( isSelfConjugate() ) {
      conjugationLabel = conjugation::kNone;
   } 
      
   FillDecayList< DecayClass , CandidateClass >::fill(
      *(*initialLoop[ kPrimary ]),
      secondLoop[ kPrimary ] ,
      endLoop[ kPrimary ] ,
      conjugationLabel,
      const_cast<CombinatoricList< CandidateClass >*>(this)->labeledParticleList() );

   if( !isSelfConjugate() ) {
      FillDecayList< DecayClass , CandidateClass >::fill(
         *(*initialLoop[ kConjugate ]),
         secondLoop[ kConjugate ] ,
         endLoop[ kConjugate ] ,
         otherLabel(conjugationLabel),
         const_cast<CombinatoricList< CandidateClass >*>(this)->labeledParticleList() );
   }
   /*
#if defined(THIS_IS_NEVER_TRUE)
   conjugation::Label entryLabel[ 2 ] ;
   if ( ! isSelfConjugate() ) {
      entryLabel[ 0 ] = kBaseLabel ;
      entryLabel[ 1 ] = otherLabel( kBaseLabel ) ;
   }
   else {
      entryLabel[ 0 ] = conjugation::kNone ;
   }
   const ConjugateList< CandidateClass >& initialList( (*(*(m_listOfLists.begin()))) ) ;
   typename dchain::CandidateList< CandidateClass >::const_partial_iterator initialListEntry[ 2 ] ;
   initialListEntry[ kPrimary ] = initialList.partial_begin() ;
   if ( ! isSelfConjugate() ) {
      initialListEntry[ kConjugate ] = initialList.conjugate_partial_begin() ;
   }
   typename dchain::CandidateList< CandidateClass >::const_iterator finished( initialList.end() ) ;
   for ( typename dchain::CandidateList< CandidateClass >::const_iterator entry( initialList.begin() ) ;
         entry != finished ;
         ++entry ) {
//
// if entry is in `primary' half of list build all decays for this
//   entry, otherwise, if list is not self-conjugate build all decays
//   for this `conjugate' entry
//
      short entryType( kConjugate ) ;
      if ( &(*entry) == &(*initialListEntry[ kPrimary ]) ) {
         entryType = kPrimary ;
      }
      if ( ( kConjugate != entryType ) ||
           ( ! isSelfConjugate() ) ) {
         (*(*initialLoop[ entryType ])).setCurrentIterator( initialListEntry[ entryType ] ) ;
         ReferenceHolder<DecayClass> initialDecay( new DecayClass( (*initialListEntry[ entryType ]).labeledClass() ) );
//
// Note: need to cast way `const' to make sure a non-const LabeledParticleList
//         is returned 
//
         typename FillDecayList<DecayClass, CandidateClass>::ChildList childList(initialDecay.pointer());

         FillDecayList< DecayClass , CandidateClass >::
            doIt( secondLoop[ entryType ] ,
                  endLoop[ entryType ] ,
                  childList,
                  entryLabel[ entryType ] ,
                  (*(CombinatoricList< CandidateClass >*)this).labeledParticleList()
                  //this->labeledParticleList()
                  ) ;
         ++initialListEntry[ entryType ] ;
      }
   }
#endif
   */
//
// delete contents of CombinatoricLoop lists.
//
   for ( short halfType( kPrimary ) ;
         halfType != kEndLoopType ;
         ++halfType ) {
      if ( ( kConjugate != halfType ) ||
           ( ! isSelfConjugate() ) ) {
         typename _combinatoricloop_vector_::iterator finishedDeletion( loopList[ halfType ].end() ) ;
         for ( typename _combinatoricloop_vector_::iterator loopInList( loopList[ halfType ].begin() ) ;
               loopInList != finishedDeletion ;
               ++loopInList ) {
            delete *loopInList ;
         }
      }
   }
   m_listFilled = !false ;
}

//
// static member functions
//
}
#endif /* DCHAIN_COMBINATORICLIST_CC */

---