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

DTagTool Class Reference

#include <DTagTool.h>

List of all members.

Public Member Functions

void clear ()
void clear ()
void clear ()
void clear ()
bool cosmicandleptonVeto ()
bool cosmicandleptonVeto ()
vector< int > D0modes ()
vector< int > D0modes ()
vector< int > D0modes ()
vector< int > D0modes ()
vector< int > Dpmodes ()
vector< int > Dpmodes ()
vector< int > Dpmodes ()
vector< int > Dpmodes ()
vector< int > Dsmodes ()
vector< int > Dsmodes ()
vector< int > Dsmodes ()
vector< int > Dsmodes ()
EvtRecDTagCol::iterator dtag1 ()
EvtRecDTagCol::iterator dtag1 ()
EvtRecDTagCol::iterator dtag1 ()
EvtRecDTagCol::iterator dtag1 ()
EvtRecDTagCol::iterator dtag2 ()
EvtRecDTagCol::iterator dtag2 ()
EvtRecDTagCol::iterator dtag2 ()
EvtRecDTagCol::iterator dtag2 ()
 DTagTool ()
 DTagTool ()
 DTagTool ()
 DTagTool ()
bool findDTag (int mode1, int tagcharm1, int mode2, int tagcharm2)
bool findDTag (int mode1, int mode2)
bool findDTag (EvtRecDTag::DecayMode mode1, int tagcharm1, EvtRecDTag::DecayMode mode2, int tagcharm2)
bool findDTag (EvtRecDTag::DecayMode mode1, EvtRecDTag::DecayMode mode2)
bool findDTag (EvtRecDTag::DecayMode mode1, int tagcharm1, EvtRecDTag::DecayMode mode2, int tagcharm2)
bool findDTag (EvtRecDTag::DecayMode mode1, int tagcharm1, EvtRecDTag::DecayMode mode2, int tagcharm2)
bool findDTag (int mode1, int tagcharm1, int mode2, int tagcharm2)
bool findDTag (int mode1, int mode2)
bool findDTag (EvtRecDTag::DecayMode mode1, int tagcharm1, EvtRecDTag::DecayMode mode2, int tagcharm2)
bool findDTag (EvtRecDTag::DecayMode mode1, EvtRecDTag::DecayMode mode2)
bool findSTag (int mode)
bool findSTag (int mode, int tagcharm)
bool findSTag (EvtRecDTag::DecayMode mode)
bool findSTag (EvtRecDTag::DecayMode mode, int tagcharm)
bool findSTag (EvtRecDTag::DecayMode mode, int tagcharm)
bool findSTag (EvtRecDTag::DecayMode mode, int tagcharm)
bool findSTag (int mode)
bool findSTag (int mode, int tagcharm)
bool findSTag (EvtRecDTag::DecayMode mode)
bool findSTag (EvtRecDTag::DecayMode mode, int tagcharm)
bool isDTagListEmpty ()
bool isDTagListEmpty ()
bool isDTagListEmpty ()
bool isDTagListEmpty ()
bool isElectron (EvtRecTrack *trk)
bool isElectron (EvtRecTrack *trk)
bool isGoodShower (EvtRecTrack *trk)
bool isGoodShower (EvtRecTrack *trk)
bool isGoodTrack (EvtRecTrack *trk)
bool isGoodTrack (EvtRecTrack *trk)
bool isKaon (EvtRecTrack *trk)
bool isKaon (EvtRecTrack *trk)
bool isKaon (EvtRecTrack *trk)
bool isKaon (EvtRecTrack *trk)
bool isMuon (EvtRecTrack *trk)
bool isMuon (EvtRecTrack *trk)
bool isPion (EvtRecTrack *trk)
bool isPion (EvtRecTrack *trk)
bool isPion (EvtRecTrack *trk)
bool isPion (EvtRecTrack *trk)
vector< int > mode (int decaymode)
vector< int > mode (EvtRecDTag::DecayMode decaymode)
vector< int > mode (EvtRecDTag::DecayMode decaymode)
vector< int > mode (EvtRecDTag::DecayMode decaymode)
vector< int > mode (int decaymode)
vector< int > mode (EvtRecDTag::DecayMode decaymode)
EvtRecDTagCol::iterator modes_begin ()
EvtRecDTagCol::iterator modes_begin ()
EvtRecDTagCol::iterator modes_begin ()
EvtRecDTagCol::iterator modes_begin ()
EvtRecDTagCol::iterator modes_end ()
EvtRecDTagCol::iterator modes_end ()
EvtRecDTagCol::iterator modes_end ()
EvtRecDTagCol::iterator modes_end ()
void name ()
void name ()
void name ()
void name ()
void operator<< (EvtRecDTagCol::iterator iter)
void operator<< (EvtRecDTagCol::iterator iter)
void operator<< (EvtRecDTagCol::iterator iter)
void operator<< (EvtRecDTagCol::iterator iter)
void setPID (bool pid)
void setPID (bool pid)
bool shareTracks (EvtRecDTagCol::iterator iter1, EvtRecDTagCol::iterator iter2)
bool shareTracks (EvtRecDTagCol::iterator iter1, EvtRecDTagCol::iterator iter2)
EvtRecDTagCol::iterator stag ()
EvtRecDTagCol::iterator stag ()
EvtRecDTagCol::iterator stag ()
EvtRecDTagCol::iterator stag ()
 ~DTagTool ()
 ~DTagTool ()
 ~DTagTool ()
 ~DTagTool ()

Protected Member Functions

IDataProviderSvc * eventSvc ()
IDataProviderSvc * eventSvc ()
IDataProviderSvc * eventSvc ()
IDataProviderSvc * eventSvc ()

Private Attributes

EvtRecTrackIterator m_chargebegin
EvtRecTrackIterator m_chargeend
vector< int > m_d0modes
vector< int > m_d0modes
vector< int > m_d0modes
vector< int > m_d0modes
vector< int > m_dpmodes
vector< int > m_dpmodes
vector< int > m_dpmodes
vector< int > m_dpmodes
vector< int > m_dsmodes
vector< int > m_dsmodes
vector< int > m_dsmodes
vector< int > m_dsmodes
IDataProviderSvc * m_evtSvc
IDataProviderSvc * m_evtSvc
IDataProviderSvc * m_evtSvc
IDataProviderSvc * m_evtSvc
bool m_isdtaglistempty
EvtRecDTagCol::iterator m_iterbegin
EvtRecDTagCol::iterator m_iterdtag1
EvtRecDTagCol::iterator m_iterdtag2
EvtRecDTagCol::iterator m_iterend
EvtRecDTagCol::iterator m_iterstag
bool m_pid
EvtRecTrackIterator m_showerbegin
EvtRecTrackIterator m_showerend

