StRoot: StHltMaker/StHltMaker.cxx Source File

00001 /***************************************************************************
00002  *
00003  * $Id: StHltMaker.cxx,v 1.1 2011/02/01 18:24:02 xueliang Exp $
00004  *
00005  * Author: L. Xue, H. Qiu, A. Tang, Jan 2011
00006  ***************************************************************************
00007  *
00008  * Description: Hlt Maker to propaganda online Hlt tracking and selection 
00009  *              information.
00010  *
00011  ***************************************************************************
00012  *
00013  * $Log: StHltMaker.cxx,v $
00014  * Revision 1.1  2011/02/01 18:24:02  xueliang
00015  * *** empty log message ***
00016  *
00017  **************************************************************************/
00018 
00019 
00020 
00021 #include <iostream>
00022 #include <fstream>
00023 #include <stdlib.h>
00024 
00025 #include <Stiostream.h>
00026 #include "StHltMaker.h"
00027 #include "StRtsTable.h"
00028 #include "HLTFormats.h"
00029 #include "RTS/src/DAQ_HLT/hlt_gl3.h"
00030 #include "StThreeVectorF.hh"
00031 
00032 #include "StEvent/StEvent.h"
00033 #include "StEvent/StHltEvent.h"
00034 #include "StEvent/StHltTrackNode.h"
00035 #include "StEvent/StHltTrack.h"
00036 #include "StEvent/StHltBTofHit.h"
00037 #include "StEvent/StHltVpdHit.h"
00038 #include "StEvent/StHltBEmcTowerHit.h"
00039 #include "StEvent/StHltTriggerReason.h"
00040 #include "StEvent/StHltHighPt.h"
00041 #include "StEvent/StHltHeavyFragment.h"
00042 #include "StEvent/StHltDiElectron.h"
00043 
00044 using namespace std;
00045 using namespace star;
00046 using namespace star::rts;
00047 using namespace star::rts::hlt;
00048 
00049 //__________________________________________________________________________________________
00050 namespace {
00051 #define HTLPAIRATTR(bank) pair<string, EHLTBANKS>(_QUOTE_(HLT_##bank),_NAME2_(kHLT_,bank))
00052 #define SELECTBANK(bank)    case _NAME2_(kHLT_,bank): { processBank((_NAME2_(HLT_,bank) *)(&(hlt.data))); break;}
00053                 class HltBanks {
00054                         map<string, EHLTBANKS> fHltBanks;
00055                         public:
00056                         HltBanks() {
00057                                 fHltBanks.insert(HTLPAIRATTR(EVE));
00058                                 fHltBanks.insert(HTLPAIRATTR(TOF));
00059                                 fHltBanks.insert(HTLPAIRATTR(PVPD));
00060                                 fHltBanks.insert(HTLPAIRATTR(EMC));
00061                                 fHltBanks.insert(HTLPAIRATTR(GT));
00062                                 fHltBanks.insert(HTLPAIRATTR(PT));
00063                                 fHltBanks.insert(HTLPAIRATTR(NODE));
00064                                 fHltBanks.insert(HTLPAIRATTR(HIPT));
00065                                 fHltBanks.insert(HTLPAIRATTR(DIEP));
00066                                 fHltBanks.insert(HTLPAIRATTR(HF));
00067                                 fHltBanks.insert(HTLPAIRATTR(NONE));
00068                         }
00069                         EHLTBANKS BankId(const char *bankName) {
00070                                 map<string,EHLTBANKS>::iterator it= 
00071                                         fHltBanks.find(string(bankName));
00072                                 return (it == fHltBanks.end()) ? kHLT_NONE : it->second;
00073                         }
00074                 };
00075                 HltBanks gHltBanks;
00076                 EHLTBANKS BankId(const char *bankName) {  
00077                         EHLTBANKS j= gHltBanks.BankId(bankName) ; 
00078                         return j;
00079                 }
00080 }
00081 
00082 ClassImp(StHltMaker)
00083 
00084 //__________________________________________________________________________________________
00086 StHltMaker::StHltMaker(const char *name) : StRTSBaseMaker("hlt",name)
00087 {
00088 
00089         mStEvent = 0;
00090         mStHltEvent = 0;
00091 
00092         mNumHighPt = 0;
00093         mNumHeavyFragment = 0;
00094         mNumDielectron = 0;
00095 
00096         SetAttr("hltMode",1);   // 1 is default value for full model production
00097 
00098         for(u_int i=0; i<NMax; i++){
00099                 mHighPtNodeSN[i] = -1;
00100                 mHeavyFragmentNodeSN[i] = -1;
00101                 mDaughter1NodeSN[i] = -1;
00102                 mDaughter2NodeSN[i] = -1;
00103         }
00104 
00105         LOG_DEBUG << "StHltMaker::ctor"  << endm;
00106 
00107 }
00108 
00109 //__________________________________________________________________________________________
00110 StHltMaker::~StHltMaker() 
00111 
00112 {
00113 }
00114 
00115 //__________________________________________________________________________________________
00117 Int_t StHltMaker::Init()
00118 {
00119         return StMaker::Init();
00120 }
00121 
00122 //__________________________________________________________________________________________
00123 Int_t StHltMaker::InitRun(int runumber)
00124 {
00125         return StMaker::Init();
00126 }
00127 
00128 //__________________________________________________________________________________________
00130 
00136 //_____________________________________________________________
00137 StRtsTable *StHltMaker::GetNextGl3()
00138 {
00141         return GetNext("gl3");
00142 }
00143 
00144 //_____________________________________________________________________________
00146 void  StHltMaker::Clear(Option_t *) 
00147 {
00148 
00149         StMaker::Clear(); 
00150 
00151 }
00152 
00153 //_____________________________________________________________________________
00155 StHltEvent *StHltMaker::GetHltEvent()
00156 {
00157         // Get StHltEvent
00158         StHltEvent *HltEvent = 0;
00159         mStEvent = dynamic_cast<StEvent *> (GetInputDS("StEvent"));
00160 
00161         if (mStEvent) {
00162                 HltEvent = mStEvent->hltEvent();
00163 
00164                 if ( !HltEvent )  {
00165                         LOG_DEBUG << "Create StHltEvent !" << endm;
00166 
00167                         HltEvent = new StHltEvent();       
00168                         mStEvent->setHltEvent(HltEvent);   
00169                 }
00170         }
00171         else {LOG_WARN << "No StEvent found" << endm; }
00172 
00173         return HltEvent;
00174 }
00175 
00176 //_____________________________________________________________________________
00178 Int_t StHltMaker::Make()
00179 {
00180 
00181         if ( Token() == 0 )  return kStOK ; 
00182         mStHltEvent = GetHltEvent();
00183         if(!mStHltEvent)  {
00184                 LOG_WARN << "No hlt event found in this data !" << endm;
00185                 return kStOK;
00186         }
00187 
00188         mNumHighPt = 0;
00189         mNumHeavyFragment = 0;
00190         mNumDielectron = 0;
00192         for(u_int i=0; i<NMax; i++){
00193                 mHighPtNodeSN[i] = -1;
00194                 mHeavyFragmentNodeSN[i] = -1;
00195                 mDaughter1NodeSN[i] = -1;
00196                 mDaughter2NodeSN[i] = -1;
00197         }
00198 
00199         int counter = 0; 
00201         while ( GetNextGl3() ) {
00202                 counter++;
00203                 TGenericTable::iterator iword = DaqDta()->begin();
00204                 hlt_gl3_t &hlt = *(hlt_gl3_t*)*iword;
00205 
00206                 switch (BankId(hlt.name)) {
00207                         SELECTBANK(EVE)
00208                                 SELECTBANK(TOF)
00209                                 SELECTBANK(PVPD)
00210                                 SELECTBANK(EMC)
00211                                 SELECTBANK(GT)
00212                                 SELECTBANK(PT)
00213                                 SELECTBANK(NODE)
00214                                 SELECTBANK(HIPT)
00215                                 SELECTBANK(DIEP)
00216                                 SELECTBANK(HF)
00217                         default: case kHLT_NONE:{
00218                                                                                 LOG_ERROR << "Unknown bank name was  delivered: <" << hlt.name << ">" << endm;
00219                                                                                 return kStERR; break;
00220                                                                         }
00221                 }
00222 
00223         }
00224 
00225         fillNodePointer(mStHltEvent);     
00226         fillHighPt(mStHltEvent);          
00227         fillHeavyFragment(mStHltEvent);   
00228         fillDielectron(mStHltEvent);      
00229         fillTriggerReason(mStHltEvent);   
00230 
00231 
00232 
00234         Int_t hltMode = IAttr("hltMode");
00235 
00236         if(!hltMode){ 
00237 
00238                 StSPtrVecHltTrack& VecgTrack = mStHltEvent->globalTrack();
00239                 VecgTrack.resize(0);
00240                 StSPtrVecHltTrack& VecpTrack = mStHltEvent->primaryTrack();
00241                 VecpTrack.resize(0);
00242                 StSPtrVecHltTrackNode& VecTrackNode = mStHltEvent->trackNode();
00243                 VecTrackNode.resize(0);
00244                 StSPtrVecHltBTofHit& VecbTofHit = mStHltEvent->bTofHit();
00245                 VecbTofHit.resize(0);
00246                 StSPtrVecHltBEmcTowerHit& VecbEmcHit = mStHltEvent->bEmcTowerHits();
00247                 VecbEmcHit.resize(0);
00248                 StSPtrVecHltVpdHit& VecpVpdHit = mStHltEvent->vpdHit();
00249                 VecpVpdHit.resize(0);
00250 
00251                 LOG_INFO << "Clear The Vector Of HLT Tracks, TrackNodes, BTofHit, BEmcTowerHit, VpdHit in <<Triggered Tracks Only>> model " << endm;
00252 
00253         }
00254 
00255         if (counter <= 0) {
00256                 LOG_DEBUG << "There was no hlt data for this event. " << endm;
00257         } else {
00258                 LOG_DEBUG << "End of hlt data for this event : " << GetEventNumber() << ", Total = "  << counter+1 
00259                         << " records were found" << endm;
00260         }
00261         return kStOK;
00262 
00263 }
00264 
00265 //_____________________________________________________________________________
00267 void StHltMaker::processBank(const HLT_EVE  *hlt_eve)
00268 {
00269 
00270         LOG_DEBUG << "Begin to fill HLT_EVE bank " << endm;
00271 
00272         mStHltEvent->setVersion((unsigned int) hlt_eve->version) ;
00274         mStHltEvent->setTriggerReasonBitOred((unsigned int) hlt_eve->hltDecision) ;
00276 
00277         mStHltEvent->setT0(hlt_eve->T0) ;  
00278         mStHltEvent->setVpdVertexZ(hlt_eve->vpdVertexZ);
00279 
00280         if( hlt_eve->version >= 0x20100216){  
00281                 mStHltEvent->setInnerSecGain(hlt_eve->innerSectorGain) ;
00282                 mStHltEvent->setOuterSecGain(hlt_eve->outerSectorGain) ;
00283         } else {
00284                 mStHltEvent->setInnerSecGain(-999.) ;
00285                 mStHltEvent->setOuterSecGain(-999.) ;
00286         }
00287 
00288         float vertX = hlt_eve->vertexX ;
00289         float vertY = hlt_eve->vertexY ;
00290         float vertZ = hlt_eve->vertexZ ;
00291         StThreeVectorF vertex(vertX,vertY,vertZ);
00292         mStHltEvent->setVertex(vertex) ;
00293 
00294         float lmvertX = hlt_eve->lmVertexX ;
00295         float lmvertY = hlt_eve->lmVertexY ;
00296         float lmvertZ = hlt_eve->lmVertexZ ;
00297         StThreeVectorF lmvertex(lmvertX,lmvertY,lmvertZ);
00298         mStHltEvent->setLowMultVertex(lmvertex) ;
00299 
00300         LOG_DEBUG << "Finish to fill HLT_EVE bank " << endm;
00301 
00302 }
00303 
00304 //_____________________________________________________________________________
00306 void StHltMaker::processBank(const HLT_TOF  *hlt_tof)
00307 {
00308 
00309         LOG_DEBUG << "Begin to fill HLT_TOF bank " << endm;
00310 
00311         for(u_int i=0 ; i < hlt_tof->nTofHits ; i++){
00312 
00313                 // create StHltBTofHit 
00314                 StHltBTofHit *aHit = new StHltBTofHit();
00315 
00316                 aHit->setTrayId(hlt_tof->tofHit[i].trayId);
00317                 aHit->setChannel(hlt_tof->tofHit[i].channel);
00318                 aHit->setTdc(hlt_tof->tofHit[i].tdc);
00319                 aHit->setTot(hlt_tof->tofHit[i].tot);
00320                 aHit->setTof(hlt_tof->tofHit[i].tof); 
00321                 aHit->setTriggerTime(hlt_tof->tofHit[i].triggertime);
00322 
00323                 // save pointer to the vector
00324                 mStHltEvent->addBTofHit(aHit);
00325 
00326         }
00327 
00328         LOG_DEBUG << "Finish to fill HLT_TOF bank " << endm;
00329 
00330 }
00331 
00332 //_____________________________________________________________________________
00334 void StHltMaker::processBank(const HLT_PVPD *hlt_pvpd)
00335 {
00336 
00337         LOG_DEBUG << "Begin to fill HLT_PVPD bank " << endm;
00338 
00339         for(u_int i=0 ; i < hlt_pvpd->nPvpdHits ; i++){
00340 
00341                 // create StHltVpdHit
00342                 StHltVpdHit *aHit = new StHltVpdHit();
00343 
00344                 int trayID = hlt_pvpd->pvpdHit[i].trayId;
00345                 if(trayID==120) aHit->setDirection(west);
00346                 else aHit->setDirection(east);
00347                 aHit->setChannel(hlt_pvpd->pvpdHit[i].channel);
00348                 aHit->setTdc(hlt_pvpd->pvpdHit[i].tdc);
00349                 aHit->setTot(hlt_pvpd->pvpdHit[i].tot);
00350                 aHit->setTof(hlt_pvpd->pvpdHit[i].tof);
00351                 aHit->setTriggerTime(hlt_pvpd->pvpdHit[i].triggertime);
00352 
00353                 // save pointer to a vector
00354                 mStHltEvent->addVpdHit(aHit);
00355 
00356         }
00357 
00358         LOG_DEBUG << "Finish to fill HLT_PVPD bank " << endm;
00359 
00360 }
00361 
00362 //_____________________________________________________________________________
00364 void StHltMaker::processBank(const HLT_EMC  *hlt_emc)
00365 {
00366 
00367         LOG_DEBUG << "Begin to fill HLT_EMC bank " << endm;
00368 
00369         for(u_int i=0 ; i< hlt_emc->nEmcTowers ; i++){
00370 
00371                 // create StHltBEmcTowerHit
00372                 StHltBEmcTowerHit *aHit = new StHltBEmcTowerHit();
00373 
00374                 aHit->setAdc(hlt_emc->emcTower[i].adc);
00375                 aHit->setEnergy(hlt_emc->emcTower[i].energy);
00376                 aHit->setPhi(hlt_emc->emcTower[i].phi);
00377                 aHit->setEta(hlt_emc->emcTower[i].eta);
00378                 aHit->setZ(hlt_emc->emcTower[i].z); 
00379                 aHit->setSoftId(hlt_emc->emcTower[i].softId);
00380                 aHit->setDaqId(hlt_emc->emcTower[i].daqId);
00381 
00382                 // save pointer to a vector
00383                 mStHltEvent->addBEmcTowerHit(aHit);
00384 
00385         }
00386 
00387         LOG_DEBUG << "Finish to fill HLT_EMC bank " << endm;
00388 
00389 }
00390 
00391 //_____________________________________________________________________________
00393 void StHltMaker::processBank(const HLT_GT   *hlt_gt)
00394 {
00395 
00396         LOG_DEBUG << "Begin to fill HLT_GT bank " << endm;
00397 
00398         for(u_int i=0 ; i < hlt_gt->nGlobalTracks; i++){
00399 
00400                 // create StHltTrack
00401                 StHltTrack *aTrack = new StHltTrack();
00402 
00403                 aTrack->setType(global);
00404                 aTrack->setId(hlt_gt->globalTrack[i].id);
00405                 aTrack->setFlag(hlt_gt->globalTrack[i].flag);
00406                 aTrack->setInnerMostRow(hlt_gt->globalTrack[i].innerMostRow);
00407                 aTrack->setOuterMostRow(hlt_gt->globalTrack[i].outerMostRow);
00408                 aTrack->setNHits(hlt_gt->globalTrack[i].nHits);
00409                 aTrack->setNDedx(hlt_gt->globalTrack[i].ndedx);
00410                 aTrack->setQ(hlt_gt->globalTrack[i].q);
00411                 aTrack->setChi2(0,hlt_gt->globalTrack[i].chi2[0]);
00412                 aTrack->setChi2(1,hlt_gt->globalTrack[i].chi2[1]);
00413                 aTrack->setDedx(hlt_gt->globalTrack[i].dedx);
00414                 aTrack->setPt(hlt_gt->globalTrack[i].pt);
00415                 aTrack->setPhi0(hlt_gt->globalTrack[i].phi0);
00416                 aTrack->setPsi(hlt_gt->globalTrack[i].psi);
00417                 aTrack->setR0(hlt_gt->globalTrack[i].r0);
00418                 aTrack->setTanl(hlt_gt->globalTrack[i].tanl);
00419                 aTrack->setZ0(hlt_gt->globalTrack[i].z0);
00420                 aTrack->setLength(hlt_gt->globalTrack[i].length);
00421                 aTrack->setDpt(hlt_gt->globalTrack[i].dpt);
00422                 aTrack->setDpsi(hlt_gt->globalTrack[i].dpsi);
00423                 aTrack->setDz0(hlt_gt->globalTrack[i].dz0);
00424                 aTrack->setDtanl(hlt_gt->globalTrack[i].dtanl);
00425 
00426                 // save pointer to a vector
00427                 mStHltEvent->addGlobalTrack(aTrack);
00428 
00429         }
00430 
00431 
00432         LOG_DEBUG << "Finish to fill HLT_GT bank " << endm;
00433 
00434 }
00435 
00436 //_____________________________________________________________________________
00438 void StHltMaker::processBank(const HLT_PT   *hlt_pt)
00439 {
00440 
00441         LOG_DEBUG << "Begin to fill HLT_PT bank " << endm;
00442 
00443         for(u_int i=0;i<hlt_pt->nPrimaryTracks;i++){
00444 
00445                 // create StHltTrack
00446                 StHltTrack *aTrack = new StHltTrack();
00447 
00448                 aTrack->setType(primary);
00449                 aTrack->setId(hlt_pt->primaryTrack[i].id);
00450                 aTrack->setFlag(hlt_pt->primaryTrack[i].flag);
00451                 aTrack->setInnerMostRow(hlt_pt->primaryTrack[i].innerMostRow);
00452                 aTrack->setOuterMostRow(hlt_pt->primaryTrack[i].outerMostRow);
00453                 aTrack->setNHits(hlt_pt->primaryTrack[i].nHits);
00454                 aTrack->setNDedx(hlt_pt->primaryTrack[i].ndedx);
00455                 aTrack->setQ(hlt_pt->primaryTrack[i].q) ;
00456                 aTrack->setChi2(0,hlt_pt->primaryTrack[i].chi2[0]);
00457                 aTrack->setChi2(1,hlt_pt->primaryTrack[i].chi2[1]);
00458                 aTrack->setDedx(hlt_pt->primaryTrack[i].dedx);
00459                 aTrack->setPt(hlt_pt->primaryTrack[i].pt);
00460                 aTrack->setPhi0(hlt_pt->primaryTrack[i].phi0);
00461                 aTrack->setPsi(hlt_pt->primaryTrack[i].psi);
00462                 aTrack->setR0(hlt_pt->primaryTrack[i].r0);
00463                 aTrack->setTanl(hlt_pt->primaryTrack[i].tanl);
00464                 aTrack->setZ0(hlt_pt->primaryTrack[i].z0);
00465                 aTrack->setLength(hlt_pt->primaryTrack[i].length);
00466                 aTrack->setDpt(hlt_pt->primaryTrack[i].dpt);
00467                 aTrack->setDpsi(hlt_pt->primaryTrack[i].dpsi);
00468                 aTrack->setDz0(hlt_pt->primaryTrack[i].dz0);
00469                 aTrack->setDtanl(hlt_pt->primaryTrack[i].dtanl);
00470 
00471                 // save pointer to a vector
00472                 mStHltEvent->addPrimaryTrack(aTrack);
00473         }
00474 
00475 
00476         LOG_DEBUG << "Finish to fill HLT_PT bank " << endm;
00477 
00478 }
00479 
00480 //_____________________________________________________________________________
00482 void StHltMaker::processBank(const HLT_NODE *hlt_node)
00483 {
00484         LOG_DEBUG << "Begin to fill HLT_NODE bank " << endm;
00485 
00486         for(u_int i=0 ; i< hlt_node->nNodes ; i++){
00487 
00488                 // create StHltTrackNode
00489                 StHltTrackNode *aNode = new StHltTrackNode();
00490 
00491                 aNode->setBEmcMatchPhiDiff(hlt_node->node[i].emcMatchPhiDiff);
00492                 aNode->setBEmcMatchZEdge(hlt_node->node[i].emcMatchZEdge);
00493                 aNode->setBTofProjChannel(hlt_node->node[i].projChannel);
00494                 aNode->setBTofCellLocalY(hlt_node->node[i].localY);
00495                 aNode->setBTofCellLocalZ(hlt_node->node[i].localZ);
00496                 aNode->setBTofPathLength(hlt_node->node[i].pathlength);
00497                 aNode->setBeta(hlt_node->node[i].beta);
00498                 aNode->setTof(hlt_node->node[i].tof);
00499 
00500                 aNode->setGlobalTrackSN(hlt_node->node[i].globalTrackSN);
00501                 aNode->setPrimaryTrackSN(hlt_node->node[i].primaryTrackSN);
00502                 aNode->setTofHitSN(hlt_node->node[i].tofHitSN);
00503                 aNode->setEmcTowerSN(hlt_node->node[i].emcTowerSN);
00504 
00505                 // save pointer to a vector
00506                 mStHltEvent->addTrackNode(aNode);
00507 
00508         }
00509 
00510         LOG_DEBUG << "Finish to fill HLT_NODE bank " << endm;
00511 
00512 }
00513 
00514 //_____________________________________________________________________________
00516 void StHltMaker::processBank(const HLT_HIPT *hlt_hipt)
00517 {
00518 
00519         LOG_DEBUG << "Begin to fill HLT_HTPT bank " << endm;
00520 
00521         mNumHighPt = hlt_hipt->nHighPt;
00522         for(u_int i=0; i<hlt_hipt->nHighPt; i++){
00523                 mHighPtNodeSN[i] = hlt_hipt->highPtNodeSN[i];
00524         }
00525 
00526         LOG_DEBUG << "Finish to fill HLT_HTPT bank " << endm;
00527 
00528 }
00529 
00530 //_____________________________________________________________________________
00532 void StHltMaker::processBank(const HLT_DIEP *hlt_diep)
00533 {
00534 
00535         LOG_DEBUG << "Begin to fill HLT_DIEP bank " << endm;
00536 
00537         mNumDielectron = hlt_diep->nEPairs;
00538         for(u_int i=0; i<hlt_diep->nEPairs; i++){
00539 
00540                 // create StHltDiElectron
00541                 StHltDiElectron *aDielectron = new StHltDiElectron();
00542 
00543                 mDaughter1NodeSN[i] = hlt_diep->ePair[i].dau1NodeSN;
00544                 mDaughter2NodeSN[i] = hlt_diep->ePair[i].dau2NodeSN;
00545                 aDielectron->setPt(hlt_diep->ePair[i].pt);
00546                 aDielectron->setPsi(hlt_diep->ePair[i].psi);
00547                 aDielectron->setTanl(hlt_diep->ePair[i].tanl);
00548                 aDielectron->setInvariantMass(hlt_diep->ePair[i].invariantMass);
00549 
00550                 aDielectron->setDaughter1SelectionBit(hlt_diep->ePair[i].dau1SelectionBit);
00551                 aDielectron->setDaughter2SelectionBit(hlt_diep->ePair[i].dau2SelectionBit);
00552 
00553                 // save pointer to a vector
00554                 mStHltEvent->addDiElectron(aDielectron);
00555 
00556         }
00557 
00558         LOG_DEBUG << "Finish to fill HLT_DIEP bank " << endm;
00559 
00560 }
00561 
00562 //_____________________________________________________________________________
00564 void StHltMaker::processBank(const HLT_HF   *hlt_hf)
00565 {
00566 
00567         LOG_DEBUG << "Begin to fill HLT_HF bank " << endm;
00568 
00569         mNumHeavyFragment = hlt_hf->nHeavyFragments;
00570         for(u_int i=0 ; i < hlt_hf->nHeavyFragments ; i++){
00571                 mHeavyFragmentNodeSN[i] = hlt_hf->heavyFragmentSN[i];
00572         }
00573 
00574         LOG_DEBUG << "Finish to fill HLT_HF bank " << endm;
00575 
00576 }
00577 
00578 //_____________________________________________________________________________
00580 void StHltMaker::fillNodePointer(StHltEvent* event)
00581 {
00582 
00583         LOG_DEBUG << "Begin to create pointers in tracknode" << endm;
00584 
00585         StSPtrVecHltTrackNode& VecTrackNode = event->trackNode();
00586         StSPtrVecHltTrack& VecgTrack = event->globalTrack();
00587         StSPtrVecHltTrack& VecpTrack = event->primaryTrack();
00588         StSPtrVecHltBTofHit& VecbTofHit = event->bTofHit();
00589         StSPtrVecHltBEmcTowerHit& VecbEmcHit = event->bEmcTowerHits();
00590 
00591         // create pointer in StHltTrackNode 
00592         for(u_int i=0 ; i<VecTrackNode.size() ; i++){
00593 
00594                 StHltTrackNode *trackNode = (StHltTrackNode*)VecTrackNode.at(i);
00595                 int globalTrackSN = trackNode->globalTrackSN();
00596                 int primaryTrackSN = trackNode->primaryTrackSN();
00597                 int tofHitSN = trackNode->tofHitSN();
00598                 int emcTowerSN = trackNode->emcTowerSN();
00599 
00600                 StHltTrack *gTrack = 0;
00601                 StHltTrack *pTrack = 0;
00602                 StHltBTofHit *TofHit = 0;
00603                 StHltBEmcTowerHit *BEmcHit = 0;
00604                 if(globalTrackSN >= 0) gTrack = (StHltTrack*)VecgTrack.at(globalTrackSN);
00605                 if(primaryTrackSN >= 0) pTrack = (StHltTrack*)VecpTrack.at(primaryTrackSN);
00606                 if(tofHitSN >= 0) TofHit = (StHltBTofHit*)VecbTofHit.at(tofHitSN);
00607                 if(emcTowerSN >= 0) BEmcHit = (StHltBEmcTowerHit*)VecbEmcHit.at(emcTowerSN);
00608 
00609                 trackNode->setGlobalTrack(gTrack);
00610                 trackNode->setPrimaryTrack(pTrack);
00611                 trackNode->setBTofHit(TofHit);
00612                 trackNode->setBEmcTowerHit(BEmcHit);
00613 
00614                 if(globalTrackSN >= 0) gTrack->setTrackNode(trackNode);
00615                 if(primaryTrackSN >= 0) pTrack->setTrackNode(trackNode);
00616                 if(tofHitSN >= 0) TofHit->setTrackNode(trackNode);
00617                 if(emcTowerSN >= 0) BEmcHit->setTrackNode(trackNode);
00618 
00619         }
00620 
00621         LOG_DEBUG << "Finish to create pointers in tracknode" << endm;
00622 
00623 }
00624 
00625 //_____________________________________________________________________________
00627 void StHltMaker::fillHighPt(StHltEvent* event)
00628 {
00629 
00630         LOG_DEBUG << "Begin to fill high pt to StHltEvent" << endm;
00631 
00632         StSPtrVecHltTrackNode& VecTrackNode = event->trackNode();
00633 
00634         for(u_int i=0 ; i<mNumHighPt ; i++){
00635 
00636                 // create StHltHighPt
00637                 StHltHighPt *highPt = new StHltHighPt();
00638                 StHltTrackNode* node = (StHltTrackNode*)VecTrackNode.at(mHighPtNodeSN[i]);
00639 
00640                 StHltTrack globalTrack ;
00641                 if(node->globalTrack()) globalTrack = *node->globalTrack();
00642                 StHltTrack primaryTrack ;
00643                 if(node->primaryTrack()) primaryTrack = *node->primaryTrack();
00644                 StHltBTofHit bTofHit ;
00645                 if(node->bTofHit()) bTofHit = *node->bTofHit();
00646                 StHltBEmcTowerHit bEmcHit ;
00647                 if(node->bEmcTowerHit()) bEmcHit = *node->bEmcTowerHit();
00648 
00649                 highPt->setGlobalTrack(globalTrack);
00650                 highPt->setPrimaryTrack(primaryTrack);
00651                 highPt->setBTofHit(bTofHit);
00652                 highPt->setBEmcTowerHit(bEmcHit);
00653                 highPt->setGlobalTrackSN(node->globalTrackSN());
00654                 highPt->setPrimaryTrackSN(node->primaryTrackSN());
00655                 highPt->setTofHitSN(node->tofHitSN());
00656                 highPt->setEmcTowerSN(node->emcTowerSN());
00657                 highPt->setBEmcMatchPhiDiff(node->bEmcMatchPhiDiff());
00658                 highPt->setBEmcMatchZEdge(node->bEmcMatchZEdge());
00659                 highPt->setBTofProjChannel(node->bTofProjChannel());
00660                 highPt->setBTofCellLocalY(node->bTofCellLocalY());
00661                 highPt->setBTofCellLocalZ(node->bTofCellLocalZ());
00662                 highPt->setBTofPathLength(node->bTofPathLength());
00663                 highPt->setBeta(node->beta());
00664                 highPt->setTof(node->tof());
00665 
00666                 // save pointer to a vector
00667                 mStHltEvent->addHighPt(highPt);
00668 
00669         }
00670 
00671         LOG_DEBUG << "Finish to fill high pt to StHltEvent" << endm;
00672 
00673 }
00674 
00675 
00676 //_____________________________________________________________________________
00678 void StHltMaker::fillHeavyFragment(StHltEvent* event)
00679 {
00680 
00681         LOG_DEBUG << "Begin to fill heavy fragment to StHltEvent" << endm;
00682 
00683         StSPtrVecHltTrackNode& VecTrackNode = event->trackNode();
00684 
00685         for(u_int i=0 ; i<mNumHeavyFragment ; i++){
00686 
00687                 // create StHltHeavyFragment
00688                 StHltHeavyFragment *heavyFragment = new StHltHeavyFragment();
00689                 StHltTrackNode* node = (StHltTrackNode*)VecTrackNode.at(mHeavyFragmentNodeSN[i]);
00690 
00691                 StHltTrack globalTrack ; 
00692                 if(node->globalTrack()) globalTrack = *node->globalTrack();
00693                 StHltTrack primaryTrack ;
00694                 if(node->primaryTrack()) primaryTrack = *node->primaryTrack();
00695                 StHltBTofHit bTofHit ;
00696                 if(node->bTofHit()) bTofHit = *node->bTofHit();
00697                 StHltBEmcTowerHit bEmcHit;
00698                 if(node->bEmcTowerHit()) bEmcHit = *node->bEmcTowerHit();
00699 
00700                 heavyFragment->setGlobalTrack(globalTrack);
00701                 heavyFragment->setPrimaryTrack(primaryTrack);
00702                 heavyFragment->setBTofHit(bTofHit);
00703                 heavyFragment->setBEmcTowerHit(bEmcHit);
00704                 heavyFragment->setGlobalTrackSN(node->globalTrackSN());
00705                 heavyFragment->setPrimaryTrackSN(node->primaryTrackSN());
00706                 heavyFragment->setTofHitSN(node->tofHitSN());
00707                 heavyFragment->setEmcTowerSN(node->emcTowerSN());
00708                 heavyFragment->setBEmcMatchPhiDiff(node->bEmcMatchPhiDiff());
00709                 heavyFragment->setBEmcMatchZEdge(node->bEmcMatchZEdge());
00710                 heavyFragment->setBTofProjChannel(node->bTofProjChannel());
00711                 heavyFragment->setBTofCellLocalY(node->bTofCellLocalY());
00712                 heavyFragment->setBTofCellLocalZ(node->bTofCellLocalZ());
00713                 heavyFragment->setBTofPathLength(node->bTofPathLength());
00714                 heavyFragment->setBeta(node->beta());
00715                 heavyFragment->setTof(node->tof());
00716 
00717                 // save pointer to a vector
00718                 mStHltEvent->addHeavyFragment(heavyFragment);
00719         }
00720 
00721         LOG_DEBUG << "Finish to fill heavy fragment to StHltEvent" << endm;
00722 
00723 }
00724 
00725 //_____________________________________________________________________________
00727 void StHltMaker::fillDielectron(StHltEvent* event)
00728 {
00729 
00730         LOG_DEBUG << "Begin to fill di-electron to StHltEvent" << endm;
00731 
00732         StSPtrVecHltTrackNode& VecTrackNode = event->trackNode();
00733         StSPtrVecHltDiElectron& VecDiElectron = event->diElectron();
00734 
00735         for(u_int i=0 ; i<mNumDielectron ; i++){
00736 
00737                 StHltDiElectron *diElectron = (StHltDiElectron*)VecDiElectron.at(i);
00738                 StHltTrackNode* daughter1node = (StHltTrackNode*)VecTrackNode.at(mDaughter1NodeSN[i]);
00739                 StHltTrackNode* daughter2node = (StHltTrackNode*)VecTrackNode.at(mDaughter2NodeSN[i]);
00740 
00741                 StHltTrack daughter1globalTrack ;
00742                 if(daughter1node->globalTrack()) daughter1globalTrack = *daughter1node->globalTrack();
00743                 StHltTrack daughter1primaryTrack ;
00744                 if(daughter1node->primaryTrack()) daughter1primaryTrack = *daughter1node->primaryTrack();
00745                 StHltBTofHit daughter1bTofHit ;
00746                 if(daughter1node->bTofHit()) daughter1bTofHit = *daughter1node->bTofHit();
00747                 StHltBEmcTowerHit daughter1bEmcHit ;
00748                 if(daughter1node->bEmcTowerHit()) daughter1bEmcHit = *daughter1node->bEmcTowerHit();
00749 
00750                 diElectron->setDaughter1GlobalTrack(daughter1globalTrack);
00751                 diElectron->setDaughter1PrimaryTrack(daughter1primaryTrack);
00752                 diElectron->setDaughter1BTofHit(daughter1bTofHit);
00753                 diElectron->setDaughter1BEmcTowerHit(daughter1bEmcHit);
00754                 diElectron->setDaughter1GlobalTrackSN(daughter1node->globalTrackSN());
00755                 diElectron->setDaughter1PrimaryTrackSN(daughter1node->primaryTrackSN());
00756                 diElectron->setDaughter1TofHitSN(daughter1node->tofHitSN());
00757                 diElectron->setDaughter1EmcTowerSN(daughter1node->emcTowerSN());
00758                 diElectron->setDaughter1BEmcMatchPhiDiff(daughter1node->bEmcMatchPhiDiff());
00759                 diElectron->setDaughter1BEmcMatchZEdge(daughter1node->bEmcMatchZEdge());
00760                 diElectron->setDaughter1BTofProjChannel(daughter1node->bTofProjChannel());
00761                 diElectron->setDaughter1BTofCellLocalY(daughter1node->bTofCellLocalY());
00762                 diElectron->setDaughter1BTofCellLocalZ(daughter1node->bTofCellLocalZ());
00763                 diElectron->setDaughter1BTofPathLength(daughter1node->bTofPathLength());
00764                 diElectron->setDaughter1Beta(daughter1node->beta());
00765                 diElectron->setDaughter1Tof(daughter1node->tof());
00766 
00767                 StHltTrack daughter2globalTrack ;
00768                 if(daughter2node->globalTrack()) daughter2globalTrack = *daughter2node->globalTrack();
00769                 StHltTrack daughter2primaryTrack ;
00770                 if(daughter2node->primaryTrack()) daughter2primaryTrack = *daughter2node->primaryTrack();
00771                 StHltBTofHit daughter2bTofHit ;
00772                 if(daughter2node->bTofHit()) daughter2bTofHit = *daughter2node->bTofHit();
00773                 StHltBEmcTowerHit daughter2bEmcHit ;
00774                 if(daughter2node->bEmcTowerHit()) daughter2bEmcHit = *daughter2node->bEmcTowerHit();
00775 
00776                 diElectron->setDaughter2GlobalTrack(daughter2globalTrack);
00777                 diElectron->setDaughter2PrimaryTrack(daughter2primaryTrack);
00778                 diElectron->setDaughter2BTofHit(daughter2bTofHit);
00779                 diElectron->setDaughter2BEmcTowerHit(daughter2bEmcHit);
00780                 diElectron->setDaughter2GlobalTrackSN(daughter2node->globalTrackSN());
00781                 diElectron->setDaughter2PrimaryTrackSN(daughter2node->primaryTrackSN());
00782                 diElectron->setDaughter2TofHitSN(daughter2node->tofHitSN());
00783                 diElectron->setDaughter2EmcTowerSN(daughter2node->emcTowerSN());
00784                 diElectron->setDaughter2BEmcMatchPhiDiff(daughter2node->bEmcMatchPhiDiff());
00785                 diElectron->setDaughter2BEmcMatchZEdge(daughter2node->bEmcMatchZEdge());
00786                 diElectron->setDaughter2BTofProjChannel(daughter2node->bTofProjChannel());
00787                 diElectron->setDaughter2BTofCellLocalY(daughter2node->bTofCellLocalY());
00788                 diElectron->setDaughter2BTofCellLocalZ(daughter2node->bTofCellLocalZ());
00789                 diElectron->setDaughter2BTofPathLength(daughter2node->bTofPathLength());
00790                 diElectron->setDaughter2Beta(daughter2node->beta());
00791                 diElectron->setDaughter2Tof(daughter2node->tof());
00792 
00793         }
00794 
00795         LOG_DEBUG << "Finish to fill di-electron to StHltEvent" << endm;
00796 
00797 }
00798 
00799 //_____________________________________________________________________________
00801 void StHltMaker::fillTriggerReason(StHltEvent* event)
00802 {
00803 
00804         LOG_DEBUG << "Begin to fill trigger reason to StHltEvent" << endm;
00805 
00806         // create StHltTriggerReason
00807         StSPtrVecHltDiElectron& VecDiElectron = event->diElectron();
00808         for(u_int i=0 ; i<VecDiElectron.size() ; i++){
00809 
00810                 StHltDiElectron *diElectron = (StHltDiElectron*)VecDiElectron.at(i);
00811                 StHltTriggerReason *aTriggerReason = new  StHltTriggerReason();
00812                 aTriggerReason->setReasonBit(kDiElectron);
00813                 aTriggerReason->setReason(diElectron);
00814                 mStHltEvent->addTriggerReason(aTriggerReason);
00815 
00816         }
00817 
00818         StSPtrVecHltHighPt& VecHighPt = event->highPt();
00819         for(u_int i=0 ; i<VecHighPt.size() ; i++){
00820 
00821                 StHltHighPt *highPt = (StHltHighPt*)VecHighPt.at(i);
00822                 StHltTriggerReason *aTriggerReason = new  StHltTriggerReason();
00823                 aTriggerReason->setReasonBit(kHighPt);
00824                 aTriggerReason->setReason(highPt);
00825                 mStHltEvent->addTriggerReason(aTriggerReason);
00826 
00827         }
00828 
00829         StSPtrVecHltHeavyFragment& VecHeavyFragment = event->heavyFragment();
00830         for(u_int i=0 ; i<VecHeavyFragment.size() ; i++){
00831 
00832                 StHltHeavyFragment *heavyFragment = (StHltHeavyFragment*)VecHeavyFragment.at(i);
00833                 StHltTriggerReason *aTriggerReason = new  StHltTriggerReason();
00834                 aTriggerReason->setReasonBit(kHeavyFragment);
00835                 aTriggerReason->setReason(heavyFragment);
00836                 mStHltEvent->addTriggerReason(aTriggerReason);
00837 
00838         }
00839 
00840         LOG_DEBUG << "Finish to fill trigger reason to StHltEvent" << endm;
00841 
00842 }
00843 
00844 //_____________________________________________________________________________
00846 Int_t StHltMaker::Finish()
00847 {
00848 
00849         return StMaker::Finish();
00850 
00851 }