Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

dchain Namespace Reference


Classes

class  dchain::CandidateList< CandidateClass >
class  dchain::ChargedVisibleList< Charged, CandidateClass >
class  dchain::ChosenChargeList< Charged, CandidateClass >
class  dchain::ChosenConjugateList< Conjugate, CandidateClass >
class  dchain::CombinatoricList< CandidateClass >
class  dchain::CombinatoricLoop< CandidateClass >
class  dchain::ConjugateList< CandidateClass >
class  dchain::DCUnaryAdapter< TFunc >
class  dchain::DecayList< DecayClass, CandidateClass >
class  dchain::FillDecayList< DecayClass, CandidateClass >
class  dchain::FillDecayList< DecayClass, CandidateClass >::ChildList
class  dchain::FillListWithSelection< TList, TSelector >
class  dchain::IndexedLabeledCandidates< CandidateClass >
class  dchain::IndexedLabeledDecays< DecayClass, CandidateClass >
class  dchain::IndexedLabeledParticles< T, CandidateClass >
class  dchain::LabeledCandidate< CandidateClass >
class  dchain::LabeledCandidateList< CandidateClass >
class  dchain::LabeledParticle< T >
class  dchain::LabeledParticleList< ParticleClass, CandidateClass >
struct  dchain::MakerTrait< T >
class  dchain::MutableReferenceHolder< T >
class  dchain::MuteWholeCandidateItr< CandidateClass >
class  dchain::MuteWholeItr< T >
class  dchain::NeutralNCVisibleList< NeutralNC, CandidateClass >
class  dchain::NeutralVisibleList< Neutral, CandidateClass >
struct  dchain::NewMaker< T >
class  dchain::PartialCandidateItr< CandidateClass >
class  dchain::PartialItr< T >
struct  dchain::ParticleTraits< T >
class  dchain::ReferenceCount
class  dchain::ReferenceHolder< T >
class  dchain::ReferenceHolderBase< TPtr, TRef >
struct  dchain::ResultTypeTrait< T >
struct  dchain::ResultTypeTrait< TReturn(*)(const TArg &)>
struct  dchain::SelectAll< T >
struct  dchain::SelectiveInserter< TList, TSelect >
class  dchain::WholeCandidateItr< CandidateClass >
class  dchain::WholeItr< T >

Functions

template<class TPtr, class TRef>
int charge_sign (const ReferenceHolderBase< TPtr, TRef > &iHolder)
template<class T>
int charge_sign (const std::auto_ptr< T > &iCharged)
template<class T>
int charge_sign (T *iCharged)
template<class T>
int charge_sign (const T *iCharged)
template<class T>
int charge_sign (const T &iCharged)
template<class TIList, class TSelector, class T, class U>
void fill_using_selector (const TIList &iList, const TSelector &iSel, NeutralVisibleList< T, U > &oList)
template<class TIList, class TSelector, class T, class U>
void fill_using_selector (const TIList &iList, const TSelector &iSel, NeutralNCVisibleList< T, U > &oList)
template<class TIList, class TSelector, class TOList>
void fill_using_selector (const TIList &iList, const TSelector &iSelector, TOList &oList)
template<class TIList, class TSelector, class T, class U>
void fill_using_selector (const TIList &iList, const TSelector &iSel, ChargedVisibleList< T, U > &oList)
template<class TPtr, class TRef>
int is_bar (const ReferenceHolderBase< TPtr, TRef > &iHolder)
template<class T>
int is_bar (T *iNeutralNC)
template<class T>
int is_bar (const T *iNeutralNC)
template<class T>
int is_bar (const T &iNeutralNC)
template<class CandidateClass>
CombinatoricList< CandidateClass > operator * (const CombinatoricList< CandidateClass > &lhs, const CombinatoricList< CandidateClass > &rhs)
template<class CandidateClass>
CombinatoricList< CandidateClass > operator * (const ConjugateList< CandidateClass > &lhs, const CombinatoricList< CandidateClass > &rhs)
template<class CandidateClass>
CombinatoricList< CandidateClass > operator * (const CombinatoricList< CandidateClass > &lhs, const ConjugateList< CandidateClass > &rhs)
template<class CandidateClass>
CombinatoricList< CandidateClass > operator * (const ConjugateList< CandidateClass > &lhs, const ConjugateList< CandidateClass > &rhs)
template<class DecayClass, class CandidateClass, class NeutralClass>
DecayList< DecayClass, CandidateClass > operator+ (const NeutralVisibleList< NeutralClass > &iList1, const DecayList< DecayClass, CandidateClass > &iList2)
template<class DecayClass, class CandidateClass, class NeutralClass>
DecayList< DecayClass, CandidateClass > operator+ (const DecayList< DecayClass, CandidateClass > &iList1, const NeutralVisibleList< NeutralClass > &iList2)
template<class DecayClass, class CandidateClass>
DecayList< DecayClass, CandidateClass > operator+ (const DecayList< DecayClass, CandidateClass > &iList1, const DecayList< DecayClass, CandidateClass > &iList2)
conjugation::Label otherLabel (const conjugation::Label &aLabel)
template<class CandidateClass>
LabeledCandidate< CandidateClass > * value_type (const MuteWholeCandidateItr< CandidateClass > &)

