| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |

In This Package:

DaqBenchmark Namespace Reference


Namespaces

namespace  __init__

Functions

 DaqBenchmark (const string &name, ISvcLocator *pSvcLocator)
 ~DaqBenchmark ()
StatusCode initialize ()
StatusCode finalize ()
StatusCode execute ()
TH1F ** getSlotLowGainHistograms (const unsigned int slot)
TH1F ** getSlotHighGainHistograms (const unsigned int slot)
TH1F ** getSlotTdcHistograms (const unsigned int slot)
TH1F ** getSlotHistogram (TH1F ***histograms, const unsigned int slot)
TH2F ** getSlotFadcHistograms (const unsigned int slot)
TH2F ** getSlotHistogram (TH2F ***histograms, const unsigned int slot)
TH1F * getLowGainHistogram (TH1F **slotLowGainHistograms, const unsigned int slot, const unsigned int channelNumber)
TH1F * getHighGainHistogram (TH1F **slotHighGainHistograms, const unsigned int slot, const unsigned int channelNumber)
TH1F * getTdcHistogram (TH1F **slotTdcHistograms, const unsigned int slot, const unsigned int channelNumber)
TH2F * getFadcHistogram (TH2F **slotFadcHistograms, const unsigned int slot, const unsigned int channelNumber)
StatusCode handleDaqFormat (const ReadoutHeader &readoutHeader)
void handleEvent (const DybDaq::EventReadout &event)
void handleFragment (const RomFragment &fragment)
void handleFee (const FeeReadout &readout, const unsigned int slot)
StatusCode handleReadoutEvent (const ReadoutHeader &readoutHeader)
void handleEvent (const DayaBay::ReadoutPmtCrate &crate)
void handleChannel (const ReadoutPmtChannel &channel)
StatusCode handleDaqEvent (const ReadoutHeader &readoutHeader)
void handleEvent (const DayaBay::DaqPmtCrate &crate)
void handleFrame (const DaqLtbFrame &)
void handleChannel (const DaqPmtChannel &channel)
void handleChannel (const DaqFadcChannel &channel)

Function Documentation

DaqBenchmark::DaqBenchmark ( const string &  name,
ISvcLocator *  pSvcLocator 
)

Definition at line 81 of file DaqBenchmark.cc.

00082                                                      :
00083     GaudiAlgorithm(name,
00084                    pSvcLocator),
00085     m_statsSvc(0),
00086     m_feeLowGainHistograms( new TH1F**[kMaxSlotCount]),
00087     m_feeHighGainHistograms( new TH1F**[kMaxSlotCount]),
00088     m_feeTdcHistograms( new TH1F**[kMaxSlotCount]),
00089     m_fadcHistograms( new TH2F**[kMaxSlotCount]),
00090     m_eventCount(0),
00091     m_payloadLength(0),
00092     m_beginTime(0),
00093     m_firstEventTime(0),
00094     m_lastEventTime(0) {
00095     for(unsigned int slot = 0;
00096         slot != kMaxSlotCount;
00097         ++slot) {
00098         m_feeLowGainHistograms[slot] = 0;
00099         m_feeHighGainHistograms[slot] = 0;
00100         m_feeTdcHistograms[slot] = 0;
00101         m_fadcHistograms[slot] = 0;
00102     }
00103     declareProperty("UseDaqFormat",
00104                     m_useDaqFormat=true,
00105                     "True is the benchmarks should us the DaqFormat products");
00106     declareProperty("UseDaqEvent",
00107                     m_useDaqEvent=false,
00108                     "True is the benchmarks should us the DaqEvent products");
00109     declareProperty("UseReadoutEvent",
00110                     m_useReadoutEvent=false,
00111                     "True is the benchmarks should us the ReadoutEvent products");
00112 }

DaqBenchmark::~DaqBenchmark (  ) 

Definition at line 114 of file DaqBenchmark.cc.

00114                             {
00115     // Histograms are cleaned up by Stats service.
00116 }

StatusCode DaqBenchmark::initialize (  ) 

Definition at line 118 of file DaqBenchmark.cc.

