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

MdcWireEff Class Reference

#include <MdcWireEff.h>

List of all members.

Public Member Functions

StatusCode execute ()
StatusCode execute ()
StatusCode finalize ()
StatusCode finalize ()
StatusCode initialize ()
StatusCode initialize ()
 MdcWireEff (const std::string &name, ISvcLocator *pSvcLocator)
 MdcWireEff (const std::string &name, ISvcLocator *pSvcLocator)

Private Member Functions

StatusCode bookNTuple ()
StatusCode bookNTuple ()
StatusCode cellPassed (const RecMdcTrack *tk)
StatusCode cellPassed (const RecMdcTrack *tk)
bool cellTrackPassedBelle (HepVector helix, int lay, int &cellId_in, int &cellId_cout)
bool cellTrackPassedBelle (HepVector helix, int lay, int &cellId_in, int &cellId_cout)
void dropMultiHotInLayer ()
void dropMultiHotInLayer ()
void fillEvent (void)
void fillEvent (void)
StatusCode fillInit ()
StatusCode fillInit ()
HepPoint3D Hel (HepPoint3D piv, double dr, double phi0, double Alpha_L, double kappa, double dz, double dphi, double tanl)
HepPoint3D Hel (HepPoint3D piv, double dr, double phi0, double Alpha_L, double kappa, double dz, double dphi, double tanl)
StatusCode keepBestDigi ()
StatusCode keepBestDigi ()
StatusCode pocaWithDigi (const RecMdcTrack *tk)
StatusCode pocaWithDigi (const RecMdcTrack *tk)
StatusCode pocaWithHot (const RecMdcTrack *tk)
StatusCode pocaWithHot (const RecMdcTrack *tk)
void wireEff (void)
void wireEff (void)
StatusCode wireEfficiency (const RecMdcTrack *tk)
StatusCode wireEfficiency (const RecMdcTrack *tk)

Private Attributes

int allNum [43][288]
double Bz
bool cellTrackPassed [43][288]
int digiLayer [43]
int evtCount
AIDA::IHistogram2D * g_layEffDigi
AIDA::IHistogram2D * g_layEffDigi
AIDA::IHistogram2D * g_layEffHot
AIDA::IHistogram2D * g_layEffHot
bool haveDigi [43][288]
bool haveHot [43][288]
double m_bigTdc
bool m_cellPassed
NTuple::Array< long > m_dbhot_adc
NTuple::Array< long > m_dbhot_adc
NTuple::Item< long > m_dbhot_evtNo
NTuple::Item< long > m_dbhot_evtNo
NTuple::Array< long > m_dbhot_layer
NTuple::Array< long > m_dbhot_layer
NTuple::Item< long > m_dbhot_nRemove
NTuple::Item< long > m_dbhot_nRemove
NTuple::Item< long > m_dbhot_nTk
NTuple::Item< long > m_dbhot_nTk
NTuple::Array< long > m_dbhot_ovfl
NTuple::Array< long > m_dbhot_ovfl
NTuple::Array< double > m_dbhot_rt
NTuple::Array< double > m_dbhot_rt
NTuple::Array< long > m_dbhot_used
NTuple::Array< long > m_dbhot_used
NTuple::Array< long > m_dbhot_wire
NTuple::Array< long > m_dbhot_wire
int m_debug
bool m_doSag
bool m_dropHot
bool m_dropMultiHotInLayer
int m_evtIndex
const MdcDetector * m_gm
const MdcDetector * m_gm
bool m_hist
double m_hotDriftDist [43][288]
bool m_keepBadTdc
bool m_keepUnmatch
int m_maxMdcDigi
const MdcCalibFunSvc * m_mdcCalibFunSvc
const MdcCalibFunSvc * m_mdcCalibFunSvc
MdcCheckUtil * m_mdcCheckUtil
MdcCheckUtil * m_mdcCheckUtil
IMdcGeomSvc * m_mdcGeomSvc
IMdcGeomSvc * m_mdcGeomSvc
NTuple::Array< long > m_pass_adc
NTuple::Array< long > m_pass_adc
NTuple::Array< long > m_pass_layer
NTuple::Array< long > m_pass_layer
NTuple::Item< long > m_pass_nDigi
NTuple::Item< long > m_pass_nDigi
NTuple::Array< double > m_pass_rt
NTuple::Array< double > m_pass_rt
NTuple::Array< long > m_pass_wire
NTuple::Array< long > m_pass_wire
IMagneticFieldSvc * m_pIMF
IMagneticFieldSvc * m_pIMF
bool m_poca
bool m_pocaWithDigi
bool m_pocaWithHot
RawDataProviderSvc * m_rawDataProviderSvc
RawDataProviderSvc * m_rawDataProviderSvc
double m_resLayer
NTuple::Tuple * m_tuple1
NTuple::Tuple * m_tuple1
NTuple::Tuple * m_tuple2
NTuple::Tuple * m_tuple2
NTuple::Tuple * m_tuple3
NTuple::Tuple * m_tuple3
NTuple::Tuple * m_tuple4
NTuple::Tuple * m_tuple4
NTuple::Array< long > m_weff_allNum
NTuple::Array< long > m_weff_allNum
NTuple::Array< double > m_weff_driftD
NTuple::Array< double > m_weff_driftD
NTuple::Array< double > m_weff_driftdHot
NTuple::Array< double > m_weff_driftdHot
NTuple::Array< double > m_weff_driftT
NTuple::Array< double > m_weff_driftT
NTuple::Item< long > m_weff_evtNo
NTuple::Item< long > m_weff_evtNo
NTuple::Array< long > m_weff_gwire
NTuple::Array< long > m_weff_gwire
NTuple::Array< long > m_weff_hot_allNum
NTuple::Array< long > m_weff_hot_allNum
NTuple::Array< double > m_weff_hot_driftD
NTuple::Array< double > m_weff_hot_driftD
NTuple::Array< double > m_weff_hot_driftT
NTuple::Array< double > m_weff_hot_driftT
NTuple::Item< long > m_weff_hot_evtNo
NTuple::Item< long > m_weff_hot_evtNo
NTuple::Array< long > m_weff_hot_gwire
NTuple::Array< long > m_weff_hot_gwire
NTuple::Array< long > m_weff_hot_layer
NTuple::Array< long > m_weff_hot_layer
NTuple::Item< long > m_weff_hot_nHot
NTuple::Item< long > m_weff_hot_nHot
NTuple::Array< long > m_weff_hot_ovfl
NTuple::Array< long > m_weff_hot_ovfl
NTuple::Array< double > m_weff_hot_poca
NTuple::Array< double > m_weff_hot_poca
NTuple::Item< long > m_weff_hot_recTk
NTuple::Item< long > m_weff_hot_recTk
NTuple::Array< double > m_weff_hot_rt
NTuple::Array< double > m_weff_hot_rt
NTuple::Item< long > m_weff_hot_runNo
NTuple::Item< long > m_weff_hot_runNo
NTuple::Item< double > m_weff_hot_t0
NTuple::Item< double > m_weff_hot_t0
NTuple::Item< long > m_weff_hot_t0Stat
NTuple::Item< long > m_weff_hot_t0Stat
NTuple::Array< long > m_weff_hot_tNum
NTuple::Array< long > m_weff_hot_tNum
NTuple::Array< long > m_weff_hot_wire
NTuple::Array< long > m_weff_hot_wire
NTuple::Array< long > m_weff_layer
NTuple::Array< long > m_weff_layer
NTuple::Item< long > m_weff_nDigi
NTuple::Item< long > m_weff_nDigi
NTuple::Array< long > m_weff_ovfl
NTuple::Array< long > m_weff_ovfl
NTuple::Array< long > m_weff_passed
NTuple::Array< long > m_weff_passed
NTuple::Item< long > m_weff_PatRec
NTuple::Item< long > m_weff_PatRec
NTuple::Array< double > m_weff_poca
NTuple::Array< double > m_weff_poca
NTuple::Array< double > m_weff_rc
NTuple::Array< double > m_weff_rc
NTuple::Item< long > m_weff_recTk
NTuple::Item< long > m_weff_recTk
NTuple::Array< double > m_weff_resid
NTuple::Array< double > m_weff_resid
NTuple::Array< double > m_weff_rt
NTuple::Array< double > m_weff_rt
NTuple::Item< long > m_weff_runNo
NTuple::Item< long > m_weff_runNo
NTuple::Item< double > m_weff_t0
NTuple::Item< double > m_weff_t0
NTuple::Item< long > m_weff_t0Stat
NTuple::Item< long > m_weff_t0Stat
NTuple::Array< long > m_weff_tNum
NTuple::Array< long > m_weff_tNum
NTuple::Item< long > m_weff_TrkReco
NTuple::Item< long > m_weff_TrkReco
NTuple::Array< long > m_weff_wire
NTuple::Array< long > m_weff_wire
bool m_wireEff
double minResid [43][288]
double minResidDigiRawT [43][288]
int passLayer [43]
int passLayerWithDigi [43]
int recLayer [43]
long t_eventNo
int t_mdcxRecTk
int t_nTk
int t_patRecTk
int t_recTkNum
long t_runNo
double t_t0
int t_t0Stat
int t_trkRecoTk

