BesSensitiveManager Class Reference

#include <BesSensitiveManager.hh>

List of all members.

Public Member Functions

 BesSensitiveManager ()
 ~BesSensitiveManager ()
void AddSensitiveDetector (BesSensitiveDetector *detector)
G4int GetCurrentTrackIndex () const
std::vector< BesTruthTrack * > * GetTrackList ()
std::vector< BesTruthVertex * > * GetVertexList ()
void BeginOfTruthEvent (const G4Event *)
void EndOfTruthEvent (const G4Event *)
G4int CheckType (const HepMC::GenEvent *hepmcevt)
void SaveParticlesFromGenerator ()
void SetVertex0 (const G4Event *)
void UpdatePrimaryTrack (const G4Track *)
G4bool CheckDecayTrack (const G4Track *)
void UpdateVertex (BesTStats, const G4Track *)
G4bool MatchDaughterTrack (const G4Track *)
void GetDaughterVertexes (BesTruthTrack *pTrack, std::vector< int > *vDau)
G4bool MatchVertex (G4int vIndex, std::vector< int > *vDau)
void BeginOfTrack (const G4Track *track)
void EndOfTrack (const G4Track *track, G4TrackingManager *)
G4int GetNumberTracks () const
G4int GetNumberVertices () const
void ClearEvent ()
void SetLogLevel (G4int level)

Static Public Member Functions

static BesSensitiveManagerGetSensitiveManager ()

Protected Member Functions

void MakeNewTrack (BesTStats &stat, const G4Track *track)
BesTStats FollowTrack (const G4Track *track)

Protected Attributes

std::vector< BesSensitiveDetector
* >::iterator 
iter
std::vector< BesSensitiveDetector
* >::iterator 
iter_end
G4int m_trackIndex
G4int m_trackFlag
std::vector< BesTruthTrack * > * m_trackList
std::vector< BesTruthVertex * > * m_vertexList
std::vector< BesSensitiveDetector * > clients
std::vector< BesTStatschain
G4int m_count
G4ThreeVector m_pos0
G4double m_t0
G4int m_logLevel
HepMC::GenEvent * m_hepmcevt

Static Protected Attributes

static BesSensitiveManagerm_sensitiveManager = 0


Detailed Description

Definition at line 73 of file BesSensitiveManager.hh.


Constructor & Destructor Documentation

BesSensitiveManager::BesSensitiveManager (  )  [inline]

Definition at line 75 of file BesSensitiveManager.hh.

References m_hepmcevt, and m_sensitiveManager.

00075                        :m_trackIndex(-1),m_trackFlag(0),m_count(0) 
00076   {
00077     m_hepmcevt = 0; 
00078     if(m_sensitiveManager) 
00079       G4Exception("BesSensitiveManager constructed twice.");
00080     m_sensitiveManager = this ;
00081   }

BesSensitiveManager::~BesSensitiveManager (  )  [inline]

Definition at line 83 of file BesSensitiveManager.hh.

00083 {;}


Member Function Documentation

void BesSensitiveManager::AddSensitiveDetector ( BesSensitiveDetector detector  )  [inline]

Definition at line 88 of file BesSensitiveManager.hh.

References clients.

Referenced by BesSensitiveDetector::BesSensitiveDetector().

00089   {
00090     clients.push_back( detector );
00091   }

void BesSensitiveManager::BeginOfTrack ( const G4Track *  track  ) 

Definition at line 252 of file BesSensitiveManager.cc.

References chain, clients, FollowTrack(), iter, iter_end, and m_trackFlag.

Referenced by BesTrackingAction::PreUserTrackingAction().

00253 {
00254   m_trackFlag = 0; //if m_trackFlag=1, this track is from generator
00255 
00256   // Append our track in the parentage history
00257   chain.push_back(FollowTrack(track));
00258 
00259   // Get TruthTrack index
00260   //int i = chain.size();
00261 
00262   /*for(;;) 
00263   {
00264     if(--i<0) G4cerr<<"::parents are corrupted"<<G4endl;
00265     m_trackIndex = chain[i].trackIndex;
00266     if (m_trackIndex != -1) break;
00267   }*/
00268   
00269   // Invoke clients
00270   //
00271   iter=clients.begin();
00272   iter_end=clients.end();
00273   while(iter!=iter_end) 
00274   {
00275     (*iter)->BeginOfTrack( track );
00276     iter++;
00277   }
00278 }

void BesSensitiveManager::BeginOfTruthEvent ( const G4Event *   ) 

Definition at line 43 of file BesSensitiveManager.cc.

References clients, iter, iter_end, m_count, m_trackList, m_vertexList, SaveParticlesFromGenerator(), and SetVertex0().

Referenced by BesEventAction::BeginOfEventAction().

00044 {
00045   // Allocate our lists. We'll own these until EndOfEvent
00046 
00047   m_trackList  = new std::vector<BesTruthTrack*>;
00048   m_vertexList = new std::vector<BesTruthVertex*>;
00049   
00050   SetVertex0(evt);
00051 
00052   m_count = 0;
00053   SaveParticlesFromGenerator();
00054   m_count += m_trackList->size();
00055 
00056   // Tell clients
00057   iter=clients.begin();
00058   iter_end=clients.end();
00059   while( iter != iter_end ) 
00060   {
00061     (*iter)->BeginOfTruthEvent(evt);
00062     iter++;
00063   }
00064 }

G4bool BesSensitiveManager::CheckDecayTrack ( const G4Track *   ) 

Definition at line 590 of file BesSensitiveManager.cc.

References chain, BesTruthTrack::Found(), GetDaughterVertexes(), BesTruthTrack::GetG4TrackId(), BesTruthVertex::GetIndex(), BesTruthTrack::GetIndex(), BesTruthTrack::GetP4(), BesTruthTrack::GetPDGCode(), BesTruthTrack::GetTerminalVertex(), BesTruthTrack::GetVertex(), genRecEmupikp::i, m_logLevel, m_trackIndex, m_trackList, mass, MatchVertex(), BesTruthTrack::SetG4TrackId(), BesTruthTrack::SetParticleName(), and BesTruthTrack::SetPDGCharge().

Referenced by FollowTrack().