00119 {
00120     StatusCode sc = service("StatisticsSvc",
00121                             m_statsSvc,
00122                             true);
00123     if (sc.isFailure()) {
00124         error() << "Failed to get StatisticsSvc" << endreq;
00125         return sc;
00126     }
00127     m_beginTime = time(0);
00128     return sc;
00129 }

StatusCode DaqBenchmark::finalize (  ) 

Definition at line 131 of file DaqBenchmark.cc.

00132 {
00133     if (m_lastEventTime != m_firstEventTime) {
00134         time_t now = time(0);
00135         const double moduleDelta = difftime(now,
00136                                             m_beginTime);
00137         const double eventDelta = difftime(m_lastEventTime,
00138                                            m_firstEventTime);
00139         info() << "Benchmark factor for this job was " << std::setprecision(2) << (moduleDelta/ eventDelta) << "." << endreq;
00140         info() << "Analysis byte rate was " << std::setprecision(2) << (m_payloadLength / (moduleDelta * 1024U * 1024U)) << " MB/s." << endreq;
00141         info() << "Data taking event rate was " << std::setprecision(4) << ((m_eventCount - 1) / eventDelta) << " Hz." << endreq;
00142         info() << "Analysis event rate was " << std::setprecision(4) << ((m_eventCount - 1) / moduleDelta) << " Hz." << endreq;
00143     }
00144 
00145     if( m_statsSvc ) {
00146         m_statsSvc->release();
00147     }
00148     return StatusCode::SUCCESS;
00149 }

StatusCode DaqBenchmark::execute (  ) 

Definition at line 151 of file DaqBenchmark.cc.

00151                                  {
00152     const ReadoutHeader* readoutHeader = get<ReadoutHeader>("/Event/Readout/ReadoutHeader");
00153     if (0 == readoutHeader) {
00154         error() << "Failed to get readout header." << endreq;
00155         return StatusCode::FAILURE;
00156     }
00157 
00158     if (m_useDaqFormat) {
00159         StatusCode sc = handleDaqFormat(*readoutHeader);
00160         if (sc.isFailure()) {
00161             return sc;
00162         }
00163     }
00164     if (m_useDaqEvent) {
00165         StatusCode sc = handleDaqEvent(*readoutHeader);
00166         if (sc.isFailure()) {
00167             return sc;
00168         }
00169     }
00170     if (m_useReadoutEvent) {
00171         StatusCode sc = handleReadoutEvent(*readoutHeader);
00172         if (sc.isFailure()) {
00173             return sc;
00174         }
00175     }
00176     ++m_eventCount;
00177     if (0 == (m_eventCount % 1000)) {
00178         info() << " Processed " << m_eventCount << " events" << endreq;
00179     }
00180     return StatusCode::SUCCESS;
00181 }

TH1F** DaqBenchmark::getSlotLowGainHistograms ( const unsigned int  slot  ) 

Definition at line 183 of file DaqBenchmark.cc.

00183                                                                      {
00184     return getSlotHistogram(m_feeLowGainHistograms,
00185                             slot); 
00186 }

TH1F** DaqBenchmark::getSlotHighGainHistograms ( const unsigned int  slot  ) 

Definition at line 188 of file DaqBenchmark.cc.

00188                                                                       {
00189     return getSlotHistogram(m_feeHighGainHistograms,
00190                             slot); 
00191 }

TH1F** DaqBenchmark::getSlotTdcHistograms ( const unsigned int  slot  ) 

Definition at line 193 of file DaqBenchmark.cc.

00193                                                                  {
00194     return getSlotHistogram(m_feeTdcHistograms,
00195                             slot);
00196 }

TH1F** DaqBenchmark::getSlotHistogram ( TH1F ***  histograms,
const unsigned int  slot 
)

Definition at line 198 of file DaqBenchmark.cc.

00199                                                                {
00200     TH1F** result = histograms[slot];
00201     if (0 == result) {
00202         result = new TH1F*[kMaxFeeChannelCount];
00203         histograms[slot] = result;
00204         for (unsigned int channel = 0;
00205              channel != kMaxFeeChannelCount;
00206              ++channel) {
00207             result[channel] = 0;
00208         }
00209     }
00210     return result;
00211 }

TH2F** DaqBenchmark::getSlotFadcHistograms ( const unsigned int  slot  ) 

Definition at line 213 of file DaqBenchmark.cc.