Constructor & Destructor Documentation

MdcWireEff::MdcWireEff (  const std::string &  name,
ISvcLocator *  pSvcLocator
) 
  

00047                                                                       : 
00048   Algorithm(name, pSvcLocator) {
00049     declareProperty("hist", m_hist = false);
00050     declareProperty("debug", m_debug= 0);
00051 
00052     declareProperty("maxMdcDigi",   m_maxMdcDigi= 0);
00053     declareProperty("keepBadTdc",   m_keepBadTdc= 0);
00054     declareProperty("dropHot",      m_dropHot= 0);
00055     declareProperty("keepUnmatch",  m_keepUnmatch= 0);
00056 
00057     declareProperty("poca", m_poca = false);
00058     declareProperty("resLayer", m_resLayer = -1);
00059     declareProperty("doSag", m_doSag = true);
00060 
00061     declareProperty("wireEff",      m_wireEff= false);
00062     declareProperty("pocaWithDigi", m_pocaWithDigi = false);
00063     declareProperty("pocaWithHot",  m_pocaWithHot = false);
00064     declareProperty("cellPassed",   m_cellPassed = false);
00065     declareProperty("dropMultiHotInLayer",   m_dropMultiHotInLayer= false);
00066     declareProperty("bigTdc",   m_bigTdc= 500.);
00067   }

MdcWireEff::MdcWireEff (  const std::string &  name,
ISvcLocator *  pSvcLocator
) 
 

Member Function Documentation

StatusCode MdcWireEff::bookNTuple (   )  [private]
 

StatusCode MdcWireEff::bookNTuple (   )  [private]
  

00217                                  {
00218   MsgStream log(msgSvc(), name());
00219   StatusCode sc = StatusCode::SUCCESS;
00220 
00221   NTuplePtr nt1(ntupleSvc(), "MdcWireEff/weffdigi");
00222   if ( nt1 ) { m_tuple1 = nt1;}
00223   else {
00224     m_tuple1 = ntupleSvc()->book ("MdcWireEff/weffdigi", CLID_ColumnWiseTuple, "event");
00225     if ( m_tuple1 ) {
00226       //sc = m_tuple1->addItem ("nTdsTk",       m_weff_recTk);
00227       sc = m_tuple1->addItem ("evtNo",  m_weff_evtNo);
00228       sc = m_tuple1->addItem ("t0",     m_weff_t0);
00229       sc = m_tuple1->addItem ("t0Stat", m_weff_t0Stat);
00230       sc = m_tuple1->addItem ("runNo",  m_weff_runNo);
00231       sc = m_tuple1->addItem ("nDigi",  m_weff_nDigi, 0, 10000);
00232       sc = m_tuple1->addIndexedItem ("layer", m_weff_nDigi, m_weff_layer);
00233       sc = m_tuple1->addIndexedItem ("wire",  m_weff_nDigi, m_weff_wire);
00234       sc = m_tuple1->addIndexedItem ("gwire", m_weff_nDigi, m_weff_gwire);
00235       sc = m_tuple1->addIndexedItem ("rt",    m_weff_nDigi, m_weff_rt);
00236       sc = m_tuple1->addIndexedItem ("rc",    m_weff_nDigi, m_weff_rc);
00237       sc = m_tuple1->addIndexedItem ("ovfl",  m_weff_nDigi, m_weff_ovfl);
00238       sc = m_tuple1->addIndexedItem ("passed",m_weff_nDigi, m_weff_passed);
00239       //sc = m_tuple1->addIndexedItem ("tNum",  m_weff_nDigi, m_weff_tNum);
00240       //sc = m_tuple1->addIndexedItem ("doca",  m_weff_nDigi, m_weff_poca);
00241       //sc = m_tuple1->addIndexedItem ("driftT",m_weff_nDigi, m_weff_driftT);
00242       //sc = m_tuple1->addIndexedItem ("driftD",m_weff_nDigi, m_weff_driftD);
00243       //sc = m_tuple1->addIndexedItem ("resid", m_weff_nDigi, m_weff_resid);
00244       //sc = m_tuple1->addIndexedItem ("driftdHot",m_weff_nDigi,m_weff_driftdHot);
00245     } else {   
00246       log << MSG::ERROR << "Cannot book tuple MdcWireEff/weffdigi" << endmsg;
00247       return StatusCode::FAILURE;
00248     }
00249   }
00250   NTuplePtr nt2(ntupleSvc(), "MdcWireEff/weffhot");
00251   if ( nt2 ) { m_tuple2 = nt2;}
00252   else {
00253     m_tuple2 = ntupleSvc()->book ("MdcWireEff/weffhot", CLID_ColumnWiseTuple, "event");
00254     if ( m_tuple2 ) {
00255       sc = m_tuple2->addItem ("nTdsTk", m_weff_hot_recTk);
00256       sc = m_tuple2->addItem ("evtNo",  m_weff_hot_evtNo);
00257       sc = m_tuple2->addItem ("t0",     m_weff_hot_t0);
00258       sc = m_tuple2->addItem ("t0Stat", m_weff_hot_t0Stat);
00259       sc = m_tuple2->addItem ("runNo",  m_weff_hot_runNo);
00260       sc = m_tuple2->addItem ("nHot",   m_weff_hot_nHot, 0, 1000);
00261       sc = m_tuple2->addIndexedItem ("layer", m_weff_hot_nHot, m_weff_hot_layer);
00262       sc = m_tuple2->addIndexedItem ("wire",  m_weff_hot_nHot, m_weff_hot_wire);
00263       sc = m_tuple2->addIndexedItem ("gwire", m_weff_hot_nHot, m_weff_hot_gwire);
00264       sc = m_tuple2->addIndexedItem ("ovfl",  m_weff_hot_nHot, m_weff_hot_ovfl);
00265       sc = m_tuple2->addIndexedItem ("tNum",  m_weff_hot_nHot, m_weff_hot_tNum);
00266       sc = m_tuple2->addIndexedItem ("doca",  m_weff_hot_nHot, m_weff_hot_poca);
00267       sc = m_tuple2->addIndexedItem ("rt",    m_weff_hot_nHot, m_weff_hot_rt);
00268       sc = m_tuple2->addIndexedItem ("driftT",m_weff_hot_nHot, m_weff_hot_driftT);
00269       sc = m_tuple2->addIndexedItem ("driftD",m_weff_hot_nHot, m_weff_hot_driftD);
00270     } else {   
00271       log << MSG::ERROR << "Cannot book tuple MdcWireEff/weffhot" << endmsg;
00272       return StatusCode::FAILURE;
00273     }
00274   }
00275 
00276 
00277   NTuplePtr nt3(ntupleSvc(), "MdcWireEff/pass");
00278   if ( nt3 ) { m_tuple3 = nt3;}
00279   else {
00280     m_tuple3 = ntupleSvc()->book ("MdcWireEff/pass", CLID_ColumnWiseTuple, "event");
00281     if ( m_tuple3 ) {
00282       sc = m_tuple3->addItem ("nDigi",          m_pass_nDigi, 0, 10000);
00283       sc = m_tuple3->addIndexedItem ("layer",   m_pass_nDigi, m_pass_layer);
00284       sc = m_tuple3->addIndexedItem ("wire",    m_pass_nDigi, m_pass_wire);
00285       sc = m_tuple3->addIndexedItem ("rt",      m_pass_nDigi, m_pass_rt);
00286       sc = m_tuple3->addIndexedItem ("adc",     m_pass_nDigi, m_pass_adc);
00287     }
00288   }
00289 
00290   NTuplePtr nt4(ntupleSvc(), "MdcWireEff/dropMultiHot");
00291   if ( nt4 ) { m_tuple4 = nt4;}
00292   else {
00293     m_tuple4 = ntupleSvc()->book ("MdcWireEff/dropMultiHot", CLID_ColumnWiseTuple, "event");
00294     if ( m_tuple4 ) {
00295       sc = m_tuple4->addItem ("evtNo",          m_dbhot_evtNo);
00296       sc = m_tuple4->addItem ("nTk",            m_dbhot_nTk);
00297       sc = m_tuple4->addItem ("nRemove",        m_dbhot_nRemove,0,8000);
00298       sc = m_tuple4->addIndexedItem ("layer",   m_dbhot_nRemove, m_dbhot_layer);
00299       sc = m_tuple4->addIndexedItem ("wire",    m_dbhot_nRemove, m_dbhot_wire);
00300       sc = m_tuple4->addIndexedItem ("rt",      m_dbhot_nRemove, m_dbhot_rt);
00301       sc = m_tuple4->addIndexedItem ("adc",     m_dbhot_nRemove, m_dbhot_adc);
00302       sc = m_tuple4->addIndexedItem ("ovfl",    m_dbhot_nRemove, m_dbhot_ovfl);
00303       sc = m_tuple4->addIndexedItem ("used",    m_dbhot_nRemove, m_dbhot_used);
00304     }
00305   }
00306 
00307   return sc;
00308 
00309 }

