ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/OSUT3Analysis/AnaTools/plugins/OSUAnalysis.cc

Comparing UserCode/OSUT3Analysis/AnaTools/plugins/OSUAnalysis.cc (file contents):
Revision 1.105 by wulsin, Mon Jul 22 16:33:25 2013 UTC vs.
Revision 1.112 by wulsin, Thu Jul 25 12:28:54 2013 UTC

#	Line 38 | Line 38 | OSUAnalysis::OSUAnalysis (const edm::Par
38		printAllTriggers_    (cfg.getParameter<bool> ("printAllTriggers")),
39		useTrackCaloRhoCorr_ (cfg.getParameter<bool> ("useTrackCaloRhoCorr")),
40		stopCTau_ (cfg.getParameter<vector<double> > ("stopCTau")),
41	<	GetPlotsAfterEachCut_ (cfg.getParameter<bool> ("GetPlotsAfterEachCut"))
41	>	GetPlotsAfterEachCut_ (cfg.getParameter<bool> ("GetPlotsAfterEachCut")),
42	>	verbose_ (cfg.getParameter<int> ("verbose"))
43		{
44
45	<	TH1::SetDefaultSumw2 ();
45	>	if (verbose_) printEventInfo_ = true;
46	>	if (verbose_) clog << "Beginning OSUAnalysis::OSUAnalysis constructor." << endl;
47	>
48	>	TH1::SetDefaultSumw2();
49
50		//create pile-up reweighting object, if necessary
51		if(datasetType_ != "data") {
#	Line 55 | Line 59 | OSUAnalysis::OSUAnalysis (const edm::Par
59		}
60		}
61		if (datasetType_ == "signalMC" && regex_match (dataset_, regex ("stop.*to.*_.*mm.*")))
62	<	stopCTauWeight_ = new StopCTauWeight (stopCTau_.at (0), stopCTau_.at (1), stops_);
62	>	stopCTauWeight_ = new StopCTauWeight (stopCTau_.at(0), stopCTau_.at(1), stops_);
63
64
65		// Construct Cutflow Objects. These store the results of cut decisions and
#	Line 91 | Line 95 | OSUAnalysis::OSUAnalysis (const edm::Par
95		TString newName = TString(br.inputCollection) + "_" + TString(br.inputVariable);
96		br.name = string(newName.Data());
97		treeBranches_.push_back(br);
98	+	if (verbose_>3) clog << "   Adding branch to BNTree: " << br.name << endl;
99		}
100
101		} // end   for (uint iBranchSet = 0; iBranchSet<treeBranchSets_.size(); iBranchSet++)
#	Line 145 | Line 150 | OSUAnalysis::OSUAnalysis (const edm::Par
150		objectsToGet.push_back(obj1);
151		objectsToGet.push_back(obj2ToGet);
152		} // end else
153	<	if (find(objectsToPlot.begin(), objectsToPlot.end(), "events") != objectsToPlot.end())
154	<	objectsToGet.push_back("jets");
155	<
156	<
153	>	if (find(objectsToPlot.begin(), objectsToPlot.end(), "events") != objectsToPlot.end())
154	>	objectsToGet.push_back("jets");
155	>
156	>
157		vector<edm::ParameterSet> histogramList_  (histogramSets_.at(currentHistogramSet).getParameter<vector<edm::ParameterSet> >("histograms"));
158
159		for(uint currentHistogram = 0; currentHistogram != histogramList_.size(); currentHistogram++){
#	Line 251 | Line 256 | OSUAnalysis::OSUAnalysis (const edm::Par
256		string channelName  (channels_.at(currentChannel).getParameter<string>("name"));
257		tempChannel.name = channelName;
258		TString channelLabel = channelName;
259	+	if (verbose_) clog << "Processing channel:  " << channelName << endl;
260
261		//set triggers for this channel
262		vector<string> triggerNames;
#	Line 401 | Line 407 | OSUAnalysis::OSUAnalysis (const edm::Par
407		}
408		subSubDirNames.push_back(subSubDirName);
409		tempCut.name = tempCutName;
410	+	if (verbose_) clog << "Setting up cut, index: " << currentCut << ", input collection: " << tempInputCollection<< ", name: " << tempCut.name << endl;
411
412		tempChannel.cuts.push_back(tempCut);
413
#	Line 441 | Line 448 | OSUAnalysis::OSUAnalysis (const edm::Par
448		for(uint currentDir = 0; !useEDMFormat_ && currentDir != treeDirectories.size(); currentDir++){
449		TTree* newTree = treeDirectories.at(currentDir).make<TTree> (TString("BNTree_"+channelLabel), TString("BNTree_"+channelLabel));
450		BNTrees_.push_back(newTree);
451	+	BNTrees_.back()->Branch("event_runInt",  &BNTreeBranchVals_runInt_,  "event_runInt/I");
452	+	BNTrees_.back()->Branch("event_lumiInt", &BNTreeBranchVals_lumiInt_, "event_lumiInt/I");
453	+	BNTrees_.back()->Branch("event_evtLong", &BNTreeBranchVals_evtLong_, "event_evtLong/L");
454		for (uint iBranch = 0; iBranch < treeBranches_.size(); iBranch++){
455		BranchSpecs currentVar = treeBranches_.at(iBranch);
456		vector<float> newVec;
#	Line 618 | Line 628 | OSUAnalysis::OSUAnalysis (const edm::Par
628		else
629		oneDHists_.at(currentChannel).at(currentDir)[histoName] = directories.at(currentDir).make<TH1D> (TString(histoName),channelLabel+" channel: Number of Selected "+currentObject+"; # "+currentObject, maxNum, 0, maxNum);
630		}
631	+
632	+	if (verbose_) {
633	+	clog << "List of 1D histograms booked for channel " << channelName << " and directory " << currentDir << ":" << endl;
634	+	for(map<string, TH1D*>::iterator
635	+	iter = oneDHists_.at(currentChannel).at(currentDir).begin();
636	+	iter  != oneDHists_.at(currentChannel).at(currentDir).end();
637	+	iter++) {
638	+	clog << " " << iter->first
639	+	<< ":  name=" << iter->second->GetName()
640	+	<< ", title=" << iter->second->GetTitle()
641	+	<< ", bins=(" << iter->second->GetNbinsX()
642	+	<< "," << iter->second->GetXaxis()->GetXmin()
643	+	<< "," << iter->second->GetXaxis()->GetXmax()
644	+	<< ")" << endl;
645	+	}
646	+	clog << "List of 2D histograms booked for channel " << channelName << " and directory " << currentDir << ":" << endl;
647	+	for(map<string, TH2D*>::iterator
648	+	iter = twoDHists_.at(currentChannel).at(currentDir).begin();
649	+	iter  != twoDHists_.at(currentChannel).at(currentDir).end();
650	+	iter++) {
651	+	clog << " " << iter->first
652	+	<< ":  name=" << iter->second->GetName()
653	+	<< ", title=" << iter->second->GetTitle()
654	+	<< ", binsX=(" << iter->second->GetNbinsX()
655	+	<< "," << iter->second->GetXaxis()->GetXmin()
656	+	<< "," << iter->second->GetXaxis()->GetXmax()
657	+	<< ")"
658	+	<< ", binsY=(" << iter->second->GetNbinsY()
659	+	<< "," << iter->second->GetYaxis()->GetXmin()
660	+	<< "," << iter->second->GetYaxis()->GetXmax()
661	+	<< ")"
662	+	<< endl;
663	+	}
664	+	}
665	+
666		}//end of loop over directories
667		channels.push_back(tempChannel);
668		tempChannel.cuts.clear();
669		}//end loop over channels
670
671
672	+	// Create the cutflow histogram and fill with 0 weight, in case no events are found in the input file.
673	+	for(uint currentChannelIndex = 0; currentChannelIndex != channels.size(); currentChannelIndex++){
674	+	channel currentChannel = channels.at(currentChannelIndex);
675	+	if(currentChannel.triggers.size() != 0 || currentChannel.triggersToVeto.size() != 0){  //triggers specified
676	+	cutFlows_.at(currentChannelIndex)->at("trigger") = true;
677	+	}
678	+	for(uint currentCutIndex = 0; currentCutIndex != currentChannel.cuts.size(); currentCutIndex++){
679	+	cut currentCut = currentChannel.cuts.at(currentCutIndex);
680	+	cutFlows_.at(currentChannelIndex)->at (currentCut.name) = true;
681	+	}
682	+	cutFlows_.at(currentChannelIndex)->fillCutFlow(0);  // fill cutflow with 0 weight, just to create the cutflow histograms
683	+	}
684	+
685		//make unique vector of objects we need to get from the event
686		sort( objectsToGet.begin(), objectsToGet.end() );
687		objectsToGet.erase( unique( objectsToGet.begin(), objectsToGet.end() ), objectsToGet.end() );
#	Line 634 | Line 692 | OSUAnalysis::OSUAnalysis (const edm::Par
692		sort( objectsToFlag.begin(), objectsToFlag.end() );
693		objectsToFlag.erase( unique( objectsToFlag.begin(), objectsToFlag.end() ), objectsToFlag.end() );
694
695	+	// Move all paired objects to the end of the list, so that the flags for single objects are always set before those of paired objects.
696	+	for (uint i=0; i<objectsToFlag.size(); i++) {
697	+	if (objectsToFlag.at(i).find("pairs")!=string::npos) { // if it contains "pairs"
698	+	objectsToFlag.push_back(objectsToFlag.at(i));
699	+	objectsToFlag.erase(objectsToFlag.begin()+i);
700	+	}
701	+	}
702	+
703	+	if (verbose_) {
704	+	clog << "List of channels:" << endl;
705	+	for (uint i=0; i<channels.size(); i++) {
706	+	clog << " " << channels.at(i).name << endl;
707	+	}
708	+	clog << "List of objects to get:" << endl;
709	+	for (uint i=0; i<objectsToGet.size(); i++) {
710	+	clog << " " << objectsToGet.at(i) << endl;
711	+	}
712	+	clog << "List of objects to plot:" << endl;
713	+	for (uint i=0; i<objectsToPlot.size(); i++) {
714	+	clog << " " << objectsToPlot.at(i) << endl;
715	+	}
716	+	clog << "List of objects to cut:" << endl;
717	+	for (uint i=0; i<objectsToCut.size(); i++) {
718	+	clog << " " << objectsToCut.at(i) << endl;
719	+	}
720	+	clog << "List of objects to flag:" << endl;
721	+	for (uint i=0; i<objectsToFlag.size(); i++) {
722	+	clog << " " << objectsToFlag.at(i) << endl;
723	+	}
724	+	}
725	+
726		produces<map<string, bool> > ("channelDecisions");
727
728		if (printEventInfo_) {
729		findEventsLog = new ofstream();
730		findEventsLog->open("findEvents.txt");
731		clog << "Listing run:lumi:event in file findEvents.txt for events that pass full selection (of any channel)." << endl;
732	<	}
732	>	} else {
733	>	findEventsLog = 0;
734	>	}
735
736		isFirstEvent_ = true;
737
738	<	} // end constructor OSUAnalysis::OSUAnalysis()
738	>	if (verbose_) clog << "Finished OSUAnalysis::OSUAnalysis constructor." << endl;
739	>
740	>
741	>	} // end constructor OSUAnalysis::OSUAnalysis()
742
743
744		OSUAnalysis::~OSUAnalysis ()
745		{
746
747	+	if (verbose_) clog << "Beginning OSUAnalysis::OSUAnalysis destructor." << endl;
748	+
749		// Destroying the CutFlow objects causes the cut flow numbers and time
750		// information to be printed to standard output.
751		for(uint currentChannel = 0; currentChannel != channels_.size(); currentChannel++){
#	Line 662 | Line 758 | OSUAnalysis::~OSUAnalysis ()
758		clog << "Successfully completed OSUAnalysis." << endl;
759		clog << "=============================================" << endl;
760
761	+	if (verbose_) clog << "Finished OSUAnalysis::OSUAnalysis destructor." << endl;
762	+
763		}
764
765		void
#	Line 669 | Line 767 | OSUAnalysis::produce (edm::Event &event,
767		{
768		// Retrieve necessary collections from the event.
769
770	+	if (verbose_) clog << "Beginning OSUAnalysis::produce." << endl;
771	+
772		if (find(objectsToGet.begin(), objectsToGet.end(), "triggers") != objectsToGet.end())
773		event.getByLabel (triggers_, triggers);
774
#	Line 746 | Line 846 | OSUAnalysis::produce (edm::Event &event,
846		auto_ptr<map<string, bool> > channelDecisions (new map<string, bool>);
847		for(uint currentChannelIndex = 0; currentChannelIndex != channels.size(); currentChannelIndex++){
848		channel currentChannel = channels.at(currentChannelIndex);
849	+	if (verbose_>1) clog << " Processing channel " << currentChannel.name << endl;
850
851		flagMap individualFlags;
852		counterMap passingCounter;
#	Line 765 | Line 866 | OSUAnalysis::produce (edm::Event &event,
866		//loop over all cuts
867		for(uint currentCutIndex = 0; currentCutIndex != currentChannel.cuts.size(); currentCutIndex++){
868		cut currentCut = currentChannel.cuts.at(currentCutIndex);
869	+	if (verbose_>2) clog << "  Processing cut, index: " << currentCutIndex << ", input collection: " << currentCut.inputCollection << ", name: " << currentCut.name << endl;
870
871		for(uint currentObjectIndex = 0; currentObjectIndex != objectsToFlag.size(); currentObjectIndex++){
872		string currentObject = objectsToFlag.at(currentObjectIndex);
#	Line 776 | Line 878 | OSUAnalysis::produce (edm::Event &event,
878		}
879
880		//set flags for all relevant objects
881	<	for(uint currentObjectIndex = 0; currentObjectIndex != objectsToFlag.size(); currentObjectIndex++){
882	<	string currentObject = objectsToFlag.at(currentObjectIndex);
883	<
884	<	int flagsForPairCutsIndex = max(int(currentCutIndex-1),0);
885	<
886	<
887	<	if     (currentObject == "jets")            setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,jets.product(),"jets");
888	<	else if(currentObject == "secondary jets")  setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,jets.product(),"secondary jets");
889	<	else if(currentObject == "secondary photons")  setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,photons.product(),"secondary photons");
890	<	else if(currentObject == "muons")           setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),"muons");
891	<	else if(currentObject == "secondary muons") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),"secondary muons");
881	>	for(int currentObjectIndex = -1; currentObjectIndex != int(objectsToFlag.size()); currentObjectIndex++){
882	>	string currentObject;
883	>	if (currentObjectIndex < 0) currentObject = currentCut.inputCollection;  // In the first loop, set the flags for the collection that the cut is acting on.  That way other paired collections can access the correct flag for the current cut.
884	>	else currentObject = objectsToFlag.at(currentObjectIndex);
885	>	if (currentObjectIndex >= 0 && currentObject == currentCut.inputCollection) continue;  // Flags have already been set for the inputCollection object, so should not be set again.
886	>
887	>	// single object collections
888	>	if     (currentObject == "jets")                setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,jets.product(),"jets");
889	>	else if(currentObject == "secondary jets")      setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,jets.product(),"secondary jets");
890	>	else if(currentObject == "secondary photons")   setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,photons.product(),"secondary photons");
891	>	else if(currentObject == "muons")               setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),"muons");
892	>	else if(currentObject == "secondary muons")     setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),"secondary muons");
893		else if(currentObject == "secondary electrons") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),"secondary electrons");
894	<	else if(currentObject == "electrons") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),"electrons");
895	<	else if(currentObject == "events") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,events.product(),"events");
896	<	else if(currentObject == "taus") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,taus.product(),"taus");
897	<	else if(currentObject == "mets") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,mets.product(),"mets");
898	<	else if(currentObject == "tracks") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,tracks.product(),"tracks");
899	<	else if(currentObject == "genjets") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,genjets.product(),"genjets");
900	<	else if(currentObject == "mcparticles") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,mcparticles.product(),"mcparticles");
901	<	else if(currentObject == "primaryvertexs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,primaryvertexs.product(),"primaryvertexs");
902	<	else if(currentObject == "bxlumis") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,bxlumis.product(),"bxlumis");
903	<	else if(currentObject == "photons") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,photons.product(),"photons");
904	<	else if(currentObject == "superclusters") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,superclusters.product(),"superclusters");
905	<	else if(currentObject == "trigobjs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,trigobjs.product(),"trigobjs");
906	<
907	<
908	<
909	<	else if(currentObject == "muon-muon pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),muons.product(), \
910	<	cumulativeFlags.at("muons").at(flagsForPairCutsIndex), \
911	<	cumulativeFlags.at("muons").at(flagsForPairCutsIndex), \
912	<	"muon-muon pairs");
913	<
914	<	else if(currentObject == "muon-secondary muon pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),muons.product(), \
915	<	cumulativeFlags.at("muons").at(flagsForPairCutsIndex), \
916	<	cumulativeFlags.at("secondary muons").at(flagsForPairCutsIndex), \
917	<	"muon-secondary muon pairs");
918	<
919	<	else if(currentObject == "muon-secondary photon pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),photons.product(), \
920	<	cumulativeFlags.at("muons").at(flagsForPairCutsIndex), \
921	<	cumulativeFlags.at("secondary photons").at(flagsForPairCutsIndex), \
922	<	"muon-secondary photon pairs");
923	<	else if(currentObject == "muon-secondary jet pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),jets.product(), \
924	<	cumulativeFlags.at("muons").at(flagsForPairCutsIndex), \
925	<	cumulativeFlags.at("secondary jets").at(flagsForPairCutsIndex), \
926	<	"muon-secondary jet pairs");
927	<	else if(currentObject == "photon-secondary jet pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,photons.product(),jets.product(), \
928	<	cumulativeFlags.at("photons").at(flagsForPairCutsIndex), \
929	<	cumulativeFlags.at("secondary jets").at(flagsForPairCutsIndex), \
930	<	"photon-secondary jet pairs");
931	<
932	<	else if(currentObject == "electron-secondary jet pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),jets.product(), \
933	<	cumulativeFlags.at("electrons").at(flagsForPairCutsIndex), \
934	<	cumulativeFlags.at("secondary jets").at(flagsForPairCutsIndex), \
935	<	"electron-secondary jet pairs");
936	<
937	<	else if(currentObject == "electron-secondary electron pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),electrons.product(), \
835	<	cumulativeFlags.at("electrons").at(flagsForPairCutsIndex), \
836	<	cumulativeFlags.at("secondary electrons").at(flagsForPairCutsIndex), \
837	<	"electron-secondary electron pairs");
838	<
839	<	else if(currentObject == "electron-electron pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),electrons.product(), \
840	<	cumulativeFlags.at("electrons").at(flagsForPairCutsIndex), \
841	<	cumulativeFlags.at("electrons").at(flagsForPairCutsIndex), \
842	<	"electron-electron pairs");
843	<	else if(currentObject == "electron-muon pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),muons.product(), \
844	<	cumulativeFlags.at("electrons").at(flagsForPairCutsIndex), \
845	<	cumulativeFlags.at("muons").at(flagsForPairCutsIndex), \
846	<	"electron-muon pairs");
847	<	else if(currentObject == "jet-jet pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,jets.product(),jets.product(), \
848	<	cumulativeFlags.at("jets").at(flagsForPairCutsIndex), \
849	<	cumulativeFlags.at("jets").at(flagsForPairCutsIndex), \
850	<	"jet-jet pairs");
851	<	else if(currentObject == "jet-secondary jet pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,jets.product(),jets.product(), \
852	<	cumulativeFlags.at("jets").at(flagsForPairCutsIndex), \
853	<	cumulativeFlags.at("secondary jets").at(flagsForPairCutsIndex),\
854	<	"jet-secondary jet pairs");
855	<	else if(currentObject == "electron-jet pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),jets.product(), \
856	<	cumulativeFlags.at("electrons").at(flagsForPairCutsIndex), \
857	<	cumulativeFlags.at("jets").at(flagsForPairCutsIndex), \
858	<	"electron-jet pairs");
859	<	else if(currentObject == "electron-photon pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),photons.product(), \
860	<	cumulativeFlags.at("electrons").at(flagsForPairCutsIndex), \
861	<	cumulativeFlags.at("photons").at(flagsForPairCutsIndex), \
862	<	"electron-photon pairs");
863	<	else if(currentObject == "photon-jet pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,photons.product(),jets.product(), \
864	<	cumulativeFlags.at("photons").at(flagsForPairCutsIndex), \
865	<	cumulativeFlags.at("jets").at(flagsForPairCutsIndex), \
866	<	"photon-jet pairs");
867	<	else if(currentObject == "muon-jet pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),jets.product(), \
868	<	cumulativeFlags.at("muons").at(flagsForPairCutsIndex), \
869	<	cumulativeFlags.at("jets").at(flagsForPairCutsIndex), \
870	<	"muon-jet pairs");
871	<	else if(currentObject == "muon-event pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),events.product(), \
872	<	cumulativeFlags.at("muons").at(flagsForPairCutsIndex), \
873	<	cumulativeFlags.at("events").at(flagsForPairCutsIndex), \
874	<	"muon-event pairs");
875	<	else if(currentObject == "met-jet pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,mets.product(),jets.product(), \
876	<	cumulativeFlags.at("mets").at(flagsForPairCutsIndex), \
877	<	cumulativeFlags.at("jets").at(flagsForPairCutsIndex), \
878	<	"met-jet pairs");
879	<	else if(currentObject == "track-jet pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,tracks.product(),jets.product(), \
880	<	cumulativeFlags.at("tracks").at(flagsForPairCutsIndex), \
881	<	cumulativeFlags.at("jets").at(flagsForPairCutsIndex), \
882	<	"track-jet pairs");
883	<	else if(currentObject == "muon-photon pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),photons.product(), \
884	<	cumulativeFlags.at("muons").at(flagsForPairCutsIndex), \
885	<	cumulativeFlags.at("photons").at(flagsForPairCutsIndex), \
886	<	"muon-photon pairs");
887	<	else if(currentObject == "track-event pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,tracks.product(),events.product(),
888	<	cumulativeFlags.at("tracks").at(flagsForPairCutsIndex),
889	<	cumulativeFlags.at("events").at(flagsForPairCutsIndex),
890	<	"track-event pairs");
891	<	else if(currentObject == "electron-track pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),tracks.product(),
892	<	cumulativeFlags.at("electrons").at(flagsForPairCutsIndex),
893	<	cumulativeFlags.at("tracks").at(flagsForPairCutsIndex),
894	<	"electron-track pairs");
895	<	else if(currentObject == "muon-track pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),tracks.product(),
896	<	cumulativeFlags.at("muons").at(flagsForPairCutsIndex),
897	<	cumulativeFlags.at("tracks").at(flagsForPairCutsIndex),
898	<	"muon-track pairs");
899	<	else if(currentObject == "muon-tau pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),taus.product(),
900	<	cumulativeFlags.at("muons").at(flagsForPairCutsIndex),
901	<	cumulativeFlags.at("taus").at(flagsForPairCutsIndex),
902	<	"muon-tau pairs");
903	<	else if(currentObject == "tau-tau pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,taus.product(),taus.product(),
904	<	cumulativeFlags.at("taus").at(flagsForPairCutsIndex),
905	<	cumulativeFlags.at("taus").at(flagsForPairCutsIndex),
906	<	"tau-tau pairs");
907	<	else if(currentObject == "tau-track pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,taus .product(),tracks.product(),
908	<	cumulativeFlags.at("taus").at(flagsForPairCutsIndex),
909	<	cumulativeFlags.at("tracks").at(flagsForPairCutsIndex),
910	<	"tau-track pairs");
911	<	else if(currentObject == "electron-trigobj pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),trigobjs.product(),
912	<	cumulativeFlags.at("electrons").at(flagsForPairCutsIndex),
913	<	cumulativeFlags.at("trigobjs").at(flagsForPairCutsIndex),
914	<	"electron-trigobj pairs");
915	<	else if(currentObject == "muon-trigobj pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),trigobjs.product(),
916	<	cumulativeFlags.at("muons").at(flagsForPairCutsIndex),
917	<	cumulativeFlags.at("trigobjs").at(flagsForPairCutsIndex),
918	<	"muon-trigobj pairs");
894	>	else if(currentObject == "electrons")           setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),"electrons");
895	>	else if(currentObject == "events")              setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,events.product(),"events");
896	>	else if(currentObject == "taus")                setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,taus.product(),"taus");
897	>	else if(currentObject == "mets")                setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,mets.product(),"mets");
898	>	else if(currentObject == "tracks")              setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,tracks.product(),"tracks");
899	>	else if(currentObject == "genjets")             setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,genjets.product(),"genjets");
900	>	else if(currentObject == "mcparticles")         setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,mcparticles.product(),"mcparticles");
901	>	else if(currentObject == "primaryvertexs")      setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,primaryvertexs.product(),"primaryvertexs");
902	>	else if(currentObject == "bxlumis")             setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,bxlumis.product(),"bxlumis");
903	>	else if(currentObject == "photons")             setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,photons.product(),"photons");
904	>	else if(currentObject == "superclusters")       setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,superclusters.product(),"superclusters");
905	>	else if(currentObject == "trigobjs")            setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,trigobjs.product(),"trigobjs");
906	>
907	>
908	>	// paired object collections
909	>	else if(currentObject == "muon-muon pairs")                   setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),muons.product(), "muon-muon pairs");
910	>	else if(currentObject == "muon-secondary muon pairs")         setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),muons.product(), "muon-secondary muon pairs");
911	>
912	>	else if(currentObject == "muon-secondary photon pairs")       setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),photons.product(), "muon-secondary photon pairs");
913	>	else if(currentObject == "muon-secondary jet pairs")          setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),jets.product(), "muon-secondary jet pairs");
914	>	else if(currentObject == "photon-secondary jet pairs")        setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,photons.product(),jets.product(), "photon-secondary jet pairs");
915	>	else if(currentObject == "electron-secondary jet pairs")      setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),jets.product(), "electron-secondary jet pairs");
916	>	else if(currentObject == "electron-secondary electron pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),electrons.product(), "electron-secondary electron pairs");
917	>
918	>	else if(currentObject == "electron-electron pairs")           setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),electrons.product(), "electron-electron pairs");
919	>	else if(currentObject == "electron-muon pairs")     setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),muons.product(), "electron-muon pairs");
920	>	else if(currentObject == "jet-jet pairs")           setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,jets.product(),jets.product(), "jet-jet pairs");
921	>	else if(currentObject == "jet-secondary jet pairs") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,jets.product(),jets.product(), "jet-secondary jet pairs");
922	>	else if(currentObject == "electron-jet pairs")      setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),jets.product(), "electron-jet pairs");
923	>	else if(currentObject == "electron-photon pairs")   setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),photons.product(), "electron-photon pairs");
924	>	else if(currentObject == "photon-jet pairs")        setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,photons.product(),jets.product(), "photon-jet pairs");
925	>	else if(currentObject == "muon-jet pairs")          setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),jets.product(), "muon-jet pairs");
926	>	else if(currentObject == "muon-event pairs")        setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),events.product(), "muon-event pairs");
927	>	else if(currentObject == "met-jet pairs")           setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,mets.product(),jets.product(), "met-jet pairs");
928	>	else if(currentObject == "track-jet pairs")         setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,tracks.product(),jets.product(), "track-jet pairs");
929	>	else if(currentObject == "muon-photon pairs")       setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),photons.product(), "muon-photon pairs");
930	>	else if(currentObject == "track-event pairs")       setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,tracks.product(),events.product(), "track-event pairs");
931	>	else if(currentObject == "electron-track pairs")    setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),tracks.product(),"electron-track pairs");
932	>	else if(currentObject == "muon-track pairs")        setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),tracks.product(),"muon-track pairs");
933	>	else if(currentObject == "muon-tau pairs")          setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),taus.product(),"muon-tau pairs");
934	>	else if(currentObject == "tau-tau pairs")           setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,taus.product(),taus.product(),"tau-tau pairs");
935	>	else if(currentObject == "tau-track pairs")         setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,taus .product(),tracks.product(),"tau-track pairs");
936	>	else if(currentObject == "electron-trigobj pairs")  setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,electrons.product(),trigobjs.product(),"electron-trigobj pairs");
937	>	else if(currentObject == "muon-trigobj pairs")      setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,muons.product(),trigobjs.product(),"muon-trigobj pairs");
938
939		if(currentObject == "stops" && datasetType_ == "signalMC") setObjectFlags(currentCut,currentCutIndex,individualFlags,cumulativeFlags,stops.product(),"stops");
940		}
941
942	+	}//end loop over all cuts
943
944
925	–	}//end loop over all cuts
926	–	//use cumulative flags to apply cuts at event level
945
946	<	//a vector to store cumulative cut descisions after each cut.
947	<	vector<bool> eventPassedPreviousCuts;
946	>	//use cumulative flags to apply cuts at event level
947	>	vector<bool> eventPassedPreviousCuts;    //a vector to store cumulative cut descisions after each cut.
948		bool eventPassedAllCuts = true;
949	<	//apply trigger (true if none were specified)
932	<	eventPassedAllCuts = eventPassedAllCuts && triggerDecision;
949	>	eventPassedAllCuts = eventPassedAllCuts && triggerDecision;    //apply trigger (true if none were specified)
950
951		for(uint currentCutIndex = 0; currentCutIndex != currentChannel.cuts.size(); currentCutIndex++){
952
953		//loop over all objects and count how many passed the cumulative selection up to this point
954		cut currentCut = currentChannel.cuts.at(currentCutIndex);
955		int numberPassing = 0;
956	+	int numberPassingPrev = 0;  // number of objects that pass cuts up to the previous one
957
958		for (uint object = 0; object != cumulativeFlags.at(currentCut.inputCollection).at(currentCutIndex).size() ; object++){
959		if(cumulativeFlags.at(currentCut.inputCollection).at(currentCutIndex).at(object).first) numberPassing++;
960		}
961	<	bool cutDecision = evaluateComparison(numberPassing,currentCut.eventComparativeOperator,currentCut.numberRequired);
961	>	bool cutDecision;
962	>	if (!currentCut.isVeto) {
963	>	cutDecision = evaluateComparison(numberPassing,currentCut.eventComparativeOperator,currentCut.numberRequired);
964	>	} else {
965	>	int prevCutIndex = currentCutIndex - 1;
966	>	if (prevCutIndex<0) {
967	>	numberPassingPrev = cumulativeFlags.at(currentCut.inputCollection).at(currentCutIndex).size();  // count all objects in collection if cut is the first
968	>	} else {
969	>	for (uint object = 0; object != cumulativeFlags.at(currentCut.inputCollection).at(prevCutIndex).size() ; object++){
970	>	if (cumulativeFlags.at(currentCut.inputCollection).at(prevCutIndex).at(object).first) {
971	>	numberPassingPrev++;
972	>	if (verbose_>1) clog << " object passed previous cut" << endl;
973	>	}
974	>	}
975	>	}
976	>	int numberFailCut = numberPassingPrev - numberPassing;
977	>	cutDecision = evaluateComparison(numberFailCut,currentCut.eventComparativeOperator,currentCut.numberRequired);
978	>	}
979	>
980		cutFlows_.at(currentChannelIndex)->at (currentCut.name) = cutDecision;
981		eventPassedAllCuts = eventPassedAllCuts && cutDecision;
982		eventPassedPreviousCuts.push_back(eventPassedAllCuts);
983	+	if (verbose_>1) clog << " Event passed cuts up to cut index " << currentCutIndex << endl;
984	+
985		}
986		//applying all appropriate scale factors
987		double scaleFactor = masterScaleFactor;
#	Line 1008 | Line 1046 | OSUAnalysis::produce (edm::Event &event,
1046		scaleFactor *= electronScaleFactor_;
1047		scaleFactor *= bTagScaleFactor_;
1048		cutFlows_.at(currentChannelIndex)->fillCutFlow(scaleFactor);
1049	+	if (verbose_>1) clog << " Scale factors applied:  "
1050	+	<< " muonScaleFactor_ = " << muonScaleFactor_
1051	+	<< ", electronScaleFactor_ = " << electronScaleFactor_
1052	+	<< ", bTagScaleFactor_ = " << bTagScaleFactor_
1053	+	<< ", total scale factor = " << scaleFactor
1054	+	<< endl;
1055	+
1056
1057		if (printEventInfo_ && eventPassedAllCuts) {
1058		// Write information about event to screen, for testing purposes.
#	Line 1026 | Line 1071 | OSUAnalysis::produce (edm::Event &event,
1071
1072
1073		//filling histograms
1074	<	for(uint currentCut = 0; currentCut != oneDHists_.at(currentChannelIndex).size(); currentCut++){//loop over all the directories in each channel.
1074	>	for(uint currentCut = 0; currentCut != oneDHists_.at(currentChannelIndex).size(); currentCut++){//loop over all the cuts in each channel; if GetPlotsAfterEachCut_ is false, only the last cut will be used.
1075	>
1076	>	if (verbose_>2) clog << "  Filling histograms for currentcut = " << currentCut << endl;
1077	>
1078		uint currentDir;
1079		if (!GetPlotsAfterEachCut_) { currentDir =  currentChannel.cuts.size() - oneDHists_.at(currentChannelIndex).size(); } //if GetPlotsAfterEachCut_ is false, set currentDir point to the last cut.
1080		else{
#	Line 1041 | Line 1089 | OSUAnalysis::produce (edm::Event &event,
1089
1090		if (cumulativeFlags.count(currentHistogram.inputCollection) == 0) clog << "Error: no flags found for collection:  " << currentHistogram.inputCollection << ", will cause a seg fault" << endl;
1091
1092	+	if (verbose_>1) clog << " Filling histogram " << currentHistogram.name << " for collection " << currentHistogram.inputCollection << endl;
1093	+
1094		if(currentHistogram.inputVariables.size() == 1){
1095		TH1D* histo;
1096		histo = oneDHists_.at(currentChannelIndex).at(currentCut).at(currentHistogram.name);
1097	<	if     (currentHistogram.inputCollection == "jets")            fill1DHistogram(histo,currentHistogram,jets.product(),cumulativeFlags.at("jets").at(currentDir),scaleFactor);
1097	>	if     (currentHistogram.inputCollection == "jets")            fill1DHistogram(histo,currentHistogram,jets.product(),cumulativeFlags.at("jets").at(currentDir),scaleFactor);
1098		else if(currentHistogram.inputCollection == "secondary jets")  fill1DHistogram(histo,currentHistogram,jets.product(),cumulativeFlags.at("secondary jets").at(currentDir),scaleFactor);
1099		else if(currentHistogram.inputCollection == "secondary photons")  fill1DHistogram(histo,currentHistogram,photons.product(),cumulativeFlags.at("secondary photons").at(currentDir),scaleFactor);
1100		else if(currentHistogram.inputCollection == "muons")           fill1DHistogram(histo,currentHistogram,muons.product(),cumulativeFlags.at("muons").at(currentDir),scaleFactor);
1101		else if(currentHistogram.inputCollection == "secondary muons") fill1DHistogram(histo,currentHistogram,muons.product(),cumulativeFlags.at("secondary muons").at(currentDir),scaleFactor);
1102		else if(currentHistogram.inputCollection == "secondary electrons") fill1DHistogram(histo,currentHistogram,electrons.product(),cumulativeFlags.at("secondary electrons").at(currentDir),scaleFactor);
1103	<	else if(currentHistogram.inputCollection == "muon-muon pairs") fill1DHistogram(histo,currentHistogram,muons.product(),muons.product(), \
1054	<	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("muons").at(currentDir), \
1103	>	else if(currentHistogram.inputCollection == "muon-muon pairs") fill1DHistogram(histo,currentHistogram,muons.product(),muons.product(),
1104		cumulativeFlags.at("muon-muon pairs").at(currentDir),scaleFactor);
1105	<	else if(currentHistogram.inputCollection == "muon-secondary muon pairs") fill1DHistogram(histo,currentHistogram,muons.product(),muons.product(), \
1057	<	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("secondary muons").at(currentDir), \
1105	>	else if(currentHistogram.inputCollection == "muon-secondary muon pairs") fill1DHistogram(histo,currentHistogram,muons.product(),muons.product(),
1106		cumulativeFlags.at("muon-secondary muon pairs").at(currentDir),scaleFactor);
1107	<	else if(currentHistogram.inputCollection == "muon-secondary photon pairs") fill1DHistogram(histo,currentHistogram,muons.product(),photons.product(), \
1060	<	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("secondary photons").at(currentDir), \
1107	>	else if(currentHistogram.inputCollection == "muon-secondary photon pairs") fill1DHistogram(histo,currentHistogram,muons.product(),photons.product(),
1108		cumulativeFlags.at("muon-secondary photon pairs").at(currentDir),scaleFactor);
1109	<	else if(currentHistogram.inputCollection == "muon-secondary jet pairs") fill1DHistogram(histo,currentHistogram,muons.product(),jets.product(), \
1063	<	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("secondary jets").at(currentDir), \
1109	>	else if(currentHistogram.inputCollection == "muon-secondary jet pairs") fill1DHistogram(histo,currentHistogram,muons.product(),jets.product(),
1110		cumulativeFlags.at("muon-secondary jet pairs").at(currentDir),scaleFactor);
1111	<	else if(currentHistogram.inputCollection == "photon-secondary jet pairs") fill1DHistogram(histo,currentHistogram,photons.product(),jets.product(), \
1066	<	cumulativeFlags.at("photons").at(currentDir),cumulativeFlags.at("secondary jets").at(currentDir), \
1111	>	else if(currentHistogram.inputCollection == "photon-secondary jet pairs") fill1DHistogram(histo,currentHistogram,photons.product(),jets.product(),
1112		cumulativeFlags.at("photon-secondary jet pairs").at(currentDir),scaleFactor);
1113	<	else if(currentHistogram.inputCollection == "electron-secondary jet pairs") fill1DHistogram(histo,currentHistogram,electrons.product(),jets.product(), \
1069	<	cumulativeFlags.at("electrons").at(currentDir),cumulativeFlags.at("secondary jets").at(currentDir), \
1113	>	else if(currentHistogram.inputCollection == "electron-secondary jet pairs") fill1DHistogram(histo,currentHistogram,electrons.product(),jets.product(),
1114		cumulativeFlags.at("electron-secondary jet pairs").at(currentDir),scaleFactor);
1115
1116		else if(currentHistogram.inputCollection == "electrons") fill1DHistogram(histo,currentHistogram,electrons.product(),cumulativeFlags.at("electrons").at(currentDir),scaleFactor);
1117	<	else if(currentHistogram.inputCollection == "electron-electron pairs") fill1DHistogram(histo,currentHistogram,electrons.product(),electrons.product(),\
1074	<	cumulativeFlags.at("electrons").at(currentDir),cumulativeFlags.at("electrons").at(currentDir),\
1117	>	else if(currentHistogram.inputCollection == "electron-electron pairs") fill1DHistogram(histo,currentHistogram,electrons.product(),electrons.product(),
1118		cumulativeFlags.at("electron-electron pairs").at(currentDir),scaleFactor);
1119	<	else if(currentHistogram.inputCollection == "jet-jet pairs") fill1DHistogram(histo,currentHistogram,jets.product(),jets.product(),\
1077	<	cumulativeFlags.at("jets").at(currentDir),cumulativeFlags.at("jets").at(currentDir),\
1119	>	else if(currentHistogram.inputCollection == "jet-jet pairs") fill1DHistogram(histo,currentHistogram,jets.product(),jets.product(),
1120		cumulativeFlags.at("jet-jet pairs").at(currentDir),scaleFactor);
1121	<	else if(currentHistogram.inputCollection == "jet-secondary jet pairs") fill1DHistogram(histo,currentHistogram,jets.product(),jets.product(), \
1080	<	cumulativeFlags.at("jets").at(currentDir),cumulativeFlags.at("secondary jets").at(currentDir), \
1121	>	else if(currentHistogram.inputCollection == "jet-secondary jet pairs") fill1DHistogram(histo,currentHistogram,jets.product(),jets.product(),
1122		cumulativeFlags.at("jet-secondary jet pairs").at(currentDir),scaleFactor);
1123
1124	<	else if(currentHistogram.inputCollection == "electron-secondary electron pairs") fill1DHistogram(histo,currentHistogram,electrons.product(),electrons.product(), \
1084	<	cumulativeFlags.at("electrons").at(currentDir),cumulativeFlags.at("secondary electrons").at(currentDir), \
1124	>	else if(currentHistogram.inputCollection == "electron-secondary electron pairs") fill1DHistogram(histo,currentHistogram,electrons.product(),electrons.product(),
1125		cumulativeFlags.at("electron-secondary electron pairs").at(currentDir),scaleFactor);
1126	<	else if(currentHistogram.inputCollection == "electron-muon pairs") fill1DHistogram(histo,currentHistogram, electrons.product(),muons.product(), \
1087	<	cumulativeFlags.at("electrons").at(currentDir),cumulativeFlags.at("muons").at(currentDir),
1126	>	else if(currentHistogram.inputCollection == "electron-muon pairs") fill1DHistogram(histo,currentHistogram, electrons.product(),muons.product(),
1127		cumulativeFlags.at("electron-muon pairs").at(currentDir),scaleFactor);
1128	<	else if(currentHistogram.inputCollection == "electron-jet pairs") fill1DHistogram(histo,currentHistogram, electrons.product(),jets.product(), \
1090	<	cumulativeFlags.at("electrons").at(currentDir),cumulativeFlags.at("jets").at(currentDir),
1128	>	else if(currentHistogram.inputCollection == "electron-jet pairs") fill1DHistogram(histo,currentHistogram, electrons.product(),jets.product(),
1129		cumulativeFlags.at("electron-jet pairs").at(currentDir),scaleFactor);
1130	<	else if(currentHistogram.inputCollection == "photon-jet pairs") fill1DHistogram(histo,currentHistogram, photons.product(),jets.product(), \
1093	<	cumulativeFlags.at("photons").at(currentDir),cumulativeFlags.at("jets").at(currentDir),
1130	>	else if(currentHistogram.inputCollection == "photon-jet pairs") fill1DHistogram(histo,currentHistogram, photons.product(),jets.product(),
1131		cumulativeFlags.at("photon-jet pairs").at(currentDir),scaleFactor);
1132	<	else if(currentHistogram.inputCollection == "muon-jet pairs") fill1DHistogram(histo,currentHistogram, muons.product(),jets.product(), \
1096	<	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("jets").at(currentDir),
1132	>	else if(currentHistogram.inputCollection == "muon-jet pairs") fill1DHistogram(histo,currentHistogram, muons.product(),jets.product(),
1133		cumulativeFlags.at("muon-jet pairs").at(currentDir),scaleFactor);
1134	<	else if(currentHistogram.inputCollection == "muon-event pairs") fill1DHistogram(histo,currentHistogram, muons.product(),events.product(), \
1099	<	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("events").at(currentDir),
1134	>	else if(currentHistogram.inputCollection == "muon-event pairs") fill1DHistogram(histo,currentHistogram, muons.product(),events.product(),
1135		cumulativeFlags.at("muon-event pairs").at(currentDir),scaleFactor);
1136	<	else if(currentHistogram.inputCollection == "met-jet pairs")  fill1DHistogram(histo,currentHistogram, mets.product(),jets.product(), \
1102	<	cumulativeFlags.at("mets").at(currentDir),cumulativeFlags.at("jets").at(currentDir),
1136	>	else if(currentHistogram.inputCollection == "met-jet pairs")  fill1DHistogram(histo,currentHistogram, mets.product(),jets.product(),
1137		cumulativeFlags.at("met-jet pairs").at(currentDir),scaleFactor);
1138	<	else if(currentHistogram.inputCollection == "track-jet pairs")  fill1DHistogram(histo,currentHistogram,tracks.product(),jets.product(), \
1105	<	cumulativeFlags.at("tracks").at(currentDir),cumulativeFlags.at("jets").at(currentDir),
1138	>	else if(currentHistogram.inputCollection == "track-jet pairs")  fill1DHistogram(histo,currentHistogram,tracks.product(),jets.product(),
1139		cumulativeFlags.at("track-jet pairs").at(currentDir),scaleFactor);
1140	<	else if(currentHistogram.inputCollection == "muon-photon pairs") fill1DHistogram(histo,currentHistogram, muons.product(),photons.product(), \
1108	<	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("photons").at(currentDir),
1140	>	else if(currentHistogram.inputCollection == "muon-photon pairs") fill1DHistogram(histo,currentHistogram, muons.product(),photons.product(),
1141		cumulativeFlags.at("muon-photon pairs").at(currentDir),scaleFactor);
1142	<	else if(currentHistogram.inputCollection == "electron-photon pairs") fill1DHistogram(histo,currentHistogram, electrons.product(),photons.product(), \
1111	<	cumulativeFlags.at("electrons").at(currentDir),cumulativeFlags.at("photons").at(currentDir),
1142	>	else if(currentHistogram.inputCollection == "electron-photon pairs") fill1DHistogram(histo,currentHistogram, electrons.product(),photons.product(),
1143		cumulativeFlags.at("electron-photon pairs").at(currentDir),scaleFactor);
1144		else if(currentHistogram.inputCollection == "electron-track pairs") fill1DHistogram(histo,currentHistogram, electrons.product(),tracks.product(),
1114	–	cumulativeFlags.at("electrons").at(currentDir),cumulativeFlags.at("tracks").at(currentDir),
1145		cumulativeFlags.at("electron-track pairs").at(currentDir),scaleFactor);
1146		else if(currentHistogram.inputCollection == "muon-track pairs") fill1DHistogram(histo,currentHistogram, muons.product(),tracks.product(),
1117	–	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("tracks").at(currentDir),
1147		cumulativeFlags.at("muon-track pairs").at(currentDir),scaleFactor);
1148		else if(currentHistogram.inputCollection == "muon-tau pairs") fill1DHistogram(histo,currentHistogram, muons.product(),taus.product(),
1120	–	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("taus").at(currentDir),
1149		cumulativeFlags.at("muon-tau pairs").at(currentDir),scaleFactor);
1150		else if(currentHistogram.inputCollection == "tau-tau pairs") fill1DHistogram(histo,currentHistogram, taus.product(),taus.product(),
1123	–	cumulativeFlags.at("taus").at(currentDir),cumulativeFlags.at("taus").at(currentDir),
1151		cumulativeFlags.at("tau-tau pairs").at(currentDir),scaleFactor);
1152		else if(currentHistogram.inputCollection == "tau-track pairs") fill1DHistogram(histo,currentHistogram, taus.product(),tracks.product(),
1126	–	cumulativeFlags.at("taus").at(currentDir),cumulativeFlags.at("tracks").at(currentDir),
1153		cumulativeFlags.at("tau-track pairs").at(currentDir),scaleFactor);
1154		else if(currentHistogram.inputCollection == "electron-trigobj pairs") fill1DHistogram(histo,currentHistogram, electrons.product(),trigobjs.product(),
1129	–	cumulativeFlags.at("electrons").at(currentDir),cumulativeFlags.at("trigobjs").at(currentDir),
1155		cumulativeFlags.at("electron-trigobj pairs").at(currentDir),scaleFactor);
1156		else if(currentHistogram.inputCollection == "muon-trigobj pairs") fill1DHistogram(histo,currentHistogram, muons.product(),trigobjs.product(),
1132	–	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("trigobjs").at(currentDir),
1157		cumulativeFlags.at("muon-trigobj pairs").at(currentDir),scaleFactor);
1158
1159		else if(currentHistogram.inputCollection == "events") fill1DHistogram(histo,currentHistogram,events.product(),cumulativeFlags.at("events").at(currentDir),scaleFactor);
#	Line 1153 | Line 1177 | OSUAnalysis::produce (edm::Event &event,
1177		else if(currentHistogram.inputCollection == "secondary photons")  fill2DHistogram(histo,currentHistogram,photons.product(),cumulativeFlags.at("secondary photons").at(currentDir),scaleFactor);
1178		else if(currentHistogram.inputCollection == "muons")           fill2DHistogram(histo,currentHistogram,muons.product(),cumulativeFlags.at("muons").at(currentDir),scaleFactor);
1179		else if(currentHistogram.inputCollection == "secondary muons") fill2DHistogram(histo,currentHistogram,muons.product(),cumulativeFlags.at("secondary muons").at(currentDir),scaleFactor);
1180	<	else if(currentHistogram.inputCollection == "muon-muon pairs") fill2DHistogram(histo,currentHistogram,muons.product(),muons.product(), \
1157	<	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("muons").at(currentDir), \
1180	>	else if(currentHistogram.inputCollection == "muon-muon pairs") fill2DHistogram(histo,currentHistogram,muons.product(),muons.product(),
1181		cumulativeFlags.at("muon-muon pairs").at(currentDir),scaleFactor);
1182	<	else if(currentHistogram.inputCollection == "muon-secondary muon pairs") fill2DHistogram(histo,currentHistogram,muons.product(),muons.product(), \
1160	<	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("secondary muons").at(currentDir), \
1182	>	else if(currentHistogram.inputCollection == "muon-secondary muon pairs") fill2DHistogram(histo,currentHistogram,muons.product(),muons.product(),
1183		cumulativeFlags.at("muon-secondary muon pairs").at(currentDir),scaleFactor);
1184	<	else if(currentHistogram.inputCollection == "muon-secondary photon pairs") fill2DHistogram(histo,currentHistogram,muons.product(),photons.product(), \
1163	<	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("secondary photons").at(currentDir), \
1184	>	else if(currentHistogram.inputCollection == "muon-secondary photon pairs") fill2DHistogram(histo,currentHistogram,muons.product(),photons.product(),
1185		cumulativeFlags.at("muon-secondary photon pairs").at(currentDir),scaleFactor);
1186	<	else if(currentHistogram.inputCollection == "muon-secondary jet pairs") fill2DHistogram(histo,currentHistogram,muons.product(),jets.product(), \
1166	<	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("secondary jets").at(currentDir), \
1186	>	else if(currentHistogram.inputCollection == "muon-secondary jet pairs") fill2DHistogram(histo,currentHistogram,muons.product(),jets.product(),
1187		cumulativeFlags.at("muon-secondary jet pairs").at(currentDir),scaleFactor);
1188	<	else if(currentHistogram.inputCollection == "electron-secondary jet pairs") fill2DHistogram(histo,currentHistogram,electrons.product(),jets.product(), \
1169	<	cumulativeFlags.at("electrons").at(currentDir),cumulativeFlags.at("secondary jets").at(currentDir), \
1188	>	else if(currentHistogram.inputCollection == "electron-secondary jet pairs") fill2DHistogram(histo,currentHistogram,electrons.product(),jets.product(),
1189		cumulativeFlags.at("electron-secondary jet pairs").at(currentDir),scaleFactor);
1190	<	else if(currentHistogram.inputCollection == "photon-secondary jet pairs") fill2DHistogram(histo,currentHistogram,photons.product(),jets.product(), \
1172	<	cumulativeFlags.at("photons").at(currentDir),cumulativeFlags.at("secondary jets").at(currentDir), \
1190	>	else if(currentHistogram.inputCollection == "photon-secondary jet pairs") fill2DHistogram(histo,currentHistogram,photons.product(),jets.product(),
1191		cumulativeFlags.at("photon-secondary jet pairs").at(currentDir),scaleFactor);
1192		else if(currentHistogram.inputCollection == "electrons") fill2DHistogram(histo,currentHistogram,electrons.product(),cumulativeFlags.at("electrons").at(currentDir),scaleFactor);
1193		else if(currentHistogram.inputCollection == "secondary electrons") fill2DHistogram(histo,currentHistogram,electrons.product(),cumulativeFlags.at("secondary electrons").at(currentDir),scaleFactor);
1194	<	else if(currentHistogram.inputCollection == "electron-electron pairs") fill2DHistogram(histo,currentHistogram,electrons.product(),electrons.product(), \
1177	<	cumulativeFlags.at("electrons").at(currentDir),cumulativeFlags.at("electrons").at(currentDir), \
1194	>	else if(currentHistogram.inputCollection == "electron-electron pairs") fill2DHistogram(histo,currentHistogram,electrons.product(),electrons.product(),
1195		cumulativeFlags.at("electron-electron pairs").at(currentDir),scaleFactor);
1196	<	else if(currentHistogram.inputCollection == "jet-jet pairs") fill2DHistogram(histo,currentHistogram,jets.product(),jets.product(), \
1180	<	cumulativeFlags.at("jets").at(currentDir),cumulativeFlags.at("jets").at(currentDir), \
1196	>	else if(currentHistogram.inputCollection == "jet-jet pairs") fill2DHistogram(histo,currentHistogram,jets.product(),jets.product(),
1197		cumulativeFlags.at("jet-jet pairs").at(currentDir),scaleFactor);
1198	<	else if(currentHistogram.inputCollection == "electron-secondary electron pairs") fill2DHistogram(histo,currentHistogram,electrons.product(),electrons.product(), \
1183	<	cumulativeFlags.at("electrons").at(currentDir),cumulativeFlags.at("secondary electrons").at(currentDir), \
1198	>	else if(currentHistogram.inputCollection == "electron-secondary electron pairs") fill2DHistogram(histo,currentHistogram,electrons.product(),electrons.product(),
1199		cumulativeFlags.at("electron-secondary electron pairs").at(currentDir),scaleFactor);
1200	<	else if(currentHistogram.inputCollection == "electron-muon pairs") fill2DHistogram(histo,currentHistogram,electrons.product(),muons.product(), \
1186	<	cumulativeFlags.at("electrons").at(currentDir),cumulativeFlags.at("muons").at(currentDir), \
1200	>	else if(currentHistogram.inputCollection == "electron-muon pairs") fill2DHistogram(histo,currentHistogram,electrons.product(),muons.product(),
1201		cumulativeFlags.at("electron-muon pairs").at(currentDir),scaleFactor);
1202	<	else if(currentHistogram.inputCollection == "electron-jet pairs") fill2DHistogram(histo,currentHistogram,electrons.product(),jets.product(), \
1189	<	cumulativeFlags.at("electrons").at(currentDir),cumulativeFlags.at("jets").at(currentDir), \
1202	>	else if(currentHistogram.inputCollection == "electron-jet pairs") fill2DHistogram(histo,currentHistogram,electrons.product(),jets.product(),
1203		cumulativeFlags.at("electron-jet pairs").at(currentDir),scaleFactor);
1204	<	else if(currentHistogram.inputCollection == "electron-photon pairs") fill2DHistogram(histo,currentHistogram,electrons.product(),photons.product(), \
1192	<	cumulativeFlags.at("electrons").at(currentDir),cumulativeFlags.at("photons").at(currentDir), \
1204	>	else if(currentHistogram.inputCollection == "electron-photon pairs") fill2DHistogram(histo,currentHistogram,electrons.product(),photons.product(),
1205		cumulativeFlags.at("electron-photon pairs").at(currentDir),scaleFactor);
1206	<	else if(currentHistogram.inputCollection == "muon-jet pairs") fill2DHistogram(histo,currentHistogram,muons.product(),jets.product(), \
1195	<	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("jets").at(currentDir), \
1206	>	else if(currentHistogram.inputCollection == "muon-jet pairs") fill2DHistogram(histo,currentHistogram,muons.product(),jets.product(),
1207		cumulativeFlags.at("muon-jet pairs").at(currentDir),scaleFactor);
1208	<	else if(currentHistogram.inputCollection == "muon-event pairs") fill2DHistogram(histo,currentHistogram,muons.product(),events.product(), \
1198	<	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("events").at(currentDir), \
1208	>	else if(currentHistogram.inputCollection == "muon-event pairs") fill2DHistogram(histo,currentHistogram,muons.product(),events.product(),
1209		cumulativeFlags.at("muon-event pairs").at(currentDir),scaleFactor);
1210	<	else if(currentHistogram.inputCollection == "met-jet pairs") fill2DHistogram(histo,currentHistogram,mets.product(),jets.product(), \
1201	<	cumulativeFlags.at("mets").at(currentDir),cumulativeFlags.at("jets").at(currentDir), \
1210	>	else if(currentHistogram.inputCollection == "met-jet pairs") fill2DHistogram(histo,currentHistogram,mets.product(),jets.product(),
1211		cumulativeFlags.at("met-jet pairs").at(currentDir),scaleFactor);
1212		else if(currentHistogram.inputCollection == "track-jet pairs") fill2DHistogram(histo,currentHistogram,tracks.product(),jets.product(),
1204	–	cumulativeFlags.at("tracks").at(currentDir),cumulativeFlags.at("jets").at(currentDir), \
1213		cumulativeFlags.at("track-jet pairs").at(currentDir),scaleFactor);
1214	<	else if(currentHistogram.inputCollection == "photon-jet pairs") fill2DHistogram(histo,currentHistogram,photons.product(),jets.product(), \
1207	<	cumulativeFlags.at("photons").at(currentDir),cumulativeFlags.at("jets").at(currentDir), \
1214	>	else if(currentHistogram.inputCollection == "photon-jet pairs") fill2DHistogram(histo,currentHistogram,photons.product(),jets.product(),
1215		cumulativeFlags.at("photon-jet pairs").at(currentDir),scaleFactor);
1216	<	else if(currentHistogram.inputCollection == "muon-photon pairs") fill2DHistogram(histo,currentHistogram,muons.product(),photons.product(), \
1210	<	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("photons").at(currentDir), \
1216	>	else if(currentHistogram.inputCollection == "muon-photon pairs") fill2DHistogram(histo,currentHistogram,muons.product(),photons.product(),
1217		cumulativeFlags.at("muon-photon pairs").at(currentDir),scaleFactor);
1218		else if(currentHistogram.inputCollection == "electron-track pairs") fill2DHistogram(histo,currentHistogram,electrons.product(),tracks.product(),
1213	–	cumulativeFlags.at("electrons").at(currentDir),cumulativeFlags.at("tracks").at(currentDir),
1219		cumulativeFlags.at("electron-track pairs").at(currentDir),scaleFactor);
1220		else if(currentHistogram.inputCollection == "muon-track pairs") fill2DHistogram(histo,currentHistogram,muons.product(),tracks.product(),
1216	–	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("tracks").at(currentDir),
1221		cumulativeFlags.at("muon-track pairs").at(currentDir),scaleFactor);
1222		else if(currentHistogram.inputCollection == "muon-tau pairs") fill2DHistogram(histo,currentHistogram,muons.product(),taus.product(),
1219	–	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("taus").at(currentDir),
1223		cumulativeFlags.at("muon-tau pairs").at(currentDir),scaleFactor);
1224		else if(currentHistogram.inputCollection == "tau-tau pairs") fill2DHistogram(histo,currentHistogram,taus.product(),taus.product(),
1222	–	cumulativeFlags.at("taus").at(currentDir),cumulativeFlags.at("taus").at(currentDir),
1225		cumulativeFlags.at("tau-tau pairs").at(currentDir),scaleFactor);
1226		else if(currentHistogram.inputCollection == "tau-track pairs") fill2DHistogram(histo,currentHistogram,taus.product(),tracks.product(),
1225	–	cumulativeFlags.at("taus").at(currentDir),cumulativeFlags.at("tracks").at(currentDir),
1227		cumulativeFlags.at("tau-track pairs").at(currentDir),scaleFactor);
1228		else if(currentHistogram.inputCollection == "electron-trigobj pairs") fill2DHistogram(histo,currentHistogram,electrons.product(),trigobjs.product(),
1228	–	cumulativeFlags.at("electrons").at(currentDir),cumulativeFlags.at("trigobjs").at(currentDir),
1229		cumulativeFlags.at("electron-trigobj pairs").at(currentDir),scaleFactor);
1230		else if(currentHistogram.inputCollection == "muon-trigobj pairs") fill2DHistogram(histo,currentHistogram,muons.product(),trigobjs.product(),
1231	–	cumulativeFlags.at("muons").at(currentDir),cumulativeFlags.at("trigobjs").at(currentDir),
1231		cumulativeFlags.at("muon-trigobj pairs").at(currentDir),scaleFactor);
1232		else if(currentHistogram.inputCollection == "events") fill2DHistogram(histo,currentHistogram,events.product(),cumulativeFlags.at("events").at(currentDir),scaleFactor);
1233		else if(currentHistogram.inputCollection == "taus") fill2DHistogram(histo,currentHistogram,taus.product(),cumulativeFlags.at("taus").at(currentDir),scaleFactor);
1234		else if(currentHistogram.inputCollection == "mets") fill2DHistogram(histo,currentHistogram,mets.product(),cumulativeFlags.at("mets").at(currentDir),scaleFactor);
1235		else if(currentHistogram.inputCollection == "tracks") fill2DHistogram(histo,currentHistogram,tracks.product(),cumulativeFlags.at("tracks").at(currentDir),scaleFactor);
1236		else if(currentHistogram.inputCollection == "track-event pairs") fill2DHistogram(histo,currentHistogram,tracks.product(),events.product(),
1238	–	cumulativeFlags.at("tracks").at(currentDir),cumulativeFlags.at("events").at(currentDir),
1237		cumulativeFlags.at("track-event pairs").at(currentDir),scaleFactor);
1238		else if(currentHistogram.inputCollection == "genjets") fill2DHistogram(histo,currentHistogram,genjets.product(),cumulativeFlags.at("genjets").at(currentDir),scaleFactor);
1239		else if(currentHistogram.inputCollection == "mcparticles") fill2DHistogram(histo,currentHistogram,mcparticles.product(),cumulativeFlags.at("mcparticles").at(currentDir),scaleFactor);
#	Line 1256 | Line 1254 | OSUAnalysis::produce (edm::Event &event,
1254		string currentObject = objectsToPlot.at(currentObjectIndex);
1255		string objectToPlot = "";
1256
1257	+	if (verbose_) clog << "Filling histogram of number of selected objects in collection: " << currentObject << endl;
1258	+
1259		// Name of objectToPlot here must match the name specified in OSUAnalysis::OSUAnalysis().
1260		if(currentObject == "muon-muon pairs")                         objectToPlot = "dimuonPairs";
1261		else if(currentObject == "electron-electron pairs")            objectToPlot = "dielectronPairs";
#	Line 1263 | Line 1263 | OSUAnalysis::produce (edm::Event &event,
1263		else if(currentObject == "electron-photon pairs")              objectToPlot = "electronPhotonPairs";
1264		else if(currentObject == "electron-jet pairs")                 objectToPlot = "electronJetPairs";
1265		else if(currentObject == "muon-jet pairs")                     objectToPlot = "muonJetPairs";
1266	<	else if(currentObject == "muon-event pairs")                     objectToPlot = "muonEventPairs";
1267	<	else if(currentObject == "muon-photon pairs")                     objectToPlot = "muonPhotonPairs";
1268	<	else if(currentObject == "photon-jet pairs")                     objectToPlot = "photonJetPairs";
1266	>	else if(currentObject == "muon-event pairs")                   objectToPlot = "muonEventPairs";
1267	>	else if(currentObject == "muon-photon pairs")                  objectToPlot = "muonPhotonPairs";
1268	>	else if(currentObject == "photon-jet pairs")                   objectToPlot = "photonJetPairs";
1269		else if(currentObject == "met-jet pairs")                      objectToPlot = "metJetPairs";
1270		else if(currentObject == "track-jet pairs")                    objectToPlot = "trackJetPairs";
1271		else if(currentObject == "jet-jet pairs")                      objectToPlot = "dijetPairs";
1272		else if(currentObject == "jet-secondary jet pairs")            objectToPlot = "jetSecondaryJetPairs";
1273		else if(currentObject == "secondary jets")                     objectToPlot = "secondaryJets";
1274	<	else if(currentObject == "secondary photons")                     objectToPlot = "secondaryPhotons";
1274	>	else if(currentObject == "secondary photons")                  objectToPlot = "secondaryPhotons";
1275		else if(currentObject == "electron-track pairs")               objectToPlot = "electronTrackPairs";
1276		else if(currentObject == "muon-track pairs")                   objectToPlot = "muonTrackPairs";
1277		else if(currentObject == "muon-tau pairs")                     objectToPlot = "muonTauPairs";
#	Line 1281 | Line 1281 | OSUAnalysis::produce (edm::Event &event,
1281		else if(currentObject == "muon-secondary muon pairs")          objectToPlot = "muonSecondaryMuonPairs";
1282		else if(currentObject == "secondary muons")                    objectToPlot = "secondaryMuons";
1283		else if(currentObject == "muon-secondary jet pairs")           objectToPlot = "muonSecondaryJetPairs";
1284	<	else if(currentObject == "muon-secondary photon pairs")           objectToPlot = "muonSecondaryJetPairs";
1284	>	else if(currentObject == "muon-secondary photon pairs")        objectToPlot = "muonSecondaryJetPairs";
1285		else if(currentObject == "electron-secondary jet pairs")       objectToPlot = "electronSecondaryJetPairs";
1286		else if(currentObject == "photon-secondary jet pairs")         objectToPlot = "photonSecondaryJetPairs";
1287		else if(currentObject == "electron-secondary electron pairs")  objectToPlot = "electronSecondaryElectronPairs";
#	Line 1295 | Line 1295 | OSUAnalysis::produce (edm::Event &event,
1295		string histoName = "num" + tempCurrentObject;
1296
1297
1298	<	if(find(objectsToCut.begin(), objectsToCut.end(), currentObject) != objectsToCut.end()) {
1298	>	if(find(objectsToPlot.begin(), objectsToPlot.end(), currentObject) != objectsToPlot.end()) {
1299		flagPair lastCutFlags = cumulativeFlags.at(currentObject).at(currentDir);
1300		int numToPlot = 0;
1301	<	for (uint currentFlag = 0; currentFlag != lastCutFlags.size(); currentFlag++){
1302	<	if(lastCutFlags.at(currentFlag).second) numToPlot++;
1301	>	for (uint iObj = 0; iObj != lastCutFlags.size(); iObj++){  // loop over all the objects
1302	>	if(lastCutFlags.at(iObj).second) {
1303	>	numToPlot++;
1304	>	if (verbose_>3) clog << "   Found object " << iObj << " in collection " << currentObject << " to plot." << endl;
1305	>	}
1306		}
1307
1308		if(objectToPlot == "primaryvertexs"){
#	Line 1307 | Line 1310 | OSUAnalysis::produce (edm::Event &event,
1310		oneDHists_.at(currentChannelIndex).at(currentCut).at(histoName+"AfterPileupCorrection")->Fill(primaryvertexs->size(),scaleFactor);
1311		}
1312		else {
1313	+	if (printEventInfo_) clog << "Number of selected " << objectToPlot << " to plot:  " << numToPlot << endl;
1314		oneDHists_.at(currentChannelIndex).at(currentCut).at(histoName)->Fill(numToPlot,scaleFactor);
1315		}
1316		}
1317	+
1318		} // end for (uint currentObjectIndex = 0; currentObjectIndex != objectsToPlot.size(); currentObjectIndex++)
1319
1320
#	Line 1344 | Line 1349 | OSUAnalysis::produce (edm::Event &event,
1349		else if(coll == "stops"
1350		&& datasetType_ == "signalMC") assignTreeBranch(brSpecs,stops.product(),         cumulativeFlags.at(coll).back());
1351		} // end loop over branches
1352	+	// set the evtLong, runInt, and lumiInt variables separately, since they are not type float
1353	+	BNTreeBranchVals_evtLong_ = events->at(0).evt;
1354	+	BNTreeBranchVals_runInt_  = events->at(0).run;
1355	+	BNTreeBranchVals_lumiInt_ = events->at(0).lumi;
1356
1357		if (!BNTrees_.at(currentChannelIndex)) { clog << "ERROR:  Undefined BNTree.  Will likely seg fault." << endl; }
1358		BNTrees_.at(currentChannelIndex)->Fill();  // only fill if event has passed cuts
#	Line 1359 | Line 1368 | OSUAnalysis::produce (edm::Event &event,
1368
1369		isFirstEvent_ = false;
1370
1371	+	if (verbose_) clog << "Finished OSUAnalysis::produce." << endl;
1372	+
1373		} // end void OSUAnalysis::produce (const edm::Event &event, const edm::EventSetup &setup)
1374
1375
#	Line 1387 | Line 1398 | OSUAnalysis::evaluateComparison (string
1398		else if(comparison == "<")  return testValue <  cutValue;
1399		else if(comparison == "<=") return testValue <= cutValue;
1400		else if(comparison == "==") return testValue == cutValue;
1401	<	else if(comparison == "=") return testValue == cutValue;
1401	>	else if(comparison == "=")  return testValue == cutValue;
1402		else if(comparison == "!=") return testValue != cutValue;
1403		else {clog << "WARNING: invalid comparison operator '" << comparison << "'\n"; return false;}
1404
#	Line 2768 | Line 2779 | OSUAnalysis::valueLookup (const BNtrack*
2779		else if(variable == "nHitsMissingInner")  value = object->nHitsMissingInner;
2780		else if(variable == "nHitsMissingMiddle") value = object->nHitsMissingMiddle;
2781		else if(variable == "depTrkRp3")          value = object->depTrkRp3;
2782	<	else if(variable == "trkRelIsoRp3")       value = (object->depTrkRp3 - object->pt) / object->pt;
2783	<	else if(variable == "trkRelIsoRp5")       value = (object->depTrkRp5 - object->pt) / object->pt;
2782	>	else if(variable == "trkRelIsoRp3")     { value = (object->depTrkRp3 - object->pt) / object->pt; if (value<0) value = 0; }
2783	>	else if(variable == "trkRelIsoRp5")     { value = (object->depTrkRp5 - object->pt) / object->pt; if (value<0) value = 0; }
2784		else if(variable == "depEcalRp3")         value = object->depEcalRp3;
2785		else if(variable == "depHcalRp3")         value = object->depHcalRp3;
2786		else if(variable == "depHoRp3")           value = object->depHoRp3;
#	Line 2793 | Line 2804 | OSUAnalysis::valueLookup (const BNtrack*
2804		else if(variable == "dZwrtBS") value = object->dZ - events->at(0).BSz;
2805		else if(variable == "depTrkRp5MinusPt"){
2806		if ( (object->depTrkRp5 - object->pt) < 0 ) {
2807	<	//       cout << "Warning:  found track with depTrkRp5 < pt:  depTrkRp5=" << object->depTrkRp5
2807	>	//       clog << "Warning:  found track with depTrkRp5 < pt:  depTrkRp5=" << object->depTrkRp5
2808		//         << "; pt=" << object->pt
2809		//         << "; object->depTrkRp5 - object->pt = " << object->depTrkRp5 - object->pt
2810		//         << endl;
#	Line 2819 | Line 2830 | OSUAnalysis::valueLookup (const BNtrack*
2830		else if(variable == "caloTotDeltaRp5ByP")         value = ((object->caloHadDeltaRp5 + object->caloEMDeltaRp5)/pMag);
2831		else if(variable == "caloTotDeltaRp5RhoCorr")     value = getTrkCaloTotRhoCorr(object);
2832		else if(variable == "caloTotDeltaRp5ByPRhoCorr")  value = getTrkCaloTotRhoCorr(object) / pMag;
2833	+	else if(variable == "depTrkRp5RhoCorr")           value = getTrkDepTrkRp5RhoCorr(object);
2834	+	else if(variable == "depTrkRp3RhoCorr")           value = getTrkDepTrkRp3RhoCorr(object);
2835	+
2836	+	else if(variable == "depTrkRp5MinusPtRhoCorr")    {
2837	+	if ( (getTrkDepTrkRp5RhoCorr(object) - object->pt) < 0 ) value = 0;
2838	+	else {value = (getTrkDepTrkRp5RhoCorr(object) - object->pt );}
2839	+	}
2840	+
2841	+	else if(variable == "depTrkRp3MinusPtRhoCorr")
2842	+	{
2843	+	if ( (getTrkDepTrkRp3RhoCorr(object) - object->pt) < 0 ) value = 0;
2844	+	else {value = (getTrkDepTrkRp3RhoCorr(object) - object->pt );}
2845	+	}
2846	+
2847		else if(variable == "isIso")                      value = getTrkIsIso(object, tracks.product());
2848		else if(variable == "isMatchedDeadEcal")          value = getTrkIsMatchedDeadEcal(object);
2849		else if(variable == "ptErrorByPt")                value = (object->ptError/object->pt);
#	Line 2843 | Line 2868 | OSUAnalysis::valueLookup (const BNtrack*
2868		value = vz - (vx * px + vy * py)/pt * (pz/pt);
2869		}
2870
2871	<
2871	>	else if(variable == "deltaRMinSubLeadJet") {
2872	>	// calculate minimum deltaR between track and any other subleading jet
2873	>	double trkJetDeltaRMin = 99.;
2874	>	for (uint ijet = 0; ijet<jets->size(); ijet++) {
2875	>	string empty = "";
2876	>	double isSubLeadingJet = valueLookup(&jets->at(ijet), "disappTrkSubLeadingJetID", "", empty);
2877	>	if (!isSubLeadingJet) continue;  // only consider jets that pass the subleading jet ID criteria
2878	>	double jetEta = valueLookup(&jets->at(ijet), "eta", "", empty);
2879	>	double jetPhi = valueLookup(&jets->at(ijet), "phi", "", empty);
2880	>	double trkJetDeltaR = deltaR(object->eta, object->phi, jetEta, jetPhi);
2881	>	if (trkJetDeltaR < trkJetDeltaRMin) trkJetDeltaRMin = trkJetDeltaR;
2882	>	}
2883	>	value = trkJetDeltaRMin;
2884	>	}
2885	>
2886		else if(variable == "genDeltaRLowest") value = getGenDeltaRLowest(object);
2887
2888		else if(variable == "genMatchedPdgId"){
#	Line 2891 | Line 2930 | OSUAnalysis::valueLookup (const BNtrack*
2930
2931
2932
2933	<	else{clog << "WARNING: invalid variable '" << variable << "'\n"; value = -999;}
2933	>	else{clog << "WARNING: invalid variable '" << variable << "' for BNtrack collection.\n"; value = -999;}
2934
2935		value = applyFunction(function, value);
2936
#	Line 4159 | Line 4198 | OSUAnalysis::getTrkCaloTotRhoCorr(const
4198
4199		}
4200
4201	+	double
4202	+	OSUAnalysis::getTrkDepTrkRp5RhoCorr(const BNtrack* track) {
4203	+	// Return the pile-up (rho) corrected isolation energy, i.e., the total calorimeter energy around the candidate track.
4204	+	if (!useTrackCaloRhoCorr_) return -99;
4205	+	// if (!rhokt6CaloJetsHandle_) {
4206	+	//   clog << "ERROR [getTrkCaloTotRhoCorr]:  The collection rhokt6CaloJetsHandle is not available!" << endl;
4207	+	//   return -99;
4208	+	// }
4209	+	double radDeltaRCone = 0.5;
4210	+	double rhoCorr_kt6CaloJets = *rhokt6CaloJetsHandle_ * TMath::Pi() * pow(radDeltaRCone, 2);  // Define effective area as pi*r^2, where r is radius of DeltaR cone.
4211	+	double rawDepTrkRp5 = track->depTrkRp5;
4212	+	double depTrkRp5RhoCorr = TMath::Max(0., rawDepTrkRp5 - rhoCorr_kt6CaloJets);
4213	+	return depTrkRp5RhoCorr;
4214	+
4215	+	}
4216	+
4217	+	double
4218	+	OSUAnalysis::getTrkDepTrkRp3RhoCorr(const BNtrack* track) {
4219	+	// Return the pile-up (rho) corrected isolation energy, i.e., the total calorimeter energy around the candidate track.
4220	+	if (!useTrackCaloRhoCorr_) return -99;
4221	+	// if (!rhokt6CaloJetsHandle_) {
4222	+	//   clog << "ERROR [getTrkCaloTotRhoCorr]:  The collection rhokt6CaloJetsHandle is not available!" << endl;
4223	+	//   return -99;
4224	+	// }
4225	+	double radDeltaRCone = 0.3;
4226	+	// Define effective area as pi*r^2, where r is radius of DeltaR cone
4227	+	double rhoCorr_kt6CaloJets = *rhokt6CaloJetsHandle_ * TMath::Pi() * pow(radDeltaRCone, 2);
4228	+	double rawDepTrkRp3 = track->depTrkRp3;
4229	+	double depTrkRp3RhoCorr = TMath::Max(0., rawDepTrkRp3 - rhoCorr_kt6CaloJets);
4230	+	return depTrkRp3RhoCorr;
4231	+
4232	+	}
4233	+
4234
4235
4236
#	Line 4235 | Line 4307 | OSUAnalysis::applyFunction(string functi
4307		template <class InputCollection>
4308		void OSUAnalysis::setObjectFlags(cut &currentCut, uint currentCutIndex, flagMap &individualFlags, flagMap &cumulativeFlags, InputCollection inputCollection, string inputType){
4309
4310	+	if (verbose_>2) clog << "  Beginning setObjectFlags for cut " << currentCutIndex << ": " << currentCut.name
4311	+	<< ", inputType=" << inputType
4312	+	<< endl;
4313		if (currentCut.inputCollection.find("pair")!=string::npos)  {
4314		string obj1, obj2;
4315		getTwoObjs(currentCut.inputCollection, obj1, obj2);
#	Line 4275 | Line 4350 | void OSUAnalysis::setObjectFlags(cut &cu
4350		}
4351		cutDecision = tempDecision;
4352		}
4353	<	//invert the cut for plotting if this cut is a veto
4354	<	if(currentCut.isVeto) plotDecision = !cutDecision;
4355	<	else plotDecision = cutDecision;
4353	>	//invert the cut if this cut is a veto
4354	>	if(currentCut.isVeto) cutDecision = !cutDecision;
4355	>	plotDecision = cutDecision;
4356		}
4357
4358		individualFlags.at(inputType).at(currentCutIndex).push_back(make_pair(cutDecision,plotDecision));
#	Line 4300 | Line 4375 | void OSUAnalysis::setObjectFlags(cut &cu
4375
4376		}
4377
4378	<	}
4378	>	} // end void OSUAnalysis::setObjectFlags
4379
4380
4381		template <class InputCollection1, class InputCollection2>
4382	<	void OSUAnalysis::setObjectFlags(cut &currentCut, uint currentCutIndex, flagMap &individualFlags, flagMap &cumulativeFlags, \
4383	<	InputCollection1 inputCollection1, InputCollection2 inputCollection2, flagPair flags1, flagPair flags2, string inputType){
4384	<
4382	>	void OSUAnalysis::setObjectFlags(cut &currentCut, uint currentCutIndex, flagMap &individualFlags, flagMap &cumulativeFlags,
4383	>	InputCollection1 inputCollection1, InputCollection2 inputCollection2, string inputType){
4384	>	// This function sets the flags for the paired object collection.
4385	>	// If the cut is applying on the given paired object collection, then the flags for the single object collections are also set.
4386	>	// If not, then the flags for the paired object collection are taken as the AND of the flags for each single object collection.
4387	>
4388	>	if (verbose_>2) clog << "  Beginning setObjectFlags for cut=" << currentCut.name
4389	>	<< ", inputType=" << inputType
4390	>	<< endl;
4391
4392		bool sameObjects = false;
4393	<	if(typeid(InputCollection1).name() == typeid(InputCollection2).name()) sameObjects = true;
4393	>	if(typeid(InputCollection1).name() == typeid(InputCollection2).name()) sameObjects = true;  // FIXME:  is sameObjects just the not of isTwoTypesOfObject?  If so, it's redundant.
4394
4395		// Get the strings for the two objects that make up the pair.
4396		string obj1Type, obj2Type;
#	Line 4340 | Line 4421 | void OSUAnalysis::setObjectFlags(cut &cu
4421		if(sameObjects && object1 >= object2) continue;//account for duplicate pairs if both collections are the same
4422
4423
4424	<	bool cutDecision = true;//object passes if this cut doesn't cut on that type of object
4424	>	bool cutDecision  = true;//object passes if this cut doesn't cut on that type of object
4425		bool plotDecision = true;
4426
4427	+	// Determine whether each pair passes the cut, only if inputCollection is the same as the inputType.
4428		if(currentCut.inputCollection == inputType){
4429
4430		vector<bool> subcutDecisions;
4431		for( int subcutIndex = 0; subcutIndex != currentCut.numSubcuts; subcutIndex++){
4432		string stringValue = "";
4433		double value = valueLookup(&inputCollection1->at(object1), &inputCollection2->at(object2), currentCut.variables.at(subcutIndex), currentCut.functions.at(subcutIndex), stringValue);
4434	+	if (verbose_>1) clog << currentCut.variables.at(subcutIndex) << " = " << value
4435	+	<< endl;
4436		if (stringValue == "") subcutDecisions.push_back(evaluateComparison(value,currentCut.comparativeOperators.at(subcutIndex),currentCut.cutValues.at(subcutIndex)));
4437		else subcutDecisions.push_back(evaluateComparison(stringValue,currentCut.comparativeOperators.at(subcutIndex),currentCut.cutStringValues.at(subcutIndex)));
4438		}
#	Line 4364 | Line 4448 | void OSUAnalysis::setObjectFlags(cut &cu
4448		}
4449		cutDecision = tempDecision;
4450		}
4451	<	//invert the cut for plotting if this cut is a veto
4452	<	if(currentCut.isVeto) plotDecision = !cutDecision;
4453	<	else plotDecision = cutDecision;
4454	<	}
4455	<	individualFlags.at(inputType).at(currentCutIndex).push_back(make_pair(cutDecision,plotDecision));
4456	<	if (cutDecision && currentCut.inputCollection == inputType) {  // only set the flags for the individual objects if the pair object is being cut on
4457	<	individualFlags.at(obj1Type).at(currentCutIndex).at(object1).first = true;
4458	<	individualFlags.at(obj2Type).at(currentCutIndex).at(object2).first = true;
4459	<	}
4460	<	if (plotDecision && currentCut.inputCollection == inputType) {  // only set the flags for the individual objects if the pair object is being cut on
4461	<	individualFlags.at(obj1Type).at(currentCutIndex).at(object1).second = true;
4462	<	individualFlags.at(obj2Type).at(currentCutIndex).at(object2).second = true;
4463	<	}
4451	>	//invert the cut if this cut is a veto
4452	>	if (currentCut.isVeto) cutDecision = !cutDecision;
4453	>	plotDecision = cutDecision;
4454	>
4455	>	if (verbose_>1) clog << " cutDecision = " << cutDecision
4456	>	<< "; for currentCut.inputCollection = " << currentCut.inputCollection
4457	>	<< "; object1 (" << obj1Type << ") = " << object1
4458	>	<< "; object2 (" << obj2Type << ") = " << object2
4459	>	<< endl;
4460	>
4461	>	if (cutDecision) {  // only set the flags for the individual objects if the pair object is being cut on
4462	>	individualFlags.at(obj1Type).at(currentCutIndex).at(object1).first = true;
4463	>	individualFlags.at(obj2Type).at(currentCutIndex).at(object2).first = true;
4464	>	}
4465	>	if (plotDecision) {  // only set the flags for the individual objects if the pair object is being cut on
4466	>	individualFlags.at(obj1Type).at(currentCutIndex).at(object1).second = true;
4467	>	individualFlags.at(obj2Type).at(currentCutIndex).at(object2).second = true;
4468	>	}
4469	>
4470	>
4471	>	} // if(currentCut.inputCollection == inputType){
4472	>
4473	>	// The individualFlags will be true if the inputCollection is not the same as the inputType.
4474	>	// They are also independent of the previous flags on the single objects.
4475	>	individualFlags.at(inputType).at(currentCutIndex).push_back(make_pair(cutDecision,plotDecision));
4476
4477	<	//set flags for objects that pass this cut AND all the previous cuts
4477	>
4478	>
4479	>	// ************************************
4480	>	// Determine cumulative flags
4481	>	// ************************************
4482	>	// determine whether this paired object passes this cut AND all previous cuts
4483		bool previousCumulativeCutFlag = true;
4484		for(uint previousCutIndex = 0; previousCutIndex != currentCutIndex; previousCutIndex++){
4485	<	if(previousCumulativeCutFlag && individualFlags.at(inputType).at(previousCutIndex).at(counter).first) previousCumulativeCutFlag = true;
4486	<	else{ previousCumulativeCutFlag = false; break;}
4485	>	if(previousCumulativeCutFlag && individualFlags.at(inputType).at(previousCutIndex).at(counter).first) previousCumulativeCutFlag = true;
4486	>	else{ previousCumulativeCutFlag = false; break;}
4487		}
4488		previousCumulativeCutFlag = previousCumulativeCutFlag && cutDecision;
4489
#	Line 4393 | Line 4494 | void OSUAnalysis::setObjectFlags(cut &cu
4494		}
4495		previousCumulativePlotFlag = previousCumulativePlotFlag && plotDecision;
4496
4497	<	//apply flags for the components of the composite object as well
4497	>	// Get the index for the flags of each of the single objects in the pair.  Usually this is the index of the previous cut, i.e., currentCutIndex-1.
4498	>	int cutIdxFlagsObj1 = max(int(currentCutIndex-1),0);
4499	>	int cutIdxFlagsObj2 = max(int(currentCutIndex-1),0);
4500	>	// If the inputCollection of the cut is not equal to the inputType but the inputCollection includes objects that are contained in inputType, then use the currentCutIndex for those collections.
4501	>	// For example, if the inputType is jet-jet pairs, and the inputCollection is track-jet pairs, then use currentCutIndex for cutIdxFlagsObj{1,2}, i.e., for both jets.
4502	>	// For example, if the inputType is jets, and the inputCollection is track-jet pairs, then use currentCutIndex for cutIdxFlagsObj2 (jets) and currentCutIndex-1 for cutIdxFlagsObj1 (tracks).
4503	>	if (currentCut.inputCollection != inputType) {
4504	>	if (currentCut.inputCollection.find(obj1Type)!=string::npos) cutIdxFlagsObj1 = currentCutIndex;
4505	>	if (currentCut.inputCollection.find(obj2Type)!=string::npos) cutIdxFlagsObj2 = currentCutIndex;
4506	>	}
4507	>	flagPair flags1 = cumulativeFlags.at(obj1Type).at(cutIdxFlagsObj1);  // flag for input collection 1
4508	>	flagPair flags2 = cumulativeFlags.at(obj2Type).at(cutIdxFlagsObj2);  // flag for input collection 2
4509	>
4510	>	// The cumulative flag is only true if the paired object cumulative flag is true, and if the single object cumulative flags are true.
4511		bool currentCumulativeCutFlag = true;
4512		bool currentCumulativePlotFlag = true;
4399	–
4513		if(flags1.size() == 0 && flags2.size() == 0) currentCumulativeCutFlag = previousCumulativeCutFlag;
4514		else if(flags1.size() == 0) currentCumulativeCutFlag = previousCumulativeCutFlag && flags2.at(object2).first;
4515		else if(flags2.size() == 0) currentCumulativeCutFlag = previousCumulativeCutFlag && flags1.at(object1).first;
#	Line 4407 | Line 4520 | void OSUAnalysis::setObjectFlags(cut &cu
4520		else if(flags2.size() == 0) currentCumulativePlotFlag = previousCumulativePlotFlag && flags1.at(object1).second;
4521		else currentCumulativePlotFlag = previousCumulativePlotFlag && flags1.at(object1).first && flags2.at(object2).second;
4522
4523	<	cumulativeFlags.at(inputType).at(currentCutIndex).push_back(make_pair(currentCumulativeCutFlag,currentCumulativePlotFlag));
4523	>	cumulativeFlags.at(inputType).at(currentCutIndex).push_back(make_pair(currentCumulativeCutFlag,currentCumulativePlotFlag));  // Set the flag for the paired object
4524
4412	–	if (currentCumulativeCutFlag && currentCut.inputCollection == inputType) {  // only set the flags for the individual objects if the pair object is being cut on
4413	–	cumulativeFlags.at(obj1Type).at(currentCutIndex).at(object1).first = true && getPreviousCumulativeFlags(currentCutIndex, individualFlags, obj1Type, object1, "cut");
4414	–	cumulativeFlags.at(obj2Type).at(currentCutIndex).at(object2).first = true && getPreviousCumulativeFlags(currentCutIndex, individualFlags, obj2Type, object2, "cut");
4415	–	}
4525
4526	<	if (currentCumulativePlotFlag && currentCut.inputCollection == inputType) {  // only set the flags for the individual objects if the pair object is being cut on
4526	>	if (currentCumulativeCutFlag && currentCut.inputCollection == inputType) {  // Set the flags for the individual objects if the paired object is being cut on.
4527	>	cumulativeFlags.at(obj1Type).at(currentCutIndex).at(object1).first  = true && getPreviousCumulativeFlags(currentCutIndex, individualFlags, obj1Type, object1, "cut");
4528	>	cumulativeFlags.at(obj2Type).at(currentCutIndex).at(object2).first  = true && getPreviousCumulativeFlags(currentCutIndex, individualFlags, obj2Type, object2, "cut");
4529		cumulativeFlags.at(obj1Type).at(currentCutIndex).at(object1).second = true && getPreviousCumulativeFlags(currentCutIndex, individualFlags, obj1Type, object1, "plot");
4530		cumulativeFlags.at(obj2Type).at(currentCutIndex).at(object2).second = true && getPreviousCumulativeFlags(currentCutIndex, individualFlags, obj2Type, object2, "plot");
4531	+
4532	+	if (verbose_>1) clog << " previousCumulativeCutFlag for object1 = " << getPreviousCumulativeFlags(currentCutIndex, individualFlags, obj2Type, object1, "cut") << endl;
4533	+	if (verbose_>1) clog << " previousCumulativeCutFlag for object2 = " << getPreviousCumulativeFlags(currentCutIndex, individualFlags, obj2Type, object2, "cut") << endl;
4534	+
4535		}
4536
4537		counter++;
#	Line 4424 | Line 4539 | void OSUAnalysis::setObjectFlags(cut &cu
4539		} // end   for (uint object2 = 0; object2 != inputCollection2->size(); object2++)
4540		}  // end   for (uint object1 = 0; object1 != inputCollection1->size(); object1++)
4541
4542	<	}
4542	>	} // end void OSUAnalysis::setObjectFlags
4543
4544
4545		bool OSUAnalysis::getPreviousCumulativeFlags(uint currentCutIndex, flagMap &individualFlags, string obj1Type, uint object1, string flagType) {
#	Line 4469 | Line 4584 | void OSUAnalysis::assignTreeBranch(Branc
4584		template <class InputCollection>
4585		void OSUAnalysis::fill1DHistogram(TH1* histo, histogram parameters, InputCollection inputCollection, flagPair flags, double scaleFactor){
4586
4587	+	if (verbose_>2) clog << "  Filling histogram for " << parameters.name << endl;
4588
4589		for (uint object = 0; object != inputCollection->size(); object++){
4590
#	Line 4492 | Line 4608 | void OSUAnalysis::fill1DHistogram(TH1* h
4608
4609		if (printEventInfo_) {
4610		// Write information about event to screen, for testing purposes.
4611	<	clog << "  Info for event:  value for histogram " << histo->GetName() << ":  " << value << endl;
4611	>	clog << "  Info for event:  value for histogram " << histo->GetName() << ":  " << value << " (object number " << object << ")" << endl;
4612		}
4613
4614		}
4615		}
4616
4617		template <class InputCollection1, class InputCollection2>
4618	<	void OSUAnalysis::fill1DHistogram(TH1* histo, histogram parameters, InputCollection1 inputCollection1, InputCollection2 inputCollection2, flagPair flags1, flagPair flags2, flagPair pairFlags, double scaleFactor){
4618	>	void OSUAnalysis::fill1DHistogram(TH1* histo, histogram parameters, InputCollection1 inputCollection1, InputCollection2 inputCollection2,
4619	>	flagPair pairFlags, double scaleFactor){
4620
4621		bool sameObjects = false;
4622		if(typeid(InputCollection1).name() == typeid(InputCollection2).name()) sameObjects = true;
#	Line 4511 | Line 4628 | void OSUAnalysis::fill1DHistogram(TH1* h
4628		if(sameObjects && object1 >= object2) continue;//account for duplicate pairs if both collections are the same
4629
4630		pairCounter++;
4514	–	//only take objects which have passed all cuts and pairs which have passed all cuts
4515	–	if(!plotAllObjectsInPassingEvents_ && !flags1.at(object1).second) continue;
4516	–	if(!plotAllObjectsInPassingEvents_ && !flags2.at(object2).second) continue;
4631		if(!plotAllObjectsInPassingEvents_ && !pairFlags.at(pairCounter).second) continue;
4632
4633		string currentString = parameters.inputVariables.at(0);
#	Line 4532 | Line 4646 | void OSUAnalysis::fill1DHistogram(TH1* h
4646		double value = valueLookup(&inputCollection1->at(object1), &inputCollection2->at(object2), inputVariable, function, stringValue);
4647		histo->Fill(value,scaleFactor);
4648
4649	+	if (printEventInfo_) {
4650	+	// Write information about event to screen, for testing purposes.
4651	+	clog << "  Info for event:  value for histogram " << histo->GetName() << ":  " << value
4652	+	<< " (object1 number " << object1 << "), "
4653	+	<< " (object2 number " << object2 << ")"
4654	+	<< endl;
4655	+	}
4656	+
4657		}
4658		}
4659
#	Line 4580 | Line 4702 | void OSUAnalysis::fill2DHistogram(TH2* h
4702		}
4703
4704		template <class InputCollection1, class InputCollection2>
4705	<	void OSUAnalysis::fill2DHistogram(TH2* histo, histogram parameters, InputCollection1 inputCollection1, InputCollection2 inputCollection2, flagPair flags1, flagPair flags2, flagPair pairFlags, double scaleFactor){
4705	>	void OSUAnalysis::fill2DHistogram(TH2* histo, histogram parameters, InputCollection1 inputCollection1, InputCollection2 inputCollection2,
4706	>	flagPair pairFlags, double scaleFactor){
4707
4708		bool sameObjects = false;
4709		if(typeid(InputCollection1).name() == typeid(InputCollection2).name()) sameObjects = true;
#	Line 4593 | Line 4716 | void OSUAnalysis::fill2DHistogram(TH2* h
4716
4717		pairCounter++;
4718
4596	–	//only take objects which have passed all cuts and pairs which have passed all cuts
4597	–	if(!plotAllObjectsInPassingEvents_ && !flags1.at(object1).second) continue;
4598	–	if(!plotAllObjectsInPassingEvents_ && !flags2.at(object2).second) continue;
4719		if(!plotAllObjectsInPassingEvents_ && !pairFlags.at(pairCounter).second) continue;
4720
4721		string stringValue = "";

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines