CDCandidate.cxx

Go to the documentation of this file.

//
//  File:   CDCandidate.cc
//  Author:     Simon Patton
//  Package:    Taxi - a prototype set of objects for Physics analysis
//  Contents:   Definitions of the members of `CDCandidate' class.
//
//  Class Description: See CDCandidate.h.
//
// $Id: CDCandidate.cxx,v 1.4 2011/10/27 06:15:12 zoujh Exp $
//
 
#include <iostream>
#include <stdlib.h> // For 'exit'
 
#include "DecayChain/Element/ReferenceHolder.h"
#include "EvtRecEvent/EvtRecEtaToGG.h"
#include "EvtRecEvent/EvtRecPi0.h"
#include "EvtRecEvent/EvtRecTrack.h"
#include "EvtRecEvent/EvtRecVeeVertex.h"
 
#include "BesDChain/CDCandidate.h"
#include "BesDChain/CDDecay.h"
#include "BesDChain/util/KinematicData.h"
 
using namespace dchain;
 
using DecayChain::KinematicData;
 
#ifdef EXTEND
// for recover 4p after kinematic fit
void CDCandidate::recover() const { kinematicData()->recover(); }
#endif
//------ Constructor -----
// copy constructor
//
CDCandidate::CDCandidate( const CDCandidate& aOtherCDCandidate )
    : ReferenceCount(), m_kinematicDataPtr( 0 ), m_footPrint( aOtherCDCandidate.footPrint() ) {
  if ( 0 != aOtherCDCandidate.m_kinematicDataPtr )
  { setKinematicData( *( aOtherCDCandidate.kinematicData() ) ); }
}
 
//------ Constructor -----
// constructor with just a footprint
//
CDCandidate::CDCandidate( const CDFootPrint& aCDFootPrint )
    : m_kinematicDataPtr( 0 ), m_footPrint( aCDFootPrint ) {}
 
//------ Destructor -----
//
CDCandidate::~CDCandidate() { delete m_kinematicDataPtr; }
 
//------ assignment -----
// fill an *empty* candidate with aother CDCandidate's information
//
const CDCandidate& CDCandidate::operator=( const CDCandidate& aOtherCDCandidate ) {
  if ( 0 == aOtherCDCandidate.m_kinematicDataPtr )
  {
    delete m_kinematicDataPtr;
    m_kinematicDataPtr = 0;
  }
  else { setKinematicData( *( aOtherCDCandidate.kinematicData() ) ); }
  m_footPrint = aOtherCDCandidate.footPrint();
  return ( *this );
}
 
void CDCandidate::setUserTag( int tag ) { this->modifiableKinematicData()->setUserTag( tag ); }
 
//------ setMomentum -----
//
CDCandidate& CDCandidate::setP4( const HepLorentzVector& aMomentum ) {
  this->modifiableKinematicData()->setP4( aMomentum );
  return ( *this );
}
 
//------ setKinematicData -----
// set the KTKinematicData to a new values
// Does not fill initial value with defaultKinematicData.
//
void CDCandidate::setKinematicData( const KinematicData& aKinematicData ) {
  if ( 0 == m_kinematicDataPtr )
  {
    m_kinematicDataPtr = new KinematicData( aKinematicData );
    if ( 0 == m_kinematicDataPtr )
    {
      std::cerr << "No memory to allocate another kinematicData" << std::endl;
      exit( 1 );
    }
    return;
  }
  ( *( this->modifiableKinematicData() ) ) = aKinematicData;
  return;
}
 
//------ setCDFootPrint -----
// set the CDFootPrint to a new value
//
void CDCandidate::setCDFootPrint( const CDFootPrint& aCDFootPrint ) {
  m_footPrint = aCDFootPrint;
}
 
//------ modifiableKinematicData -----
// get the non-const KTKinematicData for this candidate
//
KinematicData* CDCandidate::modifiableKinematicData() {
  if ( 0 == m_kinematicDataPtr )
  {
    m_kinematicDataPtr = defaultKinematicData();
    if ( 0 == m_kinematicDataPtr )
    {
      std::cerr << "No memory to allocate another kinematicData" << std::endl;
      exit( 1 );
    }
  }
  return m_kinematicDataPtr;
}
 
int CDCandidate::userTag() const { return kinematicData()->userTag(); }
 
//------ mass -----
// get the mass for this CDCandidate
//
double CDCandidate::mass() const { return kinematicData()->mass(); }
 
//------ charge -----
// get the charge for this CDCandidate
//
int CDCandidate::charge() const { return kinematicData()->charge(); }
 
//------ energy -----
// get the energy for this CDCandidate
//
double CDCandidate::energy() const { return kinematicData()->energy(); }
 
//------ momentum -----
// get the momentum for this CDCandidate
//
const Hep3Vector& CDCandidate::momentum() const { return kinematicData()->p4(); }
 
const HepLorentzVector& CDCandidate::p4() const { return kinematicData()->p4(); }
 
//------ kinematicData -----
// get the kinematicData for this CDCandidate
//
const KinematicData* CDCandidate::kinematicData() const {
  // Cast away `const' to pick up the function.
  // This is safe as the result is being returned as a `const'
  return ( ( *(CDCandidate*)this ).modifiableKinematicData() );
}
 
