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

ExtToSecondVertexTool Class Reference

#include <ExtToSecondVertexTool.h>

Inheritance diagram for ExtToSecondVertexTool:

IExtToSecondVertexTool IExtToSecondVertexTool List of all members.

Public Member Functions

void constructCylinderBes ()
void constructCylinderBes ()
void constructWallsFromGdml ()
void constructWallsFromGdml ()
virtual void doKalmanExt (const HepPoint3D &point, DstMdcKalTrack *kalTrack, const int pid)
 Do something.
virtual void doKalmanExt (const HepPoint3D &point, DstMdcKalTrack *kalTrack, const int pid)
 extrapolation to the given point, using pid particle hypothesis
 ExtToSecondVertexTool (const std::string &type, const std::string &name, const IInterface *parent)
 Standard Constructor.
 ExtToSecondVertexTool (const std::string &type, const std::string &name, const IInterface *parent)
 Standard Constructor.
virtual StatusCode finalize ()
virtual StatusCode finalize ()
const HepSymMatrix getErrorMatrix () const
const HepSymMatrix getErrorMatrix () const
const HepVector getHelixVector () const
const HepVector getHelixVector () const
void getMaterialFromGdml ()
void getMaterialFromGdml ()
virtual StatusCode initialize ()
 Overriding initialize and finalize.
virtual StatusCode initialize ()
 Overriding initialize and finalize.
virtual const std::string & message () const
 IExtToSecondVertexTool interface.
virtual const std::string & message () const
 IExtToSecondVertexTool interface.
void setErrorMatrix (const CLHEP::HepSymMatrix Ea)
void setErrorMatrix (const CLHEP::HepSymMatrix Ea)
void setHelixVector (const CLHEP::HepVector a)
void setHelixVector (const CLHEP::HepVector a)
virtual ~ExtToSecondVertexTool ()
 Standard destructor.
virtual ~ExtToSecondVertexTool ()
 Standard destructor.

Static Public Member Functions

const InterfaceID & interfaceID ()
 Retrieve interface ID.
const InterfaceID & interfaceID ()
 Retrieve interface ID.

Private Member Functions

void extToAnyPoint (KalFitTrack &track, const HepPoint3D &point)
void extToAnyPoint (KalFitTrack &track, const HepPoint3D &point)
int getWallMdcNumber (const HepPoint3D &point) const
int getWallMdcNumber (const HepPoint3D &point) const
void initKalmanFitting (void) const
void initKalmanFitting (void) const

Private Attributes

std::vector< KalFitMaterial > m_BesKalmanExtMaterials
std::vector< KalFitMaterial > m_BesKalmanExtMaterials
std::vector< KalFitCylinder > m_BesKalmanExtWalls
 Properties.
std::vector< KalFitCylinder > m_BesKalmanExtWalls
 Properties.
bool m_bool
int m_debug
 for debugging
CLHEP::HepSymMatrix m_errorMatrix
std::string m_geopath
 path of the geometry file of beampipe
CLHEP::HepVector m_helixVector
int m_loss
 eloss and MS treatment flag
int m_muls
std::string m_string

Constructor & Destructor Documentation

ExtToSecondVertexTool::ExtToSecondVertexTool (  const std::string &  type,
const std::string &  name,
const IInterface *  parent
) 
 

Standard Constructor. 

00042 : GaudiTool( type, name, parent ),m_loss(1),m_muls(1),m_debug(0) {
00043 
00044   // declare my special interface
00045   declareInterface<IExtToSecondVertexTool>(this);
00046   // 
00047   m_geopath = std::string("/ihepbatch/d09/wangjk/workarea633/Reconstruction/ExtToSecondVertexTool/ExtToSecondVertexTool-00-00-05/share/geo_cylinder.dat");
00048 
00049   // declare properties
00050   declareProperty( "Eloss",    m_loss = 1);
00051   declareProperty( "Ms",       m_muls = 1);
00052   //declareProperty( "GeoPath",  m_geopath = "");
00053   declareProperty( "String", m_string = "hundred");
00054   declareProperty( "Bool",   m_bool   = true);
00055   declareProperty( "Debug",  m_debug   = 0);
00056 }

ExtToSecondVertexTool::~ExtToSecondVertexTool (   )  [virtual]
 

Standard destructor. 

00171 { 
00172   MsgStream log(msgSvc(), name());
00173   log << MSG::INFO << "destructor has been called" << endreq;
00174 }

ExtToSecondVertexTool::ExtToSecondVertexTool (  const std::string &  type,
const std::string &  name,
const IInterface *  parent
) 
 

Standard Constructor.

virtual ExtToSecondVertexTool::~ExtToSecondVertexTool (   )  [virtual]
 

Standard destructor.

Member Function Documentation

void ExtToSecondVertexTool::constructCylinderBes (   ) 
 

void ExtToSecondVertexTool::constructCylinderBes (   ) 
  

