| 16 |
|
#include "l1menu/IMenuRate.h" |
| 17 |
|
#include "l1menu/ITriggerRate.h" |
| 18 |
|
#include "l1menu/tools/tools.h" |
| 19 |
+ |
#include "l1menu/implementation/MenuRateImplementation.h" |
| 20 |
|
#include "protobuf/l1menu.pb.h" |
| 21 |
|
#include <google/protobuf/io/zero_copy_stream_impl.h> |
| 22 |
|
#include <google/protobuf/io/gzip_stream.h> |
| 36 |
|
int fileDescriptor_; |
| 37 |
|
}; |
| 38 |
|
|
| 38 |
– |
class MenuRateImplementation; |
| 39 |
– |
|
| 40 |
– |
class TriggerRateImplementation : public l1menu::ITriggerRate |
| 41 |
– |
{ |
| 42 |
– |
public: |
| 43 |
– |
TriggerRateImplementation( const l1menu::ITrigger& trigger, float fraction, const MenuRateImplementation& menuRate ); |
| 44 |
– |
TriggerRateImplementation& operator=( TriggerRateImplementation&& otherTriggerRate ); // Move assignment |
| 45 |
– |
virtual ~TriggerRateImplementation(); |
| 46 |
– |
|
| 47 |
– |
// Methods required by the l1menu::ITriggerRate interface |
| 48 |
– |
virtual const l1menu::ITrigger& trigger() const; |
| 49 |
– |
virtual float fraction() const; |
| 50 |
– |
virtual float rate() const; |
| 51 |
– |
protected: |
| 52 |
– |
std::unique_ptr<l1menu::ITrigger> pTrigger_; |
| 53 |
– |
float fraction_; |
| 54 |
– |
const MenuRateImplementation& menuRate_; |
| 55 |
– |
}; |
| 56 |
– |
|
| 57 |
– |
class MenuRateImplementation : public l1menu::IMenuRate |
| 58 |
– |
{ |
| 59 |
– |
public: |
| 60 |
– |
void setTotalFraction( float fraction ) { totalFraction_=fraction; } |
| 61 |
– |
void setScaling( float scaling ) { scaling_=scaling; } |
| 62 |
– |
float scaling() const { return scaling_; } |
| 63 |
– |
void addTriggerRate( const l1menu::ITrigger& trigger, float fraction ) { triggerRates_.push_back( std::move(TriggerRateImplementation(trigger,fraction,*this)) ); } |
| 64 |
– |
// Methods required by the l1menu::IMenuRate interface |
| 65 |
– |
virtual float totalFraction() const { return totalFraction_; } |
| 66 |
– |
virtual float totalRate() const { return totalFraction_*scaling_; } |
| 67 |
– |
virtual const std::vector<const l1menu::ITriggerRate*>& triggerRates() const |
| 68 |
– |
{ |
| 69 |
– |
// If the sizes are the same I'll assume nothing has changed and the references |
| 70 |
– |
// are still valid. I don't expect this method to be called until the triggerRates_ |
| 71 |
– |
// vector is complete anyway. |
| 72 |
– |
if( triggerRates_.size()!=baseClassReferences_.size() ) |
| 73 |
– |
{ |
| 74 |
– |
baseClassReferences_.clear(); |
| 75 |
– |
for( const auto& triggerRate : triggerRates_ ) |
| 76 |
– |
{ |
| 77 |
– |
baseClassReferences_.push_back( &triggerRate ); |
| 78 |
– |
} |
| 79 |
– |
} |
| 80 |
– |
|
| 81 |
– |
return baseClassReferences_; |
| 82 |
– |
} |
| 83 |
– |
|
| 84 |
– |
protected: |
| 85 |
– |
float totalFraction_; |
| 86 |
– |
float scaling_; |
| 87 |
– |
std::vector<TriggerRateImplementation> triggerRates_; |
| 88 |
– |
mutable std::vector<const l1menu::ITriggerRate*> baseClassReferences_; |
| 89 |
– |
}; |
| 90 |
– |
|
| 39 |
|
/** @brief An object that stores pointers to trigger parameters to avoid costly string comparisons. |
| 40 |
|
* |
| 41 |
|
* @author Mark Grimes (mark.grimes@bristol.ac.uk) |
| 74 |
|
std::vector< std::pair<l1menu::ReducedEvent::ParameterID,const float*> > identifiers_; |
| 75 |
|
}; // end of class ReducedSampleCachedTrigger |
| 76 |
|
|
| 129 |
– |
TriggerRateImplementation::TriggerRateImplementation( const l1menu::ITrigger& trigger, float fraction, const MenuRateImplementation& menuRate ) |
| 130 |
– |
: fraction_(fraction), menuRate_(menuRate) |
| 131 |
– |
{ |
| 132 |
– |
pTrigger_=std::move( l1menu::TriggerTable::instance().copyTrigger(trigger) ); |
| 133 |
– |
} |
| 134 |
– |
TriggerRateImplementation& TriggerRateImplementation::operator=( TriggerRateImplementation&& otherTriggerRate ) |
| 135 |
– |
{ |
| 136 |
– |
pTrigger_=std::move( otherTriggerRate.pTrigger_ ); |
| 137 |
– |
fraction_=otherTriggerRate.fraction_; |
| 138 |
– |
// I can't change the menuRate_ reference, but that should already be set to the right one anyway. |
| 139 |
– |
return *this; |
| 140 |
– |
} |
| 141 |
– |
TriggerRateImplementation::~TriggerRateImplementation() {} |
| 142 |
– |
const l1menu::ITrigger& TriggerRateImplementation::trigger() const { return *pTrigger_; } |
| 143 |
– |
float TriggerRateImplementation::fraction() const { return fraction_; } |
| 144 |
– |
float TriggerRateImplementation::rate() const { return fraction_*menuRate_.scaling(); } |
| 145 |
– |
|
| 77 |
|
float sumWeights( const l1menuprotobuf::Run& run ) |
| 78 |
|
{ |
| 79 |
|
float returnValue=0; |
| 306 |
|
pCurrentRun=pImple_->protobufRuns.back().get(); |
| 307 |
|
} |
| 308 |
|
|
| 309 |
< |
const l1menu::L1TriggerDPGEvent& event=originalSample.getEvent( eventNumber ); |
| 309 |
> |
const l1menu::L1TriggerDPGEvent& event=originalSample.getFullEvent( eventNumber ); |
| 310 |
|
l1menuprotobuf::Event* pProtobufEvent=pCurrentRun->add_event(); |
| 311 |
+ |
if( event.weight()!=1 ) pProtobufEvent->set_weight( event.weight() ); |
| 312 |
|
|
| 313 |
|
// Loop over all of the triggers |
| 314 |
|
for( size_t triggerNumber=0; triggerNumber<pImple_->triggerMenu.numberOfTriggers(); ++triggerNumber ) |
| 328 |
|
catch( std::exception& error ) |
| 329 |
|
{ |
| 330 |
|
// setTriggerThresholdsAsTightAsPossible() couldn't find thresholds so record |
| 331 |
< |
// -1 for everything. |
| 331 |
> |
// a default for everything. |
| 332 |
|
// Range based for loop gives me a warning because I don't use the thresholdName. |
| 333 |
< |
for( size_t index=0; index<thresholdNames.size(); ++index ) pProtobufEvent->add_threshold(-1); |
| 333 |
> |
for( size_t index=0; index<thresholdNames.size(); ++index ) pProtobufEvent->add_threshold(100000); |
| 334 |
|
} // end of try block that sets the trigger thresholds |
| 335 |
|
|
| 336 |
|
} // end of loop over triggers |
| 506 |
|
// Should always find the event before getting to this point, so throw an |
| 507 |
|
// exception if this happens. |
| 508 |
|
throw std::runtime_error( "ReducedMenuSample::getEvent(eventNumber) was asked for an invalid eventNumber" ); |
| 577 |
– |
|
| 509 |
|
} |
| 510 |
|
|
| 511 |
|
std::unique_ptr<l1menu::ICachedTrigger> l1menu::ReducedMenuSample::createCachedTrigger( const l1menu::ITrigger& trigger ) const |
| 532 |
|
{ |
| 533 |
|
// TODO make sure the TriggerMenu is valid for this sample |
| 534 |
|
|
| 604 |
– |
// I need a non-const menu, so make a copy |
| 605 |
– |
l1menu::TriggerMenu mutableMenu( menu ); |
| 606 |
– |
|
| 535 |
|
// The number of events that pass each trigger |
| 536 |
|
std::vector<size_t> numberOfEventsPassed( menu.numberOfTriggers() ); |
| 537 |
|
float numberOfEventsPassingAnyTrigger; |
| 538 |
|
|
| 539 |
+ |
// Using cached triggers significantly increases speed for ReducedMenuSample |
| 540 |
+ |
// because it cuts out expensive string comparisons when querying the trigger |
| 541 |
+ |
// parameters. |
| 542 |
+ |
std::vector< std::unique_ptr<l1menu::ICachedTrigger> > cachedTriggers; |
| 543 |
|
for( size_t triggerNumber=0; triggerNumber<menu.numberOfTriggers(); ++triggerNumber ) |
| 544 |
|
{ |
| 545 |
< |
mutableMenu.getTrigger( triggerNumber ).initiateForReducedSample( *this ); |
| 545 |
> |
cachedTriggers.push_back( createCachedTrigger( menu.getTrigger( triggerNumber ) ) ); |
| 546 |
|
} |
| 547 |
|
|
| 548 |
|
for( size_t eventNumber=0; eventNumber<numberOfEvents(); ++eventNumber ) |
| 550 |
|
const l1menu::IEvent& event=getEvent(eventNumber); |
| 551 |
|
bool anyTriggerPassed=false; |
| 552 |
|
|
| 553 |
< |
for( size_t triggerNumber=0; triggerNumber<menu.numberOfTriggers(); ++triggerNumber ) |
| 553 |
> |
for( size_t triggerNumber=0; triggerNumber<cachedTriggers.size(); ++triggerNumber ) |
| 554 |
|
{ |
| 555 |
< |
if( event.passesTrigger( mutableMenu.getTrigger(triggerNumber) ) ) |
| 555 |
> |
if( cachedTriggers[triggerNumber]->apply(event) ) |
| 556 |
|
{ |
| 557 |
|
// If the event passes the trigger, increment the counter |
| 558 |
|
++numberOfEventsPassed[triggerNumber]; |
| 563 |
|
if( anyTriggerPassed ) ++numberOfEventsPassingAnyTrigger; |
| 564 |
|
} |
| 565 |
|
|
| 566 |
< |
::MenuRateImplementation* pRates=new ::MenuRateImplementation; |
| 566 |
> |
l1menu::implementation::MenuRateImplementation* pRates=new l1menu::implementation::MenuRateImplementation; |
| 567 |
|
// This is the value I want to return, but I still need access to the extended attributes of the subclass |
| 568 |
|
std::unique_ptr<const l1menu::IMenuRate> pReturnValue( pRates ); |
| 569 |
|
|
| 574 |
|
for( size_t triggerNumber=0; triggerNumber<numberOfEventsPassed.size(); ++triggerNumber ) |
| 575 |
|
{ |
| 576 |
|
float fraction=static_cast<float>(numberOfEventsPassed[triggerNumber])/static_cast<float>(numberOfEvents()); |
| 577 |
< |
pRates->addTriggerRate( mutableMenu.getTrigger(triggerNumber), fraction ); |
| 577 |
> |
pRates->addTriggerRate( menu.getTrigger(triggerNumber), fraction ); |
| 578 |
|
} |
| 579 |
|
|
| 580 |
|
return pReturnValue; |