00591 { 
00592   G4int flag = 0;
00593   G4int trackID = track->GetTrackID();
00594   G4int parentID = track->GetParentID();
00595   G4int pdgcode = track->GetDefinition()->GetPDGEncoding();
00596   G4ThreeVector p3 = track->GetMomentum();
00597   if(m_logLevel<=4)
00598     G4cout<<"CheckDecayTrack p3: "<<p3<<"  "<<track->GetTotalEnergy()<<G4endl;
00599 
00600   //HepLorentzVector  p4(track->GetMomentum(), track->GetTotalEnergy());
00601   
00602   BesTruthTrack* truthTrack=0;
00603   G4int nTrack = m_trackList->size();
00604   G4int parentTrackIndex=-99;
00605   G4int terminalVertexIndex=-99;
00606   BesTruthTrack* pTrack;
00607   for(int i=0;i<nTrack;i++)
00608   {
00609     truthTrack = (*m_trackList)[i];
00610     if(truthTrack->GetG4TrackId() == parentID)
00611     {
00612       //parentTrackIndex = i;
00613       parentTrackIndex = truthTrack->GetIndex();
00614       if(truthTrack->GetTerminalVertex())
00615       {
00616         terminalVertexIndex = truthTrack->GetTerminalVertex()->GetIndex();
00617         pTrack = truthTrack;
00618         if(m_logLevel<=4)
00619         {
00620           G4cout<<"parentTrackIndex:"<<parentTrackIndex<<" "
00621                 <<"parent terminate at vertex: "<<terminalVertexIndex<<G4endl;
00622           if(parentTrackIndex != i)
00623             G4cout<<"i: "<<i<<std::endl;
00624         }
00625         break;
00626       }
00627     }
00628   }
00629   if(parentTrackIndex==-99 || terminalVertexIndex==-99)
00630   {
00631     G4cout<<"MatchDecayError!"<<G4endl;
00632     //return false;
00633     exit(1);
00634   }
00635  
00636   //match decayed track with p3
00637   /*G4bool matchDauFlag=false; 
00638   if(terminalVertexIndex>0)
00639     matchDauFlag = MatchDaughterTrack(track);
00640   if(matchDauFlag)
00641     return true;*/
00642 
00643   //match decayed track with vertex index
00644   G4double minDiffP=1e99;
00645   G4int truthI=-9;
00646   /*for(int i=0;i<nTrack;i++)
00647   {
00648     truthTrack = (*m_trackList)[i];
00649     G4String source = truthTrack->GetSource();
00650     G4int pdgcode_tru = truthTrack->GetPDGCode();
00651     if(pdgcode_tru==-22)  pdgcode_tru = 22;
00652     if(truthTrack->GetVertex()->GetIndex() == terminalVertexIndex &&
00653        pdgcode_tru == pdgcode &&source=="FromGenerator"&&truthTrack->NotFound())
00654     {
00655       HepLorentzVector tp4 = truthTrack->GetP4();
00656       G4ThreeVector tp3(tp4.x(), tp4.y(), tp4.z());
00657       G4double diffP = (p3-tp3).mag2();
00658       if(m_logLevel<=4)
00659         G4cout<<"diffP: "<<diffP<<G4endl;
00660       if(diffP<minDiffP )
00661       {  minDiffP = diffP;  truthI = i; }
00662     }
00663   }*/
00664   
00665   /*if(truthI!=-9)
00666   {
00667     if(m_logLevel<=4)
00668       G4cout<<"MatchDecayedTrackWithVertexIndex, trackIndex:"<<truthI<<G4endl;
00669     m_trackIndex = truthI;
00670     truthTrack=(*m_trackList)[truthI];
00671     //truthTrack->SetP4(p4);
00672     truthTrack->SetPDGCharge(track->GetDefinition()->GetPDGCharge());
00673     truthTrack->SetParticleName(track->GetDefinition()->GetParticleName());
00674     truthTrack->SetG4TrackId(track->GetTrackID());
00675     truthTrack->Found();
00676     G4int size = truthTrack->GetDaughterIndexes().size();
00677     if(size>0)
00678     {
00679       G4int minDau = (truthTrack->GetDaughterIndexes())[0];
00680       G4int maxDau = (truthTrack->GetDaughterIndexes())[size-1];
00681       if(m_logLevel<=4)
00682         G4cout<<"daughters: "<<minDau<<" "<<maxDau<<G4endl;
00683     }
00684     else
00685     {
00686       if(m_logLevel<=4)
00687       G4cout<<G4endl;
00688     }
00689     return true; 
00690   }*/ //match decay track with vertex index
00691 
00692   //match decay track
00693   
00694   if(m_logLevel<=4)
00695     std::cout<<"chain.back().vertices.size(): "<<chain.back().vertices.size()<<std::endl;
00696   //if particle is from generator, chain.back().vertices.size()=0;
00697   //if particle is not from generator, but decayed during flight in Geant4, chain.back().vertices.size()=1;
00698   if(chain.back().vertices.size()<1)
00699   {
00700     if(m_logLevel<=4)
00701       std::cout<<"trackList size: "<<m_trackList->size()<<std::endl;
00702     std::vector<int>* vDau = new std::vector<int>;
00703     GetDaughterVertexes(pTrack, vDau);
00704     G4int sizev = vDau->size();
00705     if(sizev>0)
00706     {
00707       for(int i=0;i<nTrack;i++)
00708       {
00709         truthTrack = (*m_trackList)[i];
00710         G4int vIndex = truthTrack->GetVertex()->GetIndex();
00711         G4int pdgT = truthTrack->GetPDGCode();
00712         if(pdgT==-22)  pdgT = 22;
00713         if(pdgT == pdgcode)
00714         {
00715           G4bool matchFlag = MatchVertex(vIndex, vDau);
00716           if(matchFlag)
00717           {
00718             HepLorentzVector tp4 = truthTrack->GetP4();
00719             G4ThreeVector tp3(tp4.x(), tp4.y(), tp4.z());
00720             G4double diffP = (p3-tp3).mag2();
00721             if(m_logLevel<=4)
00722             {
00723               G4cout<<"index: "<<truthTrack->GetIndex()<<"tp3: "<<tp3<<G4endl;
00724               G4cout<<"diffP: "<<diffP<<G4endl;
00725             }
00726             if(diffP<minDiffP)
00727             {  
00728               minDiffP = diffP;  truthI = i; 
00729               if(m_logLevel<=4)
00730                 G4cout<<"truthI: "<<i<<G4endl;
00731             }
00732           }
00733         }
00734       }
00735       if(vDau)
00736         delete vDau;
00737     }
00738   }
00739 
00740   if(truthI!=-9)
00741   {
00742     m_trackIndex = truthI;
00743     if(m_logLevel<=4)
00744     {
00745       G4cout<<"MatchDecayedTrackWithTrueMother"<<G4endl;
00746       G4cout<<"MatchWithTrueMother m_trackIndex: "<<m_trackIndex<<G4endl;
00747       if(minDiffP>1e-9)
00748         G4cout<<"large minDiffP: "<<minDiffP<<G4endl;
00749     }
00750     truthTrack=(*m_trackList)[truthI];
00751     G4double mass = truthTrack->GetP4().m();
00752     G4double E = sqrt(mass*mass+p3.x()*p3.x()+p3.y()*p3.y()+p3.z()*p3.z());    
00753     truthTrack->GetP4().setX(p3.x());
00754     truthTrack->GetP4().setY(p3.y());
00755     truthTrack->GetP4().setZ(p3.z());
00756     truthTrack->GetP4().setE(E);
00757     HepLorentzVector  p4 = truthTrack->GetP4();
00758     if(m_logLevel<=4)
00759     {
00760       G4cout<<"primary p: "<<p4.x()<<" "<<p4.y()<<" "<<p4.z()<<" "<<p4.m()<<G4endl;
00761     }
00762     truthTrack->SetPDGCharge(track->GetDefinition()->GetPDGCharge());
00763     truthTrack->SetParticleName(track->GetDefinition()->GetParticleName());
00764     truthTrack->SetG4TrackId(track->GetTrackID());
00765     truthTrack->Found();
00766     //truthTrack->GetVertex()->SetPosition(track->GetPosition());
00767     //truthTrack->GetVertex()->SetTime(track->GetGlobalTime());
00768     return true;
00769   }
00770   return false;   
00771 }