00019 {
00020   // std::string  geo = std::string(getenv("$KALFITALGROOT"))+std::string("/share/geomdc_cylinder.dat");
00021   ifstream fin(m_geopath.c_str() ); 
00022   if(!fin){
00023     perror(m_geopath.c_str());
00024     cout<<"ExtToSecondVertexTool:: setCylinder.......file reading error"<<endl;
00025     exit(1);
00026   }
00027       
00028   int i;
00029   double radius, thick, length , z0;
00030   for (int j = 0; j < 8 &&
00031       fin >> i >> radius >> thick >> length >> z0; j++) {
00032     KalFitCylinder cylinder(&(m_BesKalmanExtMaterials[i]), radius, thick, length , z0);
00033     m_BesKalmanExtWalls.push_back(cylinder);
00034   }
00035   fin.close();
00036   
00037 }

void ExtToSecondVertexTool::constructWallsFromGdml (   ) 
 

void ExtToSecondVertexTool::constructWallsFromGdml (  void   ) 
 

mdcgas

inner wall aluminium

air

outer beryllium pipe

cooling oil

inner beryllium pipe

gold layer

now construct the cylinders

innerwall of inner drift chamber

outer air, be attention the calculation of the radius and thick of the air cylinder is special

outer Beryllium layer

oil layer

inner Beryllium layer

gold layer

the air in the innermost of the pipe 