Variables

const conjugation::Label kBaseLabel = conjugation::kHeads

Function Documentation

template<class TPtr, class TRef>
int dchain::charge_sign (  const ReferenceHolderBase< TPtr, TRef > &  iHolder  ) 
  

00131                                                                   {
00132       return charge_sign(*iHolder);
00133    }

template<class T>
int dchain::charge_sign (  const std::auto_ptr< T > &  iCharged  ) 
  

00126                                                    {
00127       return static_cast<int>(iCharged->charge());
00128    }

template<class T>
int dchain::charge_sign (  T *  iCharged  ) 
  

00121                                 {
00122       return static_cast<int>(iCharged->charge());
00123    }

template<class T>
int dchain::charge_sign (  const T *  iCharged  ) 
  

00116                                       {
00117       return static_cast<int>(iCharged->charge());
00118    }

template<class T>
int dchain::charge_sign (  const T &  iCharged  ) 
  

00111                                       {
00112       return static_cast<int>(iCharged.charge());
00113    }

template<class TIList, class TSelector, class T, class U>
void dchain::fill_using_selector (  const TIList &  iList,
const TSelector &  iSel,
NeutralVisibleList< T, U > &  oList
) 
  

00263                                                             {
00264       oList.fill(iList.begin(), iList.end(),
00265                  typename MakerTrait<T>::maker_type(),
00266                  iSel);
00267    }

template<class TIList, class TSelector, class T, class U>
void dchain::fill_using_selector (  const TIList &  iList,
const TSelector &  iSel,
NeutralNCVisibleList< T, U > &  oList
) 
  

00251                                                               {
00252       oList.fill(iList.begin(), iList.end(),
00253                  typename MakerTrait<T>::maker_type(),
00254                  iSel);
00255    }

template<class TIList, class TSelector, class TOList>
void dchain::fill_using_selector (  const TIList &  iList,
const TSelector &  iSelector,
TOList &  oList
) 
  

00044                                            {
00045       oList.fill(iList, iSelector);
00046    }

template<class TIList, class TSelector, class T, class U>
void dchain::fill_using_selector (  const TIList &  iList,
const TSelector &  iSel,
ChargedVisibleList< T, U > &  oList
) 
  

00330                                                             {
00331       oList.fill(iList.begin(), iList.end(),
00332                  typename MakerTrait<T>::maker_type(),
00333                  iSel);
00334    }

template<class TPtr, class TRef>
int dchain::is_bar (  const ReferenceHolderBase< TPtr, TRef > &  iHolder  ) 
  

00067                                                              {
00068       return is_bar(*iHolder);
00069    }

template<class T>
int dchain::is_bar (  T *  iNeutralNC  ) 
  

00062                              {
00063       return static_cast<int>(iNeutralNC->isBar());
00064    }

template<class T>
int dchain::is_bar (  const T *  iNeutralNC  ) 
  

00057                                    {
00058       return static_cast<int>(iNeutralNC->isBar());
00059    }

template<class T>
int dchain::is_bar (  const T &  iNeutralNC  ) 
  

00052                                    {
00053       return static_cast<int>(iNeutralNC.isBar());
00054    }