StatusCode MdcWireEff::cellPassed (  const RecMdcTrack *  tk  )  [private]
 

StatusCode MdcWireEff::cellPassed (  const RecMdcTrack *  tk  )  [private]
  

00539                                                       {
00540   MsgStream log(msgSvc(), name());
00541   StatusCode sc;
00542 
00543   uint32_t getDigiFlag = 0;
00544   getDigiFlag += m_maxMdcDigi;
00545   if(m_dropHot)     getDigiFlag |= MdcRawDataProvider::b_dropHot;
00546   if(m_keepBadTdc)  getDigiFlag |= MdcRawDataProvider::b_keepBadTdc;
00547   if(m_keepUnmatch) getDigiFlag |= MdcRawDataProvider::b_keepUnmatch;
00548   MdcDigiVec mdcDigiVec = m_rawDataProviderSvc->getMdcDigiVec(getDigiFlag);
00549 
00550   HepVector helix(5);
00551   helix[0]=tk->helix(0);
00552   helix[1]=tk->helix(1);
00553   helix[2]=tk->helix(2);
00554   helix[3]=tk->helix(3);
00555   helix[4]=tk->helix(4);
00556 
00557   for (int layer=0; layer<43; layer++){
00558     //-----cell track passed
00559     int cellId_in  = -1;
00560     int cellId_out = -1;
00561     //bool passedOneCell = m_mdcCheckUtil->cellTrackPassed(helix,layer,cellId_in,cellId_out);
00562     cellTrackPassedBelle(helix,layer,cellId_in,cellId_out);
00563     //std::cout<<__FILE__<<" "<<__LINE__<<" layer "<< layer <<" "<< passedOneCell<<" cellId_in "<<cellId_in <<" cellId_out "<<cellId_out  <<std::endl;
00564     cellTrackPassed[layer][cellId_in] = true;
00565     cellTrackPassed[layer][cellId_out] = true;
00566   }
00567 
00568   int iDigi=0;
00569   MdcDigiCol::iterator iter = mdcDigiVec.begin();
00570   for (; iter!=mdcDigiVec.end(); iter++) {
00571     Identifier id = (*iter)->identify(); 
00572     int layer = MdcID::layer(id);
00573     int wire  = MdcID::wire(id);
00574     if (!cellTrackPassed[layer][wire]) continue;
00575 
00576     double rt = RawDataUtil::MdcTime((*iter)->getTimeChannel());
00577     int adc = (*iter)->getChargeChannel();
00578     m_pass_layer[iDigi] = layer;
00579     m_pass_wire[iDigi] = wire;
00580     m_pass_rt[iDigi] = rt;
00581     m_pass_adc[iDigi] = adc;
00582     iDigi++;
00583 
00584     //if(cellTrackPassed[layer][wire]) {
00585     //mdcDigiCol->remove(aDigi);
00586     //}
00587   }
00588   m_tuple3->write();
00589 
00590   return StatusCode::SUCCESS;
00591 }

bool MdcWireEff::cellTrackPassedBelle (  HepVector  helix,
int  lay,
int &  cellId_in,
int &  cellId_cout
)  [private]
 

bool MdcWireEff::cellTrackPassedBelle (  HepVector  helix,
int  lay,
int &  cellId_in,
int &  cellId_cout
)  [private]
  

00593                                                                                             {
00594   int charge,type,nCell;
00595   double dr0,phi0,kappa,dz0,tanl;
00596   double ALPHA_loc,rho,phi,cosphi0,sinphi0,x_hc,y_hc,z_hc;
00597   double dphi0,IO_phi,C_alpha,xx,yy;
00598   double inlow,inup,outlow,outup,phi_in,phi_out,phi_bin;
00599   double rCize1,rCize2,rLay,length,phioffset,slant,shift; 
00600   double m_crio[2], phi_io[2], stphi[2],phioff[2],dphi[2];
00601 
00602   dr0   = helix[0];  
00603   phi0  = helix[1];
00604   kappa = helix[2];
00605   dz0   = helix[3];
00606   tanl  = helix[4];
00607 
00608   ALPHA_loc = 1000/(2.99792458*Bz); //magnetic field const
00609   charge    = ( kappa >=0 ) ? 1 : -1 ;
00610   rho       = ALPHA_loc/kappa ;
00611   double pi = Constants::pi;
00612   phi      = fmod(phi0 + 4*pi , 2*pi);
00613   cosphi0  = cos(phi);
00614   sinphi0  = (1.0 - cosphi0 ) * (1.0 + cosphi0 );
00615   sinphi0  = sqrt(( sinphi0 > 0.) ? sinphi0 : 0.);
00616   if( phi > pi ) sinphi0 = -sinphi0 ;
00617 
00618   x_hc     = 0. + ( dr0 + rho ) * cosphi0;
00619   y_hc     = 0. + ( dr0 + rho ) * sinphi0;
00620   z_hc     = 0. + dz0;
00621 
00622 
00623   HepPoint3D piv(0.,0.,0.); 
00624   HepPoint3D hcenter(x_hc,y_hc,0.0);
00625 
00626   double m_c_perp(hcenter.perp());
00627   Hep3Vector m_c_unit((HepPoint3D)hcenter.unit());
00628   HepPoint3D IO = (-1) * charge * m_c_unit;
00629 
00630   dphi0  = fmod(IO.phi()+4*pi, 2*pi) - phi;
00631   IO_phi = fmod(IO.phi()+4*pi, 2*pi);
00632 
00633   if(dphi0 > pi) dphi0 -= 2*pi;
00634   else if(dphi0 < -pi) dphi0 += 2*pi; 
00635 
00636   phi_io[0] = -(1+charge)*pi/2 - charge*dphi0;
00637   phi_io[1] = phi_io[0]+1.5*pi;
00638 
00639 
00640   bool outFlag = false;
00641   //retrieve Mdc geometry information
00642   rCize1 = 0.1 * m_mdcGeomSvc->Layer(lay)->RCSiz1();  //mm -> cm 
00643   rCize2 = 0.1 * m_mdcGeomSvc->Layer(lay)->RCSiz2();  //mm -> cm
00644   rLay   = 0.1 * m_mdcGeomSvc->Layer(lay)->Radius();  //mm -> cm
00645   length = 0.1 * m_mdcGeomSvc->Layer(lay)->Length();  //mm -> cm
00646   //double halfLength=length/2.;
00647   //(conversion of the units mm(mc)->cm(rec))
00648   nCell  = m_mdcGeomSvc->Layer(lay)->NCell();
00649   phioffset = m_mdcGeomSvc->Layer(lay)->Offset();
00650   slant  = m_mdcGeomSvc->Layer(lay)->Slant();
00651   shift  = m_mdcGeomSvc->Layer(lay)->Shift();
00652   type   = m_mdcGeomSvc->Layer(lay)->Sup()->Type();
00653 
00654   m_crio[0] = rLay - rCize1 ; //radius of inner field wir ( beam pipe)
00655   m_crio[1] = rLay + rCize2 ; //radius of outer field wir ( beam pipe)
00656 
00657   int sign = -1; //assumed the first half circle
00658 
00659   Hep3Vector iocand[2];
00660   Hep3Vector cell_IO[2];
00661 
00662   for(int ii =0; ii<2; ii++){
00663     // By law of cosines to calculate the alpha(up and down field wir_Ge)
00664     double cos_alpha = (m_c_perp*m_c_perp + m_crio[ii]*m_crio[ii] - rho*rho)
00665       / ( 2 * m_c_perp * m_crio[ii] ); 
00666     if(fabs(cos_alpha)>1&&(ii==0)){
00667       cos_alpha = -1;
00668       outFlag=true;
00669     }
00670     if(fabs(cos_alpha)>1&&(ii==1)){
00671       cos_alpha = (m_c_perp*m_c_perp + m_crio[0]*m_crio[0] - rho*rho)
00672         / ( 2 * m_c_perp * m_crio[0] );
00673       C_alpha   = 2*pi - acos( cos_alpha);
00674     }else {
00675       C_alpha   = acos( cos_alpha );
00676     }
00677 
00678     iocand[ii] = m_c_unit;
00679     iocand[ii].rotateZ( charge*sign*C_alpha );
00680     iocand[ii] *= m_crio[ii];
00681 
00682     xx = iocand[ii].x() - x_hc ;
00683     yy = iocand[ii].y() - y_hc ;
00684 
00685     dphi[ii] = atan2(yy,xx) - phi0 - 0.5*pi*(1-charge);
00686     dphi[ii] = fmod( dphi[ii] + 8.0*pi,2*pi);
00687 
00688 
00689     if( dphi[ii] < phi_io[0] ) {
00690       dphi[ii] += 2*pi;
00691     }else if( dphi[ii] > phi_io[1] ){  //very very nausea
00692       dphi[ii] -= 2*pi;
00693     }
00694 
00695     cell_IO[ii] = Hel(piv, dr0, phi, ALPHA_loc, kappa,dz0, dphi[ii], tanl); 
00696 
00697     //cout<<" cell_IO["<<ii<<"] : "<<cell_IO[ii]<<endl;
00698     if( (cell_IO[ii].x()==0 ) && (cell_IO[ii].y()==0) && (cell_IO[ii].z()==0)) continue;
00699   }
00700   //if(((fabs(cell_IO[0].z())*10-halfLength)>-7.) && ((fabs(cell_IO[1].z())*10-halfLength)>-7.))return true; //Out sensitive area
00701 
00702   cellId_in = cellId_out = -1 ;
00703   phi_in  = cell_IO[0].phi();
00704   phi_in = fmod ( phi_in + 4 * pi, 2 * pi );
00705   phi_out = cell_IO[1].phi();
00706   phi_out = fmod ( phi_out + 4 * pi, 2 * pi );
00707   phi_bin = 2.0 * pi / nCell ;
00708 
00709   //determine the in/out cell id
00710   stphi[0] = shift * phi_bin * (0.5 - cell_IO[0].z()/length);
00711   stphi[1] = shift * phi_bin * (0.5 - cell_IO[1].z()/length);
00712   //stphi[0],stphi[1] to position fo z axis ,the angle of deflxsion in x_Y
00713 
00714   phioff[0] = phioffset + stphi[0];
00715   phioff[1] = phioffset + stphi[1];
00716 
00717   for(int kk = 0; kk<nCell ; kk++){
00718     //for stereo layer
00719     inlow  = phioff[0] + phi_bin*kk - phi_bin*0.5;
00720     inlow  = fmod( inlow + 4.0 * pi , 2.0 * pi);
00721     inup   = phioff[0] + phi_bin*kk + phi_bin*0.5;
00722     inup   = fmod( inup  + 4.0 * pi , 2.0 * pi);
00723     outlow = phioff[1] + phi_bin*kk - phi_bin*0.5;
00724     outlow = fmod( outlow + 4.0 * pi ,2.0 * pi);
00725     outup  = phioff[1] + phi_bin*kk + phi_bin*0.5;
00726     outup  = fmod( outup + 4.0 * pi , 2.0 * pi);
00727 
00728     if((phi_in>=inlow && phi_in<=inup))   cellId_in = kk;
00729     if((phi_out>=outlow&&phi_out<outup))  cellId_out = kk;
00730     if(inlow > inup ){
00731       if((phi_in>=inlow&&phi_in<2.0*pi)||(phi_in>=0.0&&phi_in<inup)) cellId_in = kk;
00732     }
00733     if(outlow>outup){
00734       if((phi_out>=outlow&&phi_out<=2.0*pi)||(phi_out>=0.0&&phi_out<outup)) cellId_out = kk;
00735     }
00736   }//end of nCell loop  
00737 
00738   return (cellId_in==cellId_out);
00739 }