Constructor & Destructor Documentation

DTagTool::DTagTool (   ) 
  

00033                    : m_evtSvc(0), m_iterbegin(0), m_iterend(0),
00034                        m_iterstag(0),  m_iterdtag1(0), m_iterdtag2(0),
00035                        m_chargebegin(0),m_chargeend(0),m_showerbegin(0),m_showerend(0){
00036   
00037   SmartDataPtr<EvtRecEvent> evtRecEvent(eventSvc(), "/Event/EvtRec/EvtRecEvent");
00038   if ( ! evtRecEvent ) {
00039     cout << MSG::FATAL << "Could not find EvtRecEvent" << endl;
00040     exit(1);
00041   }
00042   
00043   SmartDataPtr<EvtRecTrackCol> evtRecTrackCol( eventSvc(), "/Event/EvtRec/EvtRecTrackCol");
00044   if ( ! evtRecTrackCol ) {
00045     cout << MSG::FATAL << "Could not find EvtRecTrackCol" << endl;
00046     exit(1);
00047   }
00048   
00049   m_chargebegin=evtRecTrackCol->begin();
00050   m_chargeend=evtRecTrackCol->begin()+evtRecEvent->totalCharged();
00051   m_showerbegin=evtRecTrackCol->begin()+evtRecEvent->totalCharged();
00052   m_showerend=evtRecTrackCol->begin()+evtRecEvent->totalTracks();
00053   
00054   SmartDataPtr<EvtRecDTagCol> evtRecDTagCol(eventSvc(), EventModel::EvtRec::EvtRecDTagCol);
00055   if ( ! evtRecDTagCol ) {
00056     cout << "Could not find EvtRecDTagCol" << endl;
00057     exit(1);
00058   }
00059   
00060   m_iterbegin=evtRecDTagCol->begin();
00061   m_iterend=evtRecDTagCol->end();
00062 
00063   if(evtRecDTagCol->size() > 0)
00064     m_isdtaglistempty=false;
00065   else
00066     m_isdtaglistempty=true;
00067 
00068   //set initial pid requirement
00069   m_pid=false;
00070 
00071     
00072   //fill d0, dp, ds modes seprately
00073   int index=0;
00074   for(EvtRecDTagCol::iterator iter=m_iterbegin; iter != m_iterend; iter++){
00075 
00076     if( (int)( (*iter)->decayMode())< 200 )
00077       m_d0modes.push_back( index ); 
00078     else  if( (int)( (*iter)->decayMode())< 400 )
00079       m_dpmodes.push_back( index ); 
00080     else  if( (int)( (*iter)->decayMode())< 1000 )
00081       m_dsmodes.push_back( index ); 
00082   
00083     index++;
00084   } 
00085 
00086 }

DTagTool::~DTagTool (   ) 
  

00096                    {
00097 
00098   m_d0modes.clear();
00099   m_dpmodes.clear();
00100   m_dsmodes.clear();
00101 
00102 }

DTagTool::DTagTool (   ) 
 

DTagTool::~DTagTool (   ) 
 

DTagTool::DTagTool (   ) 
 

DTagTool::~DTagTool (   ) 
 

DTagTool::DTagTool (   ) 
 

DTagTool::~DTagTool (   ) 
 

Member Function Documentation

void DTagTool::clear (   ) 
 

void DTagTool::clear (   ) 
 

void DTagTool::clear (   ) 
 

void DTagTool::clear (   ) 
  

00088                     {
00089 
00090   m_d0modes.clear();
00091   m_dpmodes.clear();
00092   m_dsmodes.clear();
00093   
00094 }

bool DTagTool::cosmicandleptonVeto (   ) 
 

bool DTagTool::cosmicandleptonVeto (   ) 
  

00801                                   {
00802   
00803   //good track list
00804   vector<EvtRecTrackIterator> iGood;
00805   iGood.clear();
00806   for(EvtRecTrackIterator iter=m_chargebegin; iter!= m_chargeend; iter++){ 
00807     if(isGoodTrack(*iter))
00808       iGood.push_back(iter);
00809   }
00810   
00811   if(iGood.size() != 2)
00812     return true;
00813   
00814   //cosmic veto
00815   double time1=-99,time2=-99;
00816   for(vector<EvtRecTrackIterator>::size_type i=0;i<2;i++){
00817     if( (*iGood[i])->isTofTrackValid() ){
00818       SmartRefVector<RecTofTrack> tofTrkCol= (*iGood[i])->tofTrack();
00819       SmartRefVector<RecTofTrack>::iterator iter_tof=tofTrkCol.begin();
00820       
00821       for(;iter_tof!=tofTrkCol.end();iter_tof++){
00822         TofHitStatus* status =new TofHitStatus;
00823         status->setStatus( (*iter_tof)->status() );
00824         if(status->is_cluster()){
00825           if(i==0)
00826             time1=(*iter_tof)->tof();
00827           else
00828             time2=(*iter_tof)->tof();
00829         }
00830         delete status;
00831       }
00832     }
00833   }
00834   if( time1!=-99 && time2!=-99 && fabs(time1-time2)>5)
00835     return false;
00836   
00837   //rad bhabha veto
00838   if(isElectron( *iGood[0]) && isElectron(*iGood[1]))
00839     return false;
00840   
00841   //rad dimu veto
00842   if(isMuon( *iGood[0]) && isMuon(*iGood[1]))
00843     return false;
00844 
00845   return true;
00846 }

vector<int> DTagTool::D0modes (   )  [inline]
  

00036 { return m_d0modes;}

vector<int> DTagTool::D0modes (   )  [inline]
  

00039 { return m_d0modes;}

vector<int> DTagTool::D0modes (   )  [inline]
  

00039 { return m_d0modes;}

vector<int> DTagTool::D0modes (   )  [inline]
  

00036 { return m_d0modes;}

vector<int> DTagTool::Dpmodes (   )  [inline]
  

00037 { return m_dpmodes;}