00213                                                                   {
00214     return getSlotHistogram(m_fadcHistograms,
00215                             slot);
00216 }

TH2F** DaqBenchmark::getSlotHistogram ( TH2F ***  histograms,
const unsigned int  slot 
)

Definition at line 218 of file DaqBenchmark.cc.

00219                                                                {
00220     TH2F** result = histograms[slot];
00221     if (0 == result) {
00222         result = new TH2F*[kMaxFeeChannelCount];
00223         histograms[slot] = result;
00224         for (unsigned int channel = 0;
00225              channel != kMaxFeeChannelCount;
00226              ++channel) {
00227             result[channel] = 0;
00228         }
00229     }
00230     return result;
00231 }

TH1F* DaqBenchmark::getLowGainHistogram ( TH1F **  slotLowGainHistograms,
const unsigned int  slot,
const unsigned int  channelNumber 
)

Definition at line 255 of file DaqBenchmark.cc.

00257                                                                             {
00258     TH1F* result = slotLowGainHistograms[channelNumber];
00259     if (0 == result) {
00260         const string name = getName("Low Gain ADC",
00261                                     slot,
00262                                     channelNumber);
00263         result = new TH1F(name.c_str(),
00264                           "ADC, low gain",
00265                           4096,
00266                           0,
00267                           4096);
00268         slotLowGainHistograms[channelNumber] = result;
00269         m_statsSvc->put(getPath(slot,
00270                                 channelNumber,
00271                                 name.c_str()), 
00272                         result);
00273     }
00274     return result;
00275 }

TH1F* DaqBenchmark::getHighGainHistogram ( TH1F **  slotHighGainHistograms,
const unsigned int  slot,
const unsigned int  channelNumber 
)

Definition at line 277 of file DaqBenchmark.cc.

00279                                                                            {
00280     TH1F* result = slotHighGainHistograms[channelNumber];
00281     if (0 == result) {
00282         const string name = getName("High Gain ADC",
00283                                     slot,
00284                                     channelNumber);
00285         result = new TH1F(name.c_str(),
00286                           "ADC, high gain",
00287                           4096,
00288                           0,
00289                           4096);
00290         slotHighGainHistograms[channelNumber] = result;
00291         m_statsSvc->put(getPath(slot,
00292                                 channelNumber,
00293                                 name.c_str()), 
00294                         result);
00295     }
00296     return result;
00297 }

TH1F* DaqBenchmark::getTdcHistogram ( TH1F **  slotTdcHistograms,
const unsigned int  slot,
const unsigned int  channelNumber 
)

Definition at line 299 of file DaqBenchmark.cc.

00301                                                                       {
00302     TH1F* result = slotTdcHistograms[channelNumber];
00303     if (0 == result) {
00304         const string name = getName("TDC",
00305                                     slot,
00306                                     channelNumber);
00307         result = new TH1F(name.c_str(),
00308                           "TDC",
00309                           1000,
00310                           300,
00311                           1300);
00312         slotTdcHistograms[channelNumber] = result;
00313         m_statsSvc->put(getPath(slot,
00314                                 channelNumber,
00315                                 name.c_str()), 
00316                         result);
00317     }
00318     return result;
00319 }

TH2F* DaqBenchmark::getFadcHistogram ( TH2F **  slotFadcHistograms,
const unsigned int  slot,
const unsigned int  channelNumber 
)

Definition at line 321 of file DaqBenchmark.cc.

00323                                                                        {
00324     TH2F* result = slotFadcHistograms[channelNumber];
00325     if (0 == result) {
00326         const string name = getName("FADC",
00327                                     slot,
00328                                     channelNumber);
00329         result = new TH2F(name.c_str(),
00330                           "FADC",
00331                           0,
00332                           120,
00333                           120,
00334                           0,
00335                           256,
00336                           256);
00337         slotFadcHistograms[channelNumber] = result;
00338         m_statsSvc->put(getPath(slot,
00339                                 channelNumber,
00340                                 name.c_str()), 
00341                         result);
00342     }
00343     return result;
00344 }

StatusCode DaqBenchmark::handleDaqFormat ( const ReadoutHeader &  readoutHeader  ) 

Definition at line 365 of file DaqBenchmark.cc.