void MdcWireEff::dropMultiHotInLayer (   )  [private]
 

void MdcWireEff::dropMultiHotInLayer (   )  [private]
  

00829                                     {
00830   int iDrop = 0;
00831   SmartDataPtr<MdcDigiCol> mdcDigiCol(eventSvc(),"/Event/Digi/MdcDigiCol");
00832   if (! mdcDigiCol) {
00833     std::cout<< "Could not find MdcDigiCol!" << endl;
00834   }
00835   MdcDigiCol::iterator iterDigi = mdcDigiCol->begin();
00836   for (;iterDigi != mdcDigiCol->end();  ) {
00837     MdcDigi* aDigi = (*iterDigi);
00838     Identifier id = aDigi->identify();
00839     int layer = MdcID::layer(id);
00840     int wire  = MdcID::wire(id);
00841     unsigned tdc = aDigi->getTimeChannel();
00842     unsigned adc = aDigi->getChargeChannel();
00843     int overflow = aDigi->getOverflow();
00844     //Skip unMatched Hit
00845     if ( ((overflow & 3)>0) || (tdc==0x7FFFFFFF) || (adc== 0x7FFFFFFF)  ) {
00846       iterDigi++;
00847       continue;
00848     }
00849 
00850     int wireLow= (wire-1) % Constants::maxCell[layer];
00851     if (wireLow< 0) wireLow += Constants::maxCell[layer];
00852     int wireHigh= (wire+1) % Constants::maxCell[layer];
00853     if (wireHigh< 0) wireHigh += Constants::maxCell[layer];
00854 
00855     double T0Walk = m_mdcCalibFunSvc->getT0(layer,wire)
00856       + m_mdcCalibFunSvc->getTimeWalk(layer,adc);
00857     if (m_mdcCalibFunSvc) { T0Walk = m_mdcCalibFunSvc->getT0(layer,wire)
00858       + m_mdcCalibFunSvc->getTimeWalk(layer,adc); }
00859     double tdr = RawDataUtil::MdcTime(tdc) - T0Walk - t_t0;
00860     if((tdr > m_bigTdc) &&  
00861         (cellTrackPassed[layer][wireLow] || cellTrackPassed[layer][wireHigh]) ){
00862       if(m_debug){
00863         std::cout<<__FILE__<<" remove ("<<layer<<","<<wire<<")"<<  std::endl;
00864       }
00865       mdcDigiCol->remove(aDigi);
00866       if(m_hist){
00867         m_dbhot_layer[iDrop] = layer;
00868         m_dbhot_wire[iDrop] = wire;
00869         m_dbhot_rt[iDrop] = RawDataUtil::MdcTime(tdc);
00870         m_dbhot_adc[iDrop] = adc;
00871         m_dbhot_ovfl[iDrop] = overflow;
00872         if(cellTrackPassed[layer][wire]){
00873           m_dbhot_used[iDrop] = 1;
00874         }else{
00875           m_dbhot_used[iDrop] = 0;
00876         }
00877       }
00878       iDrop++;
00879     } else{
00880       iterDigi++;
00881     }
00882 
00883   }
00884 
00885   if(m_hist){
00886     m_dbhot_evtNo   = t_eventNo;
00887     m_dbhot_nRemove = iDrop;
00888     m_dbhot_nTk     = t_nTk;
00889     m_tuple4->write();
00890   }
00891 
00892   if(m_debug) std::cout<<__FILE__<<"  nRemove "<<iDrop<< std::endl;
00893 
00894 }

StatusCode MdcWireEff::execute (   ) 
 

StatusCode MdcWireEff::execute (   ) 
  

00144                                {
00145   MsgStream log(msgSvc(), name());
00146   StatusCode sc = StatusCode::SUCCESS;
00147 
00148   // Get eventNo, t0 and MdcDigi
00149   if(m_hist) fillInit();
00150 
00151   // Get event header
00152   SmartDataPtr<Event::EventHeader> evtHead(eventSvc(),"/Event/EventHeader");
00153   if (evtHead) {
00154     t_runNo = evtHead->runNumber();
00155     t_eventNo = evtHead->eventNumber();
00156   }else{
00157     log << MSG::WARNING<< "Could not retreve event header" << endreq;
00158   }
00159 
00160   if(m_debug)std::cout<<"MdcWireEff No."<<m_evtIndex <<" evtNo:"<<t_eventNo << std::endl;//yzhang debug
00161   m_evtIndex++;
00162   //Get event start tme
00163 
00164   // Get RecMdcTrackCol and RecMdcHitCol
00165   SmartDataPtr<RecMdcTrackCol> recMdcTrackCol(eventSvc(), "/Event/Recon/RecMdcTrackCol");
00166   if (!recMdcTrackCol){
00167     log << MSG::WARNING<< " Unable to retreve recMdcTrackCol" << endreq;
00168     return StatusCode::SUCCESS;
00169   }
00170 
00171   t_nTk = recMdcTrackCol->size();
00172   for(int i=0;i<43;i++){
00173     for(int j=0; j<288; j++){
00174       haveHot[i][j]=false;
00175       haveDigi[i][j]=false;
00176       cellTrackPassed[i][j]=false;
00177     }
00178   }
00179 
00180   int iTk=0;
00181   for( RecMdcTrackCol::iterator it = recMdcTrackCol->begin(); it != recMdcTrackCol->end(); it++ ,iTk++ ) {   
00182     sc = wireEfficiency(*it);
00183   }
00184 
00185   wireEff();
00186 
00187   if ( m_dropMultiHotInLayer){
00188     dropMultiHotInLayer();
00189   }
00190 
00191   if(m_hist) fillEvent();
00192 
00193   return StatusCode::SUCCESS;
00194 }