vector<int> DTagTool::Dpmodes (   )  [inline]
  

00040 { return m_dpmodes;}

vector<int> DTagTool::Dpmodes (   )  [inline]
  

00040 { return m_dpmodes;}

vector<int> DTagTool::Dpmodes (   )  [inline]
  

00037 { return m_dpmodes;}

vector<int> DTagTool::Dsmodes (   )  [inline]
  

00038 { return m_dsmodes;}

vector<int> DTagTool::Dsmodes (   )  [inline]
  

00041 { return m_dsmodes;}

vector<int> DTagTool::Dsmodes (   )  [inline]
  

00041 { return m_dsmodes;}

vector<int> DTagTool::Dsmodes (   )  [inline]
  

00038 { return m_dsmodes;}

EvtRecDTagCol::iterator DTagTool::dtag1 (   )  [inline]
  

00056 { return m_iterdtag1;}

EvtRecDTagCol::iterator DTagTool::dtag1 (   )  [inline]
  

00050 { return m_iterdtag1;}

EvtRecDTagCol::iterator DTagTool::dtag1 (   )  [inline]
  

00050 { return m_iterdtag1;}

EvtRecDTagCol::iterator DTagTool::dtag1 (   )  [inline]
  

00056 { return m_iterdtag1;}

EvtRecDTagCol::iterator DTagTool::dtag2 (   )  [inline]
  

00057 { return m_iterdtag2;}

EvtRecDTagCol::iterator DTagTool::dtag2 (   )  [inline]
  

00051 { return m_iterdtag2;}

EvtRecDTagCol::iterator DTagTool::dtag2 (   )  [inline]
  

00051 { return m_iterdtag2;}

EvtRecDTagCol::iterator DTagTool::dtag2 (   )  [inline]
  

00057 { return m_iterdtag2;}

IDataProviderSvc* DTagTool::eventSvc (   )  [protected]
 

IDataProviderSvc* DTagTool::eventSvc (   )  [protected]
 

IDataProviderSvc* DTagTool::eventSvc (   )  [protected]
 

IDataProviderSvc * DTagTool::eventSvc (   )  [protected]
  

00874                                     {
00875 
00876   if(m_evtSvc == 0){
00877 
00878     StatusCode sc = Gaudi::svcLocator()->service ( "EventDataSvc", m_evtSvc, true);
00879     if( sc.isFailure() ) {
00880       assert(false);
00881     }
00882 
00883   }
00884 
00885   return m_evtSvc;
00886 
00887 }

bool DTagTool::findDTag (  int  mode1,
int  tagcharm1,
int  mode2,
int  tagcharm2
) 
 

bool DTagTool::findDTag (  int  mode1,
int  mode2
) 
 

bool DTagTool::findDTag (  EvtRecDTag::DecayMode  mode1,
int  tagcharm1,
EvtRecDTag::DecayMode  mode2,
int  tagcharm2
) 
 

bool DTagTool::findDTag (  EvtRecDTag::DecayMode  mode1,
EvtRecDTag::DecayMode  mode2
) 
 

bool DTagTool::findDTag (  EvtRecDTag::DecayMode  mode1,
int  tagcharm1,
EvtRecDTag::DecayMode  mode2,
int  tagcharm2
) 
 

bool DTagTool::findDTag (  EvtRecDTag::DecayMode  mode1,
int  tagcharm1,
EvtRecDTag::DecayMode  mode2,
int  tagcharm2
) 
 

bool DTagTool::findDTag (  int  mode1,
int  tagcharm1,
int  mode2,
int  tagcharm2
) 
  

00575                                                                          {
00576 
00577   if(tagcharm1*tagcharm2>0){
00578     cout<<"double tagging warning! two  modes can't have same nonzero charmness"<<endl; 
00579     return false;
00580   }
00581   
00582   //define D candidate mass
00583   double mDcand=0;
00584   if( (int)mode1 < 200 && (int)mode2 < 200)
00585     mDcand = 1.8645;
00586   else if ( (int)mode1 < 400 && (int)mode2 < 400)
00587     mDcand = 1.8693;
00588   else if ( (int)mode1 < 1000 && (int)mode2 < 1000)
00589     mDcand = 1.9682;
00590   else{
00591     cout<<"double tag modes are not from same particle ! "<<endl;
00592     return false;
00593   }
00594   
00595   
00596   vector<int> igood1, igood2;
00597   igood1.clear(),igood2.clear();
00598   int index=0;
00599   EvtRecDTagCol::iterator iter_dtag=m_iterbegin;
00600 
00601   for ( ; iter_dtag != m_iterend; iter_dtag++){
00602     int iter_mode=(*iter_dtag)->decayMode();
00603     int iter_charm=(*iter_dtag)->charm();
00604     int iter_type=(*iter_dtag)->type();
00605 
00606     if(m_pid){
00607       if( iter_mode == mode1 && iter_charm == tagcharm1 && iter_type==1 )
00608         igood1.push_back(index);
00609       
00610       if( iter_mode == mode2 && iter_charm == tagcharm2 && iter_type==1)
00611         igood2.push_back(index);
00612     }
00613     else{
00614       if( iter_mode == mode1 && iter_charm == tagcharm1)
00615         igood1.push_back(index);
00616       
00617       if( iter_mode == mode2 && iter_charm == tagcharm2)
00618         igood2.push_back(index);
00619     }
00620 
00621   
00622     index++;
00623   }
00624   
00625   //look for the best pair of double-tagged event
00626 
00627   bool isDtcand=false;
00628   double deltaM=1.00;
00629   int index_i=0, index_j=0;
00630   EvtRecDTagCol::iterator iter_i, iter_j;
00631   
00632   for(int i=0; i<igood1.size(); i++){
00633   
00634     iter_i=m_iterbegin+igood1[i];
00635     double mass_i=(*iter_i)->mBC();
00636     int charm_i=(*iter_i)->charm();
00637     for(int j=0;j<igood2.size();j++){
00638       iter_j=m_iterbegin+igood2[j];
00639       double mass_j=(*iter_j)->mBC();
00640       int charm_j=(*iter_j)->charm();
00641       if( charm_i*charm_j>0 || igood2[j] == igood1[i] ) continue;
00642       
00643       if(shareTracks(iter_i,iter_j)) continue;
00644 
00645       if(  fabs(0.5*(mass_i+mass_j)-mDcand) < deltaM){
00646         deltaM = fabs(0.5*(mass_i+mass_j)-mDcand);
00647         index_i = i;
00648         index_j = j;
00649         isDtcand = true;
00650       }
00651 
00652     } //end of j loop
00653   } //end of i loop
00654 
00655   if(isDtcand){
00656     m_iterdtag1=m_iterbegin+igood1[index_i];
00657     m_iterdtag2=m_iterbegin+igood2[index_j];
00658   }
00659 
00660   return isDtcand;
00661 
00662 } //end of findDtag

