00001 #ifndef RecMdcDedxHitCnv_CXX
00002 #define RecMdcDedxHitCnv_CXX 1
00003 #include "GaudiKernel/MsgStream.h"
00004 #include "GaudiKernel/DataObject.h"
00005 #include "GaudiKernel/ObjectVector.h"
00006 #include "TClonesArray.h"
00007 #include "EventModel/EventModel.h"
00008 #include "ReconEvent/ReconEvent.h"
00009 #include "MdcRecEvent/RecMdcDedxHit.h"
00010 #include "Identifier/Identifier.h"
00011
00012 #include "RootEventData/TRecMdcDedxHit.h"
00013 #include "RootEventData/TRecTrackEvent.h"
00014
00015 #include "RootCnvSvc/Rec/RecTrackCnv.h"
00016 #include "RootCnvSvc/Rec/RecMdcDedxHitCnv.h"
00017 #include "RootCnvSvc/RootAddress.h"
00018
00019 #include <vector>
00020
00021 using namespace std;
00022
00023
00024
00025
00026
00027
00028 RecMdcDedxHitCnv::RecMdcDedxHitCnv(ISvcLocator* svc)
00029 : RootEventBaseCnv(classID(), svc)
00030 {
00031
00032
00033 MsgStream log(msgSvc(), "RecMdcDedxHitCnv");
00034
00035
00036 m_rootBranchname ="m_recMdcDedxHitCol";
00037
00038 m_adresses.push_back(&m_recMdcDedxHitCol);
00039 m_recMdcDedxHitCol=0;
00040 }
00041
00042 StatusCode RecMdcDedxHitCnv::TObjectToDataObject(DataObject*& refpObject) {
00043
00044 MsgStream log(msgSvc(), "RecMdcDedxHitCnv");
00045 log << MSG::DEBUG << "RecMdcDedxHitCnv::TObjectToDataObject" << endreq;
00046 StatusCode sc=StatusCode::SUCCESS;
00047
00048 RecMdcDedxHitCol* recMdcDedxHitCol = new RecMdcDedxHitCol;
00049 refpObject=recMdcDedxHitCol;
00050
00051
00052 IDataProviderSvc* dataSvc = 0;
00053 sc = serviceLocator()->getService("EventDataSvc",
00054 IDataProviderSvc::interfaceID(), (IInterface*&)dataSvc);
00055 if ( sc.isFailure() ) {
00056 log << MSG::FATAL << "Could not get EventDataSvc in RecMdcDedxHitCnv" << endreq;
00057 return sc;
00058 }
00059
00060
00061 SmartDataPtr<RecMdcHitCol> mdcHitCol(dataSvc, EventModel::Recon::RecMdcHitCol);
00062 if(!mdcHitCol)
00063 {
00064 log << MSG::INFO << "Could not find RecMdcHitCol" << endreq;
00065 }
00066
00067
00068 SmartDataPtr<RecMdcKalHelixSegCol> mdcKalHelixSegCol(dataSvc, EventModel::Recon::RecMdcKalHelixSegCol);
00069 if (!mdcKalHelixSegCol) {
00070 log << MSG::INFO << "Could not find RecMdcKalHelixSegCol" << endreq;
00071 }
00072
00073
00074
00075
00076 if (!m_recMdcDedxHitCol) return sc;
00077 TIter dedxIter(m_recMdcDedxHitCol);
00078 TRecMdcDedxHit *recMdcDedxHitRoot = 0;
00079 while ((recMdcDedxHitRoot = (TRecMdcDedxHit*)dedxIter.Next())) {
00080 int trackId = recMdcDedxHitRoot->trkId();
00081
00082 int flagLR = recMdcDedxHitRoot->flagLR();
00083
00084 long int mdcId(recMdcDedxHitRoot->mdcId());
00085
00086 double pathlength = recMdcDedxHitRoot->pathLength();
00087
00088 double dedx = recMdcDedxHitRoot->getDedx();
00089
00090
00091 log << MSG::DEBUG<<"TObjectToDataObject: check Reconstrunction of dE/dx Hit root::"<<" trackId: "<<trackId<<" flagLR: "<<flagLR<<" pathlength: "<<pathlength<<" dedx: "<<dedx<<endreq;
00092 RecMdcDedxHit *recMdcDedxHit = new RecMdcDedxHit();
00093 m_common.m_rootRecMdcDedxHitMap[recMdcDedxHitRoot] = recMdcDedxHit;
00094 recMdcDedxHit->setTrkId(trackId);
00095 recMdcDedxHit->setFlagLR(flagLR);
00096 recMdcDedxHit->setMdcId( Identifier(mdcId) );
00097 recMdcDedxHit->setPathLength( pathlength);
00098 recMdcDedxHit->setDedx(dedx);
00099
00100
00101 int mdcHitId = recMdcDedxHitRoot->mdcHitId();
00102
00103 if ( mdcHitId >= 0 ) {
00104 recMdcDedxHit->setMdcHit( dynamic_cast<RecMdcHit*>(mdcHitCol->containedObject(mdcHitId)));
00105 }
00106 int mdcKalHelixSegId = recMdcDedxHitRoot->mdcKalHelixSegId();
00107
00108 if ( mdcKalHelixSegId >= 0 ) {
00109 recMdcDedxHit->setMdcKalHelixSeg( dynamic_cast<RecMdcKalHelixSeg*>(mdcKalHelixSegCol->containedObject(mdcKalHelixSegId)));
00110 }
00111
00112 recMdcDedxHitCol->push_back(recMdcDedxHit);
00113
00114
00115 }
00116
00117 delete m_recMdcDedxHitCol;
00118 m_recMdcDedxHitCol = 0;
00119
00120 return StatusCode::SUCCESS;
00121 }
00122
00123
00124 StatusCode RecMdcDedxHitCnv::DataObjectToTObject(DataObject* obj,RootAddress* rootaddr) {
00125 MsgStream log(msgSvc(), "RecMdcDedxHitCnv");
00126 log << MSG::DEBUG << "RecMdcDedxHitCnv::DataObjectToTObject" << endreq;
00127 StatusCode sc=StatusCode::SUCCESS;
00128
00129 RecMdcDedxHitCol * recMdcDedxHitCol=dynamic_cast<RecMdcDedxHitCol *> (obj);
00130 if (!recMdcDedxHitCol) {
00131 log << MSG::ERROR << "Could not downcast to RecMdcDedxHitCol" << endreq;
00132 return StatusCode::FAILURE;
00133 }
00134
00135 DataObject *evt;
00136 m_eds->findObject(EventModel::Recon::Event,evt);
00137 if (evt==NULL) {
00138 log << MSG::ERROR << "Could not get RecEvent in TDS " << endreq;
00139 return StatusCode::FAILURE;
00140 }
00141 ReconEvent * devtTds=dynamic_cast<ReconEvent *> (evt);
00142 if (!devtTds) {
00143 log << MSG::ERROR << "RecMdcDedxHitCnv:Could not downcast to TDS RecEvent" << endreq;
00144 }
00145 IOpaqueAddress *addr;
00146 m_cnvSvc->getRecTrackCnv()->createRep(evt,addr);
00147 TRecTrackEvent *recEvt=m_cnvSvc->getRecTrackCnv()->getWriteObject();
00148 const TObjArray *m_recMdcDedxHitCol = recEvt->getRecMdcDedxHitCol();
00149 if (!m_recMdcDedxHitCol) return sc;
00150 recEvt->clearRecMdcDedxHitCol();
00151
00152
00153
00154 RecMdcHitCol::iterator recMdcHitColbegin, recMdcHitColend;
00155 RecMdcKalHelixSegCol::iterator recMdcKalHelixSegColbegin, recMdcKalHelixSegColend;
00156
00157 IDataProviderSvc* dataSvc = 0;
00158 sc = serviceLocator()->getService("EventDataSvc",
00159 IDataProviderSvc::interfaceID(), (IInterface*&)dataSvc);
00160 if ( sc.isFailure() ) {
00161 log << MSG::FATAL << "Could not get EventDataSvc in RecMdcDedxHitCnv" << endreq;
00162 return sc;
00163 }
00164
00165
00166 SmartDataPtr<RecMdcHitCol> recMdcHitCol(dataSvc, EventModel::Recon::RecMdcHitCol);
00167 if (!recMdcHitCol) {
00168 log << MSG::ERROR << "Could not downcast to RecMdcHitCol" << endreq;
00169 return StatusCode::FAILURE;
00170 }
00171 else {
00172 recMdcHitColbegin = recMdcHitCol->begin();
00173 recMdcHitColend = recMdcHitCol->end();
00174 }
00175
00176 SmartDataPtr<RecMdcKalHelixSegCol> recMdcKalHelixSegCol(dataSvc, EventModel::Recon::RecMdcKalHelixSegCol);
00177 if (!recMdcKalHelixSegCol) {
00178 log << MSG::ERROR << "Could not downcast to RecMdcKalHelixSegCol" << endreq;
00179 return StatusCode::FAILURE;
00180 }
00181 else {
00182 recMdcKalHelixSegColbegin = recMdcKalHelixSegCol->begin();
00183 recMdcKalHelixSegColend = recMdcKalHelixSegCol->end();
00184 }
00185
00186
00187
00188 RecMdcDedxHitCol::const_iterator recMdcDedxHit;
00189 for (recMdcDedxHit = recMdcDedxHitCol->begin(); recMdcDedxHit != recMdcDedxHitCol->end(); recMdcDedxHit++) {
00190 int trackId = (*recMdcDedxHit)->getTrkId();
00191 int flagLR = (*recMdcDedxHit)->getFlagLR();
00192 UInt_t mdcId =(*recMdcDedxHit)->getMdcId().get_value();
00193 double pathlength = (*recMdcDedxHit)->getPathLength();
00194 double dedx = (*recMdcDedxHit)->getDedx();
00195
00196 log << MSG::DEBUG<<"DataObjectToTObject: check Reconstrunction of dE/dx Hit::"<<" trackId: "<<trackId<<" flagLR: "<<flagLR<<" pathlength: "<<pathlength<<" dedx: "<<dedx<<endreq;
00197 TRecMdcDedxHit *recMdcDedxHitRoot = new TRecMdcDedxHit();
00198
00199 recMdcDedxHitRoot->setTrkId(trackId);
00200 recMdcDedxHitRoot->setFlagLR(flagLR);
00201 recMdcDedxHitRoot->setMdcId( mdcId );
00202 recMdcDedxHitRoot->setPathLength( pathlength);
00203 recMdcDedxHitRoot->setDedx(dedx);
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217 if ( (*recMdcDedxHit)->isMdcHitValid() ) {
00218 RecMdcHitCol::iterator it = find(recMdcHitColbegin, recMdcHitColend, (*recMdcDedxHit)->getMdcHit());
00219 recMdcDedxHitRoot->setMdcHitId( it - recMdcHitColbegin );
00220 }
00221 else{
00222 recMdcDedxHitRoot->setMdcHitId(-1);
00223 }
00224
00225 if ( (*recMdcDedxHit)->isMdcKalHelixSegValid() ) {
00226 RecMdcKalHelixSegCol::iterator it = find(recMdcKalHelixSegColbegin, recMdcKalHelixSegColend, (*recMdcDedxHit)->getMdcKalHelixSeg());
00227 recMdcDedxHitRoot->setMdcKalHelixSegId( it - recMdcKalHelixSegColbegin );
00228 }
00229 else{
00230 recMdcDedxHitRoot->setMdcKalHelixSegId(-1);
00231 }
00232
00233
00234 recEvt->addRecMdcDedxHit(recMdcDedxHitRoot);
00235 }
00236
00237 return StatusCode::SUCCESS;
00238 }
00239
00240 #endif