void MdcWireEff::fillEvent (  void   )  [private]
 

void MdcWireEff::fillEvent (  void   )  [private]
  

00791                           {
00792 
00793   uint32_t getDigiFlag = 0;
00794   getDigiFlag += m_maxMdcDigi;
00795   if(m_dropHot)     getDigiFlag |= MdcRawDataProvider::b_dropHot;
00796   if(m_keepBadTdc)  getDigiFlag |= MdcRawDataProvider::b_keepBadTdc;
00797   if(m_keepUnmatch) getDigiFlag |= MdcRawDataProvider::b_keepUnmatch;
00798   MdcDigiVec mdcDigiVec = m_rawDataProviderSvc->getMdcDigiVec(getDigiFlag);
00799 
00800   int nDigi = mdcDigiVec.size();
00801 
00802   m_weff_evtNo = t_eventNo;
00803   m_weff_t0    = t_t0;
00804   m_weff_t0Stat= t_t0Stat;
00805   m_weff_runNo = t_runNo;
00806   m_weff_nDigi = nDigi;
00807 
00808   MdcDigiCol::iterator iter = mdcDigiVec.begin();
00809   for (int iDigi = 0; iDigi < nDigi; iter++ ,iDigi++) {
00810     int layer = MdcID::layer((*iter)->identify());
00811     int wire  = MdcID::wire((*iter)->identify());
00812     int ovfl = (*iter)->getOverflow();
00813     int gwire = Constants::nWireBeforeLayer[layer] + wire;
00814     unsigned int tdc = (*iter)->getTimeChannel();
00815     double rawTime = RawDataUtil::MdcTime(tdc);
00816     double rawCharge = RawDataUtil::MdcCharge((*iter)->getChargeChannel());
00817     m_weff_layer[iDigi] = layer;
00818     m_weff_wire[iDigi] = wire;
00819     m_weff_gwire[iDigi] = gwire;
00820     m_weff_rt[iDigi] = rawTime;
00821     m_weff_rc[iDigi] = rawCharge;
00822     m_weff_ovfl[iDigi] = ovfl;
00823     if(cellTrackPassed[layer][wire]) m_weff_passed[iDigi] = 1;
00824     else m_weff_passed[iDigi] = 0;
00825   }
00826   m_tuple1->write();
00827 }

StatusCode MdcWireEff::fillInit (   )  [private]
 

StatusCode MdcWireEff::fillInit (   )  [private]
  

00312                                {
00313   MsgStream log(msgSvc(), name());
00314   StatusCode sc = StatusCode::SUCCESS;
00315 
00316   for (int ii=0;ii<43;ii++){ 
00317     for (int jj=0;jj<288;jj++){ 
00318       m_hotDriftDist[ii][jj] = -9999.;
00319       minResid[ii][jj]= 9999.;
00320       minResidDigiRawT[ii][jj]= -9999.;
00321     }
00322   }
00323   t_t0 = -1;
00324   t_t0Stat = -1;
00325 
00326   SmartDataPtr<RecEsTimeCol> aevtmeCol(eventSvc(),"/Event/Recon/RecEsTimeCol");
00327   if (aevtmeCol) {
00328     RecEsTimeCol::iterator iter_evt = aevtmeCol->begin();
00329     for (; iter_evt!=aevtmeCol->end(); iter_evt++){
00330       t_t0 = (*iter_evt)->getTest();
00331       t_t0Stat = (*iter_evt)->getStat();
00332     }
00333   }else{
00334     log << MSG::WARNING << "Could not fnd RecEsTimeCol" << endreq;
00335   } 
00336 
00337   return sc; 
00338 }

StatusCode MdcWireEff::finalize (   ) 
 

StatusCode MdcWireEff::finalize (   ) 
  

00197                                 {
00198   MsgStream log(msgSvc(), name());
00199   log << MSG::INFO << "in finalize()" << endreq;
00200   if(m_cellPassed){
00201     for(int i=0;i<43;i++){
00202       std::cout<<__FILE__<<" "<<__LINE__<<" lay "<<i
00203         <<" rec "<< recLayer[i]
00204         <<" passWith "<<passLayerWithDigi[i]
00205         <<" digi "<<digiLayer[i]
00206         <<" pass "<<passLayer[i]
00207         <<std::endl;
00208 
00209       if (passLayerWithDigi[i]>0) g_layEffHot->fill(i,(1.*recLayer[i]/passLayerWithDigi[i]));
00210       if (passLayer[i]>0)g_layEffDigi->fill(i,(1.*digiLayer[i]/passLayer[i]));
00211     }
00212   }
00213   return StatusCode::SUCCESS;
00214 }

HepPoint3D MdcWireEff::Hel (  HepPoint3D  piv,
double  dr,
double  phi0,
double  Alpha_L,
double  kappa,
double  dz,
double  dphi,
double  tanl
)  [private]
 

HepPoint3D MdcWireEff::Hel (  HepPoint3D  piv,
double  dr,
double  phi0,
double  Alpha_L,
double  kappa,
double  dz,
double  dphi,
double  tanl
)  [private]
  

00741                                                                                                                              {
00742   double x = piv.x() + dr*cos(phi0) + (Alpha_L/kappa) * (cos(phi0) - cos(phi0+dphi));
00743   double y = piv.y() + dr*sin(phi0) + (Alpha_L/kappa) * (sin(phi0) - sin(phi0+dphi));
00744   double z = piv.z() + dz - (Alpha_L/kappa) * dphi * tanl;
00745   //cout<<"HepPoint3D(x, y, z) = "<<HepPoint3D(x, y, z)<<endl;
00746   if((x>-1000. && x<1000.) || (y >-1000. && y <1000. ) ||(z>-1000. && z<1000.)){
00747     return HepPoint3D(x, y, z);
00748   }else{
00749     return HepPoint3D(0,0,0);
00750   }
00751 }

StatusCode MdcWireEff::initialize (   ) 
 

StatusCode MdcWireEff::initialize (   ) 
  

00071                                  {
00072   MsgStream log(msgSvc(), name());
00073   StatusCode sc;
00074   int m_evtIndex = 0;
00075 
00076   //Initialize RawDataProviderSvc
00077   IRawDataProviderSvc* rawDataProviderSvc;
00078   sc = service ("RawDataProviderSvc", rawDataProviderSvc);
00079   m_rawDataProviderSvc = dynamic_cast<RawDataProviderSvc*> (rawDataProviderSvc);
00080   if ( sc.isFailure() ){
00081     log << MSG::FATAL << "Could not load RawDataProviderSvc!" << endreq;
00082     return StatusCode::FAILURE;
00083   }
00084 
00085   // Book NTuple
00086   g_layEffDigi= histoSvc()->book( "layEffDigi", "layEffDigi",43,0,42,100,0,1.1 );
00087   g_layEffHot= histoSvc()->book( "layEffHot", "layEffHot",43,0,42,100,0,1.1 );
00088   if (m_hist){ 
00089     sc = bookNTuple();
00090     if (!sc.isSuccess()) { 
00091       log << MSG::ERROR << " Could not book NTuple" << endreq; 
00092       m_hist = 0;
00093     }
00094   }
00095 
00096   //Initalze magnetic flied 
00097   sc = service ("MagneticFieldSvc",m_pIMF);
00098   if(sc!=StatusCode::SUCCESS) {
00099     log << MSG::ERROR << "Unable to open Magnetic field service"<<endreq;
00100     return StatusCode::FAILURE;
00101   }
00102   Bz = m_pIMF->getReferField()*1000.;
00103 
00104 
00105   // Initialize MdcGeomSvc
00106   IMdcGeomSvc* iMdcGeomSvc;
00107   sc = service ("MdcGeomSvc",iMdcGeomSvc);
00108   m_mdcGeomSvc = dynamic_cast<MdcGeomSvc*> (iMdcGeomSvc);
00109   if ( sc.isFailure() ){
00110     log << MSG::FATAL << "Could not load MdcGeomSvc!" << endreq;
00111     return StatusCode::FAILURE;
00112   }
00113 
00114   // Initialze MdcCalibFunSvc
00115   IMdcCalibFunSvc* imdcCalibSvc;
00116   sc = service ("MdcCalibFunSvc",imdcCalibSvc);
00117   m_mdcCalibFunSvc = dynamic_cast<MdcCalibFunSvc*> (imdcCalibSvc);
00118   if ( sc.isFailure() ){
00119     log << MSG::FATAL << "Could not load MdcCalibFunSvc!" << endreq;
00120     return StatusCode::FAILURE;
00121   }
00122 
00123 
00124   //Initialze MdcDetector
00125   m_gm = MdcDetector::instance(m_doSag);
00126 
00127   m_mdcCheckUtil = new MdcCheckUtil(m_doSag);
00128 
00129   evtCount=0;
00130 
00131   for(int i=0; i<43; i++){
00132     digiLayer[i]=0;
00133     recLayer[i]=0;
00134     passLayer[i]=0;
00135     passLayerWithDigi[i]=0;
00136   }
00137 
00138   if (m_dropMultiHotInLayer) m_cellPassed = true;
00139 
00140   return StatusCode::SUCCESS;
00141 }

