EvtValsTool.cxx Source File

00001 
00009 #include "ValBase.h"
00010 
00011 #include "GaudiKernel/MsgStream.h"
00012 #include "GaudiKernel/IDataProviderSvc.h"
00013 #include "GaudiKernel/SmartDataPtr.h"
00014 #include "GaudiKernel/AlgTool.h"
00015 #include "GaudiKernel/ToolFactory.h"
00016 #include "GaudiKernel/IToolSvc.h"
00017 
00018 #include "Event/TopLevel/EventModel.h"
00019 #include "Event/TopLevel/Event.h"
00020 
00021 #include "TkrUtil/ITkrGeometrySvc.h"
00022 
00023 #include <algorithm>
00028 class EvtValsTool : public ValBase
00029 {
00030 public:
00031 
00032     EvtValsTool( const std::string& type, 
00033         const std::string& name, 
00034         const IInterface* parent);
00035 
00036     virtual ~EvtValsTool() { }
00037 
00038     StatusCode initialize();
00039 
00040     StatusCode calculate();
00041 
00042     void zeroVals();
00043 
00044     void fillHeaderInfo();
00045 
00046 private:
00047 
00048     //Global Items
00049     unsigned int EvtRun;
00050     unsigned int EvtEventId;
00051     unsigned long long EvtEventId64;
00052     double EvtElapsedTime;
00053     double EvtLiveTime;
00054 
00055     float EvtEnergyCorr;
00056     float EvtEnergyRaw;
00057     float EvtDeltaEoE;
00058     float EvtCalEdgeAngle;
00059     float EvtTkrEdgeAngle;
00060     float EvtLogEnergy;
00061     float EvtTkr1EFrac;
00062     float EvtVtxKin;
00063     float EvtVtxEAngle;
00064     float EvtTkrComptonRatio;
00065     float EvtETkrComptonRatio;
00066     float EvtPSFModel; 
00067 
00068     float EvtETkr1Chisq;
00069     float EvtETkr1FirstChisq;
00070     float EvtETkr1Qual;
00071     float EvtTkr1PSFMdRat;
00072 
00073     float EvtECalXtalRatio;
00074     float EvtECalXtalTrunc;
00075     float EvtECalTrackDoca;
00076     float EvtECalTrackSep;
00077         float EvtECalTransRms;
00078         float EvtECalLongRms;
00079         float EvtECalLRmsAsym;
00080         float EvtECalTrackAngle;
00081     float EvtEVtxAngle;
00082     float EvtEVtxDoca;
00083     unsigned int EvtEventFlags;
00084     //test
00085     //char  EvtEvtNum[20];
00086 
00087     IValsTool* m_pMcTool;
00088     IValsTool* m_pGltTool;
00089     IValsTool* m_pTkrHitTool;
00090     IValsTool* m_pTkrTool;
00091     IValsTool* m_pVtxTool;
00092     IValsTool* m_pCalTool;
00093     IValsTool* m_pAcdTool;
00094 
00095     ITkrGeometrySvc* m_tkrGeom;
00096 
00097         // These are copies of the new DC2 vars from IM.   Left here for reference
00098 // EvtECalXtalRatio     continuous      CalXtalRatio/(2.99-1.19*LogEnergyOpt  + .122*LogEnergyOpt^2)/(.749-.355*Tkr1ZDir)
00099 // EvtECalTrackDoca     continuous      CalTrackDoca/(272-140.5*min(EvtLogEnergy, 3.8) + 18.7*min(EvtLogEnergy, 3.8)^2)/(3.08+2.67*Tkr1ZDir)
00100 // EvtECalXtalsTrunc    continuous      CalXtalsTrunc/(max(1.,(-85.4 + 65.2*LogEnergyOpt - 10.4*LogEnergyOpt^2)) + min(12*(LogEnergyOpt-3.3)^2*(max(3.3,LogEnergyOpt)-3.3)/(LogEnergyOpt-3.3),14.))/(1.2+.224*Tkr1ZDir)
00101 // EvtECalTransRms      continuous      CalTransRms/(12.5+ 22.*exp(-(EvtLogEnergy-2.3)^2/.8))/(1.34+.55*Tkr1ZDir)
00102 // EvtECalLongRms       continuous      CalLongRms/(ifelse(EvtLogEnergy < 3.8, (96.1 - 39*EvtLogEnergy + 5.6*EvtLogEnergy^2),  28.*(.847-.0134*EvtLogEnergy+.015*EvtLogEnergy^2)))/(1.06+.0867*Tkr1ZDir)
00103 // EvtECalLRmsAsym      continuous      CalLRmsAsym/(.012+.06*exp(-(EvtLogEnergy-2.0)^2/1.3))/(1.01-.0718*Tkr1ZDir)
00104 // EvtECalTrackAngle    continuous      CalTrackAngle/(2.3-1.11*min(EvtLogEnergy,4.0)+.138*min(EvtLogEnergy,4.0)^2)/(1.43+.612*Tkr1ZDir)
00105 
00106 // EvtETkr1Chisq        continuous      Tkr1Chisq/(6.49 -22.1*Tkr1ZDir -22.8*Tkr1ZDir^2)
00107 // EvtETkr1FirstChisq   continuous      Tkr1FirstChisq/(4.34-.708*EvtLogEnergy+.19*EvtLogEnergy^2)/(.751-1.74*Tkr1ZDir-1.83*Tkr1ZDir^2)
00108 // EvtETkr1Qual continuous      Tkr1Qual/(56.6 +6.78*Tkr1ZDir + 8.23*Tkr1ZDir^2)
00109 // EvtETkrComptonRatio  continuous      EvtTkrComptonRatio / (-9.34+7.22*EvtLogEnergy - .672*EvtLogEnergy^2)/(-.509 - 3.65*Tkr1ZDir - 2.03*Tkr1ZDir^2)
00110 
00111 // EvtVtxEAngle continuous      VtxAngle*sqrt(EvtEnergySumOpt)/(4.24 -1.98*EvtLogEnergy + .269*EvtLogEnergy^2)/(1.95+2.36*Tkr1ZDir+1.3*Tkr1ZDir^2)
00112 
00113 };
00114 
00115 
00116 // Static factory for instantiation of algtool objects
00117 static ToolFactory<EvtValsTool> s_factory;
00118 const IToolFactory& EvtValsToolFactory = s_factory;
00119 
00120 // Standard Constructor
00121 EvtValsTool::EvtValsTool(const std::string& type, 
00122                          const std::string& name, 
00123                          const IInterface* parent)
00124                          : ValBase( type, name, parent )
00125 {    
00126     // Declare additional interface
00127     declareInterface<IValsTool>(this);
00128 }
00129 
00210 StatusCode EvtValsTool::initialize()
00211 {
00212     StatusCode sc = StatusCode::SUCCESS;
00213     StatusCode fail = StatusCode::FAILURE;
00214 
00215     MsgStream log(msgSvc(), name());
00216 
00217     if( ValBase::initialize().isFailure()) return StatusCode::FAILURE;
00218 
00219     // get the services
00220 
00221     // try using one tool from another
00222 
00223     if(service( "TkrGeometrySvc", m_tkrGeom, true ).isFailure()) {
00224         log << MSG::ERROR << "Could not find TkrGeometrySvc" << endreq;
00225         return fail;
00226     }
00227 
00228     IToolSvc* pToolSvc = 0; 
00229     sc = service("ToolSvc", pToolSvc, true);
00230     if (!sc.isSuccess ()){
00231         log << MSG::ERROR << "Can't find ToolSvc, will quit now" << endreq;
00232         return StatusCode::FAILURE;
00233     }
00234 
00235     m_pMcTool = 0;
00236     sc = pToolSvc->retrieveTool("McValsTool", m_pMcTool);
00237     if( sc.isFailure() ) {
00238         log << MSG::INFO << "Unable to find tool: " "McValsTool" << endreq;
00239         log << "Will carry on anyway, EvtDeltaEoE will not be calculated" << endreq;
00240     }
00241         
00242     /*    
00243     m_pGltTool = 0;
00244     sc = pToolSvc->retrieveTool("GltValsTool", m_pGltTool);
00245     if( sc.isFailure() ) {
00246         log << MSG::ERROR << "Unable to find tool: " "GltValsTool" << endreq;
00247         return sc;
00248     }
00249     m_pTkrHitTool = 0;
00250     sc = pToolSvc->retrieveTool("TkrHitValsTool", m_pTkrHitTool);
00251     if( sc.isFailure() ) {
00252         log << MSG::ERROR << "Unable to find tool: " "TkrHitValsTool" << endreq;
00253         return sc;
00254     }
00255     */
00256 
00257     m_pTkrTool = 0;
00258     sc = pToolSvc->retrieveTool("TkrValsTool", m_pTkrTool);
00259     if( sc.isFailure() ) {
00260         log << MSG::ERROR << "Unable to find tool: " "TkrValsTool" << endreq;
00261         return sc;
00262     }
00263 
00264     m_pVtxTool = 0;
00265     sc = pToolSvc->retrieveTool("VtxValsTool", m_pVtxTool);
00266     if( sc.isFailure() ) {
00267         log << MSG::ERROR << "Unable to find tool: " "VtxValsTool" << endreq;
00268         return sc;
00269     }
00270 
00271     m_pCalTool = 0;
00272     sc = pToolSvc->retrieveTool("CalValsTool", m_pCalTool);
00273     if( sc.isFailure() ) {
00274         log << MSG::ERROR << "Unable to find tool: " "CalValsTool" << endreq;
00275         return sc;
00276     }
00277 
00278     /*
00279     m_pAcdTool = 0;
00280     sc = pToolSvc->retrieveTool("AcdValsTool", m_pAcdTool);
00281     if( sc.isFailure() ) {
00282         log << MSG::ERROR << "Unable to find tool: " "AcdValsTool" << endreq;
00283         return sc;
00284     }
00285     */
00286     
00287     // load up the map
00288 
00289     addItem("EvtRun",           &EvtRun);
00290     addItem("EvtEventId",       &EvtEventId);
00291     addItem("EvtEventId64",     &EvtEventId64);
00292     addItem("EvtElapsedTime",   &EvtElapsedTime);
00293     addItem("EvtLiveTime",      &EvtLiveTime);
00294 
00295     addItem("EvtEnergyCorr",    &EvtEnergyCorr);
00296     addItem("EvtEnergyRaw",     &EvtEnergyRaw);
00297     addItem("EvtDeltaEoE",      &EvtDeltaEoE);
00298     addItem("EvtCalEdgeAngle",  &EvtCalEdgeAngle);
00299     addItem("EvtTkrEdgeAngle",  &EvtTkrEdgeAngle);
00300     addItem("EvtLogEnergy",     &EvtLogEnergy);
00301     addItem("EvtTkr1EFrac",     &EvtTkr1EFrac);
00302     addItem("EvtVtxKin",        &EvtVtxKin);
00303     addItem("EvtVtxEAngle",     &EvtVtxEAngle);
00304     addItem("EvtTkrComptonRatio", &EvtTkrComptonRatio);
00305         addItem("EvtETkrComptonRatio", &EvtETkrComptonRatio);
00306     addItem("EvtPSFModel",      &EvtPSFModel);
00307 
00308     addItem("EvtETkr1Chisq",    &EvtETkr1Chisq);
00309     addItem("EvtETkr1FirstChisq", &EvtETkr1FirstChisq);
00310     addItem("EvtETkr1Qual",     &EvtETkr1Qual);
00311     addItem("EvtTkr1PSFMdRat",  &EvtTkr1PSFMdRat);
00312 
00313     addItem("EvtECalXtalRatio", &EvtECalXtalRatio);
00314     addItem("EvtECalXtalTrunc", &EvtECalXtalTrunc);
00315     addItem("EvtECalTrackDoca", &EvtECalTrackDoca);
00316     addItem("EvtECalTrackSep",  &EvtECalTrackSep);
00317         addItem("EvtECalTransRms",  &EvtECalTransRms);
00318     addItem("EvtECalLongRms",   &EvtECalLongRms);
00319         addItem("EvtECalLRmsAsym",  &EvtECalLRmsAsym);
00320         addItem("EvtECalTrackAngle",&EvtECalTrackAngle);
00321 
00322     addItem("EvtEVtxAngle",     &EvtEVtxAngle);
00323     addItem("EvtEVtxDoca",      &EvtEVtxDoca);
00324     addItem("EvtEventFlags",      &EvtEventFlags);
00325  
00326     zeroVals();
00327 
00328     return sc;
00329 }
00330 
00331 void EvtValsTool::zeroVals() 
00332 {
00333     ValBase::zeroVals();
00334     // restore some interesting event variables, no need to touch them again...
00335     fillHeaderInfo();
00336 }
00337 
00338 StatusCode EvtValsTool::calculate()
00339 {
00340     StatusCode sc = StatusCode::SUCCESS;
00341 
00342     MsgStream log(msgSvc(), name());
00343 
00344     // we may want to add TDS stuff to this method, but we haven't needed it yet.
00345 
00346     int firstCheck = m_check;
00347     int nextCheck = NOCALC;
00348 
00349 
00350     // since we know what's happening here, we can plan a little
00351     // the idea is to call the first check of each tool with the called check value,
00352     // and the rest with the no-calc value
00353     // so be careful when adding calls or moving stuff around!!!!
00354 
00355     // So far, we're only using Tkr, Cal, Vtx and Mc quantities. 
00356     // The corresponding ValsTools have already been called, 
00357     // so we can use nextCheck throughout. 
00358 
00359     float eCalSum = -1.0, eTkr = -1.0;
00360     if(    m_pCalTool->getVal("CalEnergyRaw", eCalSum, nextCheck).isSuccess()
00361         && m_pTkrTool->getVal("TkrEnergyCorr", eTkr, nextCheck).isSuccess()) {
00362         EvtEnergyRaw = eTkr + eCalSum;
00363     }
00364 
00365     float eTkrKalEne, eCalRLn, eTkrBest; //, eCal
00366     int CAL_Type;
00367     if (   m_pCalTool->getVal("CalCsIRLn", eCalRLn, nextCheck).isSuccess()
00368         && m_pTkrTool->getVal("TkrSumKalEne", eTkrKalEne, nextCheck).isSuccess()) 
00369     {
00370         eTkrBest = std::max(eTkr+eCalSum, eTkrKalEne);
00371         if(eCalSum < 350 || eCalRLn < 4) {
00372             if(eCalSum < 5 || eCalRLn < 4) {
00373                 CAL_Type = 0;
00374             }
00375             else {CAL_Type = 1;}
00376         }
00377         else {CAL_Type = 2;} 
00378     }
00379 
00380  // EdgeAngle:   distance from tower edge / cos(theta) 
00381     float tkrEdge, calEdge, tkr1ZDir = -1.;
00382     if(m_pTkrTool->getVal("Tkr1ZDir",tkr1ZDir, nextCheck).isSuccess()) {
00383                 if(tkr1ZDir == 0.) tkr1ZDir = -1.; 
00384         if (m_pTkrTool->getVal("TkrTwrEdge", tkrEdge, nextCheck).isSuccess()) {
00385             EvtTkrEdgeAngle = -tkrEdge/tkr1ZDir;
00386         }
00387         if (m_pCalTool->getVal("CalTwrEdge", calEdge, nextCheck).isSuccess()) {
00388             EvtCalEdgeAngle = -calEdge/tkr1ZDir;
00389         }
00390     }
00391         float tkr1ZDir2 = tkr1ZDir*tkr1ZDir;  
00392         // Final Energy Selection: (Combo approach) 
00393         //    Use Kalman energy when not enough in the Cal,
00394         //    use Last Layer Correction when avaialable (eCalEneLLCorr > 0) or else
00395         //    use integrated edge and leakage correction from CalValsTool
00396     float eCalSumCorr = -1.0;
00397     if(    m_pCalTool->getVal("CalEnergyCorr", eCalSumCorr, nextCheck).isSuccess()
00398                 //&& m_pCalTool->getVal("CalEnergyLLCorr", eCalEneLLCorr, nextCheck).isSuccess()
00399                 )
00400     {       // NOTE: IT IS STILL LARGELY UNDECIDED WHAT TO DO HERE....!!!!!!!  
00401             //    if(CAL_Type == 0) EvtEnergyCorr = eTkrBest;
00402             //  else {
00403             //  if(eCalEneLLCorr > 0) EvtEnergyCorr = eCalEneLLCorr; //This is wrong! LL has comp.for TkrEne!
00404             //  else { 
00405         EvtEnergyCorr = (eTkr + eCalSumCorr);
00406             //  }
00407             //  }
00408     }
00409 
00410     float mcEnergy;
00411     EvtDeltaEoE = -2.0;
00412 
00413     if(m_pMcTool!=NULL&&m_pMcTool->isLoaded()) {
00414         if(m_pMcTool->getVal("McEnergy", mcEnergy, nextCheck).isSuccess()){
00415             if (mcEnergy>0) { 
00416                 EvtDeltaEoE = (EvtEnergyCorr - mcEnergy)/(mcEnergy);
00417             }
00418         } 
00419     }
00420 
00421     // Model simple for PSF(68%) 
00422     EvtPSFModel = sqrt(pow((.061/pow((std::max(EvtEnergyCorr*1.,1.)/100),.8)),2) + (.001745*.001745));
00423 
00424         // Log(base 10) of measured energy - useful for parameterizing effects
00425     EvtLogEnergy = log10(std::min(std::max(EvtEnergyCorr,10.f),1000000.f));
00426     float logE = std::min(std::max(EvtLogEnergy,1.3f), 6.0f);
00427     float logE2 = logE*logE; 
00428     
00429 
00430         // Ratio of PSF model to event total PSF error. Note PhiErr = sin(theta)*d(phi)
00431     float tkr1ThetaErr, tkr1PhiErr;
00432     if (m_pTkrTool->getVal("Tkr1ThetaErr",tkr1ThetaErr, nextCheck).isSuccess() &&
00433         m_pTkrTool->getVal("Tkr1PhiErr",tkr1PhiErr, nextCheck).isSuccess()) {
00434             EvtTkr1PSFMdRat = sqrt(std::max(0.0f, tkr1ThetaErr*tkr1ThetaErr + tkr1PhiErr*tkr1PhiErr))/ 
00435                           EvtPSFModel;
00436     }
00437 
00438         // Fraction of energy in Track 1
00439     float tkr1ConE;
00440     if (m_pTkrTool->getVal("Tkr1ConEne",tkr1ConE, nextCheck).isSuccess()) {
00441         if(EvtEnergyCorr>0.0) EvtTkr1EFrac = std::max(0.01f, tkr1ConE/EvtEnergyCorr);
00442     }
00443 
00444         // Vtx kinematic variable:  angle * event energy / Track_1 energy fraction
00445     float vtxAngle;
00446     if (m_pVtxTool->getVal("VtxAngle", vtxAngle, nextCheck).isSuccess()) {
00447         if (EvtTkr1EFrac>0.0) EvtVtxKin = vtxAngle*EvtEnergyCorr/EvtTkr1EFrac;
00448     }
00449 
00450         // Vtx angle x event energy  ~ constant
00451     EvtVtxEAngle = vtxAngle*EvtEnergyCorr;
00452     
00453         // Hit counting around track compared to hits on track.  Compton scatters
00454         // have a ratio ~< 1 (as do MIPs etc.  - this is similar to the former
00455         // Surplus Hit Ratio
00456     float totHits, tkr1First;
00457     if (m_pTkrTool->getVal("TkrTotalHits", totHits, nextCheck).isSuccess()) {
00458         if (m_pTkrTool->getVal("Tkr1FirstLayer", tkr1First, nextCheck).isSuccess()){
00459             EvtTkrComptonRatio = totHits/(2.*(m_tkrGeom->numLayers()-tkr1First));
00460             EvtETkrComptonRatio = EvtTkrComptonRatio/(-9.34+7.22*logE - .672*logE2)
00461                                                          /(-.509 - 3.65*tkr1ZDir - 2.03*tkr1ZDir2);
00462         }
00463     }
00464 
00465         // Energy compensated track 1 chisq
00466     float tkr1Chisq;
00467     if (m_pTkrTool->getVal("Tkr1Chisq", tkr1Chisq, nextCheck).isSuccess()) {
00468         EvtETkr1Chisq = tkr1Chisq/(6.49 -22.1*tkr1ZDir -22.8*tkr1ZDir2);
00469     }
00470     float tkr1_1stChisq;
00471     if (m_pTkrTool->getVal("Tkr1FirstChisq", tkr1_1stChisq, nextCheck).isSuccess()) {
00472         EvtETkr1FirstChisq = tkr1_1stChisq/(4.34-.708*logE+.19*logE2)
00473                                          /(.751-1.74*tkr1ZDir-1.83*tkr1ZDir2);
00474     }
00475     float tkr1Qual;
00476     if (m_pTkrTool->getVal("Tkr1Qual", tkr1Qual, nextCheck).isSuccess()) {
00477         EvtETkr1Qual = tkr1Qual/(56.6 +6.78*tkr1ZDir + 8.23*tkr1ZDir2);
00478     }
00479 
00480     float calXtalRatio;
00481     if(m_pCalTool->getVal("CalXtalRatio", calXtalRatio, nextCheck).isSuccess()) {
00482         EvtECalXtalRatio = calXtalRatio/(2.99-1.19*logE  + .122*logE2)/(.749-.355*tkr1ZDir);
00483     }
00484 
00485     float calXtalsTrunc;
00486     if(m_pCalTool->getVal("CalXtalsTrunc", calXtalsTrunc, nextCheck).isSuccess()) {
00487         float term1 = std::max(1., (-85.4 + 65.2*logE - 10.4*logE2));
00488         float logE33 = logE-3.3; 
00489         float term2 = (logE33 > 0.) ? std::min(14., 12.*logE33*logE33): 0.;
00490         EvtECalXtalTrunc = calXtalsTrunc/(term1 + term2)/(.935 - .382*tkr1ZDir - .343*tkr1ZDir2);
00491     }
00492 
00493     float calTrackDoca;
00494     if(m_pCalTool->getVal("CalTrackDoca", calTrackDoca, nextCheck).isSuccess()) {
00495                 float logETrunc = std::min(EvtLogEnergy, 3.8f); 
00496         EvtECalTrackDoca = calTrackDoca/(272.-140.5*logETrunc + 18.7*logETrunc*logETrunc)
00497                                                    /(3.08+2.67*tkr1ZDir);
00498     }
00499 
00500         float calTransRms;
00501     if(m_pCalTool->getVal("CalTransRms", calTransRms, nextCheck).isSuccess()) {
00502                 float logEGaussSq = (EvtLogEnergy-2.3)*(EvtLogEnergy-2.3);
00503         EvtECalTransRms = calTransRms/(12.5+ 22.*exp(-logEGaussSq/.8))/(1.34+.55*tkr1ZDir);
00504     }
00505 
00506         float calLongRms;
00507     if(m_pCalTool->getVal("CalLongRms", calLongRms, nextCheck).isSuccess()) {
00508                 if(logE < 3.8) {
00509                     EvtECalLongRms = calLongRms/(96.1 - 39*logE + 5.6*logE2);
00510                 }
00511                 else {
00512                         EvtECalLongRms = calLongRms/(28.*(.847-.0134*logE+.015*logE2));
00513                 }
00514                 EvtECalLongRms /= (1.06+.0867*tkr1ZDir);
00515     }
00516 
00517         float calLRmsAsym;
00518     if(m_pCalTool->getVal("CalLRmsAsym", calLRmsAsym, nextCheck).isSuccess()) {
00519                 float logEGaussSq = (logE-2.0)*(logE-2.0); 
00520                 EvtECalLRmsAsym  = calLRmsAsym/(.012+.06*exp(-logEGaussSq/1.3))/(1.01-.0718*tkr1ZDir);
00521     }
00522 
00523     float calTrackAngle;
00524     if(m_pCalTool->getVal("CalTrackAngle", calTrackAngle, nextCheck).isSuccess()) {
00525                 float logETrunc = std::min(logE, 4.0f); 
00526                 EvtECalTrackAngle =     calTrackAngle/(2.3-1.11*logETrunc +.138*logETrunc*logETrunc)
00527                                         /(1.43+.612*tkr1ZDir);
00528     }
00529 
00530     EvtEVtxAngle = vtxAngle*sqrt(EvtEnergyCorr)/(4.24 -1.98*logE + .269*logE2)
00531                                                        /(1.95+2.36*tkr1ZDir+1.3*tkr1ZDir2);
00532 
00533     float vtxDoca;
00534     if (m_pVtxTool->getVal("VtxDOCA", vtxDoca, nextCheck).isSuccess()) {
00535         EvtEVtxDoca = vtxDoca/(1.55 - .685*logE+ .0851*logE2) 
00536                                 / (2.21 + 3.01*tkr1ZDir + 1.59*tkr1ZDir2);
00537     }
00538     return sc;
00539 }
00540 
00541 void EvtValsTool::fillHeaderInfo () 
00542 {
00543    SmartDataPtr<Event::EventHeader> header(m_pEventSvc, EventModel::EventHeader);
00544 
00545     if(header) {
00546         EvtRun         = header->run();
00547         EvtEventId     = header->event();
00548         EvtEventId64   = header->event();
00549         EvtElapsedTime = header->time();
00550         EvtLiveTime    = header->livetime();
00551         EvtEventFlags  = header->gleamEventFlags();
00552     }
00553 }
00554