G4int BesSensitiveManager::CheckType ( const HepMC::GenEvent *  hepmcevt  ) 

Definition at line 79 of file BesSensitiveManager.cc.

References m_logLevel.

Referenced by SaveParticlesFromGenerator().

00080 {
00081   G4int flag =0;
00082   for(HepMC::GenEvent::vertex_const_iterator vitr= hepmcevt->vertices_begin();
00083           vitr != hepmcevt->vertices_end(); ++vitr ) { // loop for vertex ...
00084     for (HepMC::GenVertex::particle_iterator
00085              pitr= (*vitr)->particles_begin(HepMC::children);
00086                 pitr != (*vitr)->particles_end(HepMC::children); ++pitr) {
00087       if((*pitr)->end_vertex())
00088         {flag = 1; break;}
00089     }
00090     if(flag) break;
00091   }
00092   if(m_logLevel <= 4)
00093   {
00094     if(flag == 0)
00095       G4cout<<G4endl<<"generator is GENBES!"<<G4endl;
00096     else
00097       G4cout<<G4endl<<"generator is not GENBES!"<<G4endl;
00098   }
00099   return flag;
00100 }

void BesSensitiveManager::ClearEvent (  ) 

Definition at line 234 of file BesSensitiveManager.cc.

References genRecEmupikp::i, m_trackList, and m_vertexList.

Referenced by BesEventAction::EndOfEventAction().

00235 {
00236   if(m_trackList)
00237   {
00238     for(size_t i=0;i<m_trackList->size();i++)
00239       delete (*m_trackList)[i];
00240     m_trackList->clear();
00241     delete m_trackList;
00242   }
00243   if(m_vertexList)
00244   {
00245     for(size_t i=0;i<m_vertexList->size();i++)
00246       delete (*m_vertexList)[i];
00247     m_vertexList->clear();
00248     delete m_vertexList;
00249   }
00250 }

void BesSensitiveManager::EndOfTrack ( const G4Track *  track,
G4TrackingManager *   
)

Definition at line 279 of file BesSensitiveManager.cc.

References chain, clients, BesTruthTrack::GetTerminalVertex(), genRecEmupikp::i, iter, iter_end, m_count, m_logLevel, m_trackFlag, m_trackIndex, m_trackList, m_vertexList, boss::pos, BesTruthVertex::SetIndex(), BesTruthVertex::SetMinDau(), BesTruthVertex::SetParentTrack(), BesTruthVertex::SetPosition(), BesTruthVertex::SetTerminal(), BesTruthVertex::SetTime(), and UpdateVertex().

Referenced by BesTrackingAction::PostUserTrackingAction().

00280 {
00281   if(chain.back().savedByDefault==true)
00282   { 
00283     BesTStats &stat = chain.back();
00284     G4int endVtxFlag = 0;
00285     if(m_trackFlag==1)
00286     {
00287       BesTruthTrack* truthTrack = (*m_trackList)[m_trackIndex];
00288       if(truthTrack->GetTerminalVertex())
00289       {
00290         UpdateVertex(stat,track); endVtxFlag = 1;}
00291     } 
00292     if(endVtxFlag == 0)
00293     {
00294       // Tracks saved to BesTruthTrack require additional work
00295       G4StepPoint *finalStep = track->GetStep()->GetPostStepPoint();
00296       G4StepStatus stepStatus = finalStep->GetStepStatus();
00297       if (track->GetNextVolume() != 0 ||
00298               (stepStatus != fGeomBoundary && stepStatus != fWorldBoundary) )
00299       {
00300         if(m_logLevel<=4)
00301           G4cout<<"Particle died. make a terminal vertex: ";
00302         // Particle died. We always make a terminal vertex
00303         const G4ThreeVector pos(finalStep->GetPosition());
00304         G4int vindex = m_vertexList->size();
00305         if(m_logLevel<=4)
00306           G4cout<<vindex<<G4endl;
00307         stat.vertices.push_back(vindex);
00308         BesTruthVertex *newVertex = new BesTruthVertex();
00309         newVertex->SetPosition(pos);
00310         newVertex->SetTime( finalStep->GetGlobalTime());
00311         if(m_trackFlag==1)
00312           newVertex->SetParentTrack( (*m_trackList)[m_trackIndex] );
00313         else
00314           newVertex->SetParentTrack( m_trackList->back() );
00315         newVertex->SetTerminal( true );
00316         newVertex->SetIndex( vindex );
00317         
00318         //set minDaughter index equal to m_count
00319         newVertex->SetMinDau(m_count);  
00320         
00321         //Get how many decayed daughters this track has, if no, 0 is set.
00322         G4TrackVector* trackVector = trackingManager->GimmeSecondaries();
00323         G4int nSecon = trackVector->size();
00324         G4Track* seconTrack;
00325         G4int nDau=0;
00326         if(nSecon>0)
00327         {
00328           for(G4int i=0;i<nSecon;i++)
00329           {
00330             seconTrack = (*trackVector)[i];
00331             G4String processName = seconTrack->GetCreatorProcess()->GetProcessName();
00332             if(processName == "Decay")
00333               nDau++;
00334           }
00335         }
00336         m_vertexList->push_back( newVertex );
00337   
00338         m_count += nDau;
00339         
00340         // Give this terminal vertex to the track
00341         //(*m_trackList)[stat.trackIndex]->SetTerminalVertex( m_vertexList->back() );
00342         // for particles from generator, 
00343         // m_trackList->back() may not be current track.
00344 
00345         if(m_trackFlag==1)
00346           (*m_trackList)[m_trackIndex]->SetTerminalVertex( m_vertexList->back() );
00347         else
00348           m_trackList->back()->SetTerminalVertex( m_vertexList->back() );
00349       }
00350     }
00351   } 
00352   // Invoke clients
00353   iter=clients.begin();
00354   iter_end=clients.end();
00355   while( iter!=iter_end) {
00356     (*iter)->EndOfTrack( track );
00357     iter++;
00358   }
00359 }

void BesSensitiveManager::EndOfTruthEvent ( const G4Event *   ) 