00013                                                       {
00014 
00015   int i(0);
00016   double Z(0.),A(0.),Ionization(0.),Density(0.),Radlen(0.);
00017   
00018   G4LogicalVolume *logicalMdc = 0;
00019   MdcG4Geo* aMdcG4Geo = new MdcG4Geo();
00020   logicalMdc = aMdcG4Geo->GetTopVolume();   
00021 
00023   G4Material* mdcMaterial = logicalMdc->GetMaterial();  
00024 
00025   for(i=0; i<mdcMaterial->GetElementVector()->size(); i++){
00026     Z += (mdcMaterial->GetElement(i)->GetZ())*
00027          (mdcMaterial->GetFractionVector()[i]);
00028     A += (mdcMaterial->GetElement(i)->GetA())*
00029          (mdcMaterial->GetFractionVector()[i]);
00030   }
00031   Ionization = mdcMaterial->GetIonisation()->GetMeanExcitationEnergy();
00032   Density = mdcMaterial->GetDensity()/(g/cm3);
00033   Radlen = mdcMaterial->GetRadlen();
00034   std::cout<<"mdcgas: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<std::endl;
00035   KalFitMaterial FitMdcMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.); 
00036   m_BesKalmanExtMaterials.push_back(FitMdcMaterial);
00037   KalFitTrack::mdcGasRadlen_ = Radlen/10.;
00038   
00040   G4LogicalVolume* innerwallVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("logicalMdcSegment2"));
00041   G4Material* innerwallMaterial = innerwallVolume->GetMaterial();
00042   G4Tubs* innerwallTub = dynamic_cast<G4Tubs*>(innerwallVolume->GetSolid());
00043   
00044   Z = 0.;
00045   A = 0.;
00046   for(i=0; i<innerwallMaterial->GetElementVector()->size(); i++){    
00047     Z += (innerwallMaterial->GetElement(i)->GetZ())*
00048          (innerwallMaterial->GetFractionVector()[i]); 
00049     A += (innerwallMaterial->GetElement(i)->GetA())*    
00050          (innerwallMaterial->GetFractionVector()[i]);
00051   }
00052 
00053   Ionization = innerwallMaterial->GetIonisation()->GetMeanExcitationEnergy();
00054   Density = innerwallMaterial->GetDensity()/(g/cm3);
00055   Radlen = innerwallMaterial->GetRadlen();
00056   std::cout<<"Mdc innerwall, Al: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<std::endl;
00057   KalFitMaterial FitInnerwallMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
00058   m_BesKalmanExtMaterials.push_back(FitInnerwallMaterial);
00059   
00061   G4LogicalVolume *logicalBes = 0;
00062   BesG4Geo* aBesG4Geo = new BesG4Geo();
00063  logicalBes = aBesG4Geo->GetTopVolume();
00064  
00066   G4LogicalVolume* logicalAirVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("logicalWorld"));
00067   G4Material* airMaterial = logicalAirVolume->GetMaterial();
00068   Z = 0.;
00069   A = 0.;
00070   for(i=0; i<airMaterial->GetElementVector()->size(); i++){
00071     Z += (airMaterial->GetElement(i)->GetZ())*
00072          (airMaterial->GetFractionVector()[i]);
00073     A += (airMaterial->GetElement(i)->GetA())*
00074          (airMaterial->GetFractionVector()[i]);
00075   }
00076   
00077   Ionization = airMaterial->GetIonisation()->GetMeanExcitationEnergy();
00078   Density = airMaterial->GetDensity()/(g/cm3);
00079   Radlen = airMaterial->GetRadlen();
00080   std::cout<<"air: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<std::endl;
00081   KalFitMaterial FitAirMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
00082   m_BesKalmanExtMaterials.push_back(FitAirMaterial);
00083    
00084   
00086   G4LogicalVolume* logicalOuterBeVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("logicalouterBe"));
00087   G4Material* outerBeMaterial = logicalOuterBeVolume->GetMaterial();
00088   G4Tubs* outerBeTub = dynamic_cast<G4Tubs*>(logicalOuterBeVolume->GetSolid());
00089    Z = 0.;
00090    A = 0.;
00091    for(i=0; i<outerBeMaterial->GetElementVector()->size(); i++){   
00092      Z += (outerBeMaterial->GetElement(i)->GetZ())*
00093           (outerBeMaterial->GetFractionVector()[i]);   
00094      A += (outerBeMaterial->GetElement(i)->GetA())*   
00095           (outerBeMaterial->GetFractionVector()[i]);
00096    }
00097    Ionization =  outerBeMaterial->GetIonisation()->GetMeanExcitationEnergy();
00098    Density = outerBeMaterial->GetDensity()/(g/cm3);
00099    Radlen = outerBeMaterial->GetRadlen();
00100    std::cout<<"outer beryllium: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<std::endl;
00101    KalFitMaterial FitOuterBeMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
00102    m_BesKalmanExtMaterials.push_back(FitOuterBeMaterial);
00103    
00104 
00106   G4LogicalVolume* logicalOilLayerVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("logicaloilLayer"));
00107   G4Material* oilLayerMaterial = logicalOilLayerVolume->GetMaterial();
00108   G4Tubs* oilLayerTub = dynamic_cast<G4Tubs*>(logicalOilLayerVolume->GetSolid());
00109    
00110   Z = 0.;
00111   A = 0.;
00112   for(i=0; i<oilLayerMaterial->GetElementVector()->size(); i++){        
00113     Z += (oilLayerMaterial->GetElement(i)->GetZ())*
00114          (oilLayerMaterial->GetFractionVector()[i]);             
00115     A += (oilLayerMaterial->GetElement(i)->GetA())*             
00116          (oilLayerMaterial->GetFractionVector()[i]);
00117   }
00118   Ionization = oilLayerMaterial->GetIonisation()->GetMeanExcitationEnergy();
00119   Density = oilLayerMaterial->GetDensity()/(g/cm3);
00120   Radlen = oilLayerMaterial->GetRadlen();
00121   std::cout<<"cooling oil: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<std::endl;
00122   KalFitMaterial FitOilLayerMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
00123   m_BesKalmanExtMaterials.push_back(FitOilLayerMaterial);
00124 
00125   
00127   G4LogicalVolume* logicalInnerBeVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("logicalinnerBe"));
00128   G4Material* innerBeMaterial = logicalInnerBeVolume->GetMaterial();
00129   G4Tubs* innerBeTub = dynamic_cast<G4Tubs*>(logicalInnerBeVolume->GetSolid());
00130   Z = 0.;
00131   A = 0.;
00132   for(i=0; i<innerBeMaterial->GetElementVector()->size(); i++){
00133     Z += (innerBeMaterial->GetElement(i)->GetZ())*
00134          (innerBeMaterial->GetFractionVector()[i]);
00135     A += (innerBeMaterial->GetElement(i)->GetA())*
00136          (innerBeMaterial->GetFractionVector()[i]);
00137   }
00138  
00139   Ionization = innerBeMaterial->GetIonisation()->GetMeanExcitationEnergy();
00140   Density = innerBeMaterial->GetDensity()/(g/cm3);
00141   Radlen = innerBeMaterial->GetRadlen();
00142   std::cout<<"inner beryllium: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<std::endl;
00143   KalFitMaterial FitInnerBeMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
00144   m_BesKalmanExtMaterials.push_back(FitInnerBeMaterial);
00145    
00146   
00148   G4LogicalVolume* logicalGoldLayerVolume = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("logicalgoldLayer"));
00149   G4Material* goldLayerMaterial = logicalGoldLayerVolume->GetMaterial();
00150   G4Tubs* goldLayerTub = dynamic_cast<G4Tubs*>(logicalGoldLayerVolume->GetSolid());
00151     
00152   Z = 0.;
00153   A = 0.;
00154   for(i=0; i<goldLayerMaterial->GetElementVector()->size(); i++){
00155     Z += (goldLayerMaterial->GetElement(i)->GetZ())*
00156          (goldLayerMaterial->GetFractionVector()[i]);
00157     A += (goldLayerMaterial->GetElement(i)->GetA())*
00158          (goldLayerMaterial->GetFractionVector()[i]);
00159   }
00160   Ionization = goldLayerMaterial->GetIonisation()->GetMeanExcitationEnergy();
00161   Density = goldLayerMaterial->GetDensity()/(g/cm3);
00162   Radlen = goldLayerMaterial->GetRadlen();
00163   std::cout<<"gold layer: Z: "<<Z<<" A: "<<(A/(g/mole))<<" Ionization: "<<(Ionization/eV)<<" Density: "<<Density<<" Radlen: "<<Radlen<<std::endl;
00164   KalFitMaterial FitGoldLayerMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
00165   m_BesKalmanExtMaterials.push_back(FitGoldLayerMaterial);
00166   
00167 
00169   double radius, thick, length , z0;
00170  
00172   radius = innerwallTub->GetInnerRadius()/(cm);
00173   thick  = innerwallTub->GetOuterRadius()/(cm) - innerwallTub->GetInnerRadius()/(cm);
00174   length = 2.0*innerwallTub->GetZHalfLength()/(cm);
00175   z0     = 0.0;
00176   std::cout<<"innerwall: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
00177   KalFitCylinder innerwallCylinder(&m_BesKalmanExtMaterials[1], radius, thick, length , z0);
00178   m_BesKalmanExtWalls.push_back(innerwallCylinder);
00179  
00181   radius = outerBeTub->GetOuterRadius()/(cm);
00182   thick  = innerwallTub->GetInnerRadius()/(cm) - outerBeTub->GetOuterRadius()/(cm);
00183   length = 2.0*innerwallTub->GetZHalfLength()/(cm);
00184   z0     = 0.0;
00185   std::cout<<"outer air: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
00186   KalFitCylinder outerAirCylinder(&m_BesKalmanExtMaterials[2], radius, thick, length , z0);
00187   m_BesKalmanExtWalls.push_back(outerAirCylinder);
00188  
00190   radius = outerBeTub->GetInnerRadius()/(cm);
00191   thick  = outerBeTub->GetOuterRadius()/(cm) - outerBeTub->GetInnerRadius()/(cm);
00192   length = 2.0*outerBeTub->GetZHalfLength()/(cm);
00193   z0     = 0.0;
00194   std::cout<<"outer Be: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl; 
00195   KalFitCylinder outerBeCylinder(&m_BesKalmanExtMaterials[3], radius, thick, length , z0);
00196   m_BesKalmanExtWalls.push_back(outerBeCylinder);
00197                
00199   radius = oilLayerTub->GetInnerRadius()/(cm);
00200   thick  = oilLayerTub->GetOuterRadius()/(cm) - oilLayerTub->GetInnerRadius()/(cm);
00201   length = 2.0*oilLayerTub->GetZHalfLength()/(cm);
00202   z0     = 0.0;
00203   std::cout<<"oil layer: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl; 
00204   KalFitCylinder oilLayerCylinder(&m_BesKalmanExtMaterials[4], radius, thick, length , z0);
00205   m_BesKalmanExtWalls.push_back(oilLayerCylinder);
00206 
00208   radius = innerBeTub->GetInnerRadius()/(cm);
00209   thick  = innerBeTub->GetOuterRadius()/(cm) - innerBeTub->GetInnerRadius()/(cm);
00210   length = 2.0*innerBeTub->GetZHalfLength()/(cm);
00211   z0     = 0.0;
00212   std::cout<<"inner Be: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl; 
00213   KalFitCylinder innerBeCylinder(&m_BesKalmanExtMaterials[5], radius, thick, length , z0);
00214   m_BesKalmanExtWalls.push_back(innerBeCylinder);
00215   
00217   radius = goldLayerTub->GetInnerRadius()/(cm);
00218   thick  = goldLayerTub->GetOuterRadius()/(cm) - goldLayerTub->GetInnerRadius()/(cm);
00219   length = 2.0*goldLayerTub->GetZHalfLength()/(cm);
00220   z0     = 0.0;
00221   std::cout<<"gold layer: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl; 
00222   KalFitCylinder goldLayerCylinder(&m_BesKalmanExtMaterials[6], radius, thick, length , z0);
00223   m_BesKalmanExtWalls.push_back(goldLayerCylinder);
00224   
00226   //radius = goldLayerTub->GetInnerRadius()/(cm);
00227   radius = 0.;
00228   thick  = goldLayerTub->GetInnerRadius()/(cm);
00229   length = 2.0*goldLayerTub->GetZHalfLength()/(cm);
00230   z0     = 0.0;
00231   std::cout<<"the innermost air: "<<" radius: "<<radius<<" thick:"<<thick<<" length: "<<length<<std::endl;
00232   KalFitCylinder innerMostAir(&m_BesKalmanExtMaterials[2], radius, thick, length , z0); 
00233   m_BesKalmanExtWalls.push_back(innerMostAir);
00234 }

