HF-Particle/HFTrigger/HFTriggerMVA.cc

0001 #include "HFTriggerMVA.h"
0002
0003 /*
0004  * Basic heavy flavor software trigger
0005  * Used in study of hardware trigger
0006  * Cameron Dean
0007  * 01/02/2021
0008  */
0009 std::map<std::string, bool> triggerDecisionsMVA =
0010 {
0011   {"cuts", false}
0012 , {"cutsWithoutCalo", false}
0013 , {"MVAWithCalo", false}
0014 , {"MVAWithoutCalo", false}
0015 , {"MVAWithoutCaloAndMinTrack", false}
0016 };
0017 /*
0018 namespace HFTriggerMVARequirement
0019 {
0020   float meanMult = 12; //Set min num. INTT hits
0021   float asymmMult = 0.1; //Set asymm between INTT layers (fraction)
0022   float trackVertex3DDCA = 0.05; //Min. 3D DCA of a track with any vertex in cm
0023   float trackVertex2DDCA = 0.05; //Max. 2D DCA of a track with any vertex in cm
0024   float trackTrackDCA = 0.05; //Max. DCA of a track with other tracks in cm
0025   float minEMCalEnergy = 0.5;
0026   float MVA_wCaloResponse = -0.05;
0027   float MVA_woutCaloResponse = -0.05;
0028   float MVA_woutCaloOrMinTrackResponse = -0.05;
0029 }
0030 */
0031 HFTriggerMVA::HFTriggerMVA()
0032   : SubsysReco("HFTRIGGER")
0033   , m_useCutsTrigger(true)
0034   , m_useCutswoutTrigger(true)
0035   , m_useMVAwCaloTrigger(true)
0036   , m_useMVAwoutCaloTrigger(true)
0037   , m_useMVAwoutCaloAndMinTrackTrigger(true)
0038 {
0039 }
0040
0041 HFTriggerMVA::HFTriggerMVA(const std::string &name)
0042   : SubsysReco(name)
0043   , m_useCutsTrigger(true)
0044   , m_useCutswoutTrigger(true)
0045   , m_useMVAwCaloTrigger(true)
0046   , m_useMVAwoutCaloTrigger(true)
0047   , m_useMVAwoutCaloAndMinTrackTrigger(true)
0048 {
0049 }
0050
0051 int HFTriggerMVA::Init(PHCompositeNode *topNode)
0052 {
0053   std::cout << "--Cut parameters--" << std::endl;
0054   std::cout << "meanMult: " << meanMult << std::endl;
0055   std::cout << "trackVertex3DDCA: " << trackVertex3DDCA << std::endl;
0056   std::cout << "trackVertex2DDCA: " << trackVertex2DDCA << std::endl;
0057   std::cout << "trackTrackDCA: " << trackTrackDCA << std::endl;
0058   std::cout << "minEMCalEnergy: " << minEMCalEnergy << std::endl;
0059   std::cout << "MVA_wCaloResponse: " << MVA_wCaloResponse << std::endl;
0060   std::cout << "MVA_woutCaloResponse: " << MVA_woutCaloResponse << std::endl;
0061   std::cout << "MVA_woutCaloOrMinTrackResponse: " << MVA_woutCaloOrMinTrackResponse << std::endl;
0062   std::cout << "-----------------" << std::endl;
0063
0064   if (m_useMVAwCaloTrigger)
0065   {
0066     std::string algorithmFile = path + "wCalo/TMVAClassification_" + mvaType + ".weights.xml";
0067     std::tie(wCaloReader, wCaloFloats) = initMVA(varListwCalo, mvaType, algorithmFile);
0068   }
0069   if (m_useMVAwoutCaloTrigger)
0070   {
0071     std::string algorithmFile = path + "woutCalo/TMVAClassification_" + mvaType + ".weights.xml";
0072     std::tie(woutCaloReader, woutCaloFloats) = initMVA(varListwoutCalo, mvaType, algorithmFile);
0073   }
0074   if (m_useMVAwoutCaloAndMinTrackTrigger)
0075   {
0076     std::string algorithmFile = path + "woutCaloAndMinTrack/TMVAClassification_" + mvaType + ".weights.xml";
0077     std::tie(woutCaloAndMinTrackReader, woutCaloAndMinTrackFloats) = initMVA(varListwoutCaloAndMinTrack, mvaType, algorithmFile);
0078   }
0079
0080   return 0;
0081 }
0082
0083 int HFTriggerMVA::process_event(PHCompositeNode *topNode)
0084 {
0085   bool successfulTrigger = runTrigger(topNode);
0086
0087   if (Verbosity() >= VERBOSITY_MORE)
0088   {
0089     if (successfulTrigger) std::cout << "One of the heavy flavor triggers fired" << std::endl;
0090     else std::cout << "No heavy flavor triggers fired" << std::endl;
0091   }
0092
0093   if (triggerDecisionsMVA.find("cuts")->second && triggerDecisionsMVA.find("MVAWithCalo")->second) m_cuts_and_mva_wcalo_counter += 1;
0094   if (!triggerDecisionsMVA.find("cuts")->second && triggerDecisionsMVA.find("MVAWithCalo")->second) m_no_cuts_and_mva_wcalo_counter += 1;
0095   if (triggerDecisionsMVA.find("cuts")->second && !triggerDecisionsMVA.find("MVAWithCalo")->second) m_cuts_and_no_mva_wcalo_counter += 1;
0096   if (!triggerDecisionsMVA.find("cuts")->second && !triggerDecisionsMVA.find("MVAWithCalo")->second) m_no_cuts_and_no_mva_wcalo_counter += 1;
0097
0098   if (triggerDecisionsMVA.find("cutsWithoutCalo")->second && triggerDecisionsMVA.find("MVAWithoutCalo")->second) m_cuts_and_mva_woutcalo_counter += 1;
0099   if (!triggerDecisionsMVA.find("cutsWithoutCalo")->second && triggerDecisionsMVA.find("MVAWithoutCalo")->second) m_no_cuts_and_mva_woutcalo_counter += 1;
0100   if (triggerDecisionsMVA.find("cutsWithoutCalo")->second && !triggerDecisionsMVA.find("MVAWithoutCalo")->second) m_cuts_and_no_mva_woutcalo_counter += 1;
0101   if (!triggerDecisionsMVA.find("cutsWithoutCalo")->second && !triggerDecisionsMVA.find("MVAWithoutCalo")->second) m_no_cuts_and_no_mva_woutcalo_counter += 1;
0102
0103   if (triggerDecisionsMVA.find("cutsWithoutCalo")->second && triggerDecisionsMVA.find("MVAWithoutCaloAndMinTrack")->second) m_cuts_and_mva_woutcalo_and_mintracks_counter += 1;
0104   if (!triggerDecisionsMVA.find("cutsWithoutCalo")->second && triggerDecisionsMVA.find("MVAWithoutCaloAndMinTrack")->second) m_no_cuts_and_mva_woutcalo_and_mintracks_counter += 1;
0105   if (triggerDecisionsMVA.find("cutsWithoutCalo")->second && !triggerDecisionsMVA.find("MVAWithoutCaloAndMinTrack")->second) m_cuts_and_no_mva_woutcalo_and_mintracks_counter += 1;
0106   if (!triggerDecisionsMVA.find("cutsWithoutCalo")->second && !triggerDecisionsMVA.find("MVAWithoutCaloAndMinTrack")->second) m_no_cuts_and_no_mva_woutcalo_and_mintracks_counter += 1;
0107
0108   m_events += 1;
0109   if (successfulTrigger) m_counter += 1;
0110   if (!successfulTrigger) m_no_trigger += 1;
0111
0112   triggerDecisionsMVA.find("cuts")->second = false;
0113   triggerDecisionsMVA.find("cutsWithoutCalo")->second = false;
0114   triggerDecisionsMVA.find("MVAWithCalo")->second = false;
0115   triggerDecisionsMVA.find("MVAWithoutCalo")->second = false;
0116   triggerDecisionsMVA.find("MVAWithoutCaloAndMinTrack")->second = false;
0117
0118   return Fun4AllReturnCodes::EVENT_OK;
0119 }
0120
0121 int HFTriggerMVA::End(PHCompositeNode *topNode)
0122 {
0123   if (Verbosity() >= VERBOSITY_SOME) printRunRecord();
0124   return 0;
0125 }
0126
0127 bool HFTriggerMVA::runTrigger(PHCompositeNode *topNode)
0128 {
0129   bool anyTriggerFired = false;
0130
0131   std::vector<Track> allTracks = makeAllTracks(topNode);
0132   std::vector<Vertex> allVertices = makeAllPrimaryVertices(topNode);
0133
0134   float min_TrackVertex_3D_DCA = 0;
0135   float min_TrackVertex_2D_DCA = 0;
0136   float max_TrackVertex_3D_DCA = 0;
0137   float max_TrackVertex_2D_DCA = 0;
0138   float min_TrackTrack_3D_DCA = 0;
0139
0140   float meanMult = 0;
0141   float asymmMult = 0;
0142   calculateMultiplicity(topNode, meanMult, asymmMult);
0143
0144   float maxEMCalEnergy = getMaxEMCalEnergy(topNode);
0145
0146   for (unsigned int k = 0; k < allVertices.size(); k++)
0147   {
0148     for (unsigned int i = 0; i < allTracks.size(); i++)
0149     {
0150       for (unsigned int j = i + 1; j < allTracks.size(); j++)
0151       {
0152
0153         getIPVariables(allTracks[i], allTracks[j], allVertices[k],
0154                        min_TrackVertex_3D_DCA, min_TrackVertex_2D_DCA,
0155                        max_TrackVertex_3D_DCA, max_TrackVertex_2D_DCA,
0156                        min_TrackTrack_3D_DCA);
0157
0158         wCaloFloats[0] = woutCaloFloats[0] = min_TrackVertex_3D_DCA;
0159         wCaloFloats[1] = woutCaloFloats[1] = min_TrackVertex_2D_DCA;
0160         wCaloFloats[2] = woutCaloFloats[2] = woutCaloAndMinTrackFloats[0] = max_TrackVertex_3D_DCA;
0161         wCaloFloats[3] = woutCaloFloats[3] = woutCaloAndMinTrackFloats[1] = max_TrackVertex_2D_DCA;
0162         wCaloFloats[4] = maxEMCalEnergy;
0163         wCaloFloats[5] = woutCaloFloats[4] = woutCaloAndMinTrackFloats[2] = min_TrackTrack_3D_DCA;
0164         wCaloFloats[6] = woutCaloFloats[5] = woutCaloAndMinTrackFloats[3] = meanMult;
0165
0166         if (m_useCutsTrigger)
0167         {
0168           bool trigger = runCutsTrigger(meanMult, maxEMCalEnergy,
0169                                         max_TrackVertex_3D_DCA,
0170                                         max_TrackVertex_2D_DCA,
0171                                         min_TrackTrack_3D_DCA);
0172
0173           if (trigger) triggerDecisionsMVA.find("cuts")->second = true;
0174         }
0175
0176         if (m_useCutswoutTrigger)
0177         {
0178           bool trigger = runCutsTrigger(meanMult, FLT_MAX,
0179                                         max_TrackVertex_3D_DCA,
0180                                         max_TrackVertex_2D_DCA,
0181                                         min_TrackTrack_3D_DCA);
0182
0183           if (trigger) triggerDecisionsMVA.find("cutsWithoutCalo")->second = true;
0184         }
0185
0186         if (m_useMVAwCaloTrigger)
0187         {
0188           bool trigger = runMVATrigger(wCaloReader, mvaType, wCaloFloats, MVA_wCaloResponse);
0189           if (trigger) triggerDecisionsMVA.find("MVAWithCalo")->second = true;
0190         }
0191
0192         if (m_useMVAwoutCaloTrigger)
0193         {
0194           bool trigger = runMVATrigger(woutCaloReader, mvaType, woutCaloFloats, MVA_woutCaloResponse);
0195           if (trigger) triggerDecisionsMVA.find("MVAWithoutCalo")->second = true;
0196         }
0197
0198         if (m_useMVAwoutCaloAndMinTrackTrigger)
0199         {
0200           bool trigger = runMVATrigger(woutCaloAndMinTrackReader, mvaType, woutCaloAndMinTrackFloats, MVA_woutCaloOrMinTrackResponse);
0201           if (trigger) triggerDecisionsMVA.find("MVAWithoutCaloAndMinTrack")->second = true;
0202         }
0203
0204       }
0205     }
0206   }
0207
0208   if (Verbosity() >= VERBOSITY_MORE) printTrigger();
0209
0210   const int numberOfFiredTriggers = std::accumulate(begin(triggerDecisionsMVA), end(triggerDecisionsMVA), 0,
0211                                                     [](const int previous, const std::pair<const std::string, bool>& element)
0212                                                     { return previous + element.second; });
0213
0214   if (numberOfFiredTriggers != 0) anyTriggerFired = true;
0215
0216   return anyTriggerFired;
0217 }
0218
0219 bool HFTriggerMVA::runCutsTrigger(float mean_hits, float emcal_energy,
0220                                   float IP, float IP_xy, float DCA)
0221 {
0222   bool triggerDecision = false;
0223
0224   if (mean_hits >= meanMult &&
0225       emcal_energy >= minEMCalEnergy &&
0226       IP >= trackVertex3DDCA &&
0227       IP_xy >= trackVertex2DDCA &&
0228       DCA <= trackTrackDCA) triggerDecision = true;
0229
0230   return triggerDecision;
0231 }
0232
0233 bool HFTriggerMVA::runMVATrigger(TMVA::Reader* reader, std::string method, std::vector<float> inputValues, float cut)
0234 {
0235   float mvaResponse = (Float_t) reader->EvaluateMVA(inputValues, method.c_str());
0236   return mvaResponse >= cut;
0237 }
0238
0239 void HFTriggerMVA::calculateMultiplicity(PHCompositeNode *topNode, float& meanMultiplicity, float& asymmetryMultiplicity)
0240 {
0241   TrkrHitSetContainer* hitContainer = findNode::getClass<TrkrHitSetContainer>(topNode, "TRKR_HITSET");
0242
0243   TrkrHitSetContainer::ConstRange inttHitSetRange[2];
0244   for (int i = 0; i < 2; i++) inttHitSetRange[i] = hitContainer->getHitSets(TrkrDefs::TrkrId::inttId, i + 4);
0245
0246   int inttHits[2] = {0};
0247
0248   for (int i = 0; i < 2; i++)
0249   {
0250     for (TrkrHitSetContainer::ConstIterator hitsetitr = inttHitSetRange[i].first;
0251          hitsetitr != inttHitSetRange[i].second;
0252          ++hitsetitr)
0253     {
0254       TrkrHitSet *hitset = hitsetitr->second;
0255       inttHits[i] += hitset->size();
0256     }
0257   }
0258
0259   meanMultiplicity = (inttHits[0] + inttHits[1])/2;
0260   asymmetryMultiplicity = (inttHits[0] - inttHits[1])/(inttHits[0] + inttHits[1]);
0261 }
0262
0263 float HFTriggerMVA::getMaxEMCalEnergy(PHCompositeNode *topNode)
0264 {
0265   float maxEnergy = 0;
0266   PHNodeIterator nodeIter(topNode);
0267   m_dst_trackmap = findNode::getClass<SvtxTrackMap>(topNode, "SvtxTrackMap");
0268
0269   for (SvtxTrackMap::Iter iter = m_dst_trackmap->begin(); iter != m_dst_trackmap->end(); ++iter)
0270   {
0271     m_dst_track = iter->second;
0272     float thisEnergy = m_dst_track->get_cal_cluster_e(SvtxTrack::CAL_LAYER(1));
0273     maxEnergy = std::max(maxEnergy, thisEnergy);
0274   }
0275
0276   return maxEnergy;
0277
0278 }
0279
0280 void HFTriggerMVA::getIPVariables(Track track1, Track track2, Vertex vertex,
0281                                float& minIP, float& minIP_xy,
0282                                float& maxIP, float& maxIP_xy, float& DCA)
0283 {
0284   float track1_IP = calcualteTrackVertexDCA(track1, vertex);
0285   float track1_IP_xy = calcualteTrackVertex2DDCA(track1, vertex);
0286   float track2_IP = calcualteTrackVertexDCA(track2, vertex);
0287   float track2_IP_xy = calcualteTrackVertex2DDCA(track2, vertex);
0288
0289   minIP = std::min(track1_IP, track2_IP);
0290   minIP_xy = std::min(track1_IP_xy, track2_IP_xy);
0291   maxIP = std::max(track1_IP, track2_IP);
0292   maxIP_xy = std::max(track1_IP_xy, track2_IP_xy);
0293   DCA = calcualteTrackTrackDCA(track1, track2);
0294 }
0295
0296 Vertex HFTriggerMVA::makeVertex(PHCompositeNode *topNode)
0297 {
0298   Vertex vertex;
0299
0300   vertex(0,0) = m_dst_vertex->get_x();
0301   vertex(1,0) = m_dst_vertex->get_y();
0302   vertex(2,0) = m_dst_vertex->get_z();
0303
0304   return vertex;
0305 }
0306
0307 std::vector<Vertex> HFTriggerMVA::makeAllPrimaryVertices(PHCompositeNode *topNode)
0308 {
0309   std::vector<Vertex> primaryVertices;
0310   m_dst_vertexmap = findNode::getClass<SvtxVertexMap>(topNode, "SvtxVertexMap");
0311
0312   for (SvtxVertexMap::ConstIter iter = m_dst_vertexmap->begin(); iter != m_dst_vertexmap->end(); ++iter)
0313   {
0314     m_dst_vertex = iter->second;
0315     primaryVertices.push_back(makeVertex(topNode));
0316   }
0317
0318   return primaryVertices;
0319 }
0320
0321 Track HFTriggerMVA::makeTrack(PHCompositeNode *topNode)
0322 {
0323   Track track;
0324
0325   track(0,0) = m_dst_track->get_x();
0326   track(1,0) = m_dst_track->get_y();
0327   track(2,0) = m_dst_track->get_z();
0328   track(3,0) = m_dst_track->get_px();
0329   track(4,0) = m_dst_track->get_py();
0330   track(5,0) = m_dst_track->get_pz();
0331
0332   return track;
0333 }
0334
0335 std::vector<Track> HFTriggerMVA::makeAllTracks(PHCompositeNode *topNode)
0336 {
0337   std::vector<Track> tracks;
0338   m_dst_trackmap = findNode::getClass<SvtxTrackMap>(topNode, "SvtxTrackMap");
0339
0340   for (SvtxTrackMap::Iter iter = m_dst_trackmap->begin(); iter != m_dst_trackmap->end(); ++iter)
0341   {
0342     m_dst_track = iter->second;
0343     tracks.push_back(makeTrack(topNode));
0344   }
0345
0346   return tracks;
0347 }
0348
0349 int HFTriggerMVA::decomposeTrack(Track track, TrackX& trackPosition, TrackP& trackMomentum)
0350 {
0351   for (unsigned int i = 0; i < 3; i++)
0352   {
0353     trackPosition(i,0) = track(i,0);
0354     trackMomentum(i,0) = track(i+3,0);
0355   }
0356
0357   return 0;
0358 }
0359
0360
0361 float HFTriggerMVA::calcualteTrackVertex2DDCA(Track track, Vertex vertex)
0362 {
0363   TrackX pos;
0364   TrackP mom;
0365   DCA dcaVertex;
0366
0367   decomposeTrack(track, pos, mom);
0368
0369   dcaVertex = pos - vertex - mom.dot(pos - vertex)*mom/(mom.dot(mom));
0370
0371   float twoD_DCA = std::sqrt(std::pow(dcaVertex[0], 2) + std::pow(dcaVertex[1], 2));
0372
0373   return twoD_DCA;
0374 }
0375
0376 float HFTriggerMVA::calcualteTrackVertexDCA(Track track, Vertex vertex)
0377 {
0378   TrackX pos;
0379   TrackP mom;
0380   DCA dcaVertex;
0381
0382   decomposeTrack(track, pos, mom);
0383
0384   dcaVertex = pos - vertex - mom.dot(pos - vertex)*mom/(mom.dot(mom));
0385
0386   return std::abs(dcaVertex.norm());
0387 }
0388
0389 float HFTriggerMVA::calcualteTrackTrackDCA(Track trackOne, Track trackTwo)
0390 {
0391   TrackX posOne;
0392   TrackP momOne;
0393   TrackX posTwo;
0394   TrackP momTwo;
0395   float dcaTrackSize;
0396
0397   decomposeTrack(trackOne, posOne, momOne);
0398   decomposeTrack(trackTwo, posTwo, momTwo);
0399
0400   Eigen::Vector3f momOneCrossmomTwo = momOne.cross(momTwo);
0401   Eigen::Vector3f posOneMinusposTwo = posOne - posTwo;
0402   dcaTrackSize = std::abs(momOneCrossmomTwo.dot(posOneMinusposTwo)/(momOneCrossmomTwo.norm()));
0403
0404   return dcaTrackSize;
0405 }
0406
0407 std::tuple<TMVA::Reader*, std::vector<Float_t>> HFTriggerMVA::initMVA(std::vector<std::string> variableList, std::string method, std::string mvaFile)
0408 {
0409   TMVA::Tools::Instance();  //Start TMVA
0410   TMVA::Reader *reader = new TMVA::Reader("!Color:!Silent");
0411
0412   std::vector<Float_t> reader_floats;
0413
0414   for (unsigned int i = 0; i < variableList.size(); ++i)
0415   {
0416     reader_floats.push_back(0);
0417     reader->AddVariable(variableList[i].c_str(), &reader_floats[i]);
0418   }
0419   reader->BookMVA(method.c_str(), mvaFile.c_str());
0420
0421   return make_tuple(reader, reader_floats);
0422 }
0423
0424 void HFTriggerMVA::printRunRecord()
0425 {
0426   std::cout << "\n---------------HFTriggerMVA run information---------------" << std::endl;
0427   std::cout << "The number of events processed is: " << m_events << std::endl;
0428   std::cout << "The number of events that did not trigger is: " << m_no_trigger << std::endl;
0429   std::cout << "The number of events that fired the cuts-based trigger is: " << m_cuts_and_no_mva_wcalo_counter + m_cuts_and_mva_wcalo_counter << std::endl;
0430   std::cout << "The number of events that fired the cuts-based trigger, with no calorimetry is: " << m_cuts_and_no_mva_woutcalo_counter + m_cuts_and_mva_woutcalo_counter << std::endl;
0431   std::cout << "The number of events that fired the MVA trigger is: " << m_no_cuts_and_mva_wcalo_counter + m_cuts_and_mva_wcalo_counter << std::endl;
0432   std::cout << "The number of events that fired the MVA trigger, with no calorimetry is: " << m_no_cuts_and_mva_woutcalo_counter + m_cuts_and_mva_woutcalo_counter << std::endl;
0433   std::cout << "The number of events that fired the MVA trigger, with no calorimetry or min track is: " << m_no_cuts_and_mva_woutcalo_and_mintracks_counter + m_cuts_and_mva_woutcalo_and_mintracks_counter << std::endl;
0434   std::cout << "The number of events triggered is: " << m_counter << std::endl;
0435   std::cout << "--Comparing cuts-based and MVA, both with Calorimetry:" << std::endl;
0436   std::cout << "----The number of events that fired the cuts-based trigger but not the MVA trigger is: " << m_cuts_and_no_mva_wcalo_counter << std::endl;
0437   std::cout << "----The number of events that fired the MVA trigger but not the cuts-based trigger is: " << m_no_cuts_and_mva_wcalo_counter << std::endl;
0438   std::cout << "----The number of events that fired both the cuts-based trigger and the MVA triggers is: " << m_cuts_and_mva_wcalo_counter  << std::endl;
0439   std::cout << "----The number of events that fired neither the cuts-based trigger or the MVA triggers is: " <<  m_no_cuts_and_no_mva_wcalo_counter << std::endl;
0440   std::cout << "--Comparing cuts-based and MVA, both without Calorimetry:" << std::endl;
0441   std::cout << "----The number of events that fired the cuts-based trigger but not the MVA trigger is: " << m_cuts_and_no_mva_woutcalo_counter << std::endl;
0442   std::cout << "----The number of events that fired the MVA trigger but not the cuts-based trigger is: " << m_no_cuts_and_mva_woutcalo_counter << std::endl;
0443   std::cout << "----The number of events that fired both the cuts-based trigger and the MVA triggers is: " << m_cuts_and_mva_woutcalo_counter  << std::endl;
0444   std::cout << "----The number of events that fired neither the cuts-based trigger or the MVA triggers is: " <<  m_no_cuts_and_no_mva_woutcalo_counter << std::endl;
0445   std::cout << "--Comparing cuts-based and MVA without Calorimetry or IP of second track:" << std::endl;
0446   std::cout << "----The number of events that fired the cuts-based trigger but not the MVA trigger is: " << m_cuts_and_no_mva_woutcalo_and_mintracks_counter << std::endl;
0447   std::cout << "----The number of events that fired the MVA trigger but not the cuts-based trigger is: " << m_no_cuts_and_mva_woutcalo_and_mintracks_counter << std::endl;
0448   std::cout << "----The number of events that fired both the cuts-based trigger and the MVA triggers is: " << m_cuts_and_mva_woutcalo_and_mintracks_counter  << std::endl;
0449   std::cout << "----The number of events that fired neither the cuts-based trigger or the MVA triggers is: " <<  m_no_cuts_and_no_mva_woutcalo_and_mintracks_counter << std::endl;
0450   std::cout << "----------------------------------------------------------\n" << std::endl;
0451 }
0452
0453 void HFTriggerMVA::printTrigger()
0454 {
0455   std::cout << "\n---------------HFTriggerMVA event information---------------" << std::endl;
0456   if (m_useCutsTrigger) std::cout << "The cuts based trigger decision is " << triggerDecisionsMVA.find("cuts")->second << std::endl;
0457   if (m_useMVAwCaloTrigger) std::cout << "The MVA wCalo trigger decision is " << triggerDecisionsMVA.find("MVAWithCalo")->second << std::endl;
0458   std::cout << "---------------------------------------------------------\n" << std::endl;
0459 }
0460