CDCandidate::TracksAndShowers CDCandidate::finalChildren() const {
  TracksAndShowers blocks;
  recurseNode( blocks, *this );
  return blocks;
}
 
void CDCandidate::recurseNode( CDCandidate::TracksAndShowers& final,
                               const CDCandidate&             cand ) const {
  if ( cand.builtFromTrack() )
  {
    final.first.push_back( cand.track() );
    return;
  }
  if ( cand.builtFromCDPhoton() )
  {
    final.second.push_back( cand.photon() );
    return;
  }
  const DecayEvidence&                                 decay     = cand.decay();
  const vector<ReferenceHolder<CDCandidate>>&          children  = decay.children();
  vector<ReferenceHolder<CDCandidate>>::const_iterator lastChild = children.end();
  for ( vector<ReferenceHolder<CDCandidate>>::const_iterator child = children.begin();
        child != lastChild; ++child )
  { recurseNode( final, **child ); }
}
 
//------ buildFromCDCharged -----
// false is there in no CDChargedEvidence associated with this CDCandidate
//
bool CDCandidate::builtFromTrack() const { return ( false ); }
 
//------ chargedEvidence -----
// return the CDChargedEvidence that is associated with this CDCandidate
//
const EvtRecTrack* CDCandidate::track() const {
  std::cerr << "No navtrack for this CDCandidate" << std::endl;
  exit( 1 );
  return ( (EvtRecTrack*)0 );
}
 
//------ builtFromCDPhoton -----
// false is there in no CDNeutralEvidence associated with this CDCandidate
//
bool CDCandidate::builtFromCDPhoton() const { return ( false ); }
 
//------ photon -----
// return the NavShower that is associated with this CDCandidate
//
const EvtRecTrack* CDCandidate::photon() const {
  std::cerr << "No NavShower for this CDCandidate" << std::endl;
  exit( 1 );
  return ( (EvtRecTrack*)0 );
}
 
//------ builtFromCDPi0 -----
// false is there in no CDNeutralEvidence associated with this CDCandidate
//
bool CDCandidate::builtFromCDPi0() const { return ( false ); }
 
//------ pi0 -----
// return the NavCDPi0 that is associated with this CDCandidate
//
const EvtRecPi0* CDCandidate::navPi0() const {
  std::cerr << "No NavCDPi0 for this CDCandidate" << std::endl;
  exit( 1 );
  return ( (EvtRecPi0*)0 );
}
 
//------ builtFromCDEta -----
// false is there in no CDNeutralEvidence associated with this CDCandidate
//
bool CDCandidate::builtFromCDEta() const { return ( false ); }
 
//------ eta -----
// return the NavCDEta that is associated with this CDCandidate
//
const EvtRecEtaToGG* CDCandidate::navEta() const {
  std::cerr << "No NavCDEta for this CDCandidate" << std::endl;
  exit( 1 );
  return ( (EvtRecEtaToGG*)0 );
}
 
//------ builtFromCDKs -----
// false is there in no CDNeutralEvidence associated with this CDCandidate
//
bool CDCandidate::builtFromCDKs() const { return ( false ); }
 
//------ CDKs -----
// return the NavKs that is associated with this CDCandidate
//
const EvtRecVeeVertex* CDCandidate::navKshort() const {
  std::cerr << "No NavKs for this CDCandidate" << std::endl;
  exit( 1 );
  return ( (EvtRecVeeVertex*)0 );
}
 
//------ builtFromCDLambda -----
// false is there in no CDNeutralEvidence associated with this CDCandidate
//
bool CDCandidate::builtFromCDLambda() const { return ( false ); }
 
//------ CDLambda -----
// return the NavLambda that is associated with this CDCandidate
//
const EvtRecVeeVertex* CDCandidate::navLambda() const {
  std::cerr << "No NavLambda for this CDCandidate" << std::endl;
  exit( 1 );
  return ( (EvtRecVeeVertex*)0 );
}
 
//------ builtFromCDDecay -----
// false is there in no CDDecay associated with this CDCandidate
//
bool CDCandidate::builtFromCDDecay() const { return ( false ); }
 
//------ decay -----
// return the decay that is associated with this CDCandidate
//
const CDDecay& CDCandidate::decay() const {
  std::cerr << "No CDDecay for this CDCandidate" << std::endl;
  exit( 1 );
  return ( *(CDDecay*)0 );
}
 
//------ overlap -----
// returns false if this Candodate and OtherCDCandidate have no elements
//   in common
//
bool CDCandidate::overlap( const CDCandidate& aOtherCDCandidate ) const {
  return ( m_footPrint.overlap( aOtherCDCandidate.footPrint() ) );
}
 
//------ footPrint -----
// get the CDFootPrint for this CDCandidate
//
const CDFootPrint& CDCandidate::footPrint() const { return ( m_footPrint ); }
 