Definition at line 222 of file BesSensitiveManager.cc.

References clients, iter, and iter_end.

Referenced by BesEventAction::EndOfEventAction().

00223 {
00224   // Tell clients
00225   iter=clients.begin();
00226   iter_end=clients.end();
00227   while( iter != iter_end ) 
00228   {
00229     (*iter)->EndOfTruthEvent(evt);
00230     iter++;
00231   }
00232 }

BesTStats BesSensitiveManager::FollowTrack ( const G4Track *  track  )  [protected]

Definition at line 505 of file BesSensitiveManager.cc.

References chain, CheckDecayTrack(), m_hepmcevt, m_logLevel, m_pos0, m_t0, m_trackFlag, MakeNewTrack(), and UpdatePrimaryTrack().

Referenced by BeginOfTrack().

00506 {
00507   // Some default stats for this track
00508   BesTStats stat( track->GetTrackID(),
00509                   HepLorentzVector( track->GetMomentum(), track->GetTotalEnergy() ),
00510                   track->GetGlobalTime());
00511 
00512   // Check immediate parent
00513   G4int parentId = track->GetParentID();
00514   G4int pdg = track->GetDefinition()->GetPDGEncoding();
00515   G4String particleName = track->GetDefinition()->GetParticleName();
00516   G4ThreeVector trackPos = track->GetPosition();
00517   G4double diffT = m_t0-track->GetGlobalTime();
00518   G4ThreeVector diffPos = (m_pos0-trackPos).mag2();
00519 
00520   if (parentId == 0) 
00521   {
00522     if(m_logLevel<=4)
00523     {
00524       G4cout<<G4endl;
00525       G4cout<<"trackId:"<<track->GetTrackID()<<" ";
00526       G4cout<<"parentId:"<<parentId<<" ";
00527       G4cout<<"pdg:"<<pdg<<" ";
00528       G4cout<<"name:"<<particleName<<" ";
00529       G4cout<<"timeDiff:"<<diffT<<" ";
00530       G4cout<<"posDiff:"<<diffPos<<G4endl;
00531     }
00532 
00533     // Primary particle: wipe decay chain
00534     chain.clear();
00535     // Always save
00536     stat.savedByDefault = true;
00537     // Make TruthTrack
00538     if(m_hepmcevt==0)
00539       MakeNewTrack( stat, track );  
00540     else
00541     {
00542       UpdatePrimaryTrack(track);
00543       m_trackFlag = 1;
00544     }
00545     return stat;
00546   }
00547         
00548   // Not primary particle: trim down chain until
00549   // we uncover the parent. The parent must be there!
00550   for(;;) 
00551   {
00552     if (chain.back().G4index == parentId) break;
00553     chain.pop_back();
00554   }
00555 
00556   // This track is a candidate for saving by default
00557   // only if its parent was saved by default
00558   if (chain.back().savedByDefault) 
00559   {
00560     // There are three ways particles are saved by default:
00561     //   1. if they are a primary particle
00562     //   2. if they are the result of a decay
00563     //
00564     G4String processName = track->GetCreatorProcess()->GetProcessName();
00565     if (processName=="Decay") 
00566     {
00567       if(m_logLevel<=4)
00568       {
00569         G4cout<<G4endl;
00570         G4cout<<"trackId: "<<track->GetTrackID()<<" ";
00571         G4cout<<"parentId: "<<parentId<<" ";
00572         G4cout<<"pdg: "<<pdg<<" ";
00573         G4cout<<"pname: "<<particleName<<G4endl;
00574       }
00575       stat.savedByDefault = true;
00576 
00577       if(CheckDecayTrack(track))
00578         m_trackFlag = 1;
00579       else
00580         MakeNewTrack( stat, track);
00581       return stat;
00582     }
00583   }
00584   
00585   //now this track will not be saved as BesTruthTrack
00586   stat.savedByDefault = false;
00587   return stat;
00588 }

G4int BesSensitiveManager::GetCurrentTrackIndex (  )  const [inline]

Definition at line 93 of file BesSensitiveManager.hh.

References m_trackIndex.

Referenced by BesSensitiveDetector::GetCurrentTrackIndex().

00093 { return m_trackIndex; }

void BesSensitiveManager::GetDaughterVertexes ( BesTruthTrack pTrack,
std::vector< int > *  vDau 
)

Definition at line 773 of file BesSensitiveManager.cc.

References BesTruthTrack::GetDaughterIndexes(), m_trackList, and delete_small_size::size.

Referenced by CheckDecayTrack().

00774 {
00775   G4int size = pTrack->GetDaughterIndexes().size();
00776   if(size>0)
00777   {
00778     G4int minDau = (pTrack->GetDaughterIndexes())[0];
00779     G4int maxDau = (pTrack->GetDaughterIndexes())[size-1];
00780     //note! here, dau<=maxDau, not dau<maxDau
00781     for(G4int dau=minDau;dau<=maxDau;dau++)
00782     {
00783       if(dau<m_trackList->size())
00784       {
00785         BesTruthTrack* truthTrack = (*m_trackList)[dau];
00786         if(truthTrack->GetVertex())
00787         {
00788           vDau->push_back(truthTrack->GetVertex()->GetIndex());
00789           GetDaughterVertexes(truthTrack,vDau);
00790         }
00791       } 
00792     }
00793   }
00794 }

G4int BesSensitiveManager::GetNumberTracks (  )  const [inline]

Definition at line 119 of file BesSensitiveManager.hh.

References m_trackList.

00119 { return m_trackList ? m_trackList->size() : 0; }

G4int BesSensitiveManager::GetNumberVertices (  )  const [inline]

Definition at line 120 of file BesSensitiveManager.hh.

References m_vertexList.

00120 { return m_vertexList ? m_vertexList->size() : 0; }

static BesSensitiveManager* BesSensitiveManager::GetSensitiveManager (  )  [inline, static]

Definition at line 85 of file BesSensitiveManager.hh.

References m_sensitiveManager.

Referenced by BesEventAction::BeginOfEventAction(), BesSensitiveDetector::BesSensitiveDetector(), BesEventAction::EndOfEventAction(), BesSensitiveDetector::GetCurrentTrackIndex(), BesTrackingAction::PostUserTrackingAction(), BesTrackingAction::PreUserTrackingAction(), BesEmcSD::ProcessHits(), BesMcTruthWriter::SaveMcParticle(), BesAsciiIO::SaveTrackTruth(), and BesAsciiIO::SaveVertexTruth().

00085 {return m_sensitiveManager; }

std::vector<BesTruthTrack*>* BesSensitiveManager::GetTrackList (  )  [inline]

Definition at line 94 of file BesSensitiveManager.hh.

References m_trackList.

Referenced by BesSensitiveDetector::GetCurrentTrackIndex(), BesEmcSD::ProcessHits(), BesMcTruthWriter::SaveMcParticle(), and BesAsciiIO::SaveTrackTruth().