bool DTagTool::findDTag (  int  mode1,
int  mode2
) 
  

00475                                            {
00476   
00477   int tagcharm1= (mode1<10 || mode1>=200)?+1:0;
00478   int tagcharm2= (mode2<10 || mode2>=200)?-1:0;
00479     
00480   if(tagcharm1*tagcharm2>0){
00481     cout<<"double tagging warning! two  modes can't have same nonzero charmness"<<endl; 
00482     return false;
00483   }
00484   
00485   //define D candidate mass
00486   double mDcand=0;
00487   if( (int)mode1 < 200 && (int)mode2 < 200)
00488     mDcand = 1.8645;
00489   else if ( (int)mode1 < 400 && (int)mode2 < 400)
00490     mDcand = 1.8693;
00491   else if ( (int)mode1 < 1000 && (int)mode2 < 1000)
00492     mDcand = 1.9682;
00493   else{
00494     cout<<"double tag modes are not from same particle ! "<<endl;
00495     return false;
00496   }
00497   
00498   
00499   vector<int> igood1, igood2;
00500   igood1.clear(),igood2.clear();
00501   int index=0;
00502   EvtRecDTagCol::iterator iter_dtag=m_iterbegin;
00503 
00504   //charge conjucation considered
00505   for ( ; iter_dtag != m_iterend; iter_dtag++){
00506     int iter_mode=(*iter_dtag)->decayMode();
00507     int iter_charm=(*iter_dtag)->charm();
00508     int iter_type=(*iter_dtag)->type();
00509 
00510     if(m_pid){
00511       if( iter_mode == mode1 && iter_charm == tagcharm1 && iter_type==1 )
00512         igood1.push_back(index);
00513       if( tagcharm1!=0 && iter_mode == mode1 && iter_charm == -tagcharm1 && iter_type==1 )
00514         igood1.push_back(index);
00515       
00516       if( iter_mode == mode2 && iter_charm == tagcharm2 && iter_type==1 )
00517         igood2.push_back(index);
00518       if( tagcharm2!=0 && iter_mode == mode2 && iter_charm == -tagcharm2 && iter_type==1 )
00519         igood2.push_back(index);
00520     }
00521     else{
00522       if( iter_mode == mode1 && iter_charm == tagcharm1 )
00523         igood1.push_back(index);
00524       if( tagcharm1!=0 && iter_mode == mode1 && iter_charm == -tagcharm1 )
00525         igood1.push_back(index);
00526       
00527       if( iter_mode == mode2 && iter_charm == tagcharm2 )
00528         igood2.push_back(index);
00529       if( tagcharm2!=0 && iter_mode == mode2 && iter_charm == -tagcharm2 )
00530         igood2.push_back(index);
00531     }
00532 
00533     index++;
00534   }
00535   
00536   //look for the best pair of double-tagged event
00537 
00538   bool isDtcand=false;
00539   double deltaM=1.00;
00540   int index_i=0, index_j=0;
00541   EvtRecDTagCol::iterator iter_i, iter_j;
00542   
00543   for(int i=0; i<igood1.size(); i++){
00544   
00545     iter_i=m_iterbegin+igood1[i];
00546     double mass_i=(*iter_i)->mBC();
00547     int charm_i=(*iter_i)->charm();
00548     for(int j=0;j<igood2.size();j++){
00549       iter_j=m_iterbegin+igood2[j];
00550       double mass_j=(*iter_j)->mBC();
00551       int charm_j=(*iter_j)->charm();
00552       if( charm_i*charm_j>0 || igood2[j] == igood1[i] ) continue;
00553       
00554       if(shareTracks(iter_i,iter_j)) continue;
00555 
00556       if(  fabs(0.5*(mass_i+mass_j)-mDcand) < deltaM){
00557         deltaM = fabs(0.5*(mass_i+mass_j)-mDcand);
00558         index_i = i;
00559         index_j = j;
00560         isDtcand = true;
00561       }
00562 
00563     } //end of j loop
00564   } //end of i loop
00565 
00566   if(isDtcand){
00567     m_iterdtag1=m_iterbegin+igood1[index_i];
00568     m_iterdtag2=m_iterbegin+igood2[index_j];
00569   }
00570 
00571   return isDtcand;
00572 }

bool DTagTool::findDTag (  EvtRecDTag::DecayMode  mode1,
int  tagcharm1,
EvtRecDTag::DecayMode  mode2,
int  tagcharm2
) 
  

