dchain Namespace Reference


Classes

class  LabeledCandidate
struct  ParticleTraits
class  LabeledParticle
struct  NewMaker
struct  MakerTrait
struct  ResultTypeTrait
struct  ResultTypeTrait< TReturn(*)(const TArg &)>
class  MutableReferenceHolder
class  ReferenceCount
class  ReferenceHolder
class  ReferenceHolderBase
class  DCUnaryAdapter
struct  SelectAll
class  MuteWholeCandidateItr
class  MuteWholeItr
class  PartialCandidateItr
class  PartialItr
struct  SelectiveInserter
class  WholeCandidateItr
class  WholeItr
class  CandidateList
class  ChargedVisibleList
class  ChosenChargeList
class  ChosenConjugateList
class  CombinatoricList
class  CombinatoricLoop
class  ConjugateList
class  IndexedLabeledDecays
class  DecayList
class  FillListWithSelection
class  IndexedLabeledCandidates
class  IndexedLabeledParticles
class  LabeledCandidateList
class  LabeledParticleList
class  NeutralNCVisibleList
class  NeutralVisibleList
class  FillDecayList

Namespaces

namespace  candidateitr
namespace  children
namespace  conjugation

Functions

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

Variables

static const conjugation::Label kBaseLabel = conjugation::kHeads


Function Documentation

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

Definition at line 51 of file conjugation.h.

References dchain::conjugation::kNone.

Referenced by dchain::DecayList< DecayClass, CandidateClass >::bar(), dchain::CombinatoricList< CandidateClass >::bar(), dchain::ConjugateList< CandidateClass >::conjugate_partial_begin(), dchain::ConjugateList< CandidateClass >::conjugate_partial_end(), dchain::CombinatoricList< CandidateClass >::fill(), and dchain::ConjugateList< CandidateClass >::isConjugateOf().

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

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

Definition at line 319 of file MuteWholeCandidateItr.h.

Referenced by RootCnvSvc::declareObject(), RawDataCnvSvc::declareObject(), BesRndmGenSvc::handle(), TofBuilder::initialize(), MucBuilder::initialize(), MdcBuilder::initialize(), HltBuilder::initialize(), EmcBuilder::initialize(), std__set_HepMC__GenParticlep__dict::method_x13(), std__vector_longsint__dict::method_x16(), std__vector_double__dict::method_x23(), std__vector_HepMC__GenEventp__dict::method_x9(), PrintMcInfo::mkmap(), ers::IssueFactory::register_issue(), and MdcSegFinder::tryPatterns().

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

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

Definition at line 111 of file ChargedVisibleList.h.

Referenced by charge_sign(), and dchain::ChargedVisibleList< Charged, Charged::CandidateClass >::insert().

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

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

Definition at line 116 of file ChargedVisibleList.h.

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

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

Definition at line 121 of file ChargedVisibleList.h.

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

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

Definition at line 126 of file ChargedVisibleList.h.

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

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

Definition at line 131 of file ChargedVisibleList.h.

References charge_sign().

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

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

Definition at line 328 of file ChargedVisibleList.h.

References dchain::ChargedVisibleList< Charged, CandidateClass >::fill().

Referenced by dchain::FillListWithSelection< TList, TSelector >::operator=().

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

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

Definition at line 241 of file CombinatoricList.h.

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

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

Definition at line 250 of file CombinatoricList.h.

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

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

Definition at line 259 of file CombinatoricList.h.

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

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

Definition at line 268 of file CombinatoricList.h.

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

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

Definition at line 258 of file DecayList.h.

References dchain::DecayList< DecayClass, CandidateClass >::fill(), and dchain::ConjugateList< CandidateClass >::isSelfConjugate().

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 }

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

Definition at line 275 of file DecayList.h.

References dchain::DecayList< DecayClass, CandidateClass >::attempt_insert(), dchain::ConjugateList< CandidateClass >::isSelfConjugate(), dchain::NeutralVisibleList< Neutral, CandidateClass >::particle_begin(), and dchain::NeutralVisibleList< Neutral, CandidateClass >::particle_end().

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, class NeutralClass>
DecayList< DecayClass, CandidateClass > dchain::operator+ ( const NeutralVisibleList< NeutralClass > &  iList1,
const DecayList< DecayClass, CandidateClass > &  iList2 
) [inline]

Definition at line 298 of file DecayList.h.

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

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

Definition at line 45 of file FillListWithSelection.h.

00047                                            {
00048       oList.fill(iList, iSelector);
00049    }

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

Definition at line 52 of file NeutralNCVisibleList.h.

Referenced by dchain::NeutralNCVisibleList< NeutralNC, NeutralNC::CandidateClass >::insert(), and is_bar().

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

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

Definition at line 57 of file NeutralNCVisibleList.h.

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

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

Definition at line 62 of file NeutralNCVisibleList.h.

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

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

Definition at line 67 of file NeutralNCVisibleList.h.

References is_bar().

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

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

Definition at line 249 of file NeutralNCVisibleList.h.

References dchain::NeutralNCVisibleList< NeutralNC, CandidateClass >::fill().

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

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

Definition at line 261 of file NeutralVisibleList.h.

References dchain::NeutralVisibleList< Neutral, CandidateClass >::fill().

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


Variable Documentation

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

Definition at line 117 of file CombinatoricList.cc.

Referenced by dchain::CombinatoricList< CandidateClass >::determineConjugation(), and dchain::CombinatoricList< CandidateClass >::fill().


Generated on Tue Nov 29 23:36:25 2016 for BOSS_7.0.2 by  doxygen 1.4.7