00094 {return m_trackList;}

std::vector<BesTruthVertex*>* BesSensitiveManager::GetVertexList (  )  [inline]

Definition at line 95 of file BesSensitiveManager.hh.

References m_vertexList.

Referenced by BesMcTruthWriter::SaveMcParticle(), and BesAsciiIO::SaveVertexTruth().

00095 {return m_vertexList;}

void BesSensitiveManager::MakeNewTrack ( BesTStats stat,
const G4Track *  track 
) [protected]

Definition at line 381 of file BesSensitiveManager.cc.

References BesTruthTrack::AddDaughterIndex(), chain, BesTruthVertex::GetCurrentDau(), BesTruthTrack::GetIndex(), BesTruthVertex::GetMinDau(), BesTruthVertex::GetParentTrack(), BesTruthTrack::GetVertex(), genRecEmupikp::i, m_count, m_logLevel, m_trackIndex, m_trackList, m_vertexList, BesTStats::originVertex, BesTStats::p4, BesTruthTrack::SetG4TrackId(), BesTruthTrack::SetIndex(), BesTruthVertex::SetIndex(), BesTruthTrack::SetP4(), BesTruthVertex::SetParentTrack(), BesTruthTrack::SetParticleName(), BesTruthTrack::SetPDGCharge(), BesTruthTrack::SetPDGCode(), BesTruthVertex::SetPosition(), BesTruthVertex::SetProcessName(), BesTruthTrack::SetSource(), BesTruthVertex::SetTerminal(), BesTruthVertex::SetTime(), BesTruthTrack::SetVertex(), BesTStats::trackIndex, and v.

Referenced by FollowTrack().

00382 {
00383   if (stat.originVertex < 0 && chain.size() > 0) 
00384   {
00385     if(m_logLevel<=4)
00386       G4cout<<"MakeNewTrack for decayed particles,";
00387     //for decayed particles, there may already be a BesTruthVertex that is suitable for this track.
00388     //If so, it's always the terminal vertex of its immediate parent( chain.back() ).
00389 
00390     G4int parentVstat = chain.back().vertices.size();
00391     while( --parentVstat >= 0)
00392     {
00393       G4int vindex = chain.back().vertices[parentVstat];
00394 
00395       G4ThreeVector diff((*m_vertexList)[vindex]->GetPosition());
00396       diff = diff - track->GetPosition();
00397       if (diff.mag2() < 1E-9) 
00398       {
00399               stat.originVertex = vindex;
00400         if(m_logLevel<=4)
00401           G4cout<<"find a vertex:"<<vindex;
00402         (*m_vertexList)[vindex]->AddCurrentDau();
00403         break;
00404       }
00405     }
00406     
00407   }
00408   
00409   if(stat.originVertex < 0 && chain.size() == 0)
00410   {
00411     //for primary track, check if there is already a vertex suitable for it.
00412     G4int nVertex = m_vertexList->size();         
00413     for(G4int i=0;i<nVertex;i++)
00414     {
00415       G4ThreeVector diff((*m_vertexList)[i]->GetPosition());
00416       diff = diff -track->GetPosition();
00417       if(diff.mag2() < 1E-9)
00418       {
00419         stat.originVertex = i; 
00420         if(m_logLevel<=4)
00421           G4cout<<"MakeNewTrack for primary particles,find a vertex:"
00422                 <<i;
00423         break;
00424       }
00425     }
00426   }
00427   
00428   if (stat.originVertex < 0)
00429   {
00430     if(m_logLevel<=4) 
00431       G4cout<<"MakeNewTrack for primary particles,make new vertex:"
00432             <<m_vertexList->size();
00433     // it's a primary track(there's no vertex suitable for it)
00434     // Make a new BesTruthVertex
00435     const G4ThreeVector v(track->GetPosition());
00436                 
00437     stat.originVertex = m_vertexList->size();
00438 
00439     BesTruthVertex *newVertex = new BesTruthVertex();
00440     newVertex->SetPosition(v);
00441     newVertex->SetTime( track->GetGlobalTime());
00442     
00443     //if (chain.size() > 0) {
00444     //  G4int trackIndex = -1;
00445     //  G4int i = chain.size();
00446     //  while(--i>=0 && trackIndex < 0) trackIndex = chain[i].trackIndex;
00447     //  newVertex->SetParentTrack( trackIndex < 0 ? 0 : (*m_trackList)[trackIndex] );
00448     //}
00449     
00450     newVertex->SetParentTrack( 0 );
00451     newVertex->SetTerminal( false );
00452     newVertex->SetIndex( stat.originVertex );
00453     if(track->GetCreatorProcess())
00454       newVertex->SetProcessName(track->GetCreatorProcess()->GetProcessName());
00455     else
00456       newVertex->SetProcessName("generator");    
00457     
00458     m_vertexList->push_back( newVertex );
00459   }
00460         
00461   // Now, finally make our new BesTruthTrack
00462   // We'll leave the assignment of terminalVertex until
00463   // we know what happens to this track         
00464   BesTruthTrack *newTrack = new BesTruthTrack();
00465   newTrack->SetP4( stat.p4 );
00466   newTrack->SetPDGCode(track->GetDefinition()->GetPDGEncoding());
00467   newTrack->SetPDGCharge(track->GetDefinition()->GetPDGCharge());
00468   newTrack->SetParticleName(track->GetDefinition()->GetParticleName());
00469   newTrack->SetSource("FromG4");
00470   BesTruthVertex* vertex = (*m_vertexList)[stat.originVertex];
00471   newTrack->SetVertex(vertex);
00472   
00473   if(track->GetParentID()==0)
00474   {
00475     stat.trackIndex = m_count;
00476     m_count++;
00477   }
00478   else
00479     stat.trackIndex = vertex->GetMinDau() + vertex->GetCurrentDau()-1;
00480   
00481   newTrack->SetIndex( stat.trackIndex );
00482   m_trackIndex = stat.trackIndex;
00483   if(m_logLevel<=4)
00484     G4cout<<"  m_trackIndex:"<<m_trackIndex<<G4endl;
00485   
00486   newTrack->SetG4TrackId( track->GetTrackID()); 
00487   m_trackList->push_back( newTrack );
00488   //tell the parent track its daughter track index
00489   BesTruthTrack* parent = newTrack->GetVertex()->GetParentTrack();
00490   if(parent)
00491   {
00492     parent->AddDaughterIndex(stat.trackIndex);
00493     if(m_logLevel<=4)
00494       G4cout<<"add this daughter to:"<<parent->GetIndex()<<G4endl;
00495   }
00496 }

G4bool BesSensitiveManager::MatchDaughterTrack ( const G4Track *   ) 

Definition at line 810 of file BesSensitiveManager.cc.