00385                                                                                                          {
00386 
00387   if(tagcharm1*tagcharm2>0){
00388     cout<<"double tagging warning! two  modes can't have same nonzero charmness"<<endl; 
00389     return false;
00390   }
00391   
00392   //define D candidate mass
00393   double mDcand=0;
00394   if( (int)mode1 < 200 && (int)mode2 < 200)
00395     mDcand = 1.8645;
00396   else if ( (int)mode1 < 400 && (int)mode2 < 400)
00397     mDcand = 1.8693;
00398   else if ( (int)mode1 < 1000 && (int)mode2 < 1000)
00399     mDcand = 1.9682;
00400   else{
00401     cout<<"double tag modes are not from same particle ! "<<endl;
00402     return false;
00403   }
00404   
00405   
00406   vector<int> igood1, igood2;
00407   igood1.clear(),igood2.clear();
00408   int index=0;
00409   EvtRecDTagCol::iterator iter_dtag=m_iterbegin;
00410 
00411   for ( ; iter_dtag != m_iterend; iter_dtag++){
00412     int iter_mode=(*iter_dtag)->decayMode();
00413     int iter_charm=(*iter_dtag)->charm();
00414     int iter_type=(*iter_dtag)->type();
00415 
00416     if(m_pid){
00417       if( iter_mode == mode1 && iter_charm == tagcharm1 && iter_type==1 )
00418         igood1.push_back(index);
00419       
00420       if( iter_mode == mode2 && iter_charm == tagcharm2 && iter_type==1)
00421         igood2.push_back(index);
00422     }
00423     else{
00424       if( iter_mode == mode1 && iter_charm == tagcharm1)
00425         igood1.push_back(index);
00426       
00427       if( iter_mode == mode2 && iter_charm == tagcharm2)
00428         igood2.push_back(index);
00429     }
00430     
00431     index++;
00432   }
00433   
00434   //look for the best pair of double-tagged event
00435 
00436   bool isDtcand=false;
00437   double deltaM=1.00;
00438   int index_i=0, index_j=0;
00439   EvtRecDTagCol::iterator iter_i, iter_j;
00440   
00441   for(int i=0; i<igood1.size(); i++){
00442   
00443     iter_i=m_iterbegin+igood1[i];
00444     double mass_i=(*iter_i)->mBC();
00445     int charm_i=(*iter_i)->charm();
00446     for(int j=0;j<igood2.size();j++){
00447       iter_j=m_iterbegin+igood2[j];
00448       double mass_j=(*iter_j)->mBC();
00449       int charm_j=(*iter_j)->charm();
00450       if( charm_i*charm_j>0 || igood2[j] == igood1[i] ) continue;
00451       
00452       if(shareTracks(iter_i,iter_j)) continue;
00453 
00454       if(  fabs(0.5*(mass_i+mass_j)-mDcand) < deltaM){
00455         deltaM = fabs(0.5*(mass_i+mass_j)-mDcand);
00456         index_i = i;
00457         index_j = j;
00458         isDtcand = true;
00459       }
00460 
00461     } //end of j loop
00462   } //end of i loop
00463 
00464   if(isDtcand){
00465     m_iterdtag1=m_iterbegin+igood1[index_i];
00466     m_iterdtag2=m_iterbegin+igood2[index_j];
00467   }
00468 
00469   return isDtcand;
00470 
00471 } //end of findDtag

bool DTagTool::findDTag (  EvtRecDTag::DecayMode  mode1,
EvtRecDTag::DecayMode  mode2
) 
  

00284                                                                            {
00285   
00286   int tagcharm1= (mode1<10 || mode1>=200)?+1:0;
00287   int tagcharm2= (mode2<10 || mode2>=200)?-1:0;
00288     
00289   if(tagcharm1*tagcharm2>0){
00290     cout<<"double tagging warning! two  modes can't have same nonzero charmness"<<endl; 
00291     return false;
00292   }
00293   
00294   //define D candidate mass
00295   double mDcand=0;
00296   if( (int)mode1 < 200 && (int)mode2 < 200)
00297     mDcand = 1.8645;
00298   else if ( (int)mode1 < 400 && (int)mode2 < 400)
00299     mDcand = 1.8693;
00300   else if ( (int)mode1 < 1000 && (int)mode2 < 1000)
00301     mDcand = 1.9682;
00302   else{
00303     cout<<"double tag modes are not from same particle ! "<<endl;
00304     return false;
00305   }
00306   
00307   
00308   vector<int> igood1, igood2;
00309   igood1.clear(),igood2.clear();
00310   int index=0;
00311   EvtRecDTagCol::iterator iter_dtag=m_iterbegin;
00312 
00313   //charge conjucation considered
00314   for ( ; iter_dtag != m_iterend; iter_dtag++){
00315     int iter_mode=(*iter_dtag)->decayMode();
00316     int iter_charm=(*iter_dtag)->charm();
00317     int iter_type=(*iter_dtag)->type();
00318 
00319     if(m_pid){
00320       if( iter_mode == mode1 && iter_charm == tagcharm1 && iter_type==1 )
00321         igood1.push_back(index);
00322       if( tagcharm1!=0 && iter_mode == mode1 && iter_charm == -tagcharm1 && iter_type==1 )
00323         igood1.push_back(index);
00324       
00325       if( iter_mode == mode2 && iter_charm == tagcharm2 && iter_type==1 )
00326         igood2.push_back(index);
00327       if( tagcharm2!=0 && iter_mode == mode2 && iter_charm == -tagcharm2 && iter_type==1 )
00328         igood2.push_back(index);
00329     }
00330     else{
00331       if( iter_mode == mode1 && iter_charm == tagcharm1 )
00332         igood1.push_back(index);
00333       if( tagcharm1!=0 && iter_mode == mode1 && iter_charm == -tagcharm1 )
00334         igood1.push_back(index);
00335       
00336       if( iter_mode == mode2 && iter_charm == tagcharm2 )
00337         igood2.push_back(index);
00338       if( tagcharm2!=0 && iter_mode == mode2 && iter_charm == -tagcharm2 )
00339         igood2.push_back(index);
00340     }
00341 
00342 
00343     index++;
00344   }
00345   
00346   //look for the best pair of double-tagged event
00347 
00348   bool isDtcand=false;
00349   double deltaM=1.00;
00350   int index_i=0, index_j=0;
00351   EvtRecDTagCol::iterator iter_i, iter_j;
00352   
00353   for(int i=0; i<igood1.size(); i++){
00354   
00355     iter_i=m_iterbegin+igood1[i];
00356     double mass_i=(*iter_i)->mBC();
00357     int charm_i=(*iter_i)->charm();
00358     for(int j=0;j<igood2.size();j++){
00359       iter_j=m_iterbegin+igood2[j];
00360       double mass_j=(*iter_j)->mBC();
00361       int charm_j=(*iter_j)->charm();
00362       if( charm_i*charm_j>0 || igood2[j] == igood1[i] ) continue;
00363       
00364       if(shareTracks(iter_i,iter_j)) continue;
00365 
00366       if(  fabs(0.5*(mass_i+mass_j)-mDcand) < deltaM){
00367         deltaM = fabs(0.5*(mass_i+mass_j)-mDcand);
00368         index_i = i;
00369         index_j = j;
00370         isDtcand = true;
00371       }
00372 
00373     } //end of j loop
00374   } //end of i loop
00375 
00376   if(isDtcand){
00377     m_iterdtag1=m_iterbegin+igood1[index_i];
00378     m_iterdtag2=m_iterbegin+igood2[index_j];
00379   }
00380 
00381   return isDtcand;
00382 }

bool DTagTool::findSTag (  int  mode  ) 
 

