00001
00002 #include "GaudiKernel/MsgStream.h"
00003 #include "GaudiKernel/INTuple.h"
00004 #include "GaudiKernel/INTupleSvc.h"
00005 #include "BesEventMixer/MixerAlg.h"
00006 #include "RawDataCnv/EventManagement/RAWEVENT.h"
00007 #include "IRawFile/RawFileExceptions.h"
00008
00009 #include "EventModel/EventModel.h"
00010 #include "EventModel/Event.h"
00011 #include "EventModel/EventHeader.h"
00012
00013 #include "TrigEvent/TrigGTD.h"
00014 #include "HltEvent/DstHltInf.h"
00015
00016 #include "BesKernel/IBesRndmGenSvc.h"
00017 #include "CLHEP/Random/Random.h"
00018 #include "CLHEP/Random/RandFlat.h"
00019 #include "CLHEP/Random/RandExponential.h"
00020
00021 #include "RawDataCnv/Util/MdcConverter.h"
00022 #include "RawDataCnv/Util/MucConverter.h"
00023 #include "RawDataCnv/Util/TofConverter.h"
00024 #include "RawDataCnv/Util/EmcConverter.h"
00025
00026 #include "RootCnvSvc/RootInterface.h"
00027
00028 #include <vector>
00029 #include <map>
00030 #include <algorithm>
00031
00032 #include <libgen.h>
00033
00034 using namespace std;
00035 using namespace CLHEP;
00036
00037 MixerAlg::MixerAlg(const std::string& name, ISvcLocator* pSvcLocator) : Algorithm(name, pSvcLocator){
00038 declareProperty("MixMdcDigi", b_mdc=true);
00039 declareProperty("MixEmcDigi", b_emc=true);
00040 declareProperty("MixMucDigi", b_muc=true);
00041 declareProperty("MixTofDigi", b_tof=true);
00042
00043 declareProperty("DBUserRequest", m_dbUserRequest=false);
00044 declareProperty("RandomTrgRun", m_run);
00045 declareProperty("RandomTrgRunRange", m_runs);
00046 declareProperty("RandomTrgTimeRange", m_dates);
00047
00048 declareProperty("BackgroundDataFiles", m_bgfiles);
00049 declareProperty("NumRanTrgEvents", m_ranTrgEvents);
00050 declareProperty("NBgEventsToSignal", m_nevent=1);
00051
00052 declareProperty("ReplaceDataPath", m_pattern);
00053 declareProperty("UseNewDataDir", m_newdatadir);
00054 declareProperty("IfSkip", m_skip=true);
00055 declareProperty("NSkip", m_NSkip=150);
00056 declareProperty("OutPut", m_ifOutPut=false);
00057 declareProperty("MixingMethod", m_mixingMethod=1);
00058 declareProperty("MaxLoop", m_maxLoop=10);
00059 declareProperty("SmearT0", m_ifSmearT0=true);
00060 declareProperty("ReadBGMethod", m_readBGMethod=1);
00061
00062 declareProperty("ExWireFromRun", m_exRunFrom = 0 );
00063 declareProperty("ExWireToRun", m_exRunTo = 999999);
00064
00065 declareProperty("UsingFilter", m_usingFilter = true);
00066
00067 m_raw_event = 0;
00068 m_fr = 0;
00069 m_runNo = 0;
00070 m_skipCount = 0;
00071 currentBGFile = "";
00072 currentMCFile = "";
00073 m_totalEvent = 0;
00074 m_totEvtNumInCurFile = 0;
00075 m_nEventsToEnd = 0;
00076 m_ranStepLenInCurrentFile.clear();
00077
00078 m_mdcCnv = MdcConverter::instance();
00079 m_mucCnv = MucConverter::instance();
00080 m_tofCnv = TofConverter::instance();
00081 m_emcCnv = EmcConverter::instance();
00082 }
00083
00084 std::string MixerAlg::prepareDbQuery()
00085 {
00086 std::string query = "SELECT FilePath,FileName,NumEvent FROM RanTrgData";
00087
00088 if (! m_run.empty() || m_runs.size()==2 || m_dates.size()==2)
00089 {
00090 query = query + " WHERE ";
00091 bool use_and = false;
00092 if(! m_run.empty() )
00093 {
00094 query = query + " RunNo=" + m_run;
00095 use_and = true;
00096 }
00097 if( m_runs.size()==2 )
00098 {
00099 if(use_and) query = query + " AND ";
00100 query = query + " RunNo>=" + m_runs[0] + " AND RunNo<=" + m_runs[1];
00101 use_and = true;
00102 }
00103 if( m_dates.size()==2 )
00104 {
00105 if(use_and) query = query + " AND ";
00106 query = query + " TimeSOR>='" + m_dates[0] + "' AND TimeEOR<='" + m_dates[1] + "'";
00107 }
00108 }
00109
00110 query = query + ";";
00111 return query;
00112 }
00113
00114
00115 StatusCode MixerAlg::initialize()
00116 {
00117 log = new MsgStream(messageService(), name() );
00118
00119 IRealizationSvc *tmpReal;
00120 StatusCode status = service("RealizationSvc",tmpReal);
00121 if (!status.isSuccess())
00122 {
00123 (*log) << MSG::FATAL << " Could not initialize Realization Service" << endreq;
00124 } else {
00125 m_RealizationSvc=dynamic_cast<RealizationSvc*>(tmpReal);
00126 }
00127
00128 if(m_RealizationSvc->UseDBFlag() == true && m_RealizationSvc->ifReadRandTrg() == true && m_dbUserRequest == true) {
00129 std::string query = prepareDbQuery();
00130 m_bgfiles = m_RealizationSvc->getBgFileName(query);
00131 }
00132
00133 if(! m_pattern.empty())
00134 {
00135 for(unsigned int k = 0; k < m_bgfiles.size(); k++) {
00136 size_t pos_round = m_bgfiles[k].rfind("round");
00137 (*log) << MSG::INFO <<"m_bgfiles: "<<m_bgfiles[k]<<endreq;
00138 if(pos_round!=string::npos){
00139 m_bgfiles[k].replace(m_bgfiles[k].begin(), m_bgfiles[k].begin()+pos_round, m_pattern);
00140 (*log) << MSG::INFO<<"new random trigger data path: "<<m_bgfiles[k]<<endreq;
00141 }
00142 else{
00143 (*log) << MSG::ERROR<<"string 'round' not found in random trigger path!"<<endreq;
00144 exit(-1);
00145 }
00146 }
00147 }
00148 if (! m_newdatadir.empty())
00149 {
00150 for(unsigned int k = 0; k < m_bgfiles.size(); k++) {
00151 char tmp[255];
00152 std::strcpy (tmp, m_bgfiles[k].c_str());
00153 string fname = basename(tmp);
00154 m_bgfiles[k].replace(m_bgfiles[k].begin(), m_bgfiles[k].end(), m_newdatadir+'/'+fname);
00155 (*log) << MSG::INFO<<"new random trigger data path: "<<m_bgfiles[k]<<endreq;
00156 }
00157 }
00158
00159
00160
00161 m_mdcCnv->init(m_exRunFrom,m_exRunTo);
00162
00163
00164 static const bool CREATEIFNOTTHERE(true);
00165 StatusCode RndmStatus = service("BesRndmGenSvc", p_BesRndmGenSvc, CREATEIFNOTTHERE);
00166 if (!RndmStatus.isSuccess() || 0 == p_BesRndmGenSvc)
00167 {
00168 (*log) << MSG::ERROR << " Could not initialize Random Number Service" << endreq;
00169 return RndmStatus;
00170 }
00171
00172
00173 IDataInfoSvc *tmpInfoSvc;
00174 status = service("DataInfoSvc",tmpInfoSvc);
00175 if (status.isSuccess()) {
00176 (*log) << MSG::INFO << "get the DataInfoSvc" << endreq;
00177 m_jobInfoSvc=dynamic_cast<DataInfoSvc *>(tmpInfoSvc);
00178 }else {
00179 (*log) << MSG::WARNING << "could not get the DataInfoSvc." << endreq;
00180 }
00181
00182
00183 if(m_RealizationSvc->UseDBFlag() == false || m_dbUserRequest == true) {
00184 if(m_bgfiles.empty()) {
00185 (*log) << MSG::WARNING << "No background datafiles found" << endreq;
00186 return StatusCode::SUCCESS;
00187 }
00188
00189
00190 try {
00191 m_bgfilesIndex.clear();
00192 for(unsigned int bg_index = 0; bg_index < m_bgfiles.size(); bg_index++) {
00193 m_bgfilesIndex.push_back(m_bgfiles[bg_index] + ".idx");
00194 }
00195 if(m_skip == true && m_readBGMethod == 1) m_fr = new RawFileReader(m_bgfiles, m_bgfilesIndex) ;
00196 else m_fr = new RawFileReader(m_bgfiles) ;
00197 }
00198 catch (RawFileException& ex) {
00199 ex.print();
00200 return StatusCode::FAILURE;
00201 }
00202
00203 }
00204 m_raw_event = new RAWEVENT;
00205
00206 if(m_ifOutPut) {
00207 NTuplePtr nt1(ntupleSvc(), "FILE1/n1");
00208 if(nt1) m_tuple1 = nt1;
00209 else {
00210 m_tuple1 = ntupleSvc()->book("FILE1/n1",CLID_ColumnWiseTuple,"Field");
00211 if( m_tuple1 ) {
00212 status = m_tuple1->addItem("time1", m_time1 );
00213 status = m_tuple1->addItem("time2", m_time2 );
00214 status = m_tuple1->addItem("time3", m_time3 );
00215 }
00216 else {
00217 (*log) << MSG::ERROR << " Cannot book N-tuple:" <<long(m_tuple1)<< endreq;
00218 return StatusCode::FAILURE;
00219 }
00220 }
00221
00222 NTuplePtr nt2(ntupleSvc(), "FILE1/n2");
00223 if(nt2) m_tuple2 = nt2;
00224 else {
00225 m_tuple2 = ntupleSvc()->book("FILE1/n2",CLID_ColumnWiseTuple,"Field");
00226 if( m_tuple2 ) {
00227 status = m_tuple2->addItem("tdc", m_tdc );
00228 }
00229 else {
00230 (*log) << MSG::ERROR << " Cannot book N-tuple:" <<long(m_tuple2)<< endreq;
00231 return StatusCode::FAILURE;
00232 }
00233 }
00234
00235 NTuplePtr nt3(ntupleSvc(), "FILE1/n3");
00236 if(nt3) m_tuple3 = nt3;
00237 else {
00238 m_tuple3 = ntupleSvc()->book("FILE1/n3",CLID_ColumnWiseTuple,"Field");
00239 if( m_tuple3 ) {
00240 status = m_tuple3->addItem("time4", m_time4 );
00241 status = m_tuple3->addItem("time5", m_time5 );
00242 }
00243 else {
00244 (*log) << MSG::ERROR << " Cannot book N-tuple:" <<long(m_tuple3)<< endreq;
00245 return StatusCode::FAILURE;
00246 }
00247 }
00248
00249 status = service("BesTimerSvc", m_timersvc);
00250 if (status.isFailure()) {
00251 (*log) << MSG::ERROR << name() << ": Unable to locate BesTimer Service" << endreq;
00252 return StatusCode::FAILURE;
00253 }
00254 m_timer = m_timersvc->addItem("Read field Time");
00255 m_timer1 = m_timersvc->addItem("Read raw files");
00256 }
00257
00258
00259 CLHEP::HepRandomEngine* engine = p_BesRndmGenSvc->GetEngine("MIX");
00260 HepRandom::setTheEngine(engine);
00261 HepRandom::showEngineStatus();
00262
00263 return StatusCode::SUCCESS;
00264 }
00265
00266 StatusCode MixerAlg::execute()
00267 {
00268
00269 if(m_ifOutPut) {
00270 m_timer->start();
00271 }
00272
00273
00274 SmartDataPtr<Event::EventHeader> evt(eventSvc(),"/Event/EventHeader");
00275 if( !evt ){
00276 return StatusCode::FAILURE;
00277 }
00278
00279 if(m_RealizationSvc->UseDBFlag() == true && m_RealizationSvc->ifReadRandTrg() == true && m_dbUserRequest == false) {
00280 int runNo = evt -> runNumber();
00281 if((runNo != m_runNo) || (RootInterface::Instance(*log)->getCurrentFileName() != currentMCFile)) {
00282 m_runNo = runNo;
00283 currentMCFile = RootInterface::Instance(*log)->getCurrentFileName();
00284 m_mdcCnv->setRunId(runNo);
00285 std::vector<std::string> bgfiles = m_RealizationSvc->getBgFileName();
00286 if(bgfiles.size() == 0) {
00287 (*log) << MSG::ERROR << "No random trigger files are found in the run " << m_runNo << std::endl;
00288 exit(-1);
00289 }
00290
00291 if(! m_pattern.empty())
00292 {
00293 for(unsigned int k = 0; k < bgfiles.size(); k++) {
00294 size_t pos_round = bgfiles[k].rfind("round");
00295 (*log) << MSG::INFO<<"bgfiles: "<<bgfiles[k]<<endreq;
00296 if(pos_round!=string::npos){
00297 bgfiles[k].replace(bgfiles[k].begin(), bgfiles[k].begin()+pos_round, m_pattern);
00298 (*log) << MSG::INFO<<"new random trigger data path: "<<bgfiles[k]<<endreq;
00299 }
00300 else{
00301 (*log) << MSG::ERROR<<"string 'round' not found in random trigger path!"<<endreq;
00302 exit(-1);
00303 }
00304 }
00305 }
00306 if (! m_newdatadir.empty())
00307 {
00308 for(unsigned int k = 0; k < bgfiles.size(); k++) {
00309 char tmp[255];
00310 std::strcpy (tmp, bgfiles[k].c_str());
00311 string fname = basename(tmp);
00312 bgfiles[k].replace(bgfiles[k].begin(), bgfiles[k].end(), m_newdatadir+'/'+fname);
00313 (*log) << MSG::INFO<<"new random trigger data path: "<<bgfiles[k]<<endreq;
00314 }
00315 }
00316
00317
00318 std::vector<std::string> bgfilesIndex;
00319 bgfilesIndex.clear();
00320 for(unsigned int bg_index = 0; bg_index < bgfiles.size(); bg_index++) {
00321 bgfilesIndex.push_back(bgfiles[bg_index] + ".idx");
00322 }
00323
00324
00325 if(m_fr) delete m_fr;
00326 m_fr = new RawFileReader(bgfiles);
00327 std::vector<int> ranTrgEvents = m_fr->getEventNumber(bgfilesIndex);
00328
00329
00330 m_bgfiles.clear();
00331 m_bgfilesIndex.clear();
00332 m_ranTrgEvents.clear();
00333 for(unsigned int bg_index = 0; bg_index < bgfiles.size(); bg_index++) {
00334 if(ranTrgEvents[bg_index] > 0) {
00335 m_bgfiles.push_back(bgfiles[bg_index]);
00336 m_bgfilesIndex.push_back(bgfilesIndex[bg_index]);
00337 m_ranTrgEvents.push_back(ranTrgEvents[bg_index]);
00338 }
00339 }
00340
00341
00342 if(m_fr) delete m_fr;
00343 m_fr = new RawFileReader(m_bgfiles);
00344
00345
00346 bgfiles.clear();
00347 bgfilesIndex.clear();
00348 ranTrgEvents.clear();
00349
00350
00351 if(m_bgfiles.empty() || m_ranTrgEvents.empty()) {
00352 (*log) << MSG::WARNING << "No background datafiles found!!!" << endreq;
00353 return StatusCode::SUCCESS;
00354 }
00355
00356 if(m_skip == true) {
00357 if(m_mixingMethod == 1) {
00358
00359 m_ranStepLenInCurrentFile.clear();
00360 currentBGFile = "";
00361 m_skipCount = 0;
00362 m_totalEvent = 0;
00363
00364
00365 bool ifsucc = file_sort(m_bgfiles,m_ranTrgEvents);
00366 if( !ifsucc ) return StatusCode::FAILURE;
00367
00368
00369 m_bgfilesIndex.clear();
00370 for(unsigned int bg_index = 0; bg_index < m_bgfiles.size(); bg_index++) {
00371 m_bgfilesIndex.push_back(m_bgfiles[bg_index] + ".idx");
00372 }
00373
00374
00375 m_vRanEvtNumInSubSet.clear();
00376 m_vStreamNumInSubSet.clear();
00377 m_totRanEvtNum = 0;
00378 int set_no = -1;
00379 int ranEvtNumInSubSet = 0;
00380 int nstream = 0;
00381 for(unsigned int i = 0; i < m_ranTrgEvents.size(); i++) {
00382 if(i == 0) set_no = m_numSets[i];
00383 if((i != 0) && (set_no != m_numSets[i])) {
00384 m_vRanEvtNumInSubSet.push_back(ranEvtNumInSubSet);
00385 m_vStreamNumInSubSet.push_back(nstream);
00386 ranEvtNumInSubSet = 0;
00387 nstream = 0;
00388 set_no = m_numSets[i];
00389 }
00390
00391 m_totRanEvtNum += m_ranTrgEvents[i];
00392 ranEvtNumInSubSet += m_ranTrgEvents[i];
00393 nstream++;
00394 if(i == m_ranTrgEvents.size() - 1) {
00395 m_vRanEvtNumInSubSet.push_back(ranEvtNumInSubSet);
00396 m_vStreamNumInSubSet.push_back(nstream);
00397 }
00398 }
00399
00400
00401 int evtNumInRun = -1;
00402 std::vector<int> vtotEvtNo = m_jobInfoSvc->getTotEvtNo();
00403 for(unsigned int ii = 0; ii < vtotEvtNo.size(); ii+=2) {
00404 if(std::abs(runNo) == std::abs(vtotEvtNo[ii]))
00405 evtNumInRun = vtotEvtNo[ii+1];
00406 }
00407
00408
00409 double tau = m_RealizationSvc->getTauValue();
00410 double totalTime = m_RealizationSvc->getRunTotalTime();
00411 if(m_RealizationSvc->getTauValue() == 0. || m_RealizationSvc->getRunTotalTime() == 0.) {
00412 std::cout << "ERROR: In MixerAlg::execute() ---> The tau value or total run time is 0, please check it. Exit! " << std::endl;
00413 exit(1);
00414 }
00415
00416 bool using_exp = true;
00417 if(totalTime*100 < tau) using_exp = false;
00418 m_vStepLength.clear();
00419 while(1) {
00420 double ranNum;
00421 if(using_exp == true) ranNum = RandExponential::shoot(tau);
00422 else ranNum = RandFlat::shoot(0., totalTime);
00423 if(ranNum > totalTime) continue;
00424 ranNum = ranNum*m_totRanEvtNum/totalTime;
00425 m_vStepLength.push_back((int)ranNum);
00426 if(m_vStepLength.size() == evtNumInRun) break;
00427 }
00428
00429 sort(m_vStepLength.begin(), m_vStepLength.end());
00430
00431
00432
00433
00434 if(evtNumInRun <= 0 || m_totRanEvtNum <= 0) {
00435 (*log) << MSG::ERROR << "The event number (or random trigger event number) in run " << evt->runNumber() << " is zero" << endreq;
00436 return StatusCode::FAILURE;
00437 }
00438
00439
00440
00441
00442
00443 map_stepLength.clear();
00444 for(unsigned int i = 0; i < m_ranTrgEvents.size(); i++) {
00445 std::vector<int> vstepLength;
00446 typedef pair<int, std::vector<int> > vpair;
00447 map_stepLength.insert(vpair(i,vstepLength));
00448 }
00449
00450 for(unsigned int i = 0; i < m_ranTrgEvents.size(); ) {
00451
00452 int pre_ranEvtNumSubSet = 0;
00453 int cur_ranEvtNumSubSet = 0;
00454 set_no = m_numSets[i];
00455 for(int j = 0; j < set_no; j++) {
00456 if(j != (set_no - 1)) pre_ranEvtNumSubSet += m_vRanEvtNumInSubSet[j];
00457 cur_ranEvtNumSubSet += m_vRanEvtNumInSubSet[j];
00458 }
00459
00460 for(unsigned j = 0; j < m_vStepLength.size(); j++) {
00461
00462 if((m_vStepLength[j] >= pre_ranEvtNumSubSet) && (m_vStepLength[j] < cur_ranEvtNumSubSet)) {
00463 int sub_stepLength = int((m_vStepLength[j]-pre_ranEvtNumSubSet)/m_vStreamNumInSubSet[set_no - 1]);
00464 int file_id = 0;
00465 int begin_fileId = -1, end_fileId = -1;
00466 for(std::map<int,std::vector<int> >::iterator iter = map_stepLength.begin(); iter != map_stepLength.end(); iter++) {
00467
00468 if(set_no == m_numSets[iter->first]) {
00469 if(begin_fileId == -1) begin_fileId = iter->first;
00470 file_id++;
00471 }
00472 }
00473 end_fileId = begin_fileId + file_id;
00474 bool add_succ = false;
00475 long loop_count = 0;
00476
00477 while(1) {
00478 int random_file = int(RandFlat::shootInt(long(begin_fileId), long(end_fileId)));
00479 if(sub_stepLength < m_ranTrgEvents[random_file]) {
00480 map_stepLength[random_file].push_back(sub_stepLength);
00481 add_succ = true;
00482 loop_count = 0;
00483 }
00484 if(add_succ) break;
00485 loop_count++;
00486 if(loop_count >= MAX_LOOP_TIMES) {
00487 (*log) << MSG::ALWAYS << "Loop time is larger than MAX_LOOP_TIMES(" << MAX_LOOP_TIMES << ") in MixAlg, when assigning step length for each bg file." << endreq;
00488 exit(1);
00489 }
00490 }
00491 }
00492 }
00493 i += m_vStreamNumInSubSet[set_no - 1];
00494 }
00495
00496
00497 unsigned int ranSelectedNum = 0;
00498 for(std::map<int,std::vector<int> >::iterator iter = map_stepLength.begin(); iter != map_stepLength.end(); iter++) {
00499 ranSelectedNum += (iter->second).size();
00500
00501 }
00502 if(ranSelectedNum != m_vStepLength.size()) {
00503 (*log) << MSG::ERROR << "In MixerAlg::excute()--> selected bg events number not equal to MC events" << endreq;
00504 return StatusCode::FAILURE;
00505 }
00506 }
00507 }
00508
00509 if(m_mixingMethod == 2) {
00510
00511 if (m_fr) delete m_fr;
00512 m_fr = NULL;
00513 try {
00514 m_bgfilesIndex.clear();
00515 for(unsigned int bg_index = 0; bg_index < m_bgfiles.size(); bg_index++) {
00516 m_bgfilesIndex.push_back(m_bgfiles[bg_index] + ".idx");
00517 }
00518 if(m_skip == true && m_readBGMethod == 1) m_fr = new RawFileReader(m_bgfiles, m_bgfilesIndex) ;
00519 else m_fr = new RawFileReader(m_bgfiles) ;
00520 }
00521 catch (RawFileException& ex) {
00522 ex.print();
00523 return StatusCode::FAILURE;
00524 }
00525 }
00526
00527 m_raw_event->reset();
00528 }
00529 }
00530 if(m_ifOutPut) {
00531 m_timer->stop();
00532 m_time1 = m_timer->elapsed();
00533 m_timer->start();
00534 }
00535
00536 SmartDataPtr<MdcDigiCol> mdcMcDigits(eventSvc(),"/Event/Digi/MdcDigiCol");
00537 if( ! mdcMcDigits )
00538 (*log) << MSG::ERROR << "Unable to retrieve MdcDigiCol" << endreq;
00539 else
00540 (*log) << MSG::INFO << "MdcDigiCol retrieved of size "<< mdcMcDigits->size() << endreq;
00541
00542 SmartDataPtr<EmcDigiCol> emcMcDigits(eventSvc(),"/Event/Digi/EmcDigiCol");
00543 if( ! emcMcDigits )
00544 (*log) << MSG::ERROR << "Unable to retrieve EmcDigiCol" << endreq;
00545 else
00546 (*log) << MSG::INFO << "EmcDigiCol retrieved of size "<< emcMcDigits->size() << endreq;
00547
00548 SmartDataPtr<MucDigiCol> mucMcDigits(eventSvc(),"/Event/Digi/MucDigiCol");
00549 if( ! mucMcDigits )
00550 (*log) << MSG::ERROR << "Unable to retrieve MucDigiCol" << endreq;
00551 else
00552 (*log) << MSG::INFO << "MucDigiCol retrieved of size "<< mucMcDigits->size() << endreq;
00553
00554 SmartDataPtr<TofDigiCol> tofMcDigits(eventSvc(),"/Event/Digi/TofDigiCol");
00555 if( ! tofMcDigits )
00556 (*log) << MSG::ERROR << "Unable to retrieve TofDigiCol" << endreq;
00557 else
00558 (*log) << MSG::INFO << "TofDigiCol retrieved of size "<< tofMcDigits->size() << endreq;
00559
00560 for(int ievent = 0; ievent<m_nevent; ievent++)
00561 {
00562 (*log) << MSG::INFO << "Mixing BG Event " << ievent << endreq;
00563
00564
00565
00566
00567 bool next = false;
00568 if(m_skip == true) {
00569 int nskip = 0;
00570 if(m_mixingMethod == 1) {
00571 if(m_RealizationSvc->UseDBFlag() == true && m_dbUserRequest == false) {
00572 if(m_skipCount >= m_ranStepLenInCurrentFile.size()) {
00573 m_ranStepLenInCurrentFile.clear();
00574 for(std::map<int,std::vector<int> >::iterator iter = map_stepLength.begin(); iter != map_stepLength.end(); iter++) {
00575 if(currentBGFile == "") {
00576 if((iter->second).size() == 0) continue;
00577 if(m_fr) delete m_fr;
00578 try {
00579 if(m_readBGMethod == 1) m_fr = new RawFileReader(m_bgfiles[iter->first], m_bgfiles[iter->first]+".idx") ;
00580 else m_fr = new RawFileReader(m_bgfiles[iter->first]) ;
00581 m_totEvtNumInCurFile = m_ranTrgEvents[iter->first];
00582 }
00583 catch (RawFileException& ex) {
00584 ex.print();
00585 }
00586 m_ranStepLenInCurrentFile = iter->second;
00587 m_skipCount = 0;
00588 currentBGFile = m_fr->currentFile();
00589 break;
00590 }
00591 if(currentBGFile == m_bgfiles[iter->first]) {
00592 iter++;
00593 if(iter == map_stepLength.end()) return StatusCode::FAILURE;
00594 if((iter->second).size() == 0) {
00595 while(1) {
00596 iter++;
00597 if(iter == map_stepLength.end()) return StatusCode::FAILURE;
00598 if((iter->second).size() > 0) break;
00599 }
00600 }
00601 if(m_fr) delete m_fr;
00602 try {
00603 if(m_readBGMethod == 1) m_fr = new RawFileReader(m_bgfiles[iter->first], m_bgfiles[iter->first]+".idx") ;
00604 else m_fr = new RawFileReader(m_bgfiles[iter->first]) ;
00605 m_totEvtNumInCurFile = m_ranTrgEvents[iter->first];
00606 }
00607 catch (RawFileException& ex) {
00608 ex.print();
00609 }
00610 m_ranStepLenInCurrentFile = iter->second;
00611 m_skipCount = 0;
00612 currentBGFile = m_fr->currentFile();
00613 break;
00614 }
00615 }
00616 }
00617
00618
00619 if(m_skipCount == 0) nskip = m_ranStepLenInCurrentFile[m_skipCount];
00620 else nskip = m_ranStepLenInCurrentFile[m_skipCount] - m_ranStepLenInCurrentFile[m_skipCount - 1];
00621
00622 m_nEventsToEnd = (m_totEvtNumInCurFile - 1) - m_ranStepLenInCurrentFile[m_skipCount];
00623
00624 if(m_skipCount == 0 && nskip == 0) nskip = 1;
00625
00626 m_skipCount++;
00627 }
00628 if(m_RealizationSvc->UseDBFlag() == false || m_dbUserRequest == true) nskip = int (2*m_NSkip*(RandFlat::shoot())) + 1;
00629 if(m_totalEvent == 0 && nskip == 0) nskip = 1;
00630 }
00631 if(m_mixingMethod == 2) {
00632 nskip = int (2*m_NSkip*(RandFlat::shoot())) + 1;
00633 }
00634 if(m_ifOutPut) {
00635 m_timer->stop();
00636 m_time2 = m_timer->elapsed();
00637 m_timer->start();
00638 }
00639
00640
00641 if(m_readBGMethod == 0) {
00642
00643 for(int j = 0; j < nskip; j++) {
00644 next = nextEvent();
00645 if ( ! next )
00646 {
00647 (*log) << MSG::ERROR << "Cannot get next background event" << endreq;
00648 return StatusCode::FAILURE;
00649 }
00650 }
00651 }
00652 if(m_readBGMethod == 1) {
00653
00654 next = nextEvent(nskip,0,m_nEventsToEnd);
00655 if ( ! next )
00656 {
00657 (*log) << MSG::ERROR << "Cannot get next background event" << endreq;
00658 return StatusCode::FAILURE;
00659 }
00660 }
00661 if(m_readBGMethod == 2) {
00662
00663 next = nextEvent(nskip, 14*1024);
00664 if ( ! next )
00665 {
00666 (*log) << MSG::ERROR << "Cannot get next background event" << endreq;
00667 return StatusCode::FAILURE;
00668 }
00669 }
00670 }
00671 else {
00672 next = nextEvent();
00673 }
00674
00675 if(m_mixingMethod == 1) {
00676 if ( !next && m_totalEvent == 0) {
00677 (*log) << MSG::ERROR << "Cannot get next background event" << endreq;
00678 return StatusCode::FAILURE;
00679 }
00680 }
00681
00682 if(m_mixingMethod == 2) {
00683 if ( !next ) {
00684 (*log) << MSG::ERROR << "Cannot get next background event" << endreq;
00685 return StatusCode::FAILURE;
00686 }
00687 }
00688
00689 mixDigi(mdcMcDigits, emcMcDigits, mucMcDigits, tofMcDigits);
00690 }
00691
00692 m_totalEvent++;
00693
00694 if(m_ifOutPut) {
00695 m_timer->stop();
00696 m_time3 = m_timer->elapsed();
00697 m_tuple1->write();
00698 }
00699
00700
00701 return StatusCode::SUCCESS;
00702 }
00703
00704 StatusCode MixerAlg::finalize() {
00705 if( m_raw_event ) delete m_raw_event;
00706 if( log ) delete log;
00707 if( m_fr) delete m_fr;
00708 return StatusCode::SUCCESS;
00709 }
00710
00711
00712 bool MixerAlg::nextEvent(int nskip, int evtbyte, int eventsToEnd)
00713 {
00714
00715 m_raw_event->reset();
00716
00717 try {
00718 if(m_ifOutPut) {
00719 m_timer1->start();
00720 }
00721
00722 const uint32_t* fragment;
00723 if(m_skip == true && m_readBGMethod == 0) fragment = m_fr->nextEvent();
00724 if(m_skip == true && m_readBGMethod == 1) {
00725 if(nskip == 0) fragment = m_fr->currentEvent();
00726 else fragment = m_fr->nextEvent(nskip - 1);
00727 }
00728 if(m_skip == true && m_readBGMethod == 2) {
00729 if(nskip == 0) fragment = m_fr->currentEvent();
00730 else fragment = m_fr->roughlyNextEvent(nskip - 1, evtbyte);
00731 }
00732 if(m_skip == false) fragment = m_fr->nextEvent();
00733
00734 if(m_ifOutPut) {
00735 m_timer1->stop();
00736 m_time4 = m_timer1->elapsed();
00737 m_timer1->start();
00738 }
00739
00740
00741
00742
00743
00744 RawEvent f(fragment);
00745 if (!f.check()) {
00746 std::cerr << "Found invalid event (traceback):" << std::endl;
00747 std::exit(1);
00748 }
00749
00750 uint32_t fFragmentSize = f.fragment_size_word();
00751 (*log) << MSG::DEBUG << "[Event No. #" << f.global_id()
00752 << "] " << f.fragment_size_word() << " words in "
00753 << f.nchildren() << " subdetectors "
00754 << endreq;
00755 m_raw_event->setRunNo(f.run_no());
00756 m_raw_event->setEventNo(f.global_id());
00757
00758
00759 const uint32_t* ef=NULL;
00760 f.event_filter_info(ef);
00761 if(!ef){
00762 (*log) << MSG::ERROR << "Event Filter Data Failed!!!" << endreq;
00763 exit(1);
00764 }
00765 else{
00766 (*log) << MSG::DEBUG<< "Event Filter Information*********" <<std::hex<<endreq
00767 <<*ef<< " "<<*(ef+1)<<" "<<*(ef+2)<<" "<<*(ef+3)<<std::dec<<endreq;
00768 m_raw_event->addReHltRaw((uint32_t*)ef, (uint32_t)4);
00769 }
00770
00771 uint32_t *robs[64];
00772 int nrobs = eformat::get_robs(fragment, (const uint32_t **)robs, 64);
00773
00774 for (int robi = 0; robi < nrobs; robi++) {
00775 eformat::ROBFragment<uint32_t*> rob(robs[robi]);
00776 if ((rob.rod_detev_type() & 0x2) != 0) continue;
00777 uint32_t* dataptr = NULL;
00778 rob.rod_data(dataptr);
00779
00780 uint32_t source_id_number = rob.rod_source_id();
00781
00782 source_id_number <<= 8;
00783 source_id_number >>= 24;
00784
00785
00786 switch(source_id_number) {
00787 case 161:
00788 m_raw_event->addReMdcDigi(dataptr, rob.rod_ndata());
00789 break;
00790 case 163:
00791 m_raw_event->addReEmcDigi(dataptr, rob.rod_ndata());
00792 break;
00793 case 162:
00794 m_raw_event->addReTofDigi(dataptr, rob.rod_ndata());
00795 break;
00796 case 167:
00797 m_raw_event->addReEtfDigi(dataptr, rob.rod_ndata());
00798 break;
00799 case 164:
00800 m_raw_event->addReMucDigi(dataptr, rob.rod_ndata());
00801 break;
00802 case 165:
00803
00804
00805
00806
00807 m_raw_event->addReTrigGTD(dataptr, rob.rod_ndata());
00808 break;
00809 case 124:
00810 m_raw_event->addReHltRaw(dataptr, rob.rod_ndata());
00811 break;
00812 case 241:
00813 m_raw_event->addMcParticle(dataptr, rob.rod_ndata());
00814 break;
00815 default:
00816
00817 break;
00818 }
00819 }
00820 if(m_ifOutPut) {
00821 m_timer1->stop();
00822 m_time5 = m_timer1->elapsed();
00823 m_tuple3->write();
00824 }
00825
00826 if(m_usingFilter == true) {
00827 if(eventType() == "GHadron" || eventType() == "GEBhabha" || eventType() == "GBBhabha" || eventType() == "GCosmic" || eventType() == "GDimuon") {
00828 if(m_skip == true && m_readBGMethod == 0) {
00829 return nextEvent(1, evtbyte, eventsToEnd);
00830 }
00831 if(m_skip == true && m_readBGMethod == 1) {
00832 if(m_RealizationSvc->UseDBFlag() == false || m_dbUserRequest == true) return nextEvent(1, evtbyte, eventsToEnd);
00833 if(eventsToEnd > 0 && m_RealizationSvc->UseDBFlag() == true && m_dbUserRequest == false ) {
00834 eventsToEnd--;
00835 return nextEvent(1, evtbyte, eventsToEnd);
00836 }
00837 }
00838 if(m_skip == true && m_readBGMethod == 2) {
00839 return nextEvent(1, evtbyte, eventsToEnd);
00840 }
00841 if(m_skip == false) return nextEvent(nskip, evtbyte, eventsToEnd);
00842 }
00843 }
00844
00845 return true;
00846 }
00847 catch (ReachEndOfFileList& ex){
00848 ex.print();
00849
00850 delete m_fr;
00851 try {
00852 if(m_skip == true && m_readBGMethod == 1) m_fr = new RawFileReader(m_bgfiles, m_bgfilesIndex) ;
00853 else m_fr = new RawFileReader(m_bgfiles);
00854 }
00855 catch (RawFileException& ex) {
00856 ex.print();
00857 return false;
00858 }
00859
00860 return nextEvent(nskip, evtbyte, eventsToEnd);
00861 }
00862 catch (RawFileException& ex) {
00863 ex.print();
00864 }
00865 catch (eformat::Issue& ex) {
00866 std::cerr << std::endl << "Uncaught eformat issue: " << ex.what() << std::endl;
00867 }
00868 catch (ers::Issue& ex) {
00869 std::cerr << std::endl << "Uncaught ERS issue: " << ex.what() << std::endl;
00870 }
00871 catch (std::exception& ex) {
00872 std::cerr << std::endl << "Uncaught std exception: " << ex.what() << std::endl;
00873 }
00874 catch (...) {
00875 std::cerr << std::endl << "Uncaught unknown exception" << std::endl;
00876 }
00877
00878 return false;
00879 }
00880
00881 template <class T1, class T2>
00882 void combineDigits (SmartDataPtr<T1>& mcDigits, T1& bgDigits, int verbosity)
00883 {
00884 vector<T2*> newDigiCol;
00885 typename T1::iterator mc;
00886 typename T1::const_iterator bg;
00887 bool new_digi;
00888 for(bg = bgDigits.begin(); bg != bgDigits.end(); bg++ )
00889 {
00890 new_digi = true;
00891 for(mc = mcDigits->begin(); mc != mcDigits->end(); mc++ )
00892 {
00893 if((*mc)->identify()==(*bg)->identify())
00894 {
00895 if( verbosity < 2 )
00896 {
00897 cout << "****************************************"<<endl;
00898 cout << "MC id " << (*mc)->identify().get_value()
00899 << " BG Id " << (*bg)->identify().get_value() << endl;
00900 cout<<"==> MC Digi : ";
00901 (*mc)->fillStream(cout);
00902 cout<<"==> BG Digi : ";
00903 (*bg)->fillStream(cout);
00904 }
00905
00906 (*mc)->setTrackIndex((*mc)->getTrackIndex() - 999);
00907 *(*mc) += *(*bg);
00908
00909 new_digi = false;
00910 if( verbosity < 2 )
00911 {
00912 cout<<"==> New MC Digi: ";
00913 (*mc)->fillStream(cout);
00914 cout << "****************************************"<<endl;
00915 }
00916 }
00917 }
00918
00919
00920 if (new_digi) {
00921 (*bg)->setTrackIndex(-1000);
00922 newDigiCol.push_back(*bg);
00923 }
00924 }
00925
00926 for(bg=newDigiCol.begin(); bg!=newDigiCol.end(); bg++ )
00927 mcDigits->push_back(*bg);
00928 }
00929
00930 void combineMdcDigits (SmartDataPtr<MdcDigiCol>& mcDigits, MdcDigiCol& bgDigits, int verbosity)
00931 {
00932 vector<MdcDigi*> newDigiCol;
00933 MdcDigiCol::const_iterator mc;
00934 MdcDigiCol::const_iterator bg;
00935 bool new_digi;
00936 for(bg = bgDigits.begin(); bg != bgDigits.end(); bg++ )
00937 {
00938 if((*bg)->getChargeChannel() < 0x7FFFFFFF) (*bg)->setChargeChannel(0);
00939 new_digi = true;
00940 for(mc = mcDigits->begin(); mc != mcDigits->end(); mc++ )
00941 {
00942 if((*mc)->identify()==(*bg)->identify())
00943 {
00944 if( verbosity < 2 )
00945 {
00946 cout << "****************************************"<<endl;
00947 cout << "MC id " << (*mc)->identify().get_value()
00948 << " BG Id " << (*bg)->identify().get_value() << endl;
00949 cout<<"==> MC Digi : ";
00950 (*mc)->fillStream(cout);
00951 cout<<"==> BG Digi : ";
00952 (*bg)->fillStream(cout);
00953 }
00954
00955 (*mc)->setTrackIndex((*mc)->getTrackIndex() - 999);
00956 *(*mc) += *(*bg);
00957
00958 new_digi = false;
00959 if( verbosity < 2 )
00960 {
00961 cout<<"==> New MC Digi: ";
00962 (*mc)->fillStream(cout);
00963 cout << "****************************************"<<endl;
00964 }
00965 }
00966 }
00967
00968
00969 if (new_digi) {
00970 (*bg)->setTrackIndex(-1000);
00971 newDigiCol.push_back(*bg);
00972 }
00973 }
00974
00975 for(bg=newDigiCol.begin(); bg!=newDigiCol.end(); bg++ )
00976 mcDigits->push_back(*bg);
00977 }
00978
00979 void combineTofDigits(SmartDataPtr<TofDigiCol>& mcDigits, TofDigiCol& bgDigits, int verbosity)
00980 {
00981 vector<TofDigi*> newDigiCol;
00982
00983 TofDigiCol::const_iterator bgTof = bgDigits.begin();
00984 for(; bgTof!=bgDigits.end(); bgTof++ )
00985 {
00986 (*bgTof)->setTrackIndex(-1000);
00987 newDigiCol.push_back(*bgTof);
00988 }
00989 for(bgTof=newDigiCol.begin(); bgTof!=newDigiCol.end(); bgTof++ ) {
00990 mcDigits->push_back(*bgTof);
00991 }
00992 }
00993
00994 void MixerAlg::mixDigi(SmartDataPtr<MdcDigiCol>& mdcMcDigits,
00995 SmartDataPtr<EmcDigiCol>& emcMcDigits,
00996 SmartDataPtr<MucDigiCol>& mucMcDigits,
00997 SmartDataPtr<TofDigiCol>& tofMcDigits)
00998 {
00999 if( b_mdc )
01000 {
01001 MdcDigiCol mdcCol;
01002 decodeMdc(&mdcCol);
01003
01004
01005
01006 if(m_ifSmearT0 && getTiming() > 0) {
01007 int tdc_min = -9, tdc_max = -9, tdc_tot = 0, tdc_num = 0;
01008 for(MdcDigiCol::const_iterator bg = mdcCol.begin(); bg != mdcCol.end(); bg++ )
01009 {
01010 if((*bg)->getTimeChannel() < 0x7FFFFFFF) {
01011 tdc_tot += (*bg)->getTimeChannel();
01012 tdc_num++;
01013 if(tdc_min < 0) tdc_min = (*bg)->getTimeChannel();
01014 else {
01015 if(tdc_min > (*bg)->getTimeChannel()) tdc_min = (*bg)->getTimeChannel();
01016 }
01017 if(tdc_max < 0) tdc_max = (*bg)->getTimeChannel();
01018 else {
01019 if(tdc_max < (*bg)->getTimeChannel()) tdc_max = (*bg)->getTimeChannel();
01020 }
01021 }
01022 }
01023 int tdc_mean = (int) ((double)tdc_tot/(double)tdc_num);
01024 tdc_num = 0;
01025 int tdc_shift;
01026 while(1) {
01027 tdc_shift = tdc_mean - CLHEP::RandFlat::shootInt(long(0), long(80*24/0.09375));
01028 if((tdc_min - tdc_shift)>=0 && (tdc_max - tdc_shift) <= int(80*24/0.09375)) break;
01029 tdc_num++;
01030 if(tdc_num > m_maxLoop) break;
01031 }
01032
01033
01034 for(MdcDigiCol::const_iterator bg = mdcCol.begin(); bg != mdcCol.end(); bg++ )
01035 {
01036 if((*bg)->getTimeChannel() >= 0x7FFFFFFF) continue;
01037 int newTDC = (*bg)->getTimeChannel() - tdc_shift;
01038 if(newTDC < 0 || newTDC > int(80*24/0.09375)) newTDC = int(CLHEP::RandFlat::shoot()*80*24/0.09375);
01039 (*bg)->setTimeChannel(newTDC);
01040
01041
01042
01043 }
01044 }
01045
01046 combineMdcDigits(mdcMcDigits, mdcCol, log->level());
01047 }
01048 if( b_emc )
01049 {
01050 EmcDigiCol emcCol;
01051 decodeEmc(&emcCol);
01052 combineDigits<EmcDigiCol, EmcDigi>(emcMcDigits, emcCol, log->level());
01053 }
01054 if( b_muc )
01055 {
01056 MucDigiCol mucCol;
01057 decodeMuc(&mucCol);
01058 combineDigits<MucDigiCol, MucDigi>(mucMcDigits, mucCol, log->level());
01059 }
01060 if( b_tof )
01061 {
01062 TofDigiCol tofCol;
01063 decodeTof(&tofCol);
01064
01065 combineTofDigits(tofMcDigits, tofCol, log->level());
01066 }
01067 }
01068
01069 void MixerAlg::decodeMdc(MdcDigiCol* digiCol)
01070 {
01071 const BufferHolder& mdcBuf = m_raw_event->getMdcBuf();
01072 m_mdcCnv->convert(mdcBuf, digiCol);
01073 }
01074
01075 void MixerAlg::decodeMuc(MucDigiCol* digiCol)
01076 {
01077 const BufferHolder& mucBuf = m_raw_event->getMucBuf();
01078 m_mucCnv->convert(mucBuf, digiCol);
01079 }
01080
01081 void MixerAlg::decodeEmc(EmcDigiCol* digiCol)
01082 {
01083 const BufferHolder& emcBuf = m_raw_event->getEmcBuf();
01084 m_emcCnv->convert(emcBuf, digiCol);
01085 }
01086
01087 void MixerAlg::decodeTof(TofDigiCol* digiCol)
01088 {
01089 const BufferHolder& tofBuf = m_raw_event->getTofBuf();
01090 const BufferHolder& etfBuf = m_raw_event->getEtfBuf();
01091 if( etfBuf.nBuf()>0 ) {
01092 m_tofCnv->convert(tofBuf, etfBuf, digiCol);
01093 }
01094 else {
01095 m_tofCnv->convert(tofBuf, digiCol);
01096 }
01097 }
01098
01099 std::string MixerAlg::eventType()
01100 {
01101 const BufferHolder& hltBuf = m_raw_event->getHltBuf();
01102 DstHltInf* hlt = new DstHltInf();
01103 hlt->setEventType(hltBuf(0)[0]);
01104
01105 std::string evtType = hlt->getEventName();
01106
01107 if(hlt) delete hlt;
01108
01109 return evtType;
01110 }
01111
01112 int MixerAlg::getTiming()
01113 {
01114 int timing = 0;
01115
01116 TrigGTD* trigGTD = NULL;
01117 TrigGTDCol* gtdCol = new TrigGTDCol;
01118
01119 const BufferHolder& gtdBuf = m_raw_event->getGTDBuf();
01120 uint32_t nbuf = gtdBuf.nBuf();
01121
01122 for (uint32_t i = 0; i < nbuf; i++) {
01123 uint32_t* buf = gtdBuf(i);
01124 uint32_t bufSize = gtdBuf.bufSize(i);
01125 uint32_t index = 0;
01126 while (bufSize - index > 1) {
01127 uint32_t blockSize = ( ((*(buf+index))>>14) & 0x3FF);
01128 uint32_t id = ((*(buf+index))>>24);
01129 if (blockSize == 0 || (index+blockSize) > bufSize) break;
01130 if ((id> 0xD1 && id < 0xD8 && id != 0xD5) || id == 0xDA || (id > 0xE1 && id < 0xED)) {
01131 trigGTD = new TrigGTD(buf+index);
01132 gtdCol->push_back(trigGTD);
01133 }
01134 index += blockSize;
01135 }
01136 }
01137
01138 TrigGTDCol::iterator iter = gtdCol->begin();
01139 for (;iter != gtdCol->end(); iter++ ) {
01140 const uint32_t boardId = (*iter)->getId();
01141 const uint32_t timeWindow = (*iter)->getTimeWindow();
01142 const uint32_t size = (*iter)->getDataSize();
01143 const uint32_t* trigData = (*iter)->getDataPtr();
01144
01145
01146 if(boardId == 0xd3) {
01147 if(size%timeWindow != 0) {
01148 std::cout << "GTL data is NOT completed, exit." << std::endl;
01149 exit(0);
01150 }
01151 for(uint32_t j = 0; j < size; j++) {
01152 uint32_t dataId = ((trigData[j] >> 24) & 0x7);
01153 if(dataId != 5) continue;
01154 for(uint32_t i = 1, loop = 0; loop < 24; i <<= 1, loop++) {
01155 if((loop == 16) && (trigData[j] & i)) timing = 1;
01156 if((loop == 17) && (trigData[j] & i) && (timing != 1)) timing = 2;
01157 if((loop == 18) && (trigData[j] & i) && (timing == 0)) timing = 3;
01158 }
01159 }
01160 }
01161 }
01162
01163 return timing;
01164 }
01165
01166 bool MixerAlg::file_sort(std::vector<std::string>& files, std::vector<int>& ranEvtNums) {
01167 std::vector<std::string> tmp_files = files;
01168 std::vector<int> tmp_ranEvtNums = ranEvtNums;
01169 files.clear();
01170 ranEvtNums.clear();
01171 m_numSets.clear();
01172
01173 const char* file_index[100];
01174 int num_index[100];
01175 int set_index[100];
01176 for(int i = 0; i < 100; i++) {
01177 file_index[i] = "";
01178 num_index[i] = 0;
01179 set_index[i] = 0;
01180 }
01181
01182 if(tmp_files.size() >= 100) {
01183 std::cout << "ERROR: In MixerAlg::file_sort(), please change bigger array size" << std::endl;
01184 return false;
01185 }
01186
01187 for(unsigned int i = 0; i < tmp_files.size(); i++) {
01188 int index = 0;
01189 const char* file1 = tmp_files[i].c_str();
01190 const char* substr1 = strstr(file1,"_file");
01191 int strlen1 = strlen(substr1);
01192 char cset1[4];
01193 char cnum1[2];
01194
01195 for(int sub1 = 0; sub1 < strlen1; sub1++) {
01196 if(substr1[sub1] == 'e') {
01197 cset1[0] = substr1[sub1+1];
01198 cset1[1] = substr1[sub1+2];
01199 cset1[2] = substr1[sub1+3];
01200 cset1[3] = '\0';
01201 }
01202 else if(substr1[sub1] == '-') {
01203 cnum1[0] = substr1[sub1+1];
01204 cnum1[1] = '\0';
01205 break;
01206 }
01207 else {
01208 continue;
01209 }
01210 }
01211
01212 int set1 = atoi(cset1);
01213 int num1 = atoi(cnum1);
01214 int encode_set1 = set1*100 + num1;
01215
01216 for(unsigned int j = 0; j < tmp_files.size(); j++) {
01217 if(i == j) continue;
01218 const char* file2 = tmp_files[j].c_str();
01219 const char* substr2 = strstr(file2,"_file");
01220 int strlen2 = strlen(substr2);
01221 char cset2[4];
01222 char cnum2[2];
01223 for(int sub2 = 0; sub2 < strlen2; sub2++) {
01224 if(substr2[sub2] == 'e') {
01225 cset2[0] = substr2[sub2+1];
01226 cset2[1] = substr2[sub2+2];
01227 cset2[2] = substr2[sub2+3];
01228 cset2[3] = '\0';
01229 }
01230 else if(substr2[sub2] == '-') {
01231 cnum2[0] = substr2[sub2+1];
01232 cnum2[1] = '\0';
01233 break;
01234 }
01235 else {
01236 continue;
01237 }
01238 }
01239 int set2 = atoi(cset2);
01240 int num2 = atoi(cnum2);
01241 int encode_set2 = set2*100 + num2;
01242 if(encode_set1 > encode_set2) index++;
01243 }
01244 file_index[index] = tmp_files[i].c_str();
01245 num_index[index] = tmp_ranEvtNums[i];
01246 set_index[index] = set1;
01247 }
01248
01249 int setNo = -10;
01250 for(unsigned int i = 0; i < tmp_files.size(); i++) {
01251 files.push_back(file_index[i]);
01252 ranEvtNums.push_back(num_index[i]);
01253 if(setNo != set_index[i]) {
01254 setNo = set_index[i];
01255 int numSets_size = m_numSets.size();
01256 if(numSets_size == 0) m_numSets.push_back(1);
01257 if(numSets_size != 0) m_numSets.push_back(m_numSets[numSets_size - 1] + 1);
01258 }
01259 else {
01260 int numSets_size = m_numSets.size();
01261 m_numSets.push_back(m_numSets[numSets_size - 1]);
01262 }
01263 }
01264
01265 return true;
01266 }