StatusCode MdcWireEff::keepBestDigi (   )  [private]
 

StatusCode MdcWireEff::keepBestDigi (   )  [private]
  

00365                                    {
00366   StatusCode sc;
00367   MdcDigiCol *bestMdcDigiCol= new MdcDigiCol;
00368 
00369   uint32_t getDigiFlag = 0;
00370   getDigiFlag += m_maxMdcDigi;
00371   if(m_dropHot)     getDigiFlag |= MdcRawDataProvider::b_dropHot;
00372   if(m_keepBadTdc)  getDigiFlag |= MdcRawDataProvider::b_keepBadTdc;
00373   if(m_keepUnmatch) getDigiFlag |= MdcRawDataProvider::b_keepUnmatch;
00374   MdcDigiVec mdcDigiVec = m_rawDataProviderSvc->getMdcDigiVec(getDigiFlag);
00375 
00376   MdcDigiCol::iterator iter = mdcDigiVec.begin();
00377   for (; iter!=mdcDigiVec.end();iter++  ) {
00378     Identifier id = (*iter)->identify();
00379     int layer  = MdcID::layer(id);
00380     int wire   = MdcID::wire(id);
00381     unsigned int tdc = (*iter)->getTimeChannel();
00382     double rawTime = RawDataUtil::MdcTime(tdc);
00383     if(m_debug>0)std::cout<<"digi "<<layer<<" "<<wire<<" time "<<rawTime
00384       <<" ovfl "<<(*iter)->getOverflow()<<std::endl;
00385     if ((m_resLayer == layer)&&(minResidDigiRawT[layer][wire] != rawTime)){
00386       if(m_debug>0)std::cout<<"erase   "<<layer<<" "<<wire<<" "<<rawTime<<" ovfl "<<(*iter)->getOverflow()<<std::endl;
00387       if (m_debug>1)std::cout<<"erase ("<<layer<<","<<wire<<") rt "<<rawTime <<" ovfl "<<(*iter)->getOverflow()<<" minResid "<<minResid[layer][wire]<<std::endl;
00388     }else{
00389       unsigned int adc = (*iter)->getChargeChannel();
00390       MdcDigi* newDigi = new MdcDigi(id,tdc,adc);
00391       newDigi->setOverflow((*iter)->getOverflow());
00392       bestMdcDigiCol->push_back(newDigi);
00393     }
00394   }
00395 
00396   IDataManagerSvc *dataManSvc = dynamic_cast<IDataManagerSvc*> (eventSvc()); 
00397   DataObject *digiCol;
00398   eventSvc()->findObject("/Event/Digi/MdcDigiCol",digiCol);
00399 
00400   if(digiCol!= NULL) {
00401     dataManSvc->clearSubTree("/Event/Digi/MdcDigiCol");
00402     eventSvc()->unregisterObject("/Event/Digi/MdcDigiCol");
00403   }
00404 
00405   sc = eventSvc()->registerObject(EventModel::Digi::MdcDigiCol, bestMdcDigiCol);
00406   if(!sc.isSuccess()) {
00407     std::cout << " Could not register hit collection" <<std::endl;
00408     return StatusCode::FAILURE;
00409   } 
00410 
00411   std::cout<<"in MdcWireEff new  MdcDigiCol size "<<bestMdcDigiCol->size()<<std::endl;
00412   return sc;
00413 }

StatusCode MdcWireEff::pocaWithDigi (  const RecMdcTrack *  tk  )  [private]
 

StatusCode MdcWireEff::pocaWithDigi (  const RecMdcTrack *  tk  )  [private]
  

00473                                                         {
00474   // Get MdcDigiVec from RawDataProviderSvc
00475 
00476   uint32_t getDigiFlag = 0;
00477   getDigiFlag += m_maxMdcDigi;
00478   if(m_dropHot)     getDigiFlag |= MdcRawDataProvider::b_dropHot;
00479   if(m_keepBadTdc)  getDigiFlag |= MdcRawDataProvider::b_keepBadTdc;
00480   if(m_keepUnmatch) getDigiFlag |= MdcRawDataProvider::b_keepUnmatch;
00481   MdcDigiVec mdcDigiVec = m_rawDataProviderSvc->getMdcDigiVec(getDigiFlag);
00482   if (0 == mdcDigiVec.size()) { 
00483     std::cout<<"no MdcDigi   "<<std::endl;
00484     return StatusCode::SUCCESS;
00485   } 
00486   int nDigi = mdcDigiVec.size();
00487 
00488 
00489   MdcDigiCol::iterator iter = mdcDigiVec.begin();
00490   for (int iDigi = 0; iDigi < nDigi; iter++ ,iDigi++) {
00491     MdcDigi* digi = (*iter);
00492     int layer   = MdcID::layer((*iter)->identify());
00493     int wire  = MdcID::wire((*iter)->identify());
00494     int ovfl = digi->getOverflow();
00495 
00496     double doca;
00497     doca = m_mdcCheckUtil->doca(layer,wire,tk->helix(),tk->err());
00498 
00499     //guess raw drift dist of digi
00500     //int    gwire = Constants::nWireBeforeLayer[layer] + wire;
00501     double rawTime = RawDataUtil::MdcTime(digi->getTimeChannel());
00502     double rawCharge = RawDataUtil::MdcCharge(digi->getChargeChannel());
00503     double t0Walk = m_mdcCalibFunSvc->getT0(layer,wire) +  m_mdcCalibFunSvc->getTimeWalk(layer, rawCharge);
00504     double rMid = m_gm->Layer(layer)->rMid();
00505     double tof = rMid / Constants::c;
00506     double z = tk->helix(3) + rMid*tk->helix(4);//z=z0+fltLen*tan(lambda);set fltLen=rMid
00507     double _vprop = (layer<8) ? Constants::vpropInner : Constants::vpropOuter;
00508     double zlen = m_gm->Layer(layer)->zLength();
00509     double tprop = 0.;
00510     if (0 == layer%2){
00511       tprop = (0.5*zlen + z)/_vprop; //odd
00512     }else{
00513       tprop = (0.5*zlen - z)/_vprop; //even
00514     }
00515     double driftT = rawTime - t0Walk - t_t0 - tprop - tof;
00516 
00517     //std::cout<<"d driftT   "<<tprop+tof<<std::endl;
00518     int    lrCalib = 2;//ambig
00519     double entranceAngle = 0.;//ambig
00520     double driftD = 0.1 *m_mdcCalibFunSvc->driftTimeToDist(driftT,layer,wire,lrCalib,entranceAngle); //mm to cm
00521     if (m_debug>0)std::cout<<"pocaWithDigi ("<<layer<<","<<wire<<")  doca="<<doca<<" dd "<<driftD<<" diff "<<(fabs(doca)-driftD)<<" minResid "<<minResid[layer][wire]<<" tprop "<<tprop<<" tof "<<tof<<std::endl;
00522     double resid = -9999.;
00523     if(abs(doca) >0.00001) resid = abs(driftD - abs(doca))*(doca/abs(doca));
00524     if(abs(resid)< minResid[layer][wire]){
00525       if ((m_debug>0)&&(ovfl>12)) std::cout<<"min resid ovfl  >12 "<<ovfl<<std::endl;
00526 
00527       minResid[layer][wire] = abs(resid);
00528       minResidDigiRawT[layer][wire] = rawTime;
00529       //minResidDigiOvfl[layer][wire] = ovfl;
00530     }
00531 
00532   }
00533   if(m_hist && m_tuple1) m_tuple1->write();
00534 
00535   return StatusCode::SUCCESS; 
00536 }

StatusCode MdcWireEff::pocaWithHot (  const RecMdcTrack *  tk  )  [private]
 

StatusCode MdcWireEff::pocaWithHot (  const RecMdcTrack *  tk  )  [private]
  