bool DTagTool::findSTag (  int  mode,
int  tagcharm
) 
 

bool DTagTool::findSTag (  EvtRecDTag::DecayMode  mode  ) 
 

bool DTagTool::findSTag (  EvtRecDTag::DecayMode  mode,
int  tagcharm
) 
 

bool DTagTool::findSTag (  EvtRecDTag::DecayMode  mode,
int  tagcharm
) 
 

bool DTagTool::findSTag (  EvtRecDTag::DecayMode  mode,
int  tagcharm
) 
 

bool DTagTool::findSTag (  int  mode  ) 
  

00247                                {
00248 
00249   bool isStcand=false;
00250   double de_min=1;
00251  
00252   //loop over the dtag list
00253   EvtRecDTagCol::iterator iter_dtag=m_iterbegin;
00254   for ( ; iter_dtag != m_iterend; iter_dtag++){
00255  
00256     if(m_pid){
00257       if(  (*iter_dtag)->type()!=1 || (*iter_dtag)->decayMode() != mode ) 
00258         continue;
00259     }
00260     else{
00261       if(  (*iter_dtag)->decayMode() != mode ) 
00262         continue;
00263     }
00264 
00265     if(fabs((*iter_dtag)->deltaE())<fabs(de_min)){
00266       isStcand=true;
00267       m_iterstag=iter_dtag;
00268       de_min=(*iter_dtag)->deltaE();
00269     }
00270  
00271   } //end of looping over the entire DTag list
00272  
00273   return isStcand;
00274  
00275 }//end of stag

bool DTagTool::findSTag (  int  mode,
int  tagcharm
) 
  

00217                                              {
00218 
00219   bool isStcand=false;
00220   double de_min=1;
00221  
00222   //loop over the dtag list
00223   EvtRecDTagCol::iterator iter_dtag=m_iterbegin;
00224   for ( ; iter_dtag != m_iterend; iter_dtag++){
00225 
00226     if(m_pid){
00227       if( (*iter_dtag)->type()!=1 || (*iter_dtag)->decayMode() != mode ||  (*iter_dtag)->charm() != tagcharm ) 
00228         continue;
00229     }
00230     else{
00231       if( (*iter_dtag)->decayMode() != mode ||  (*iter_dtag)->charm() != tagcharm ) 
00232         continue;
00233     }
00234     if(fabs((*iter_dtag)->deltaE())<fabs(de_min)){
00235       isStcand=true;
00236       m_iterstag=iter_dtag;
00237       de_min=(*iter_dtag)->deltaE();
00238     }
00239  
00240   } //end of looping over the entire DTag list
00241  
00242   return isStcand;
00243  
00244 }//end of stag

bool DTagTool::findSTag (  EvtRecDTag::DecayMode  mode  ) 
  

00185                                                {
00186 
00187   bool isStcand=false;
00188   double de_min=1;
00189  
00190   //loop over the dtag list
00191   EvtRecDTagCol::iterator iter_dtag=m_iterbegin;
00192   for ( ; iter_dtag != m_iterend; iter_dtag++){
00193  
00194     if(m_pid){
00195       if( (*iter_dtag)->type()!=1 || (*iter_dtag)->decayMode() != mode ) 
00196         continue;
00197     }
00198     else{
00199       if(  (*iter_dtag)->decayMode() != mode ) 
00200         continue;
00201     }
00202 
00203     if(fabs((*iter_dtag)->deltaE())<fabs(de_min)){
00204       isStcand=true;
00205       m_iterstag=iter_dtag;
00206       de_min=(*iter_dtag)->deltaE();
00207     }
00208  
00209   } //end of looping over the entire DTag list
00210  
00211   return isStcand;
00212  
00213 }//end of stag

bool DTagTool::findSTag (  EvtRecDTag::DecayMode  mode,
int  tagcharm
) 
  

00152                                                              {
00153 
00154   bool isStcand=false;
00155   double de_min=1;
00156  
00157   //loop over the dtag list
00158   EvtRecDTagCol::iterator iter_dtag=m_iterbegin;
00159   for ( ; iter_dtag != m_iterend; iter_dtag++){
00160  
00161     if(m_pid){
00162       if( (*iter_dtag)->type()!=1 || (*iter_dtag)->decayMode() != mode ||  (*iter_dtag)->charm() != tagcharm ) 
00163         continue;
00164     }
00165     else{
00166       if( (*iter_dtag)->decayMode() != mode ||  (*iter_dtag)->charm() != tagcharm ) 
00167         continue;
00168     }
00169 
00170     if(fabs((*iter_dtag)->deltaE())<fabs(de_min)){
00171       isStcand=true;
00172       m_iterstag=iter_dtag;
00173       de_min=(*iter_dtag)->deltaE();
00174     }
00175 
00176     
00177   } //end of looping over the entire DTag list
00178  
00179   return isStcand;
00180  
00181 }//end of stag

bool DTagTool::isDTagListEmpty (   )  [inline]
  

00028 { return m_isdtaglistempty; }

bool DTagTool::isDTagListEmpty (   )  [inline]
  

00033 { return m_isdtaglistempty; }

bool DTagTool::isDTagListEmpty (   )  [inline]
  

00033 { return m_isdtaglistempty; }

bool DTagTool::isDTagListEmpty (   )  [inline]
  

00028 { return m_isdtaglistempty; }

bool DTagTool::isElectron (  EvtRecTrack *  trk  ) 
 

bool DTagTool::isElectron (  EvtRecTrack *  trk  ) 
  

00718                                          {
00719   double dedxchi=-99;
00720   double Eemc=0;
00721   double ptrk=-99;
00722  
00723   if(trk->isMdcDedxValid()){
00724     RecMdcDedx* dedxTrk=trk->mdcDedx();
00725     dedxchi=dedxTrk->chiE();
00726   }
00727    
00728   if( trk->isMdcKalTrackValid() ){
00729     RecMdcKalTrack *mdcKalTrk = trk->mdcKalTrack();
00730     ptrk= mdcKalTrk->p();
00731   }
00732   if( trk->isEmcShowerValid()){
00733     RecEmcShower *emcTrk = trk->emcShower();
00734     Eemc=emcTrk->energy();
00735   }
00736  
00737   double eop = Eemc/ptrk;
00738  
00739   if( fabs(eop)>0.8 && fabs(dedxchi)<5)
00740     return true;
00741   else
00742     return false;
00743 }