00811 {
00812   /*G4int flag=0;
00813   G4int pdgcode = track->GetDefinition()->GetPDGEncoding();
00814   G4ThreeVector p = track->GetMomentum();
00815   HepLorentzVector  p4(track->GetMomentum(), track->GetTotalEnergy());
00816   G4ThreeVector pos = track->GetPosition();
00817   G4double time = track->GetGlobalTime();
00818   BesTruthTrack* truthTrack=0;
00819   G4int size = m_trackList->size();
00820   if(size>0)
00821   { 
00822     for(G4int i=0;i<size;i++)
00823     {
00824       truthTrack=(*m_trackList)[i];
00825       G4String source = truthTrack->GetSource(); 
00826       G4int pdgcode_tru = truthTrack->GetPDGCode();
00827       if(pdgcode_tru==-22)  pdgcode_tru = 22;
00828       HepLorentzVector tp4 = truthTrack->GetP4();
00829       G4ThreeVector tp3(tp4.x(), tp4.y(), tp4.z());
00830       G4double diffP = (p-tp3).mag2();
00831       if(source=="FromGenerator"&&pdgcode_tru==pdgcode&&diffP<1e-9&&truthTrack->NotFound())
00832       {
00833         m_trackIndex = i;
00834         //truthTrack->SetP4(p4);
00835         truthTrack->SetPDGCharge(track->GetDefinition()->GetPDGCharge());
00836         truthTrack->SetParticleName(track->GetDefinition()->GetParticleName());
00837         truthTrack->SetG4TrackId(track->GetTrackID());
00838         truthTrack->Found();
00839         //truthTrack->GetVertex()->SetPosition(pos);
00840         //truthTrack->GetVertex()->SetTime(time);
00841         flag=1;
00842         if(m_logLevel<=4)
00843         {
00844           G4cout<<"MatchDecayedTrackWithP3!"<<"trackIndex:"<<m_trackIndex
00845                 <<" pdgcode:"<<pdgcode<<G4endl;
00846           G4cout<<"parentIndex:"<<truthTrack->GetVertex()->GetParentTrack()->GetIndex()
00847                 <<"  PDGCode:"<<truthTrack->GetVertex()->GetParentTrack()->GetPDGCode()<<G4endl; 
00848         }
00849         return true;
00850       }
00851     }
00852   }
00853   if(flag!=1)
00854     return false;*/
00855   return true;
00856 }

G4bool BesSensitiveManager::MatchVertex ( G4int  vIndex,
std::vector< int > *  vDau 
)

Definition at line 796 of file BesSensitiveManager.cc.

References genRecEmupikp::i, and delete_small_size::size.

Referenced by CheckDecayTrack().

00797 {
00798   G4int size = vDau->size();
00799   if(size>0)
00800   {
00801     for(G4int i=0;i<size;i++)
00802     {
00803       if(vIndex==(*vDau)[i])
00804         return true;
00805     }
00806   }
00807   return false;
00808 }

void BesSensitiveManager::SaveParticlesFromGenerator (  ) 

Definition at line 102 of file BesSensitiveManager.cc.

References CheckType(), BesTruthTrack::GetBarcodeEndVtx(), McGenEvent::getGenEvt(), BesTruthTrack::GetIndex(), genRecEmupikp::i, m_hepmcevt, m_logLevel, m_trackList, m_vertexList, mass, BesTruthTrack::SetBarcodeEndVtx(), BesTruthTrack::SetIndex(), BesTruthTrack::SetP4(), BesTruthTrack::SetParticleName(), BesTruthTrack::SetPDGCharge(), BesTruthTrack::SetPDGCode(), BesTruthTrack::SetSource(), BesTruthTrack::SetTerminalVertex(), BesTruthTrack::SetVertex(), and v.

Referenced by BeginOfTruthEvent().

00103 {
00104   IDataProviderSvc* p_evtSvc=0;
00105   ISvcLocator* svcLocator = Gaudi::svcLocator();
00106   StatusCode sc=svcLocator->service("EventDataSvc", p_evtSvc);
00107   if (sc.isFailure())
00108       std::cout<<"BesHepMCInterface could not access EventDataSvc!!"<<std::endl;
00109 
00110   SmartDataPtr<McGenEventCol> mcCollptr( p_evtSvc, "/Event/Gen");
00111 
00112   if ( mcCollptr == 0 )
00113     std::cout << "no McGenEventCollection found."  << std::endl;
00114 
00115   else 
00116   {
00117     McGenEventCol::const_iterator it = mcCollptr->begin();
00118     McGenEvent* mcEvent = (McGenEvent* ) (*it);
00119     m_hepmcevt = mcEvent->getGenEvt();
00120     G4int typeFlag = CheckType(m_hepmcevt); 
00121     
00122 
00123     for(HepMC::GenEvent::vertex_const_iterator vitr= m_hepmcevt->vertices_begin();
00124               vitr != m_hepmcevt->vertices_end(); ++vitr ) 
00125     {
00126       G4int barcodeVtx = (*vitr)->barcode();
00127       if(m_logLevel<=4)
00128         G4cout<<G4endl<<"barcodeVtx:"<<barcodeVtx<<" ";
00129   
00130       G4LorentzVector xvtx((*vitr)->position().x(),(*vitr)->position().y(),(*vitr)->position().z(),(*vitr)->position().t());
00131       G4ThreeVector v(xvtx.x(), xvtx.y(), xvtx.z());
00132       BesTruthVertex* newVertex = new BesTruthVertex();
00133       newVertex->SetPosition(v);
00134       newVertex->SetTime(xvtx.t()*mm/c_light);
00135       if(m_logLevel<=4)
00136         G4cout<<"xyzt:"<<xvtx.x()<<" "<<xvtx.y()<<" "
00137             <<xvtx.z()<<" "<<xvtx.t()*mm/c_light<<" ";
00138       G4int nTrack = m_trackList->size();
00139       BesTruthTrack* parentTrack=0;
00140       G4int parentTrackIndex= -99;
00141       for(int i=0;i<nTrack;i++)
00142       {
00143         parentTrack = (*m_trackList)[i];
00144         if(parentTrack->GetBarcodeEndVtx() == barcodeVtx)
00145         {
00146           newVertex->SetParentTrack(parentTrack);
00147           parentTrackIndex = parentTrack->GetIndex();
00148           if(m_logLevel<=4)
00149             G4cout<<"parentTrack:"<<parentTrackIndex<<" ";
00150           parentTrack->SetTerminalVertex(newVertex);
00151           //break;
00152         }
00153       }
00154   
00155       G4int vtxFlag=0;
00156       G4int pOut = (*vitr)->particles_out_size();
00157       HepMC::GenVertex::particle_iterator pitr = (*vitr)->particles_begin(HepMC::children);
00158       G4int pdgcode= (*pitr)-> pdg_id();
00159       if(pOut == 1 && pdgcode == -11 && typeFlag==1)
00160         vtxFlag=1;
00161           
00162       if(vtxFlag==0)
00163       {
00164         m_vertexList->push_back(newVertex);
00165         newVertex->SetIndex(m_vertexList->size()-1);
00166         if(m_logLevel<=4)
00167           G4cout<<"vindex:"<<m_vertexList->size()-1<<G4endl;
00168   
00169         for (HepMC::GenVertex::particle_iterator pitr= (*vitr)->particles_begin(HepMC::children); pitr != (*vitr)->particles_end(HepMC::children); ++pitr)
00170         {
00171           G4LorentzVector p((*pitr)->momentum().x(), (*pitr)->momentum().y(),(*pitr)->momentum().z(),(*pitr)->momentum().t());
00172           G4LorentzVector pGeV(p.x()*GeV,p.y()*GeV,p.z()*GeV,p.t()*GeV);
00173           G4int pdgcode = (*pitr)->pdg_id();
00174   
00175           BesTruthTrack* newTrack = new BesTruthTrack;
00176           newTrack->SetP4(pGeV);
00177           newTrack->SetPDGCode(pdgcode);
00178           if(m_logLevel<=4)
00179           {  
00180             G4cout<<"pdg:"<<pdgcode<<" ";
00181             G4cout<<"p:"<<p.x()<<" "<<p.y()<<" "<<p.z()<<" "<<p.t()<<" ";
00182             G4double mass = sqrt(p.t()*p.t()-p.x()*p.x()-p.y()*p.y()-p.z()*p.z());
00183             G4cout<<mass<<" ";
00184           }
00185           newTrack->SetPDGCharge(99);
00186           newTrack->SetParticleName("unknown");
00187           newTrack->SetVertex(newVertex);
00188           newTrack->SetTerminalVertex(0);
00189           newTrack->SetSource("FromGenerator");
00190         
00191           G4int barcodeEndVtx=0;
00192           if((*pitr)->end_vertex())
00193           {
00194             barcodeEndVtx = (*pitr)->end_vertex()->barcode();
00195             if(m_logLevel<=4)
00196               G4cout<<"endVtx:"<<barcodeEndVtx<<" ";
00197           }
00198           newTrack->SetBarcodeEndVtx(barcodeEndVtx);
00199   
00200           m_trackList->push_back(newTrack);
00201           newTrack->SetIndex(m_trackList->size()-1);
00202           if(m_logLevel<=4)
00203             G4cout<<"index:"<<m_trackList->size()-1<<" ";
00204           //here, parentTrack->GetIndex can't be used,
00205           //use parentTrackIndex instead
00206           if(parentTrackIndex>=0)
00207           {
00208             if(m_logLevel<=4)
00209               G4cout<<"mother:"<<parentTrackIndex; 
00210             (*m_trackList)[parentTrackIndex]->AddDaughterIndex(m_trackList->size()-1);
00211           }
00212           if(m_logLevel<=4)
00213             G4cout<<G4endl;
00214         }  
00215       }
00216     } 
00217   } 
00218 }