virtual void ExtToSecondVertexTool::doKalmanExt (  const HepPoint3D &  point,
DstMdcKalTrack *  kalTrack,
const int  pid
)  [virtual]
 

Do something.

Implements IExtToSecondVertexTool.

void ExtToSecondVertexTool::doKalmanExt (  const HepPoint3D &  point,
DstMdcKalTrack *  kalTrack,
const int  pid
)  [virtual]
 

extrapolation to the given point, using pid particle hypothesis

Implements IExtToSecondVertexTool.

00072 {
00073   MsgStream log(msgSvc(), name());
00074   log << MSG::DEBUG << "doKalmanExt() [DEBUG] has been called" << endreq;
00075 
00076   //IDataProviderSvc* eventSvc = NULL;
00077   //Gaudi::svcLocator()->service("EventDataSvc", eventSvc);
00078   //SmartDataPtr<RecMdcKalTrackCol> newkaltrkCol(eventSvc,"/Event/Recon/RecMdcKalTrackCol");
00079   
00080   HepVector    tdsHelix  = kalTrack->getFHelix(pid);
00081   HepSymMatrix tdsMatrix = kalTrack->getFError(pid);
00082 
00083   // debugging purpose 
00084   log << MSG::DEBUG << " before Ext. helix: " <<tdsHelix<< endreq;
00085   log << MSG::DEBUG << " before Ext. error: " <<tdsMatrix<< endreq;
00086   
00087   HepPoint3D IP(0.,0.,0.); 
00088   // construct a KalFitTrack
00089   KalFitTrack fitTrack(IP, tdsHelix, tdsMatrix, pid, 0, 0);
00090   
00091   // design is only temporal, more consideration is needed.
00092   // Strictly speaking, it should be Mdc first hit layer here.
00093   // radius of Mdc first layer, be attention this radius I set it by hand.
00094   const double radius = 7.885; //centimeter
00095   const double rp = point.perp();
00096   log << MSG::DEBUG << "radius of point: "<<rp<< endreq; 
00097   
00098   if(rp<=radius){
00099        
00100     KalFitTrack::numf_ = 21;        
00101     KalFitElement::muls(1);
00102     KalFitElement::loss(1);
00103     
00104     const double dphi = fitTrack.intersect_cylinder(radius);
00105     //std::cout<< "dphi: "<<dphi<<std::endl;
00106     // is this usage right???
00107     // Here the lastPivot is the pivot before the extrapolation
00108     // it is the last pivot in MDC 
00109     const HepPoint3D lastPivot = fitTrack.x(dphi);
00110     //std::cout<<" lastPivot in MDC: "<<lastPivot<<std::endl;
00111     //std::cout<<" r of lastPivot: "<<lastPivot.perp()<<std::endl;
00112     fitTrack.pivot(lastPivot);
00113     // extrapolate the track to the given point 
00114     extToAnyPoint(fitTrack, point);
00115        
00116     //std::cout<<" fitTrack1: "<<fitTrack.a()<<std::endl;
00117   }
00118   
00119   //std::cout<<" fitTrack2: "<<fitTrack.a()<<std::endl;
00120   
00121   // set the pivot back to IP
00122   fitTrack.pivot(IP);
00123   setHelixVector(fitTrack.a());
00124   setErrorMatrix(fitTrack.Ea());
00125  
00126   // debugging purpose 
00127   log << MSG::DEBUG << " after Ext. helix: " <<getHelixVector()<< endreq;
00128   log << MSG::DEBUG << " after Ext. error: " <<getErrorMatrix()<< endreq;
00129   
00130 }