bool DTagTool::isGoodShower (  EvtRecTrack *  trk  ) 
 

bool DTagTool::isGoodShower (  EvtRecTrack *  trk  ) 
  

00787                                            {
00788   RecEmcShower *emcTrk = trk->emcShower();
00789   double eraw = emcTrk->energy();
00790   double time = emcTrk->time();
00791   double costh = cos(emcTrk->theta());
00792   if( ( 
00793        (fabs(costh)<0.80 && eraw>0.025) 
00794        || (fabs(costh)>0.84 && eraw>0.05) 
00795        ) && time>0 && time<14 ) 
00796     return true;
00797 
00798   return false;
00799 }

bool DTagTool::isGoodTrack (  EvtRecTrack *  trk  ) 
 

bool DTagTool::isGoodTrack (  EvtRecTrack *  trk  ) 
  

00757                                           {
00758   Hep3Vector xorigin(0,0,0);
00759   IVertexDbSvc*  vtxsvc;
00760   Gaudi::svcLocator()->service("VertexDbSvc", vtxsvc);
00761   if(vtxsvc->isVertexValid()){
00762     double* dbv = vtxsvc->PrimaryVertex();
00763     double*  vv = vtxsvc->SigmaPrimaryVertex();
00764     xorigin.setX(dbv[0]);
00765     xorigin.setY(dbv[1]);
00766     xorigin.setZ(dbv[2]);
00767   }
00768   
00769   RecMdcKalTrack *mdcKalTrk = trk->mdcKalTrack();
00770   mdcKalTrk->setPidType(RecMdcKalTrack::pion);
00771   HepVector    a  = mdcKalTrk->getZHelix();
00772   HepSymMatrix Ea = mdcKalTrk->getZError();
00773   HepPoint3D pivot(0.,0.,0.);
00774   HepPoint3D IP(xorigin[0],xorigin[1],xorigin[2]);
00775   VFHelix helixp(pivot,a,Ea);
00776   helixp.pivot(IP);
00777   HepVector vec    = helixp.a();
00778   double    vrl    = vec[0];
00779   double    vzl    = vec[3];
00780   double costheta  = cos(mdcKalTrk->theta());
00781   
00782   if(fabs(vrl)<1 && fabs(vzl)<10 && fabs(costheta)<0.93)
00783     return true;
00784   return false;
00785 }

bool DTagTool::isKaon (  EvtRecTrack *  trk  ) 
 

bool DTagTool::isKaon (  EvtRecTrack *  trk  ) 
 

bool DTagTool::isKaon (  EvtRecTrack *  trk  ) 
 

bool DTagTool::isKaon (  EvtRecTrack *  trk  ) 
  

00703                                      {
00704   SmartRefVector<EvtRecTrack> kaonid=(*m_iterbegin)->kaonId();
00705 
00706   for(int i=0; i < kaonid.size() ;i++){
00707     if( trk->trackId() == kaonid[i]->trackId()){
00708       return true;
00709       break;
00710     }
00711   }
00712  
00713   return false;
00714 }

bool DTagTool::isMuon (  EvtRecTrack *  trk  ) 
 

bool DTagTool::isMuon (  EvtRecTrack *  trk  ) 
  

00745                                      {
00746   
00747   double depth=-99;
00748   if(  trk->isMucTrackValid() ){
00749     RecMucTrack* mucTrk=trk->mucTrack();
00750     depth=mucTrk->depth();
00751   }
00752   if(depth>=5)
00753     return true;
00754   return false;
00755 }

bool DTagTool::isPion (  EvtRecTrack *  trk  ) 
 

bool DTagTool::isPion (  EvtRecTrack *  trk  ) 
 

bool DTagTool::isPion (  EvtRecTrack *  trk  ) 
 

bool DTagTool::isPion (  EvtRecTrack *  trk  ) 
  

00688                                      {
00689   
00690   SmartRefVector<EvtRecTrack> pionid=(*m_iterbegin)->pionId();
00691   
00692   for(int i=0; i < pionid.size() ;i++){
00693     if( trk->trackId() == pionid[i]->trackId()){
00694       return true;
00695       break;
00696     }
00697   }
00698   
00699   return false;
00700 }

vector<int> DTagTool::mode (  int  decaymode  ) 
 

vector<int> DTagTool::mode (  EvtRecDTag::DecayMode  decaymode  ) 
 

vector<int> DTagTool::mode (  EvtRecDTag::DecayMode  decaymode  ) 
 

vector<int> DTagTool::mode (  EvtRecDTag::DecayMode  decaymode  ) 
 

vector< int > DTagTool::mode (  int  decaymode  ) 
  

00127                                        {
00128 
00129   vector<int> mode;
00130   int index=0;
00131   for(EvtRecDTagCol::iterator iter=m_iterbegin; iter != m_iterend; iter++){
00132     
00133     if(m_pid){
00134       if( (*iter)->decayMode() == decaymode && (*iter)->type() == 1 )
00135         mode.push_back( index ); 
00136     }
00137     else{
00138       if( (*iter)->decayMode() == decaymode )
00139         mode.push_back( index ); 
00140     }
00141 
00142     index++;
00143   }
00144   
00145   return mode;
00146 }

vector< int > DTagTool::mode (  EvtRecDTag::DecayMode  decaymode  ) 
  

00105                                                        {
00106 
00107   vector<int> mode;
00108   int index=0;
00109   for(EvtRecDTagCol::iterator iter=m_iterbegin; iter != m_iterend; iter++){
00110     
00111     if(m_pid){
00112       if( (*iter)->decayMode() == decaymode && (*iter)->type() == 1 )
00113         mode.push_back( index ); 
00114     }
00115     else{
00116       if( (*iter)->decayMode() == decaymode )
00117         mode.push_back( index ); 
00118     }
00119 
00120     index++;
00121   }
00122   
00123   return mode;
00124 }

EvtRecDTagCol::iterator DTagTool::modes_begin (   )  [inline]
  

00031 { return m_iterbegin;}

EvtRecDTagCol::iterator DTagTool::modes_begin (   )  [inline]
  

00036 { return m_iterbegin;}

EvtRecDTagCol::iterator DTagTool::modes_begin (   )  [inline]
  

00036 { return m_iterbegin;}