//----------------------------------------------------------------------
//
// $Log: CDCandidate.cxx,v $
// Revision 1.4  2011/10/27 06:15:12  zoujh
// add user tag to particle data
//
// Revision 1.3  2009/09/22 08:24:41  hujf
// see ChangeLog
//
// Revision 1.2  2009/06/22 14:55:48  zoujh
// See ChangeLog
//
// Revision 1.1.1.1  2009/03/03 06:05:56  maqm
// first import of BesDChain
//
// Revision 1.7  2006/06/05 16:14:58  gregor
// Reordered constructor initializers to match .h file
//
// Revision 1.6  2006/01/11 20:37:25  cdj
// work with renaming done in DChain package
//
// Revision 1.5  2004/03/05 22:01:43  chengp
// implemented Monte Carlo matching
//
// Revision 1.4  2003/05/15 19:58:08  cdj
// revamped memory handling so always use a ReferenceHolder to deal with the reference counting
//
// Revision 1.3  2001/09/12 19:10:32  ajm36
// add lambda functions to CDCandidate
//
// Revision 1.2  2001/04/20 14:03:34  ajm36
// add finalChildren function to return tracks and showers
//
// Revision 1.1  2001/04/11 13:19:00  urner
// transition to files with CD prefix. Addition of new files
//
// Revision 1.3  2001/04/03 17:24:57  cdj
// now always initialize m_kinematicDataPtr to 0
//
// Revision 1.2  2001/03/23 23:05:27  urner
// added pi0 eta and CDKs decay lists
//
// Revision 1.1.1.1  2000/12/18 22:17:24  cdj
// imported CleoDChain
//
// Revision 1.29  1998/05/04 19:10:41  sjp
// Fixed access confusion for kinematicData
//
// Revision 1.28  1998/04/17 18:55:49  sjp
// Modified to use latest types
//
// Revision 1.27  1997/09/03 14:58:30  sjp
// Use new report.h and KTKinematicData
//
// Revision 1.26  1997/08/29 17:00:32  sjp
// Modified to handle new Cairn Templated classes
//
// Revision 1.25  1997/08/25 02:50:34  sjp
// empty returns now use typedef names
//
// Revision 1.24  1997/08/22 16:18:51  sjp
// New name for access functions
//
// Revision 1.23  1997/08/20 12:45:36  sjp
// Removed unnecessary <math.h>
//
// Revision 1.22  1997/08/19 23:02:44  sjp
// Restructured package to be independent of CleoDChain
//
// Revision 1.21  1997/08/19 20:40:14  sjp
// Updated to use <package>/<file>.h include structure.
//   (Note: This version of the code has not been compiled)
//
// Revision 1.20  1997/01/21 20:29:57  sjp
// Changed CPP flags and include because of library reorganization
//
// Revision 1.19  1996/12/20 21:00:32  sjp
// Request of non-existant reference is now and error
//
// Revision 1.18  1996/11/04 16:58:33  sjp
// Separaqted of CDDecay part of CDCandidate into new class
//
// Revision 1.17  1996/07/16 19:05:28  sjp
// Restructed Libraries
// Put relative pathnames into all includes
//
// Revision 1.16  1996/06/21 21:21:19  sjp
// Fixed bug, which was missing a return statment
//
// Revision 1.15  1996/06/19 19:30:13  sjp
// Changed to use vector<> rather than deque<>
//
// Revision 1.14  1996/06/13 18:18:37  sjp
// KTKinematicData is now a cached value
//
// Revision 1.13  1996/06/04 14:54:17  sjp
// Coverted to use DB Classes
//
// Revision 1.12  1996/04/11 14:25:16  sjp
// Set Z of missedDistance to Z0CD (a kludge)
//
// Revision 1.11  1996/04/05 20:05:12  sjp
// Added function to get MCParticle, Track and Shower matches.
// Reorganized the file.
// Added a cobbled version of missedDistance.
//
// Revision 1.10  1996/02/27 15:50:15  sjp
// Added functions to link CDCandidate with Track and Showers.
// Allowed derived classes ability to addChild to children.
//
// Revision 1.9  1996/02/06 20:37:24  sjp
// Added new functionality to map a CDCandidate onto its `truth'.
//
// Revision 1.8  1995/11/28 17:34:46  sjp
// Changed `list' class to `deque' and added SJP_NOSTL switch.
// Added child() and iterateChild() operations, and thus added Children
//   include file for enum.
// Moved `Log' information.
//
// Revision 1.6  1995/11/25 23:26:43  sjp
// Ammended to use KTKinematicData a basis for kinematic data.
//
// Revision 1.5  1995/11/22 02:49:59  sjp
// list constructors no longer accept Size, now use set_max_size.
//
// Revision 1.4  1995/11/14 22:04:56  sjp
// Updated to use `list' rather than SimpleList, and to use STL style
//   iterators.
//
// Revision 1.3  1995/11/14 21:24:01  sjp
// Corrected bug, energy was not begin accumulated in constructor.
//
// Revision 1.2  1995/11/09 16:53:48  sjp
// Move responsibility for mass, charge, momentum and energy into this class.
//
// Revision 1.1  1995/11/07 21:26:57  sjp
// New base class for all CDCandidates.
//
//