void ExtToSecondVertexTool::extToAnyPoint (  KalFitTrack &  track,
const HepPoint3D &  point
)  [private]
 

void ExtToSecondVertexTool::extToAnyPoint (  KalFitTrack &  track,
const HepPoint3D &  point
)  [private]
  

00020                                                                                     {
00021   
00022   const int index = getWallMdcNumber(point);
00023   if(m_debug){
00024     std::cout<<" wall index: "<<index<<std::endl;
00025     std::cout<<"m_BesKalmanExtWalls.size: "<<m_BesKalmanExtWalls.size()<<std::endl;
00026   }
00027 
00028   // not in the pipe  
00029   if (-1==index) return;
00030   // in the innermost pipe
00031   if (6==index){
00032     for(int j=0; j<index; j++){
00033       m_BesKalmanExtWalls[j].updateTrack(track, 1);
00034       if(m_debug){
00035         std::cout<<" track a1: "<<track.a()<<std::endl;
00036         std::cout<<"ptot1: "<<(sqrt(1.+track.a()[4]*track.a()[4])/track.a()[2])<<std::endl;
00037       }
00038     } 
00039   } 
00040  
00041   else if(index>0){
00042     for(int j=0; j<index; j++){
00043       if(m_debug){
00044         std::cout<<" track a2: "<<track.a()<<std::endl;
00045         std::cout<<"ptot2: "<<(sqrt(1.+track.a()[4]*track.a()[4])/track.a()[2])<<std::endl;
00046       }
00047 
00048       m_BesKalmanExtWalls[j].updateTrack(track, 1);
00049    
00050       if(m_debug){
00051         std::cout<<" track a3: "<<track.a()<<std::endl;
00052         std::cout<<"ptot3: "<<std::setprecision(10)<<(sqrt(1.+track.a()[4]*track.a()[4])/track.a()[2])<<std::endl;
00053       }
00054     }
00055    
00056     // complement some part
00057     const KalFitMaterial& material = m_BesKalmanExtWalls[index].material();
00058     HepPoint3D x;
00059      
00060     double path = m_BesKalmanExtWalls[index].intersect(track, x, point);
00061     //std::cout<<" path2: "<<path<<std::endl;
00062     //std::cout<<" x: "<<x<<std::endl;
00063     //std::cout<<" x.r: "<<x.perp()<<std::endl;
00064     
00065     if(path > 0){
00066       // move pivot
00067       track.pivot_numf(x);
00068       // multiple scattering and energy loss
00069       int index_element(index);
00070       if (index_element==0) index_element=1;
00071       if(m_muls) track.ms(path, material, index_element);
00072       if(m_loss) track.eloss(path, material, index_element);
00073     }
00074    
00075       if(m_debug){
00076         std::cout<<" track a4: "<<track.a()<<std::endl;
00077         std::cout<<"ptot4: "<<std::setprecision(10)<<(sqrt(1.+track.a()[4]*track.a()[4])/track.a()[2])<<std::endl;
00078       }
00079   }
00080 
00081   // situation index=0
00082   else{
00083    
00084     const KalFitMaterial& material = m_BesKalmanExtWalls[index].material();
00085     HepPoint3D x;
00086    
00087     double path = m_BesKalmanExtWalls[index].intersect(track, x, point);
00088     //std::cout<<" path2: "<<path<<std::endl;
00089     //std::cout<<" x: "<<x<<std::endl;
00090     //std::cout<<" x.r: "<<x.perp()<<std::endl;
00091     
00092     if(path > 0){
00093       // move pivot
00094       track.pivot_numf(x);
00095       // multiple scattering and energy loss
00096       int index_element(index);
00097       if (index_element==0) index_element=1;
00098       if(m_muls) track.ms(path, material, index_element);
00099       if(m_loss) track.eloss(path, material, index_element);
00100     }
00101   
00102     if(m_debug){
00103       std::cout<<" track a5: "<<track.a()<<std::endl;
00104       std::cout<<"ptot5: "<<(sqrt(1.+track.a()[4]*track.a()[4])/track.a()[2])<<std::endl;
00105     }
00106   }
00107 }