00365                                                                            {
00366     const EventReadout* event = 0;
00367     const DaqCrate* daqCrate = readoutHeader.daqCrate();
00368     if (0 == daqCrate) {
00369         const Readout* readout = readoutHeader.readout();
00370         if (0 == readout) {
00371             error() << "Failed to get DAQ readout or readout from header" << endreq;
00372             return StatusCode::FAILURE;
00373         }
00374         event = readout->eventReadout();
00375         if (0 == event) {
00376             error() << "Failed to get event readout from readout" << endreq;
00377             return StatusCode::FAILURE;
00378         }
00379     } else {
00380         event = &(daqCrate->eventReadout());
00381     }
00382 
00383     m_lastEventTime = getEventTime(*event);
00384     if (0 == m_firstEventTime) {
00385         m_firstEventTime = m_lastEventTime;
00386     }
00387     handleEvent(*event);
00388     m_payloadLength += event->header().totalSize() * kBytesInInt;
00389     return StatusCode::SUCCESS;
00390  }

void DaqBenchmark::handleEvent ( const DybDaq::EventReadout &  event  ) 

Definition at line 392 of file DaqBenchmark.cc.

00392                                                               {
00393     const EventReadout::RomFragmentPtrList& fragments = event.romFragments();
00394     for (EventReadout::RomFragmentPtrList::const_iterator fragment = fragments.begin();
00395          fragment != fragments.end();
00396          ++fragment) {
00397         handleFragment(*(*fragment));
00398     }
00399 }

void DaqBenchmark::handleFragment ( const RomFragment &  fragment  ) 

Definition at line 401 of file DaqBenchmark.cc.

00401                                                              {
00402     const RomHeader& header = fragment.header();
00403     const unsigned int slot = header.slot();
00404     const unsigned int kFeeModuleType = header.eventTraits().moduleType(EventTraits::kFeeModule);
00405     if (kFeeModuleType == header.moduleType()) {
00406         handleFee(dynamic_cast<const FeeReadout&>(fragment.unwrappedData()),
00407                   slot);
00408     }
00409 }

void DaqBenchmark::handleFee ( const FeeReadout &  readout,
const unsigned int  slot 
)

Definition at line 411 of file DaqBenchmark.cc.

00412                                                       {
00413     TH1F** slotLowGainHistograms = getSlotLowGainHistograms(slot);
00414     TH1F** slotHighGainHistograms = getSlotHighGainHistograms(slot);
00415     TH1F** slotTdcHistograms = getSlotTdcHistograms(slot);
00416 
00417     const FeeReadout::FeeHitPtrList& hits = readout.feeHits();
00418     for (FeeReadout::FeeHitPtrList::const_iterator hitPtr = hits.begin();
00419          hitPtr != hits.end();
00420          ++hitPtr) {
00421         const FeeHit& hit = *(*hitPtr);
00422         const unsigned int channelNumber = hit.channelId() + 1;
00423         TH1F* rangeHistogram = 0;
00424         if (hit.isHighRangeAdc()) {
00425             rangeHistogram = getLowGainHistogram(slotLowGainHistograms,
00426                                                    slot,
00427                                                    channelNumber);
00428         } else {
00429             rangeHistogram = getHighGainHistogram(slotHighGainHistograms,
00430                                                   slot,
00431                                                   channelNumber);
00432         }
00433         rangeHistogram->Fill(hit.adc());
00434         TH1F* tdcHistogram = getTdcHistogram(slotTdcHistograms,
00435                                              slot,
00436                                              channelNumber);
00437         tdcHistogram->Fill(hit.tdc());
00438     }
00439 }

StatusCode DaqBenchmark::handleReadoutEvent ( const ReadoutHeader &  readoutHeader  ) 

Definition at line 446 of file DaqBenchmark.cc.

00446                                                                               {
00447     const Readout* readout = readoutHeader.readout();
00448     if (0 == readout) {
00449         error() << "Failed to get readout from header" << endreq;
00450         return StatusCode::FAILURE;
00451     }
00452 
00453     m_lastEventTime = getEventTime(readout->triggerTime());
00454     if (0 == m_firstEventTime) {
00455         m_firstEventTime = m_lastEventTime;
00456     }
00457     const ReadoutPmtCrate* pmtReadout = dynamic_cast<const ReadoutPmtCrate*>(readout);
00458     if (0 != pmtReadout) {
00459         handleEvent(*pmtReadout);
00460     }
00461     return StatusCode::SUCCESS;
00462  }

