inline EventPtr Simulator::getNextEvent() { EventPtr nextEvent (*m_eventPtrQueue.begin()); m_eventPtrQueue.erase(m_eventPtrQueue.begin()); nextEvent->setInEventQueue(false); return nextEvent; }
void JetAnalyser::analyse(const EventPtr event) { histMan_->setCurrentHistogramFolder(histogramFolder_); weight_ = event->weight() * prescale_ * scale_; const JetCollection jets = event->Jets(); unsigned int numberOfBJets(0); for (unsigned int index = 0; index < jets.size(); ++index) { const JetPointer jet(jets.at(index)); histMan_->H1D_BJetBinned("all_jet_pT")->Fill(jet->pt(), weight_); histMan_->H1D_BJetBinned("all_jet_phi")->Fill(jet->phi(), weight_); histMan_->H1D_BJetBinned("all_jet_eta")->Fill(jet->eta(), weight_); if (jet->isBJet(BtagAlgorithm::CombinedSecondaryVertex, BtagAlgorithm::MEDIUM)) ++numberOfBJets; if (index < 7) { stringstream temp; temp << "jet" << (index + 1); string nthJet = temp.str(); histMan_->H1D_BJetBinned(nthJet + "_pT")->Fill(jet->pt(), weight_); histMan_->H1D_BJetBinned(nthJet + "_phi")->Fill(jet->phi(), weight_); histMan_->H1D_BJetBinned(nthJet + "_eta")->Fill(jet->eta(), weight_); } } histMan_->H1D_BJetBinned("N_Jets")->Fill(jets.size(), weight_); histMan_->H1D("N_BJets")->Fill(numberOfBJets, weight_); }
void ElectronAnalyser::analyse(const EventPtr event) { histMan_->setCurrentHistogramFolder(histogramFolder_); weight_ = event->weight() * prescale_ * scale_; const ElectronCollection electrons = event->Electrons(); if (singleElectronOnly_) return; histMan_->H1D("Number_Of_Electrons")->Fill(electrons.size(), weight_); for (unsigned int index = 0; index < electrons.size(); ++index) { const ElectronPointer electron(electrons.at(index)); histMan_->H1D("All_Electron_Pt")->Fill(electron->pt(), weight_); histMan_->H1D("All_Electron_Eta")->Fill(electron->eta(), weight_); histMan_->H1D("All_Electron_AbsEta")->Fill(fabs(electron->eta()), weight_); histMan_->H1D("All_Electron_Phi")->Fill(electron->phi(), weight_); histMan_->H1D("All_Electron_pfIsolation_03_deltaBeta")->Fill(electron->PFRelIso03DeltaBeta(), weight_); histMan_->H1D("All_Electron_sigma_ietaieta")->Fill(electron->sigmaIEtaIEta(), weight_); histMan_->H1D("All_Electron_dPhi_in")->Fill(electron->dPhiIn(), weight_); histMan_->H1D("All_Electron_dEta_in")->Fill(electron->dEtaIn(), weight_); histMan_->H1D("All_Electron_HadOverEM")->Fill(electron->HadOverEm(), weight_); histMan_->H1D("All_Electron_mvaTrigV0")->Fill(electron->mvaTrigV0(), weight_); histMan_->H1D("All_Electron_mvaNonTrigV0")->Fill(electron->mvaNonTrigV0(), weight_); histMan_->H1D("All_Electron_dB")->Fill(electron->d0(), weight_); } }
void METAnalyser::analyse(const EventPtr event) { histMan_->setCurrentHistogramFolder(histogramFolder_); weight_ = event->weight() * prescale_ * scale_; for (unsigned index = 0; index < METAlgorithm::NUMBER_OF_METALGORITHMS; ++index) { std::string prefix = METAlgorithm::prefixes.at(index); METAlgorithm::value metType = (METAlgorithm::value) index; if (!MET::isAvailableInNTupleVersion(Globals::NTupleVersion, index)) continue; bool isMCOnlyMET = MET::isMCOnlyMETType(index); if (isMCOnlyMET && event->isRealData()) //these METs are MC only (Jet resolution systematics) continue; const METPointer met(event->MET(metType)); histMan_->setCurrentHistogramFolder(histogramFolder_ + "/" + prefix); histMan_->H1D_BJetBinned("MET")->Fill(met->et(), weight_); if (index != METAlgorithm::GenMET && !event->isRealData()) { histMan_->H2D_BJetBinned("RecoMET_vs_GenMET")->Fill(event->GenMET()->et(), met->et(), weight_); } //do not fill other histograms for met systematics if ((index > METAlgorithm::patType1p2CorrectedPFMet) && (index != METAlgorithm::recoMetPFlow)) continue; histMan_->H1D_BJetBinned("MET_phi")->Fill(met->phi(), weight_); histMan_->H1D_BJetBinned("METsignificance")->Fill(met->significance(), weight_); histMan_->H2D_BJetBinned("METsignificance_vs_MET")->Fill(met->et(), met->significance(), weight_); } }
void METAnalyser::analyseTransverseMass(const EventPtr event, const ParticlePointer particle) { histMan_->setCurrentHistogramFolder(histogramFolder_); weight_ = event->weight() * prescale_ * scale_; for (unsigned index = 0; index < METAlgorithm::NUMBER_OF_METALGORITHMS; ++index) { std::string prefix = METAlgorithm::prefixes.at(index); METAlgorithm::value metType = (METAlgorithm::value) index; if (!MET::isAvailableInNTupleVersion(Globals::NTupleVersion, index)) continue; if (MET::isMCOnlyMETType(index) && event->isRealData()) continue; //skip MC only METs for real data const METPointer met(event->MET(metType)); histMan_->setCurrentHistogramFolder(histogramFolder_ + "/" + prefix); //do not fill histograms for met systematics if (index > METAlgorithm::patType1p2CorrectedPFMet) continue; double MT = Event::MT(particle, met); double angle = met->angle(particle); double delPhi = met->deltaPhi(particle); histMan_->H1D_BJetBinned("Transverse_Mass")->Fill(MT, weight_); histMan_->H1D_BJetBinned("Angle_lepton_MET")->Fill(angle, weight_); histMan_->H1D_BJetBinned("DeltaPhi_lepton_MET")->Fill(delPhi, weight_); if (met->et() < 20) histMan_->H1D_BJetBinned("Transverse_Mass_MET20")->Fill(MT, weight_); } }
/** * @brief Video::convertToEvent * @param path * @return */ EventPtr Video::convertToEvent(std::string path){ cv::Mat shot; FramePtr frame; EventPtr event; unsigned int j=0; int framecount=0; double tmpPos = getFramePos(); setFramePos(0); emit startProgress(0, (uint) getLengthFrames()); while(getNextFrame(shot)){ emit progressChanged(j); if (event.isNull()){ event = EventPtr(new Event(this)); } // create new frame frame = FramePtr(new Frame(this, shot, path)); // add frame to event event->addFrame(frame); framecount ++; j++; } setFramePos(tmpPos); return event; }
Bool Connection::Send( EventPtr e ) { PacketStream ps; e->Pack( ps ); // Go through the ModifierStack, if required. if (GetState() == MODIFIED_LINE) { ModifierStack* modifier_stack = GetModifierStack(); if (modifier_stack != NULL && !ModifierSkipper::Instance().Has( e->GetEvent() ) ) { // Exclude packet length header void* buffer = ps.getPtr(); UInt32 encLength = ps.size(); if (modifier_stack->Modify(buffer, &encLength) == false) { // Error!!! return false; } } } // 공유 되므로 락 필요 { asio::detail::mutex::scoped_lock sl( m_sendLock ); m_accBuf->write( ps.size() ); m_accBuf->write( ps.getPtr(), ps.size() ); } return requestSend(); }
UUID SubgraphNode::addForwardingSlot(const UUID& internal_uuid, const TokenDataConstPtr& type, const std::string& label) { graph_->registerUUID(internal_uuid); EventPtr relay = createInternalEvent(type, internal_uuid, label); auto cb = [relay](const TokenConstPtr& data) { relay->triggerWith(std::make_shared<Token>(*data)); relay->message_processed(relay); }; Slot* external_slot = VariadicSlots::createVariadicSlot(type, label, cb, false, false); relay->message_processed.connect(std::bind(&Slot::notifyEventHandled, external_slot)); crossConnectLabelChange(external_slot, relay.get()); external_to_internal_events_[external_slot->getUUID()] = relay; relay_to_external_slot_[internal_uuid] = external_slot->getUUID(); forwarding_connector_added(relay); return external_slot->getUUID(); }
// Goes through the event queue and processes events for the given time. bool EventManager::tick(unsigned int maxMS) { unsigned int curTick = GetTickCount(); unsigned int maxTime = maxMS + curTick; bool processed = false; while (m_eventQueue.size() > 0) { EventPtr event = m_eventQueue.front(); m_eventQueue.pop_front(); EventType type = event->getType(); EventListenerMap::iterator itMap = m_listenerMap.find(type.getId()); if (itMap == m_listenerMap.end()) continue; EventListenerList theList = (*itMap).second; for (EventListenerList::iterator i = theList.begin(); i != theList.end(); i++) { if ((*i)->HandleEvent(*event)) break; } curTick = GetTickCount(); if (curTick >= maxTime) break; } return processed; }
void METAnalyser::analyse_ST(const EventPtr event, const ParticlePointer particle, const JetCollection jets) { histMan_->setCurrentHistogramFolder(histogramFolder_); weight_ = event->weight() * prescale_ * scale_; for (unsigned index = 0; index < METAlgorithm::NUMBER_OF_METALGORITHMS; ++index) { std::string prefix = METAlgorithm::prefixes.at(index); METAlgorithm::value metType = (METAlgorithm::value) index; if (!MET::isAvailableInNTupleVersion(Globals::NTupleVersion, index)) continue; bool isMCOnlyMET = MET::isMCOnlyMETType(index); if (isMCOnlyMET && event->isRealData()) //these METs are MC only (Jet resolution systematics) continue; const METPointer met(event->MET(metType)); float ST = Event::ST(jets, particle, met); float WPT = Event::WPT(particle, met); float MT = Event::MT(particle, met); histMan_->setCurrentHistogramFolder(histogramFolder_ + "/" + prefix); histMan_->H1D("ST")->Fill(ST, weight_); histMan_->H1D("WPT")->Fill(WPT, weight_); histMan_->H1D("MT")->Fill(MT, weight_); treeMan_->setCurrentFolder(histogramFolder_); treeMan_->Fill("ST",ST); treeMan_->Fill("WPT",WPT); treeMan_->Fill("MT",MT); histMan_->H2D("HT_vs_MET_plus_leptonPt")->Fill(particle->pt() + met->et(), Event::HT(jets), weight_); } }
void TTbar_plus_X_analyser::fillLeptonEfficiencyCorrectionBranches( const EventPtr event, const unsigned int selectionCriteria, const LeptonPointer signalLepton ) { SelectionCriteria::selection selection = SelectionCriteria::selection(selectionCriteria); if ( selection == SelectionCriteria::ElectronPlusJetsReference ) { double electronEfficiencyCorrection = 1, electronEfficiencyCorrection_down = 1, electronEfficiencyCorrection_up = 1; if ( !event->isRealData() ) { const ElectronPointer signalElectron(boost::static_pointer_cast<Electron>(signalLepton)); electronEfficiencyCorrection = signalElectron->getEfficiencyCorrection( 0 ); electronEfficiencyCorrection_down = signalElectron->getEfficiencyCorrection( -1 ); electronEfficiencyCorrection_up = signalElectron->getEfficiencyCorrection( 1 ); } treeMan_->Fill("ElectronEfficiencyCorrection",electronEfficiencyCorrection); treeMan_->Fill("ElectronUp",electronEfficiencyCorrection_up); treeMan_->Fill("ElectronDown",electronEfficiencyCorrection_down); } else if ( selection == SelectionCriteria::MuonPlusJetsReference ) { double muonEfficiencyCorrection = 1, muonEfficiencyCorrection_down = 1, muonEfficiencyCorrection_up = 1; if ( !event->isRealData() ) { const MuonPointer signalMuon(boost::static_pointer_cast<Muon>(signalLepton)); muonEfficiencyCorrection = signalMuon->getEfficiencyCorrection( 0 ); muonEfficiencyCorrection_down = signalMuon->getEfficiencyCorrection( -1 ); muonEfficiencyCorrection_up = signalMuon->getEfficiencyCorrection( 1 ); } treeMan_->Fill("MuonEfficiencyCorrection",muonEfficiencyCorrection); treeMan_->Fill("MuonUp",muonEfficiencyCorrection_up); treeMan_->Fill("MuonDown",muonEfficiencyCorrection_down); } }
bool EventManager::processEvents(Time max_process_time) { Time curr_time = g_app->getCurrentTime(); Time max_time = curr_time + max_process_time; // swap active queues and clear the new queue after the swap int queueToProcess = m_active_queue; m_active_queue = (m_active_queue + 1) % EVENTMANAGER_NUM_QUEUES; m_queues[m_active_queue].clear(); // Process the queue while (!m_queues[queueToProcess].empty()) { // pop the front of the queue EventPtr event = m_queues[queueToProcess].front(); m_queues[queueToProcess].pop_front(); cout<<"Send event \""<<event->getName()<<"\""<<endl; // find all the delegate functions registered for this event auto findIt = m_event_listeners.find(typeid(*event)); if (findIt != m_event_listeners.end()) { const EventListenerList& eventListeners = findIt->second; // call each listener for (auto it = eventListeners.begin(); it != eventListeners.end();++it) { EventListenerFunction event_function = (*it); if (event_function.getOwner() != event->getSender()) event_function.execute(event); } } // check to see if time ran out curr_time = g_app->getCurrentTime(); if (curr_time >= max_time) { cout<<"EventLoop: Aborting event processing; time ran out. Already "<<(curr_time-max_time).asMilliseconds()<<"ms too long."<<endl; break; } } // If we couldn’t process all of the events, push the remaining events to // the new active queue. // Note: To preserve sequencing, go back-to-front, inserting them at the // head of the active queue. bool queueFlushed = (m_queues[queueToProcess].empty()); if (!queueFlushed) { while (!m_queues[queueToProcess].empty()) { EventPtr event = m_queues[queueToProcess].back(); m_queues[queueToProcess].pop_back(); m_queues[m_active_queue].push_front(event); } } return queueFlushed; }
inline void Simulator::dispatchEvent(EventPtr event) { assert(event.get() != 0); SimTime fireTime = event->getFireTime(); assert(m_clock <= fireTime); m_clock = fireTime; event->execute(); }
void* EventProcesseor(void* unused) { while (true) { EventPtr event; // fetch a event from event queue and handle with it EventQueue::Instance()->PopFront(&event); event->Handle(); } return NULL; }
void TTbar_plus_X_analyser::ePlusJetsQcdAnalysis(const EventPtr event) { if ( event->PassesElectronTriggerAndQCDSelection() ) { fillCommonTrees( event, SelectionCriteria::ElectronPlusJetsQCDNonIsolated, histogramFolder_ + "/EPlusJets/QCD non iso e+jets" ); } if ( event->PassesElectronTriggerAndConversionSelection() ) { fillCommonTrees( event, SelectionCriteria::ElectronPlusJetsQCDConversion, histogramFolder_ + "/EPlusJets/QCDConversions" ); } }
void EventRecorder::handle(EventPtr theEvent) { if (_myMode == RECORD && filterEvent(theEvent) == false) { EventPtr myEvent = theEvent->copy(); myEvent->when = asl::Time() - _myStartTime; DB(AC_TRACE << "push node=" << *myEvent->asNode()); _myEvents.push_back(myEvent); } }
void MockEventHandler(EventPtr& e, const ExpectedTerms& expected_terms) { if (m_num_events_validated > 0) return; BOOST_REQUIRE(! e->empty()); for (ExpectedTerms::const_iterator i = expected_terms.begin(); i != expected_terms.end(); ++i) BOOST_CHECK_EQUAL(e->getString(i->first), i->second); ++m_num_events_validated; }
void TTbar_plus_X_analyser::muPlusJetsQcdAnalysis(const EventPtr event) { //selection with respect to reference selection if ( event->PassesMuonTriggerAndQCDSelection1p5to3() ) { fillCommonTrees( event, SelectionCriteria::MuonPlusJetsQCDNonIsolated1p5to3, histogramFolder_ + "/MuPlusJets/QCD non iso mu+jets 1p5to3" ); } if ( event->PassesMuonTriggerAndQCDSelection3toInf() ) { fillCommonTrees( event, SelectionCriteria::MuonPlusJetsQCDNonIsolated3toInf, histogramFolder_ + "/MuPlusJets/QCD non iso mu+jets 3toInf" ); } }
void TTbar_plus_X_analyser::muPlusJetsSignalAnalysis(const EventPtr event) { if ( event->PassesMuonTriggerAndSelectionNoB() ){ BTagEffAnalyserMuPlusJetsRefSelection_->analyse(event); fillCommonTreesNoBSelection( event, SelectionCriteria::MuonPlusJetsReference, histogramFolder_ + "/MuPlusJets/Ref selection NoBSelection" ); } if ( event->PassesMuonTriggerAndSelection() ) { fillCommonTrees( event, SelectionCriteria::MuonPlusJetsReference, histogramFolder_ + "/MuPlusJets/Ref selection" ); } }
/*! * Method called by Application::handleMessage if object already exists. */ void VsMagnitude::updateObject(const string &parentID, Object *obj) { EventPtr event = Event::Cast(obj); if ( event ) { SEISCOMP_DEBUG("Event updated"); // Get the already cached event instance and not the temporary instance // in the message event = _cache.get<Event>(event->publicID()); handleEvent(event.get()); return; } }
void TTbar_plus_X_analyser::ePlusJetsSignalAnalysis(const EventPtr event) { if ( event->PassesElectronTriggerAndSelectionNoB() ){ BTagEffAnalyserEPlusJetsRefSelection_->analyse(event); fillCommonTreesNoBSelection( event, SelectionCriteria::ElectronPlusJetsReference, histogramFolder_ + "/EPlusJets/Ref selection NoBSelection" ); } if ( event->PassesElectronTriggerAndSelection() ) { // Fill branches that are common amongst all regions fillCommonTrees( event, SelectionCriteria::ElectronPlusJetsReference, histogramFolder_ + "/EPlusJets/Ref selection" ); } }
bool EventComparator::operator() (EventPtr& evt1, EventPtr& evt2) { if (!evt1.get()) return true; if (!evt2.get()) return false; // The more or less standard definition for a priority queue // assigns more priority to values with lower numbers. // However, the STL implementation does the opposite. // To stick with the more familiar convention, the comparison operator // used for this method is > instead of <, so that the queue ordering // gets reversed. return evt1->getPriority()>evt2->getPriority(); }
bool TopPairMuPlusJetsReferenceSelection2011::passesTriggerSelection(const EventPtr event) const { unsigned int runNumber(event->runnumber()); if (event->isRealData()) { if (runNumber >= 160404 && runNumber < 173236) return event->HLT(HLTriggers::HLT_IsoMu24); else if (runNumber >= 173236) return event->HLT(HLTriggers::HLT_IsoMu24_eta2p1); else return false; } else { //Fall11 MC return event->HLT(HLTriggers::HLT_IsoMu24); } }
bool Map::doProcessOneEvent() { commandQueue_.runCommands(); // search next event while (nowItr_->second->empty()) { if (events_.size() == 1) { // No more events left! return false; } else { delete events_.begin()->second; events_.erase(events_.begin()); } nowItr_ = events_.begin(); } assure(!nowItr_->second->empty(), "There MUST be events!"); // get next event EventPtr nextEvent = nowItr_->second->front(); wns::simulator::Time newTime = nextEvent->getScheduled(); // run until all now events are processed if (simTime_ < newTime) { if(stop_) { return false; } onNewSimTime(newTime); } simTime_ = newTime; nextEvent->state_ = Event::Running; (*nextEvent)(); nextEvent->state_ = Event::Finished; // remove the event nowItr_->second->pop_front(); return true; }
void EventManager::dispatchEvents() { while(!mEventQueue.empty()) { EventPtr evt = removeEvent(); TEventType type=evt->getEventType(); if (mEventHandlers.count(type)) { for (TEventHandlerList::iterator it = mEventHandlers[type].begin();it!=mEventHandlers[type].end();++it) { (*it)->handleEvent(evt); } } } }
void CEventLog::Remove(const EventPtr& eventPtr) { if (eventPtr == nullptr || eventPtr->GetIdentifier().empty()) return; CSingleLock lock(m_critical); const auto& itEvent = m_eventsMap.find(eventPtr->GetIdentifier()); if (itEvent == m_eventsMap.end()) return; m_eventsMap.erase(itEvent); std::remove_if(m_events.begin(), m_events.end(), [eventPtr](const EventPtr& otherEvent) { return eventPtr == otherEvent; }); SendMessage(eventPtr, GUI_MSG_EVENT_REMOVED); }
void DiElectronAnalyser::analyse(const EventPtr event, const ElectronCollection electrons) { histMan_->setCurrentHistogramFolder(histogramFolder_); weight_ = event->weight() * prescale_ * scale_; if (electrons.size() == 2) { ElectronPointer leadingElectron = electrons.front(); ElectronPointer secondElectron = electrons.at(1); //both histMan_->H1D_BJetBinned("diLepton_Mass")->Fill(leadingElectron->invariantMass(secondElectron), weight_); histMan_->H1D_BJetBinned("diLepton_DeltaR")->Fill(leadingElectron->deltaR(secondElectron), weight_); //lead histMan_->H1D_BJetBinned("LeadLepton_Pt")->Fill(leadingElectron->pt(), weight_); histMan_->H1D_BJetBinned("LeadLepton_Eta")->Fill(leadingElectron->eta(), weight_); histMan_->H1D_BJetBinned("LeadLepton_AbsEta")->Fill(abs(leadingElectron->eta()), weight_); histMan_->H1D_BJetBinned("LeadLepton_Phi")->Fill(leadingElectron->phi(), weight_); histMan_->H1D_BJetBinned("LeadLepton_RelIso")->Fill(leadingElectron->pfRelativeIsolationRhoCorrected(), weight_); histMan_->H1D_BJetBinned("LeadLepton_HadOverEM")->Fill(leadingElectron->HadOverEm(), weight_); histMan_->H1D_BJetBinned("LeadLepton_dB")->Fill(leadingElectron->d0_wrtBeamSpot(), weight_); //second histMan_->H1D_BJetBinned("SecondLepton_Pt")->Fill(secondElectron->pt(), weight_); histMan_->H1D_BJetBinned("SecondLepton_Eta")->Fill(secondElectron->eta(), weight_); histMan_->H1D_BJetBinned("SecondLepton_AbsEta")->Fill(abs(secondElectron->eta()), weight_); histMan_->H1D_BJetBinned("SecondLepton_Phi")->Fill(secondElectron->phi(), weight_); histMan_->H1D_BJetBinned("SecondLepton_RelIso")->Fill(secondElectron->pfRelativeIsolationRhoCorrected(), weight_); histMan_->H1D_BJetBinned("SecondLepton_HadOverEM")->Fill(secondElectron->HadOverEm(), weight_); histMan_->H1D_BJetBinned("SecondLepton_dB")->Fill(secondElectron->d0_wrtBeamSpot(), weight_); } }
void CEventLog::Remove(const EventPtr& eventPtr) { if (eventPtr == nullptr) return; Remove(eventPtr->GetIdentifier()); }
inline bool Simulator::cancelEvent(EventPtr eventToCancel) { assert(eventToCancel != 0); // Get the range of elements that match this key (i.e., // have the same fire time). pair<EventPtrQueueIterator,EventPtrQueueIterator> keyIteratorPair = m_eventPtrQueue.equal_range(eventToCancel); bool didErase = false; // If the key was not found, pair.first == pair.second for(EventPtrQueueIterator keyIterator = keyIteratorPair.first; keyIterator != keyIteratorPair.second; ++keyIterator) { // If we iterator finds the pointer we want to delete, // then erase the element and return. if(*keyIterator == eventToCancel) { m_eventPtrQueue.erase(keyIterator); eventToCancel->setInEventQueue(false); didErase = true; break; } } return didErase; }
bool TopPairEMuReferenceSelection::passesMetCut(const EventPtr event) const { const METPointer met(event->MET()); return met->pt() > 40; }