virtual StatusCode ExtToSecondVertexTool::finalize (   )  [virtual]
 

StatusCode ExtToSecondVertexTool::finalize (   )  [virtual]
  

00162 {
00163   MsgStream log(msgSvc(), name());
00164   log << MSG::INFO << "finalize() has been called" << endreq;
00165   return StatusCode::SUCCESS;
00166 }

const HepSymMatrix ExtToSecondVertexTool::getErrorMatrix (   )  const [inline, virtual]
 

Implements IExtToSecondVertexTool.

00035                                                           {
00036             return m_errorMatrix;
00037           }

const HepSymMatrix ExtToSecondVertexTool::getErrorMatrix (   )  const [inline, virtual]
 

Implements IExtToSecondVertexTool.

00035                                                           {
00036             return m_errorMatrix;
00037           }

const HepVector ExtToSecondVertexTool::getHelixVector (   )  const [inline, virtual]
 

Implements IExtToSecondVertexTool.

00031                                                        {
00032             return m_helixVector;
00033           }

const HepVector ExtToSecondVertexTool::getHelixVector (   )  const [inline, virtual]
 

Implements IExtToSecondVertexTool.

00031                                                        {
00032             return m_helixVector;
00033           }

void ExtToSecondVertexTool::getMaterialFromGdml (   ) 
 

void ExtToSecondVertexTool::getMaterialFromGdml (  void   ) 
 

mdcgas

aluminium

beryllium

helium gas

air 

