Example #1
0
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_);
	}
}
Example #4
0
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_);
	}

}
Example #5
0
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_);
	}
}
Example #6
0
/**
 * @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;
}
Example #7
0
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();
}
Example #9
0
// 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;
}
Example #10
0
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_);
	}
}
Example #11
0
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;
}
Example #13
0
inline void Simulator::dispatchEvent(EventPtr event)
{
	assert(event.get() != 0);
	SimTime fireTime = event->getFireTime();
	assert(m_clock <= fireTime);

	m_clock = fireTime;
	event->execute();
}
Example #14
0
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" );
	}
}
Example #16
0
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" );
	}
}
Example #20
0
/*!
 * 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" );
	}
}
Example #22
0
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);
	}
}
Example #24
0
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;
}
Example #25
0
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);				
			}
		}
	}
}
Example #26
0
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_);

	}
}
Example #28
0
void CEventLog::Remove(const EventPtr& eventPtr)
{
  if (eventPtr == nullptr)
    return;

  Remove(eventPtr->GetIdentifier());
}
Example #29
0
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;
}
Example #30
0
bool TopPairEMuReferenceSelection::passesMetCut(const EventPtr event) const {

	const METPointer met(event->MET());

	return met->pt() > 40;

}