void BesSensitiveManager::SetLogLevel ( G4int  level  )  [inline]

Definition at line 124 of file BesSensitiveManager.hh.

References m_logLevel.

Referenced by BesSim::initialize().

00124 {m_logLevel = level;}

void BesSensitiveManager::SetVertex0 ( const G4Event *   ) 

Definition at line 66 of file BesSensitiveManager.cc.

References genRecEmupikp::i, m_logLevel, m_pos0, and m_t0.

Referenced by BeginOfTruthEvent().

00067 {
00068   //G4int n_vertex = anEvent->GetNumberOfPrimaryVertex();
00069   for( G4int i=0; i<1; i++ )
00070   {
00071     G4PrimaryVertex* primaryVertex = anEvent->GetPrimaryVertex(i);
00072     m_pos0 = primaryVertex->GetPosition();
00073     m_t0 = primaryVertex->GetT0();
00074   }
00075   if(m_logLevel<=4)
00076     G4cout<<"pos0:"<<m_pos0<<"   t0:"<<m_t0<<G4endl;
00077 }

void BesSensitiveManager::UpdatePrimaryTrack ( const G4Track *   ) 

Definition at line 858 of file BesSensitiveManager.cc.

References BesTruthTrack::Found(), BesTruthTrack::GetDaughterIndexes(), BesTruthTrack::GetIndex(), BesTruthTrack::GetP4(), BesTruthTrack::GetPDGCode(), genRecEmupikp::i, m_logLevel, m_trackIndex, m_trackList, mass, BesTruthTrack::NotFound(), BesTruthTrack::SetG4TrackId(), BesTruthTrack::SetParticleName(), BesTruthTrack::SetPDGCharge(), and delete_small_size::size.

Referenced by FollowTrack().

00859 {
00860   if(m_logLevel<=4)
00861   {
00862     G4cout<<"UpdatePrimaryTrack! ";
00863     G4cout<<"position: "<<track->GetPosition()<<G4endl;
00864     G4cout<<"time: "<<track->GetGlobalTime()<<G4endl;
00865     G4cout<<"momentum: "<<track->GetMomentum()<<"  "<<track->GetTotalEnergy()<<G4endl;
00866   }
00867   G4int pdgcode = track->GetDefinition()->GetPDGEncoding();
00868   G4ThreeVector p = track->GetMomentum();
00869   //HepLorentzVector  p4(track->GetMomentum(), track->GetTotalEnergy());
00870   G4int nTrack = m_trackList->size();
00871   BesTruthTrack* truthTrack;
00872   G4int flag = 0;
00873   G4double minDiffP=1e99;
00874   for(int i=0;i<nTrack;i++)
00875   {
00876     truthTrack = (*m_trackList)[i];
00877     HepLorentzVector tp4 = truthTrack->GetP4();
00878     G4ThreeVector tp3(tp4.x(), tp4.y(), tp4.z());
00879     G4double diffP=(p-tp3).mag2();
00880     G4int pdgT = truthTrack->GetPDGCode();
00881     if(pdgT==-22) pdgT=22;
00882     if(pdgcode == pdgT && diffP<minDiffP)
00883       minDiffP = diffP;
00884     if(pdgcode == pdgT && diffP < 1E-9 && 
00885        truthTrack->NotFound())
00886     {
00887       m_trackIndex = truthTrack->GetIndex();
00888       if(m_logLevel<=4)
00889         G4cout<<"m_trackIndex: "<<m_trackIndex<<" "<<G4endl;
00890       truthTrack->SetPDGCharge(track->GetDefinition()->GetPDGCharge());
00891       truthTrack->SetParticleName(track->GetDefinition()->GetParticleName());
00892       truthTrack->SetG4TrackId(track->GetTrackID());
00893       truthTrack->Found();
00894       G4double mass = truthTrack->GetP4().m();
00895       G4double E = sqrt(mass*mass+p.x()*p.x()+p.y()*p.y()+p.z()*p.z());
00896       truthTrack->GetP4().setX(p.x());
00897       truthTrack->GetP4().setY(p.y());
00898       truthTrack->GetP4().setZ(p.z());
00899       truthTrack->GetP4().setT(E);
00900       if(m_logLevel<=4)
00901       {
00902         HepLorentzVector  p4 = truthTrack->GetP4();
00903         G4cout<<"primary p: "<<p4.x()<<" "<<p4.y()<<" "<<p4.z()<<" "<<p4.m()<<G4endl;
00904       }
00905       G4int size = truthTrack->GetDaughterIndexes().size();
00906       if(size>0)
00907       {
00908         G4double minDau = (truthTrack->GetDaughterIndexes())[0];
00909         G4double maxDau = (truthTrack->GetDaughterIndexes())[size-1];
00910         if(m_logLevel<=4)
00911           G4cout<<"daughters: "<<minDau<<" "<<maxDau<<G4endl;
00912       }
00913       else
00914       {
00915         if(m_logLevel<=4)
00916           G4cout<<G4endl;
00917       }
00918       flag = 1; break;
00919     }
00920   }
00921   if(flag==0)
00922   {
00923     G4cout<<"MatchError! parentID=0, but match no track in trackList"<<G4endl;
00924     G4cout<<"pdgcode: "<<pdgcode<<" min p diff: "<<minDiffP<<G4endl;
00925     exit(1);
00926   }
00927 }