00041                                                      {
00042 
00043     int i(0);
00044     double Z(0.),A(0.),Ionization(0.),Density(0.),Radlen(0.);
00045     G4LogicalVolume *logicalMdc = 0;
00046     MdcG4Geo* aMdcG4Geo = new MdcG4Geo();
00047     logicalMdc = aMdcG4Geo->GetTopVolume();   
00048         
00049     
00051     G4Material* mdcMaterial = logicalMdc->GetMaterial();  
00052     
00053     for(i=0; i<mdcMaterial->GetElementVector()->size(); i++){
00054       Z += (mdcMaterial->GetElement(i)->GetZ())*
00055         (mdcMaterial->GetFractionVector()[i]);
00056       A += (mdcMaterial->GetElement(i)->GetA())*
00057         (mdcMaterial->GetFractionVector()[i]);
00058     }
00059     Ionization = mdcMaterial->GetIonisation()->GetMeanExcitationEnergy();
00060     Density = mdcMaterial->GetDensity()/(g/cm3);
00061     Radlen = mdcMaterial->GetRadlen();
00062     KalFitMaterial FitMdcMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.); 
00063     m_BesKalmanExtMaterials.push_back(FitMdcMaterial);
00064     // Is this sentence need??
00065     KalFitTrack::mdcGasRadlen_ = Radlen/10.;
00066 
00067 
00069     G4LogicalVolume* innerCylinder = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("logicalMdcSegment2"));
00070     G4Material* innerCylinderMaterial = innerCylinder->GetMaterial();
00071 
00072     Z = 0.;
00073     A = 0.;
00074     for(i=0; i<innerCylinderMaterial->GetElementVector()->size(); i++){    
00075       Z += (innerCylinderMaterial->GetElement(i)->GetZ())*
00076         (innerCylinderMaterial->GetFractionVector()[i]); 
00077       A += (innerCylinderMaterial->GetElement(i)->GetA())*      
00078         (innerCylinderMaterial->GetFractionVector()[i]);
00079     }
00080     Ionization = innerCylinderMaterial->GetIonisation()->GetMeanExcitationEnergy();
00081     Density = innerCylinderMaterial->GetDensity()/(g/cm3);
00082     Radlen = innerCylinderMaterial->GetRadlen();
00083     KalFitMaterial FitInnerCylinderMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
00084     m_BesKalmanExtMaterials.push_back(FitInnerCylinderMaterial);
00085 
00087 
00088     G4LogicalVolume *logicalBes = 0;
00089     BesG4Geo* aBesG4Geo = new BesG4Geo();
00090     logicalBes = aBesG4Geo->GetTopVolume();
00091 
00093     G4LogicalVolume* logicalPipe1 = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("logicalPip1"));
00094     G4Material* Pipe1Material = logicalPipe1->GetMaterial();
00095     Z = 0.;
00096     A = 0.;
00097     for(i=0; i<Pipe1Material->GetElementVector()->size(); i++){   
00098       Z += (Pipe1Material->GetElement(i)->GetZ())*
00099         (Pipe1Material->GetFractionVector()[i]);   
00100       A += (Pipe1Material->GetElement(i)->GetA())*   
00101         (Pipe1Material->GetFractionVector()[i]);
00102     }
00103     Ionization = Pipe1Material->GetIonisation()->GetMeanExcitationEnergy();
00104     Density = Pipe1Material->GetDensity()/(g/cm3);
00105     Radlen = Pipe1Material->GetRadlen();
00106 
00107     KalFitMaterial FitPipe1Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
00108     m_BesKalmanExtMaterials.push_back(FitPipe1Material);
00109     
00110 
00112     G4LogicalVolume* logicalPipe2 = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("logicalPip2"));
00113     G4Material* Pipe2Material = logicalPipe2->GetMaterial();
00114     Z = 0.;
00115     A = 0.;
00116     for(i=0; i<Pipe2Material->GetElementVector()->size(); i++){        
00117       Z += (Pipe2Material->GetElement(i)->GetZ())*
00118         (Pipe2Material->GetFractionVector()[i]);             
00119       A += (Pipe2Material->GetElement(i)->GetA())*             
00120         (Pipe2Material->GetFractionVector()[i]);
00121     }
00122     Ionization = Pipe2Material->GetIonisation()->GetMeanExcitationEnergy();
00123     Density = Pipe2Material->GetDensity()/(g/cm3);
00124     Radlen = Pipe2Material->GetRadlen();
00125     KalFitMaterial FitPipe2Material(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
00126     m_BesKalmanExtMaterials.push_back(FitPipe2Material);
00127     
00128 
00130     G4LogicalVolume* logicalPipe = const_cast<G4LogicalVolume*>(GDMLProcessor::GetInstance()->GetLogicalVolume("logicalPipe"));
00131     G4Material* PipeMaterial = logicalPipe->GetMaterial();
00132     Z = 0.;
00133     A = 0.;
00134     for(i=0; i<PipeMaterial->GetElementVector()->size(); i++){
00135       Z += (PipeMaterial->GetElement(i)->GetZ())*
00136         (PipeMaterial->GetFractionVector()[i]);
00137       A += (PipeMaterial->GetElement(i)->GetA())*
00138         (PipeMaterial->GetFractionVector()[i]);
00139     }
00140     Ionization = PipeMaterial->GetIonisation()->GetMeanExcitationEnergy();
00141     Density = PipeMaterial->GetDensity()/(g/cm3);
00142     Radlen = PipeMaterial->GetRadlen();
00143     KalFitMaterial FitPipeMaterial(Z,A/g/mole,Ionization/eV,Density,Radlen/10.);
00144     m_BesKalmanExtMaterials.push_back(FitPipeMaterial);
00145   }

int ExtToSecondVertexTool::getWallMdcNumber (  const HepPoint3D &  point  )  const [private]
 

int ExtToSecondVertexTool::getWallMdcNumber (  const HepPoint3D &  point  )  const [private]
  