template<class CandidateClass>
CombinatoricList< CandidateClass > dchain::operator * (  const CombinatoricList< CandidateClass > &  lhs,
const CombinatoricList< CandidateClass > &  rhs
)  [inline]
  

00270 {
00271    return CombinatoricList<CandidateClass>( lhs, rhs);
00272 }

template<class CandidateClass>
CombinatoricList< CandidateClass > dchain::operator * (  const ConjugateList< CandidateClass > &  lhs,
const CombinatoricList< CandidateClass > &  rhs
)  [inline]
  

00261 {
00262    return CombinatoricList<CandidateClass>( lhs, rhs);
00263 }

template<class CandidateClass>
CombinatoricList< CandidateClass > dchain::operator * (  const CombinatoricList< CandidateClass > &  lhs,
const ConjugateList< CandidateClass > &  rhs
)  [inline]
  

00252 {
00253    return CombinatoricList<CandidateClass>( lhs, rhs); 
00254 }

template<class CandidateClass>
CombinatoricList< CandidateClass > dchain::operator * (  const ConjugateList< CandidateClass > &  lhs,
const ConjugateList< CandidateClass > &  rhs
)  [inline]
  

00243 {
00244    return CombinatoricList<CandidateClass>( lhs, rhs); 
00245 }

template<class DecayClass, class CandidateClass, class NeutralClass>
DecayList< DecayClass, CandidateClass > dchain::operator+ (  const NeutralVisibleList< NeutralClass > &  iList1,
const DecayList< DecayClass, CandidateClass > &  iList2
)  [inline]
  

00301 {
00302      DecayList< DecayClass, CandidateClass> returnValue;
00303      returnValue = iList2 + iList1;
00304      return returnValue;
00305 }

template<class DecayClass, class CandidateClass, class NeutralClass>
DecayList< DecayClass, CandidateClass > dchain::operator+ (  const DecayList< DecayClass, CandidateClass > &  iList1,
const NeutralVisibleList< NeutralClass > &  iList2
)  [inline]
  

00278 {
00279    bool can_only_add_lists_with_same_conjugation =
00280       iList1.isSelfConjugate()== iList2.isSelfConjugate();
00281    assert(can_only_add_lists_with_same_conjugation);
00282 
00283    
00284    DecayList< DecayClass, CandidateClass> returnValue =iList1 ;
00285    typename LabeledParticleList< NeutralClass , CandidateClass >::const_iterator finished( iList2.particle_end() ) ;
00286    for( typename LabeledParticleList< NeutralClass , CandidateClass >::const_iterator entry(iList2.particle_begin()) ;
00287         entry != finished ;
00288         ++entry ){
00289      NeutralClass* localCopy = new NeutralClass( (*entry).particle() ) ;
00290      returnValue.attempt_insert( localCopy, (*entry).label(),SelectAll<DecayClass>() ) ;
00291    }
00292    return returnValue;
00293 }

template<class DecayClass, class CandidateClass>
DecayList< DecayClass, CandidateClass > dchain::operator+ (  const DecayList< DecayClass, CandidateClass > &  iList1,
const DecayList< DecayClass, CandidateClass > &  iList2
)  [inline]
  

00261 {
00262    bool can_only_add_lists_with_same_conjugation =
00263       iList1.isSelfConjugate()== iList2.isSelfConjugate();
00264    assert(can_only_add_lists_with_same_conjugation);
00265 
00266    DecayList< DecayClass, CandidateClass> returnValue( iList1 );
00267    if( &iList1 != &iList2 ) {
00268       returnValue.fill( iList2, SelectAll<DecayClass>() );
00269    }
00270    return returnValue;
00271 }

conjugation::Label dchain::otherLabel (  const conjugation::Label &  aLabel  )  [inline]
  

00052       {
00053          return ( conjugation::Label( conjugation::kNone - aLabel ) ) ;
00054       }

template<class CandidateClass>
LabeledCandidate< CandidateClass > * dchain::value_type (  const MuteWholeCandidateItr< CandidateClass > &   )  [inline]
  

00320 {
00321    return ( (CandidateClass*)0 ) ;
00322 }

Variable Documentation

const conjugation::Label dchain::kBaseLabel = conjugation::kHeads [static]
 

Generated on Wed Feb 2 19:16:26 2011 for BOSS6.5.5 by  doxygen 1.3.9.1