void BesSensitiveManager::UpdateVertex ( BesTStats  ,
const G4Track *   
)

Definition at line 361 of file BesSensitiveManager.cc.

References BesTruthVertex::GetIndex(), BesTruthTrack::GetTerminalVertex(), m_logLevel, m_trackIndex, boss::pos, BesTruthVertex::SetPosition(), BesTruthVertex::SetTerminal(), and BesTruthVertex::SetTime().

Referenced by EndOfTrack().

00362 {
00363   BesTruthTrack* truthTrack = (*m_trackList)[m_trackIndex];
00364   G4int terminalIndex = truthTrack->GetTerminalVertex()->GetIndex();
00365   if(m_logLevel<=4)  
00366     G4cout<<"updateVertex:"<<terminalIndex<<" ";
00367   BesTruthVertex* vertex = (*m_vertexList)[terminalIndex];
00368   G4StepPoint *finalStep = track->GetStep()->GetPostStepPoint();
00369   const G4ThreeVector pos(finalStep->GetPosition());
00370   G4double time = finalStep->GetGlobalTime();
00371   if(m_logLevel<=4)
00372     G4cout<<"newPos:"<<pos<<" "<<"newTime:"<<time<<G4endl;
00373   vertex->SetPosition(pos);
00374   vertex->SetTime(time);
00375   vertex->SetTerminal( true );
00376   //G4int vindex = m_vertexList->size();
00377   //stat.vertices.push_back(terminalIndex);
00378 
00379 }


Member Data Documentation

std::vector<BesTStats> BesSensitiveManager::chain [protected]

Definition at line 148 of file BesSensitiveManager.hh.

Referenced by BeginOfTrack(), CheckDecayTrack(), EndOfTrack(), FollowTrack(), and MakeNewTrack().

std::vector<BesSensitiveDetector*> BesSensitiveManager::clients [protected]

Definition at line 146 of file BesSensitiveManager.hh.

Referenced by AddSensitiveDetector(), BeginOfTrack(), BeginOfTruthEvent(), EndOfTrack(), and EndOfTruthEvent().

std::vector<BesSensitiveDetector*>::iterator BesSensitiveManager::iter [protected]

Definition at line 130 of file BesSensitiveManager.hh.

Referenced by BeginOfTrack(), BeginOfTruthEvent(), EndOfTrack(), and EndOfTruthEvent().

std::vector<BesSensitiveDetector*>::iterator BesSensitiveManager::iter_end [protected]

Definition at line 131 of file BesSensitiveManager.hh.

Referenced by BeginOfTrack(), BeginOfTruthEvent(), EndOfTrack(), and EndOfTruthEvent().

G4int BesSensitiveManager::m_count [protected]

Definition at line 158 of file BesSensitiveManager.hh.

Referenced by BeginOfTruthEvent(), EndOfTrack(), and MakeNewTrack().

HepMC::GenEvent* BesSensitiveManager::m_hepmcevt [protected]

Definition at line 164 of file BesSensitiveManager.hh.

Referenced by BesSensitiveManager(), FollowTrack(), and SaveParticlesFromGenerator().

G4int BesSensitiveManager::m_logLevel [protected]

Definition at line 163 of file BesSensitiveManager.hh.

Referenced by CheckDecayTrack(), CheckType(), EndOfTrack(), FollowTrack(), MakeNewTrack(), SaveParticlesFromGenerator(), SetLogLevel(), SetVertex0(), UpdatePrimaryTrack(), and UpdateVertex().

G4ThreeVector BesSensitiveManager::m_pos0 [protected]

Definition at line 160 of file BesSensitiveManager.hh.

Referenced by FollowTrack(), and SetVertex0().

BesSensitiveManager * BesSensitiveManager::m_sensitiveManager = 0 [static, protected]

Definition at line 128 of file BesSensitiveManager.hh.

Referenced by BesSensitiveManager(), and GetSensitiveManager().

G4double BesSensitiveManager::m_t0 [protected]

Definition at line 161 of file BesSensitiveManager.hh.

Referenced by FollowTrack(), and SetVertex0().

G4int BesSensitiveManager::m_trackFlag [protected]

Definition at line 135 of file BesSensitiveManager.hh.

Referenced by BeginOfTrack(), EndOfTrack(), and FollowTrack().

G4int BesSensitiveManager::m_trackIndex [protected]

Definition at line 134 of file BesSensitiveManager.hh.

Referenced by CheckDecayTrack(), EndOfTrack(), GetCurrentTrackIndex(), MakeNewTrack(), UpdatePrimaryTrack(), and UpdateVertex().

std::vector<BesTruthTrack*>* BesSensitiveManager::m_trackList [protected]

Definition at line 139 of file BesSensitiveManager.hh.

Referenced by BeginOfTruthEvent(), CheckDecayTrack(), ClearEvent(), EndOfTrack(), GetDaughterVertexes(), GetNumberTracks(), GetTrackList(), MakeNewTrack(), SaveParticlesFromGenerator(), and UpdatePrimaryTrack().

std::vector<BesTruthVertex*>* BesSensitiveManager::m_vertexList [protected]

Definition at line 140 of file BesSensitiveManager.hh.

Referenced by BeginOfTruthEvent(), ClearEvent(), EndOfTrack(), GetNumberVertices(), GetVertexList(), MakeNewTrack(), and SaveParticlesFromGenerator().


Generated on Tue Nov 29 23:17:35 2016 for BOSS_7.0.2 by  doxygen 1.4.7