00008                                                                          {
00009   const int size = m_BesKalmanExtWalls.size();
00010   int index = -1;
00011   //std::cout<<" point: "<<point<<std::endl;
00012   for(int i=0; i<size; i++){
00013     if(m_BesKalmanExtWalls[i].isInside2(point)) index = i;
00014   } 
00015   return index;
00016 }

virtual StatusCode ExtToSecondVertexTool::initialize (   )  [virtual]
 

Overriding initialize and finalize.

StatusCode ExtToSecondVertexTool::initialize (   )  [virtual]
 

Overriding initialize and finalize. 

00136 {
00137   // Make use of svc<>
00138   IMessageSvc* msg = svc<IMessageSvc>("MessageSvc");
00139   MsgStream log(msg, name());
00140   log << MSG::INFO << "intialize() has been called" << endreq;
00141 
00142   // Make use of tool<>
00143 
00144   log << MSG::INFO << "eloss   = " << m_loss  << endreq;
00145   log << MSG::INFO << "ms      = " << m_muls  << endreq;
00146   log << MSG::INFO << "String = " << m_string << endreq;
00147   log << MSG::INFO << "Bool   = " << m_bool   << endreq;
00148    
00149   m_BesKalmanExtWalls.clear();
00150   m_BesKalmanExtMaterials.clear();
00151              
00152   //getMaterialFromGdml();
00153   //constructCylinderBes();
00154   constructWallsFromGdml();
00155   initKalmanFitting();
00156   
00157   return StatusCode::SUCCESS;
00158 }

void ExtToSecondVertexTool::initKalmanFitting (  void   )  const [private]
 

void ExtToSecondVertexTool::initKalmanFitting (  void   )  const [private]
  

00007                                                        {
00008 
00009   KalFitTrack::numf_ = 21;
00010   KalFitElement::muls(1);
00011   KalFitElement::loss(1);
00012   KalFitTrack::setMagneticFieldSvc();
00013   KalFitTrack::Bznom_ = -10.;
00014 }

const InterfaceID& IExtToSecondVertexTool::interfaceID (   )  [inline, static, inherited]
 

Retrieve interface ID. 

00019 { return IID_IExtToSecondVertexTool; }

const InterfaceID& IExtToSecondVertexTool::interfaceID (   )  [inline, static, inherited]
 

Retrieve interface ID. 

00019 { return IID_IExtToSecondVertexTool; }

virtual const std::string& ExtToSecondVertexTool::message (   )  const [virtual]
 

IExtToSecondVertexTool interface.

Implements IExtToSecondVertexTool.

const std::string & ExtToSecondVertexTool::message (   )  const [virtual]
 

IExtToSecondVertexTool interface.

Implements IExtToSecondVertexTool.

00061 {
00062   static std::string msg("It works!!!");
00063   return msg;
00064 }

void ExtToSecondVertexTool::setErrorMatrix (  const CLHEP::HepSymMatrix  Ea  )  [inline, virtual]
 

Implements IExtToSecondVertexTool.

00043                                                                 {
00044             m_errorMatrix = Ea;
00045           }

void ExtToSecondVertexTool::setErrorMatrix (  const CLHEP::HepSymMatrix  Ea  )  [inline, virtual]
 

Implements IExtToSecondVertexTool.

00043                                                                 {
00044             m_errorMatrix = Ea;
00045           }

void ExtToSecondVertexTool::setHelixVector (  const CLHEP::HepVector  a  )  [inline, virtual]
 

Implements IExtToSecondVertexTool.

00039                                                             {
00040             m_helixVector = a;
00041           }

void ExtToSecondVertexTool::setHelixVector (  const CLHEP::HepVector  a  )  [inline, virtual]
 

Implements IExtToSecondVertexTool.

00039                                                             {
00040             m_helixVector = a;
00041           }

Member Data Documentation

std::vector<KalFitMaterial> ExtToSecondVertexTool::m_BesKalmanExtMaterials [private]
 

std::vector<KalFitMaterial> ExtToSecondVertexTool::m_BesKalmanExtMaterials [private]
 

std::vector<KalFitCylinder> ExtToSecondVertexTool::m_BesKalmanExtWalls [private]
 

Properties.

std::vector<KalFitCylinder> ExtToSecondVertexTool::m_BesKalmanExtWalls [private]
 

Properties.

bool ExtToSecondVertexTool::m_bool [private]
 

int ExtToSecondVertexTool::m_debug [private]
 

for debugging

CLHEP::HepSymMatrix ExtToSecondVertexTool::m_errorMatrix [private]
 

std::string ExtToSecondVertexTool::m_geopath [private]
 

path of the geometry file of beampipe

CLHEP::HepVector ExtToSecondVertexTool::m_helixVector [private]
 

int ExtToSecondVertexTool::m_loss [private]
 

eloss and MS treatment flag

int ExtToSecondVertexTool::m_muls [private]
 

std::string ExtToSecondVertexTool::m_string [private]
 

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