void DaqBenchmark::handleEvent ( const DayaBay::ReadoutPmtCrate &  crate  ) 

Definition at line 464 of file DaqBenchmark.cc.

00464                                                                   {
00465     const std::vector<DayaBay::FeeChannelId> channels = const_cast<ReadoutPmtCrate&>(crate).channels();
00466     std::vector<DayaBay::FeeChannelId>::const_iterator finished = channels.end();
00467     for (std::vector<DayaBay::FeeChannelId>::const_iterator channel = channels.begin();
00468          channel != finished;
00469          ++channel) {
00470         handleChannel(const_cast<ReadoutPmtCrate&>(crate).channel(*channel));
00471     }
00472 }

void DaqBenchmark::handleChannel ( const ReadoutPmtChannel &  channel  ) 

Definition at line 474 of file DaqBenchmark.cc.

00474                                                                  {
00475     const FeeChannelId& feeChannelId = channel.channelId();
00476     const unsigned int slot = feeChannelId.board();
00477     TH1F** slotLowGainHistograms = getSlotLowGainHistograms(slot);
00478     TH1F** slotHighGainHistograms = getSlotHighGainHistograms(slot);
00479     TH1F** slotTdcHistograms = getSlotTdcHistograms(slot);
00480   
00481     const unsigned int channelNumber = feeChannelId.connector();
00482     TH1F* lowGainHistogram = getLowGainHistogram(slotLowGainHistograms,
00483                                                  slot,
00484                                                  channelNumber);
00485     TH1F* highGainHistogram = getHighGainHistogram(slotHighGainHistograms,
00486                                                    slot,
00487                                                    channelNumber);
00488     unsigned int hit = 0;
00489     const std::vector<int>& charges = channel.adc();
00490     const std::vector<int>::const_iterator finishedCharges = charges.end();
00491     for(std::vector<int>::const_iterator charge = charges.begin();
00492         finishedCharges != charge;
00493         ++charge) {
00494         if (channel.adcRange(hit) == DayaBay::FeeGain::kHigh) {
00495             highGainHistogram->Fill(*charge);
00496         } else {
00497             lowGainHistogram->Fill(*charge);
00498         }
00499         ++hit;
00500     }
00501 
00502     TH1F* tdcHistogram = getTdcHistogram(slotTdcHistograms,
00503                                          slot,
00504                                          channelNumber);
00505     const std::vector<int>& times = channel.tdc();
00506     const std::vector<int>::const_iterator finishedTimes = times.end();
00507     for(std::vector<int>::const_iterator time = times.begin();
00508         finishedTimes != time;
00509         ++time) {
00510         tdcHistogram->Fill(*time);
00511     }
00512 }

StatusCode DaqBenchmark::handleDaqEvent ( const ReadoutHeader &  readoutHeader  ) 

Definition at line 514 of file DaqBenchmark.cc.

00514                                                                           {
00515     const DaqCrate* daqCrate = readoutHeader.daqCrate();
00516     if (0 == daqCrate) {
00517         error() << "Failed to get readout from header" << endreq;
00518         return StatusCode::FAILURE;
00519     }
00520 
00521     m_lastEventTime = getEventTime(daqCrate->triggerTime());
00522     if (0 == m_firstEventTime) {
00523         m_firstEventTime = m_lastEventTime;
00524     }
00525     const DaqPmtCrate* pmtCrate = daqCrate->asPmtCrate();
00526     if (0 != pmtCrate) {
00527         handleEvent(*pmtCrate);
00528     }
00529     return StatusCode::SUCCESS;
00530  }

void DaqBenchmark::handleEvent ( const DayaBay::DaqPmtCrate &  crate  ) 

Definition at line 532 of file DaqBenchmark.cc.

