00001 #include "RawEventReader/RawEventReader.h"
00002
00003 #include "GaudiKernel/MsgStream.h"
00004 #include "GaudiKernel/AlgFactory.h"
00005 #include "GaudiKernel/Bootstrap.h"
00006 #include "GaudiKernel/ISvcLocator.h"
00007 #include "GaudiKernel/SmartDataPtr.h"
00008 #include "GaudiKernel/IDataProviderSvc.h"
00009 #include "GaudiKernel/PropertyMgr.h"
00010
00011 #include "RawDataCnv/EventManagement/RAWEVENT.h"
00012 #include "RawDataCnv/Util/MdcConverter.h"
00013 #include "RawDataCnv/Util/TofConverter.h"
00014 #include "RawDataCnv/Util/EmcConverter.h"
00015 #include "RawDataCnv/Util/MucConverter.h"
00016 #include "Identifier/Identifier.h"
00017 #include "Identifier/MdcID.h"
00018 #include "Identifier/TofID.h"
00019 #include "Identifier/EmcID.h"
00020 #include "Identifier/MucID.h"
00021 #include "IRawFile/RawFileExceptions.h"
00022
00023 #include "RawFile/RawFileReader.h"
00024 #include "RawEvent/DigiEvent.h"
00025
00026 #include "EventModel/EventModel.h"
00027 #include "EventModel/EventHeader.h"
00028
00030
00031 RawEventReader::RawEventReader(const std::string& name, ISvcLocator* pSvcLocator) :
00032 Algorithm(name, pSvcLocator)
00033 {
00034 m_mdcCnv = MdcConverter::instance();
00035 m_tofCnv = TofConverter::instance();
00036 m_emcCnv = EmcConverter::instance();
00037 m_mucCnv = MucConverter::instance();
00038
00039 declareProperty("MdcDigi",m_mdcdigi=1);
00040 declareProperty("TofDigi",m_tofdigi=1);
00041 declareProperty("EmcDigi",m_emcdigi=1);
00042 declareProperty("MucDigi",m_mucdigi=1);
00043 declareProperty("InputFiles",m_inputFiles);
00044
00045 }
00046
00047 RawEventReader::~RawEventReader()
00048 {
00049 MdcConverter::destroy();
00050 TofConverter::destroy();
00051 EmcConverter::destroy();
00052 MucConverter::destroy();
00053 }
00054
00055
00056 StatusCode RawEventReader::initialize(){
00057
00058 MsgStream log(msgSvc(), name());
00059 log << MSG::INFO << "in initialize()" << endreq;
00060
00061 m_raw_event = new RAWEVENT;
00062
00063 m_mdcCnv->init(0, 999999);
00064
00065 ISvcLocator* svcLocator = Gaudi::svcLocator();
00066 StatusCode sc=svcLocator->service("EventDataSvc", m_evtSvc);
00067 if (sc.isFailure())
00068 std::cout<<"Could not accesss EventDataSvc!"<<std::endl;
00069
00070 return StatusCode::SUCCESS;
00071 }
00072
00073
00074 StatusCode RawEventReader::execute() {
00075
00076 MsgStream log(msgSvc(), name());
00077 log << MSG::INFO << "in execute()" << endreq;
00078
00079 DigiEvent* aDigiEvent = new DigiEvent;
00080 StatusCode sc = m_evtSvc->registerObject("/Event/Digi",aDigiEvent);
00081 if(sc!=StatusCode::SUCCESS) {
00082 std::cout<< "Could not register DigiEvent" <<std::endl;
00083 }
00084
00085 readEvent();
00086
00087
00088 if(m_mdcdigi)
00089 {
00090 const BufferHolder& mdcBuf = m_raw_event->getMdcBuf();
00091
00092 MdcDigiCol* mdcDigiCol = new MdcDigiCol;
00093 m_mdcCnv->convert(mdcBuf, mdcDigiCol);
00094
00095
00096
00097
00098
00099
00100
00101 StatusCode scMdc = m_evtSvc->registerObject("/Event/Digi/MdcDigiCol", mdcDigiCol);
00102 if( scMdc!=StatusCode::SUCCESS ) {
00103 std::cout<< "Could not register MDC digi collection" <<std::endl;
00104 }
00105 }
00106
00107
00108 if(m_tofdigi)
00109 {
00110 const BufferHolder& tofBuf = m_raw_event->getTofBuf();
00111
00112 TofDigiCol* tofDigiCol = new TofDigiCol;
00113 m_tofCnv->convert(tofBuf, tofDigiCol);
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129 StatusCode scTof = m_evtSvc->registerObject("/Event/Digi/TofDigiCol", tofDigiCol);
00130 if( scTof!=StatusCode::SUCCESS ) {
00131 std::cout<< "Could not register TOF digi collection" <<std::endl;
00132 }
00133 }
00134
00135 if(m_emcdigi)
00136 {
00137 const BufferHolder& emcBuf = m_raw_event->getEmcBuf();
00138
00139 EmcDigiCol* emcDigiCol = new EmcDigiCol;
00140 m_emcCnv->convert(emcBuf, emcDigiCol);
00141
00142 StatusCode scEmc = m_evtSvc->registerObject("/Event/Digi/EmcDigiCol", emcDigiCol);
00143 if( scEmc!=StatusCode::SUCCESS ) {
00144 std::cout<< "Could not register EMC digi collection" <<std::endl;
00145 }
00146 }
00147
00148 if(m_mucdigi)
00149 {
00150 const BufferHolder& mucBuf = m_raw_event->getMucBuf();
00151
00152 MucDigiCol* mucDigiCol = new MucDigiCol;
00153 m_mucCnv->convert(mucBuf, mucDigiCol);
00154
00155 StatusCode scMuc = m_evtSvc->registerObject("/Event/Digi/MucDigiCol", mucDigiCol);
00156 if( scMuc!=StatusCode::SUCCESS ) {
00157 std::cout<< "Could not register MUC digi collection" <<std::endl;
00158 }
00159 }
00160
00161 m_raw_event->reset();
00162
00163 return StatusCode::SUCCESS;
00164 }
00165
00166 StatusCode RawEventReader::readEvent()
00167 {
00168 static RawFileReader* fileReader = new RawFileReader(m_inputFiles);
00169 const uint32_t* fragment;
00170
00171 try {
00172 fragment = fileReader->nextEvent();
00173 }
00174 catch (RawFileException& ex) {
00175 ex.print();
00176 }
00177 catch (...) {
00178 std::cerr << std::endl << "Uncaught unknown exception" << std::endl;
00179 }
00180
00181 RawEvent f(fragment);
00182 uint32_t *robs[64];
00183 int nrobs = eformat::get_robs(fragment, (const uint32_t **)robs, 64);
00184 for (int robi = 0; robi < nrobs; robi++) {
00185 eformat::ROBFragment<uint32_t*> rob(robs[robi]);
00186 if ((rob.rod_detev_type() & 0x2) != 0) continue;
00187 uint32_t* dataptr = NULL;
00188 rob.rod_data(dataptr);
00189 uint32_t source_id_number = rob.rod_source_id();
00190 source_id_number <<= 8;
00191 source_id_number >>= 24;
00192 switch(source_id_number) {
00193 case 161:
00194 m_raw_event->addReMdcDigi(dataptr, rob.rod_ndata());
00195 break;
00196 case 163:
00197 m_raw_event->addReEmcDigi(dataptr, rob.rod_ndata());
00198 break;
00199 case 162:
00200 m_raw_event->addReTofDigi(dataptr, rob.rod_ndata());
00201 break;
00202 case 164:
00203 m_raw_event->addReMucDigi(dataptr, rob.rod_ndata());
00204 break;
00205 }
00206 }
00207 return StatusCode::SUCCESS;
00208 }
00209
00210 StatusCode RawEventReader::finalize() {
00211
00212 MsgStream log(msgSvc(), name());
00213 log << MSG::INFO << "in finalize()" << endreq;
00214
00215
00216 delete m_raw_event;
00217
00218
00219 return StatusCode::SUCCESS;
00220 }