00416                                                        {
00417   SmartDataPtr<RecMdcHitCol> recMdcHitCol(eventSvc(), "/Event/Recon/RecMdcHitCol");
00418   if (!recMdcHitCol){ return StatusCode::FAILURE; }
00419   int nHot = recMdcHitCol->size();
00420   if (m_hist && m_tuple2){
00421     m_weff_hot_recTk = tk->trackId();
00422     m_weff_hot_evtNo = t_eventNo;
00423     m_weff_hot_t0    = t_t0;
00424     m_weff_hot_t0Stat= t_t0Stat;
00425     m_weff_hot_runNo = t_runNo;
00426     m_weff_hot_nHot = nHot;
00427   }
00428 
00429   RecMdcHitCol::iterator iter = recMdcHitCol->begin();
00430   for (int iHot=0 ;iter != recMdcHitCol->end(); iter++ , iHot++) {
00431     RecMdcHit* hot = *iter;
00432     int layer = MdcID::layer(hot->getMdcId());
00433     int wire  = MdcID::wire(hot->getMdcId());
00434 
00435     //std::cout << " test " <<helix<<endl;
00436     //std::cout << " test " <<helixErr <<endl;
00437     double hotDoca = hot->getDoca();
00438     //double doca = m_mdcCheckUtil->doca(layer,wire,tk->helix(),tk->err());
00439     double flagLR = hot->getFlagLR();
00440     double hotDriftT,hotDriftD;
00441     Identifier id = hot->getMdcId();
00442     hotDriftT = hot->getDriftT();
00443     if (0 == flagLR){
00444       hotDriftD = hot->getDriftDistLeft();
00445     }else{
00446       hotDriftD = hot->getDriftDistRight();
00447     }
00448     m_hotDriftDist[layer][wire] = hotDriftD;
00449     if(m_debug>0){
00450       std::cout<<"pocaWithHot ("<<layer<<","<<wire<<") "<<
00451         //"doca="<<doca<<" "<<
00452         "doca "<<hotDoca<< " drift "<<-hotDriftD<<" diff " << hotDoca+hotDriftD<<std::endl;
00453     }
00454     int    gwire = Constants::nWireBeforeLayer[layer] + wire;
00455     if(m_hist && m_tuple2){
00456       m_weff_hot_layer[iHot] = layer;
00457       m_weff_hot_wire[iHot] = wire;
00458       m_weff_hot_gwire[iHot] = gwire;
00459       m_weff_hot_poca[iHot] = hotDoca;
00460       m_weff_hot_driftT[iHot] = hotDriftT;
00461       m_weff_hot_driftD[iHot] = hotDriftD;
00462       //m_weff_hot_ovfl[iHot] = overflow[layer][wire];
00463       //m_weff_hot_tNum[iHot] = tNum;
00464       //m_weff_hot_rt[iHot] = rawTime;
00465     }
00466   }
00467   if (m_hist && m_tuple2) m_tuple2->write();
00468 
00469   return StatusCode::SUCCESS; 
00470 }

void MdcWireEff::wireEff (  void   )  [private]
 

void MdcWireEff::wireEff (  void   )  [private]
  

00753                         {
00754   SmartDataPtr<RecMdcHitCol> recMdcHitCol(eventSvc(), "/Event/Recon/RecMdcHitCol");
00755   //int nHot = recMdcHitCol->size();
00756 
00757   RecMdcHitCol::iterator iter = recMdcHitCol->begin();
00758   for (int iHot=0 ;iter != recMdcHitCol->end(); iter++ , iHot++) {
00759     RecMdcHit* hot = *iter;
00760     int layer = MdcID::layer(hot->getMdcId());
00761     int wire  = MdcID::wire(hot->getMdcId());
00762     haveHot[layer][wire]= true;
00763   }
00764 
00765 
00766   uint32_t getDigiFlag = 0;
00767   getDigiFlag += m_maxMdcDigi;
00768   if(m_dropHot)     getDigiFlag |= MdcRawDataProvider::b_dropHot;
00769   if(m_keepBadTdc)  getDigiFlag |= MdcRawDataProvider::b_keepBadTdc;
00770   if(m_keepUnmatch) getDigiFlag |= MdcRawDataProvider::b_keepUnmatch;
00771   MdcDigiVec mdcDigiVec = m_rawDataProviderSvc->getMdcDigiVec(getDigiFlag);
00772   MdcDigiCol::iterator iter1 = mdcDigiVec.begin();
00773   for (; iter1!=mdcDigiVec.end(); iter1++ ) {
00774     int layer = MdcID::layer((*iter1)->identify());
00775     int wire  = MdcID::wire((*iter1)->identify());
00776     haveDigi[layer][wire]=true;
00777   }
00778 
00779   for(int i=0;i<43;i++){
00780     for(int j=0;j<288;j++){
00781       if(haveDigi[i][j]) digiLayer[i]++;
00782       if(cellTrackPassed[i][j]){ passLayer[i]++;}
00783       if(cellTrackPassed[i][j] && haveDigi[i][j]){
00784         passLayerWithDigi[i]++;
00785         if(haveHot[i][j]) recLayer[i]++;
00786       }
00787     }
00788   }
00789 }

StatusCode MdcWireEff::wireEfficiency (  const RecMdcTrack *  tk  )  [private]
 

StatusCode MdcWireEff::wireEfficiency (  const RecMdcTrack *  tk  )  [private]
  

00341                                                           {
00342   StatusCode sc;
00343 
00344   if(m_pocaWithHot){
00345     if(m_debug>0)std::cout<<"with Hot   "<<std::endl;
00346     sc = pocaWithHot(tk);
00347   }
00348 
00349   if(m_pocaWithDigi){
00350     if(m_debug>0)std::cout<<"with Digi   "<<std::endl;
00351     sc = pocaWithDigi(tk);
00352   }
00353 
00354 
00355   if(m_cellPassed){
00356     sc = cellPassed(tk);
00357   }
00358 
00359 
00360 
00361   return StatusCode::SUCCESS;
00362 }

Member Data Documentation

int MdcWireEff::allNum [private]
 

double MdcWireEff::Bz [private]
 

bool MdcWireEff::cellTrackPassed [private]
 

int MdcWireEff::digiLayer [private]
 

int MdcWireEff::evtCount [private]
 

AIDA::IHistogram2D* MdcWireEff::g_layEffDigi [private]
 

AIDA::IHistogram2D* MdcWireEff::g_layEffDigi [private]
 

AIDA::IHistogram2D* MdcWireEff::g_layEffHot [private]
 

AIDA::IHistogram2D* MdcWireEff::g_layEffHot [private]
 

bool MdcWireEff::haveDigi [private]
 

bool MdcWireEff::haveHot [private]
 

double MdcWireEff::m_bigTdc [private]
 

bool MdcWireEff::m_cellPassed [private]
 

NTuple::Array<long> MdcWireEff::m_dbhot_adc [private]
 

NTuple::Array<long> MdcWireEff::m_dbhot_adc [private]
 

NTuple::Item<long> MdcWireEff::m_dbhot_evtNo [private]
 

NTuple::Item<long> MdcWireEff::m_dbhot_evtNo [private]
 

NTuple::Array<long> MdcWireEff::m_dbhot_layer [private]
 

NTuple::Array<long> MdcWireEff::m_dbhot_layer [private]
 

NTuple::Item<long> MdcWireEff::m_dbhot_nRemove [private]
 

NTuple::Item<long> MdcWireEff::m_dbhot_nRemove [private]
 

NTuple::Item<long> MdcWireEff::m_dbhot_nTk [private]
 

NTuple::Item<long> MdcWireEff::m_dbhot_nTk [private]
 

NTuple::Array<long> MdcWireEff::m_dbhot_ovfl [private]
 

NTuple::Array<long> MdcWireEff::m_dbhot_ovfl [private]
 

NTuple::Array<double> MdcWireEff::m_dbhot_rt [private]
 

NTuple::Array<double> MdcWireEff::m_dbhot_rt [private]
 

NTuple::Array<long> MdcWireEff::m_dbhot_used [private]
 

NTuple::Array<long> MdcWireEff::m_dbhot_used [private]
 

NTuple::Array<long> MdcWireEff::m_dbhot_wire [private]
 

NTuple::Array<long> MdcWireEff::m_dbhot_wire [private]
 

int MdcWireEff::m_debug [private]
 

bool MdcWireEff::m_doSag [private]
 

bool MdcWireEff::m_dropHot [private]
 

bool MdcWireEff::m_dropMultiHotInLayer [private]
 

int MdcWireEff::m_evtIndex [private]
 

const MdcDetector* MdcWireEff::m_gm [private]
 

const MdcDetector* MdcWireEff::m_gm [private]
 

bool MdcWireEff::m_hist [private]
 

double MdcWireEff::m_hotDriftDist [private]
 

bool MdcWireEff::m_keepBadTdc [private]
 

bool MdcWireEff::m_keepUnmatch [private]
 

int MdcWireEff::m_maxMdcDigi [private]
 

const MdcCalibFunSvc* MdcWireEff::m_mdcCalibFunSvc [private]
 

const MdcCalibFunSvc* MdcWireEff::m_mdcCalibFunSvc [private]
 

MdcCheckUtil* MdcWireEff::m_mdcCheckUtil [private]
 

MdcCheckUtil* MdcWireEff::m_mdcCheckUtil [private]
 

IMdcGeomSvc* MdcWireEff::m_mdcGeomSvc [private]
 

IMdcGeomSvc* MdcWireEff::m_mdcGeomSvc [private]
 

NTuple::Array<long> MdcWireEff::m_pass_adc [private]
 

NTuple::Array<long> MdcWireEff::m_pass_adc [private]
 