00532                                                               {
00533     {
00534         const DaqLtb& triggerBoard = crate.localTriggerBoard();
00535         const DaqLtb::LtbFramePtrList& frames = triggerBoard.frames();
00536         const DaqLtb::LtbFramePtrList::const_iterator finished = frames.end();
00537         for(DaqLtb::LtbFramePtrList::const_iterator frame = frames.begin();
00538             finished != frame;
00539             ++frame) {
00540             handleFrame(*(*frame));
00541         }
00542     }
00543 
00544     {
00545         const DaqPmtCrate::PmtChannelPtrList& channels = crate.pmtChannelReadouts();
00546         const DaqPmtCrate::PmtChannelPtrList::const_iterator finished = channels.end();
00547         for (DaqPmtCrate::PmtChannelPtrList::const_iterator channel = channels.begin();
00548              channel != finished;
00549              ++channel) {
00550             handleChannel(*(*channel));
00551         }
00552     }
00553 
00554     {
00555         const DaqPmtCrate::FadcChannelPtrList& channels = crate.fadcChannelReadouts();
00556         const DaqPmtCrate::FadcChannelPtrList::const_iterator finished = channels.end();
00557         for (DaqPmtCrate::FadcChannelPtrList::const_iterator channel = channels.begin();
00558              channel != finished;
00559              ++channel) {
00560             handleChannel(*(*channel));
00561         }
00562     }
00563 }

void DaqBenchmark::handleFrame ( const DaqLtbFrame &   ) 

Definition at line 565 of file DaqBenchmark.cc.

00565                                                              {
00566 }

void DaqBenchmark::handleChannel ( const DaqPmtChannel &  channel  ) 

Definition at line 568 of file DaqBenchmark.cc.

00568                                                              {
00569     const FeeChannelId& feeChannelId = channel.channelId();
00570     const unsigned int slot = feeChannelId.board();
00571     TH1F** slotLowGainHistograms = getSlotLowGainHistograms(slot);
00572     TH1F** slotHighGainHistograms = getSlotHighGainHistograms(slot);
00573     TH1F** slotTdcHistograms = getSlotTdcHistograms(slot);
00574     
00575     const unsigned int channelNumber = feeChannelId.connector();
00576     TH1F* lowGainHistogram = getLowGainHistogram(slotLowGainHistograms,
00577                                            slot,
00578                                            channelNumber);
00579     TH1F* highGainHistogram = getHighGainHistogram(slotHighGainHistograms,
00580                                                    slot,
00581                                                    channelNumber);
00582     TH1F* tdcHistogram = getTdcHistogram(slotTdcHistograms,
00583                                          slot,
00584                                          channelNumber);
00585 
00586     const unsigned int finished = channel.hitCount();
00587     for(unsigned int hit = 0;
00588         hit != finished;
00589         ++hit) {
00590         if (channel.isHighGainAdc(hit)) {
00591             highGainHistogram->Fill(channel.adc(hit));
00592         } else {
00593             lowGainHistogram->Fill(channel.adc(hit));
00594         }
00595         tdcHistogram->Fill(channel.tdc(hit));
00596     }
00597 }

void DaqBenchmark::handleChannel ( const DaqFadcChannel &  channel  ) 

Definition at line 599 of file DaqBenchmark.cc.

00599                                                               {
00600     const FadcChannelId& fadcChannelId = channel.channelId();
00601     const unsigned int slot = fadcChannelId.board();
00602     TH2F** slotFadcHistograms = getSlotFadcHistograms(slot);
00603     
00604     const unsigned int channelNumber = fadcChannelId.connector();
00605     TH2F* fadcHistogram = getFadcHistogram(slotFadcHistograms,
00606                                            slot,
00607                                            channelNumber);
00608 
00609     const DaqFadcChannel::FadcSamples& samples = channel.samples();
00610     unsigned int bin = 0;
00611     const DaqFadcChannel::FadcSamples::const_iterator finished = samples.end();
00612     for (DaqFadcChannel::FadcSamples::const_iterator sample = samples.begin();
00613          finished != sample;
00614          ++sample) {
00615         fadcHistogram->Fill(bin,
00616                             *sample,
00617                             1.0);
00618         ++bin;
00619     }
00620 }

| Classes | Job Modules | Data Objects | Services | Algorithms | Tools | Packages | Directories | Tracs |
Generated on Mon Apr 11 20:46:30 2011 for DaqFormatModules by doxygen 1.4.7