EvtRecDTagCol::iterator DTagTool::modes_begin (   )  [inline]
  

00031 { return m_iterbegin;}

EvtRecDTagCol::iterator DTagTool::modes_end (   )  [inline]
  

00032 { return m_iterend;}

EvtRecDTagCol::iterator DTagTool::modes_end (   )  [inline]
  

00037 { return m_iterend;}

EvtRecDTagCol::iterator DTagTool::modes_end (   )  [inline]
  

00037 { return m_iterend;}

EvtRecDTagCol::iterator DTagTool::modes_end (   )  [inline]
  

00032 { return m_iterend;}

void DTagTool::name (   )  [inline]
  

00073 { cout<<" I am the dtag tool"<<endl;}

void DTagTool::name (   )  [inline]
  

00060 { cout<<" I am the dtag tool"<<endl;}

void DTagTool::name (   )  [inline]
  

00060 { cout<<" I am the dtag tool"<<endl;}

void DTagTool::name (   )  [inline]
  

00073 { cout<<" I am the dtag tool"<<endl;}

void DTagTool::operator<< (  EvtRecDTagCol::iterator  iter  ) 
 

void DTagTool::operator<< (  EvtRecDTagCol::iterator  iter  ) 
 

void DTagTool::operator<< (  EvtRecDTagCol::iterator  iter  ) 
 

void DTagTool::operator<< (  EvtRecDTagCol::iterator  iter  ) 
  

00670                                                      {
00671 
00672   cout<<" print mode:"<< (*iter)->decayMode()<<endl;
00673   cout<<"beam energy is:"<< (*iter)->beamE()<<endl;
00674   cout<<"mBC is:"<< (*iter)->mBC()<<endl;
00675   cout<<"deltaE is:"<< (*iter)->deltaE()<<endl;
00676   cout<<"inv mass is:"<< (*iter)->mass()<<endl;
00677   cout<<"charge is:"<< (*iter)->charge()<<endl;
00678   cout<<"charm is:"<< (*iter)->charm()<<endl;
00679   cout<<"num of children is:"<< (*iter)->numOfChildren()<<endl;
00680 
00681   cout<<"found "<< (*iter)->tracks().size()<<" same side tracks."<<endl;
00682   cout<<"found "<< (*iter)->otherTracks().size()<<" other side tracks."<<endl;
00683   cout<<"found "<< (*iter)->showers().size()<<" same side showers."<<endl;
00684   cout<<"found "<< (*iter)->otherShowers().size()<<" other side showers."<<endl;
00685 
00686 }

void DTagTool::setPID (  bool  pid  )  [inline]
  

00034 {m_pid = pid;}

void DTagTool::setPID (  bool  pid  )  [inline]
  

00034 {m_pid = pid;}

bool DTagTool::shareTracks (  EvtRecDTagCol::iterator  iter1,
EvtRecDTagCol::iterator  iter2
) 
 

bool DTagTool::shareTracks (  EvtRecDTagCol::iterator  iter1,
EvtRecDTagCol::iterator  iter2
) 
  

00848                                                                                  {
00849   
00850   SmartRefVector<EvtRecTrack> tracks1=(*iter1)->tracks();
00851   SmartRefVector<EvtRecTrack> showers1=(*iter1)->showers();
00852   SmartRefVector<EvtRecTrack> tracks2=(*iter2)->tracks();
00853   SmartRefVector<EvtRecTrack> showers2=(*iter2)->showers();
00854   
00855   //charged tracks
00856   for(int i=0; i<tracks1.size(); i++){
00857     for(int j=0; j<tracks2.size(); j++){
00858       if(tracks1[i]==tracks2[j])
00859         return true;
00860     }
00861   }
00862 
00863   //neutral showers
00864   for(int i=0; i<showers1.size(); i++){
00865     for(int j=0; j<showers2.size(); j++){
00866       if(showers1[i]==showers2[j])
00867         return true;
00868     }
00869   }  
00870 
00871   return false;
00872 }

EvtRecDTagCol::iterator DTagTool::stag (   )  [inline]
  

00055 { return m_iterstag;}

EvtRecDTagCol::iterator DTagTool::stag (   )  [inline]
  

00049 { return m_iterstag;}

EvtRecDTagCol::iterator DTagTool::stag (   )  [inline]
  

00049 { return m_iterstag;}

EvtRecDTagCol::iterator DTagTool::stag (   )  [inline]
  

00055 { return m_iterstag;}

Member Data Documentation

EvtRecTrackIterator DTagTool::m_chargebegin [private]
 

EvtRecTrackIterator DTagTool::m_chargeend [private]
 

vector<int> DTagTool::m_d0modes [private]
 

vector<int> DTagTool::m_d0modes [private]
 

vector<int> DTagTool::m_d0modes [private]
 

vector<int> DTagTool::m_d0modes [private]
 

vector<int> DTagTool::m_dpmodes [private]
 

vector<int> DTagTool::m_dpmodes [private]
 

vector<int> DTagTool::m_dpmodes [private]
 

vector<int> DTagTool::m_dpmodes [private]
 

vector<int> DTagTool::m_dsmodes [private]
 

vector<int> DTagTool::m_dsmodes [private]
 

vector<int> DTagTool::m_dsmodes [private]
 

vector<int> DTagTool::m_dsmodes [private]
 

IDataProviderSvc* DTagTool::m_evtSvc [private]
 

IDataProviderSvc* DTagTool::m_evtSvc [private]
 

IDataProviderSvc* DTagTool::m_evtSvc [private]
 

IDataProviderSvc* DTagTool::m_evtSvc [private]
 

bool DTagTool::m_isdtaglistempty [private]
 

EvtRecDTagCol::iterator DTagTool::m_iterbegin [private]
 

EvtRecDTagCol::iterator DTagTool::m_iterdtag1 [private]
 

EvtRecDTagCol::iterator DTagTool::m_iterdtag2 [private]
 

EvtRecDTagCol::iterator DTagTool::m_iterend [private]
 

EvtRecDTagCol::iterator DTagTool::m_iterstag [private]
 

bool DTagTool::m_pid [private]
 

EvtRecTrackIterator DTagTool::m_showerbegin [private]
 

EvtRecTrackIterator DTagTool::m_showerend [private]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 16:00:47 2011 for BOSS6.5.5 by  doxygen 1.3.9.1