NTuple::Array<long> MdcWireEff::m_pass_layer [private]
 

NTuple::Array<long> MdcWireEff::m_pass_layer [private]
 

NTuple::Item<long> MdcWireEff::m_pass_nDigi [private]
 

NTuple::Item<long> MdcWireEff::m_pass_nDigi [private]
 

NTuple::Array<double> MdcWireEff::m_pass_rt [private]
 

NTuple::Array<double> MdcWireEff::m_pass_rt [private]
 

NTuple::Array<long> MdcWireEff::m_pass_wire [private]
 

NTuple::Array<long> MdcWireEff::m_pass_wire [private]
 

IMagneticFieldSvc* MdcWireEff::m_pIMF [private]
 

IMagneticFieldSvc* MdcWireEff::m_pIMF [private]
 

bool MdcWireEff::m_poca [private]
 

bool MdcWireEff::m_pocaWithDigi [private]
 

bool MdcWireEff::m_pocaWithHot [private]
 

RawDataProviderSvc* MdcWireEff::m_rawDataProviderSvc [private]
 

RawDataProviderSvc* MdcWireEff::m_rawDataProviderSvc [private]
 

double MdcWireEff::m_resLayer [private]
 

NTuple::Tuple* MdcWireEff::m_tuple1 [private]
 

NTuple::Tuple* MdcWireEff::m_tuple1 [private]
 

NTuple::Tuple* MdcWireEff::m_tuple2 [private]
 

NTuple::Tuple* MdcWireEff::m_tuple2 [private]
 

NTuple::Tuple* MdcWireEff::m_tuple3 [private]
 

NTuple::Tuple* MdcWireEff::m_tuple3 [private]
 

NTuple::Tuple* MdcWireEff::m_tuple4 [private]
 

NTuple::Tuple* MdcWireEff::m_tuple4 [private]
 

NTuple::Array<long> MdcWireEff::m_weff_allNum [private]
 

NTuple::Array<long> MdcWireEff::m_weff_allNum [private]
 

NTuple::Array<double> MdcWireEff::m_weff_driftD [private]
 

NTuple::Array<double> MdcWireEff::m_weff_driftD [private]
 

NTuple::Array<double> MdcWireEff::m_weff_driftdHot [private]
 

NTuple::Array<double> MdcWireEff::m_weff_driftdHot [private]
 

NTuple::Array<double> MdcWireEff::m_weff_driftT [private]
 

NTuple::Array<double> MdcWireEff::m_weff_driftT [private]
 

NTuple::Item<long> MdcWireEff::m_weff_evtNo [private]
 

NTuple::Item<long> MdcWireEff::m_weff_evtNo [private]
 

NTuple::Array<long> MdcWireEff::m_weff_gwire [private]
 

NTuple::Array<long> MdcWireEff::m_weff_gwire [private]
 

NTuple::Array<long> MdcWireEff::m_weff_hot_allNum [private]
 

NTuple::Array<long> MdcWireEff::m_weff_hot_allNum [private]
 

NTuple::Array<double> MdcWireEff::m_weff_hot_driftD [private]
 

NTuple::Array<double> MdcWireEff::m_weff_hot_driftD [private]
 

NTuple::Array<double> MdcWireEff::m_weff_hot_driftT [private]
 

NTuple::Array<double> MdcWireEff::m_weff_hot_driftT [private]
 

NTuple::Item<long> MdcWireEff::m_weff_hot_evtNo [private]
 

NTuple::Item<long> MdcWireEff::m_weff_hot_evtNo [private]
 

NTuple::Array<long> MdcWireEff::m_weff_hot_gwire [private]
 

NTuple::Array<long> MdcWireEff::m_weff_hot_gwire [private]
 

NTuple::Array<long> MdcWireEff::m_weff_hot_layer [private]
 

NTuple::Array<long> MdcWireEff::m_weff_hot_layer [private]
 

NTuple::Item<long> MdcWireEff::m_weff_hot_nHot [private]
 

NTuple::Item<long> MdcWireEff::m_weff_hot_nHot [private]
 

NTuple::Array<long> MdcWireEff::m_weff_hot_ovfl [private]
 

NTuple::Array<long> MdcWireEff::m_weff_hot_ovfl [private]
 

NTuple::Array<double> MdcWireEff::m_weff_hot_poca [private]
 

NTuple::Array<double> MdcWireEff::m_weff_hot_poca [private]
 

NTuple::Item<long> MdcWireEff::m_weff_hot_recTk [private]
 

NTuple::Item<long> MdcWireEff::m_weff_hot_recTk [private]
 

NTuple::Array<double> MdcWireEff::m_weff_hot_rt [private]
 

NTuple::Array<double> MdcWireEff::m_weff_hot_rt [private]
 

NTuple::Item<long> MdcWireEff::m_weff_hot_runNo [private]
 

NTuple::Item<long> MdcWireEff::m_weff_hot_runNo [private]
 

NTuple::Item<double> MdcWireEff::m_weff_hot_t0 [private]
 

NTuple::Item<double> MdcWireEff::m_weff_hot_t0 [private]
 

NTuple::Item<long> MdcWireEff::m_weff_hot_t0Stat [private]
 

NTuple::Item<long> MdcWireEff::m_weff_hot_t0Stat [private]
 

NTuple::Array<long> MdcWireEff::m_weff_hot_tNum [private]
 

NTuple::Array<long> MdcWireEff::m_weff_hot_tNum [private]
 

NTuple::Array<long> MdcWireEff::m_weff_hot_wire [private]
 

NTuple::Array<long> MdcWireEff::m_weff_hot_wire [private]
 

NTuple::Array<long> MdcWireEff::m_weff_layer [private]
 

NTuple::Array<long> MdcWireEff::m_weff_layer [private]
 

NTuple::Item<long> MdcWireEff::m_weff_nDigi [private]
 

NTuple::Item<long> MdcWireEff::m_weff_nDigi [private]
 

NTuple::Array<long> MdcWireEff::m_weff_ovfl [private]
 

NTuple::Array<long> MdcWireEff::m_weff_ovfl [private]
 

NTuple::Array<long> MdcWireEff::m_weff_passed [private]
 

NTuple::Array<long> MdcWireEff::m_weff_passed [private]
 

NTuple::Item<long> MdcWireEff::m_weff_PatRec [private]
 

NTuple::Item<long> MdcWireEff::m_weff_PatRec [private]
 

NTuple::Array<double> MdcWireEff::m_weff_poca [private]
 

NTuple::Array<double> MdcWireEff::m_weff_poca [private]
 

NTuple::Array<double> MdcWireEff::m_weff_rc [private]
 

NTuple::Array<double> MdcWireEff::m_weff_rc [private]
 

NTuple::Item<long> MdcWireEff::m_weff_recTk [private]
 

NTuple::Item<long> MdcWireEff::m_weff_recTk [private]
 

NTuple::Array<double> MdcWireEff::m_weff_resid [private]
 

NTuple::Array<double> MdcWireEff::m_weff_resid [private]
 

NTuple::Array<double> MdcWireEff::m_weff_rt [private]
 

NTuple::Array<double> MdcWireEff::m_weff_rt [private]
 

NTuple::Item<long> MdcWireEff::m_weff_runNo [private]
 

NTuple::Item<long> MdcWireEff::m_weff_runNo [private]
 

NTuple::Item<double> MdcWireEff::m_weff_t0 [private]
 

NTuple::Item<double> MdcWireEff::m_weff_t0 [private]
 

NTuple::Item<long> MdcWireEff::m_weff_t0Stat [private]
 

NTuple::Item<long> MdcWireEff::m_weff_t0Stat [private]
 

NTuple::Array<long> MdcWireEff::m_weff_tNum [private]
 

NTuple::Array<long> MdcWireEff::m_weff_tNum [private]
 

NTuple::Item<long> MdcWireEff::m_weff_TrkReco [private]
 

NTuple::Item<long> MdcWireEff::m_weff_TrkReco [private]
 

NTuple::Array<long> MdcWireEff::m_weff_wire [private]
 

NTuple::Array<long> MdcWireEff::m_weff_wire [private]
 

bool MdcWireEff::m_wireEff [private]
 

double MdcWireEff::minResid [private]
 

double MdcWireEff::minResidDigiRawT [private]
 

int MdcWireEff::passLayer [private]
 

int MdcWireEff::passLayerWithDigi [private]
 

int MdcWireEff::recLayer [private]
 

long MdcWireEff::t_eventNo [private]
 

int MdcWireEff::t_mdcxRecTk [private]
 

int MdcWireEff::t_nTk [private]
 

int MdcWireEff::t_patRecTk [private]
 

int MdcWireEff::t_recTkNum [private]
 

long MdcWireEff::t_runNo [private]
 

double MdcWireEff::t_t0 [private]
 

int MdcWireEff::t_t0Stat [private]
 

int MdcWireEff::t_trkRecoTk [private]
 

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