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.2 2009/09/22 08:22:26 hujf Exp $
//
// Revision history
//
// $Log: CombinatoricList.cc,v $
// Revision 1.2  2009/09/22 08:22:26  hujf
// see ChangeLog
//
// 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 ;
}
//*******************************************************************************
    template <class CandidateClass>
CombinatoricList< CandidateClass >& CombinatoricList< CandidateClass >::operator=( const CombinatoricList< CandidateClass >& another)/*: m_listFilled(another.m_listFilled), m_conjugationKnown(another.m_conjugationKnown), m_listOfLists(another.m_listOfLists)*/
{
    if( this != &another) 
    {
        //        std::cout<<"operator="<<std::endl;
        //        //        std::cout<<"lv#"<<(this)<<", A#"<<(&m_listOfLists)<<std::endl;
        //        //        std::cout<<"rv#"<<(&another)<<", A#"<<&(another.m_listOfLists)<<std::endl;
        m_listOfLists.erase(m_listOfLists.begin(), m_listOfLists.end());
        m_listOfLists.insert(m_listOfLists.end(),
                another.m_listOfLists.begin(),
                another.m_listOfLists.end());
        //m_listOfLists =  another.m_listOfLists ;
        m_listFilled = another.m_listFilled;
        m_conjugationKnown = another.m_conjugationKnown;
    }
    return *this;
}
 
//********************************************************************************
//
// 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 */