ViewVC Help
View File | Revision Log | Show Annotations | Root Listing
root/cvsroot/UserCode/MitPhysics/Utils/src/MuonIDMVA.cc
(Generate patch)

Comparing UserCode/MitPhysics/Utils/src/MuonIDMVA.cc (file contents):
Revision 1.3 by sixie, Wed Jan 4 10:32:05 2012 UTC vs.
Revision 1.7 by sixie, Mon Jan 23 20:05:41 2012 UTC

# Line 114 | Line 114 | void MuonIDMVA::Initialize( TString meth
114        fTMVAReader[i]->AddVariable( "NeutralIso04OverPt",   &fMVAVar_MuNeutralIso04OverPt    );      
115      }
116      
117 +    if (type == kIDIsoCombinedDetIso) {
118 +      fTMVAReader[i]->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
119 +      fTMVAReader[i]->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
120 +      fTMVAReader[i]->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
121 +      fTMVAReader[i]->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
122 +      fTMVAReader[i]->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
123 +      fTMVAReader[i]->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
124 +      fTMVAReader[i]->AddVariable( "D0",                   &fMVAVar_MuD0                    );      
125 +      fTMVAReader[i]->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );      
126 +      fTMVAReader[i]->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );      
127 +      fTMVAReader[i]->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );      
128 +      fTMVAReader[i]->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );      
129 +      fTMVAReader[i]->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );      
130 +      fTMVAReader[i]->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );      
131 +      fTMVAReader[i]->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );      
132 +      fTMVAReader[i]->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );      
133 +      fTMVAReader[i]->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );      
134 +      fTMVAReader[i]->AddVariable( "TrkIso03OverPt",       &fMVAVar_MuTrkIso03OverPt        );
135 +      fTMVAReader[i]->AddVariable( "EMIso03OverPt",        &fMVAVar_MuEMIso03OverPt         );
136 +      fTMVAReader[i]->AddVariable( "HadIso03OverPt",       &fMVAVar_MuHadIso03OverPt        );
137 +      fTMVAReader[i]->AddVariable( "TrkIso05OverPt",       &fMVAVar_MuTrkIso05OverPt        );
138 +      fTMVAReader[i]->AddVariable( "EMIso05OverPt",        &fMVAVar_MuEMIso05OverPt         );
139 +      fTMVAReader[i]->AddVariable( "HadIso05OverPt",       &fMVAVar_MuHadIso05OverPt        );
140 +    
141 +    }
142 +    
143      if (i==0) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt10To14p5Weights );
144      if (i==1) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt10To14p5Weights );
145      if (i==2) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt14p5To20Weights );
# Line 157 | Line 183 | Double_t MuonIDMVA::MVAValue(Double_t Mu
183                               Double_t                   MuChargedIso03OverPt,
184                               Double_t                   MuNeutralIso03OverPt,
185                               Double_t                   MuChargedIso04OverPt,
186 <                             Double_t                   MuNeutralIso04OverPt                            
186 >                             Double_t                   MuNeutralIso04OverPt,
187 >                             Bool_t                     printDebug                            
188    ) {
189    
190    if (!fIsInitialized) {
# Line 212 | Line 239 | Double_t MuonIDMVA::MVAValue(Double_t Mu
239                                                  
240    mva = reader->EvaluateMVA( fMethodname );
241  
242 <  Bool_t printdebug = kFALSE;
216 <  if (printdebug == kTRUE) {
242 >  if (printDebug) {
243      std::cout << "Debug Muon MVA: "
244           << MuPt << " " << MuEta << " --> MVABin " << MVABin << " : "    
245           << fMVAVar_MuTkNchi2              << " "
# Line 247 | Line 273 | Double_t MuonIDMVA::MVAValue(Double_t Mu
273   }
274  
275  
276 + //--------------------------------------------------------------------------------------------------
277 + Double_t MuonIDMVA::MVAValue(Double_t MuPt , Double_t MuEta,
278 +                             Double_t                   MuTkNchi2,
279 +                             Double_t                   MuGlobalNchi2,
280 +                             Double_t                   MuNValidHits,
281 +                             Double_t                   MuNTrackerHits,
282 +                             Double_t                   MuNPixelHits,
283 +                             Double_t                   MuNMatches,
284 +                             Double_t                   MuD0,
285 +                             Double_t                   MuIP3d,
286 +                             Double_t                   MuIP3dSig,
287 +                             Double_t                   MuTrkKink,
288 +                             Double_t                   MuSegmentCompatibility,
289 +                             Double_t                   MuCaloCompatibility,
290 +                             Double_t                   MuHadEnergyOverPt,
291 +                             Double_t                   MuHoEnergyOverPt,
292 +                             Double_t                   MuEmEnergyOverPt,
293 +                             Double_t                   MuHadS9EnergyOverPt,
294 +                             Double_t                   MuHoS9EnergyOverPt,
295 +                             Double_t                   MuEmS9EnergyOverPt,
296 +                             Double_t                   MuTrkIso03OverPt,
297 +                             Double_t                   MuEMIso03OverPt,
298 +                             Double_t                   MuHadIso03OverPt,
299 +                             Double_t                   MuTrkIso05OverPt,
300 +                             Double_t                   MuEMIso05OverPt,
301 +                             Double_t                   MuHadIso05OverPt,
302 +                             Bool_t                     printDebug                            
303 +  ) {
304 +  
305 +  if (!fIsInitialized) {
306 +    std::cout << "Error: MuonIDMVA not properly initialized.\n";
307 +    return -9999;
308 +  }
309 +
310 +  Int_t subdet = 0;
311 +  if (fabs(MuEta) < 1.479) subdet = 0;
312 +  else subdet = 1;
313 +  Int_t ptBin = 0;
314 +  if (MuPt > 14.5) ptBin = 1;
315 +  if (MuPt > 20.0) ptBin = 2;
316  
251 – // //--------------------------------------------------------------------------------------------------
252 – // Double_t MuonIDMVA::MVAValue(const Muon *ele, const Vertex *vertex) {
317    
318 < //   if (!fIsInitialized) {
319 < //     std::cout << "Error: MuonIDMVA not properly initialized.\n";
320 < //     return -9999;
321 < //   }
322 <
323 < //   Int_t subdet = 0;
324 < //   if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
325 < //   else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
326 < //   else subdet = 2;
327 < //   Int_t ptBin = 0;
328 < //   if (ele->Pt() > 20.0) ptBin = 1;
329 <  
330 < //   //set all input variables
331 < //   fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
332 < //   fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
333 < //   fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
334 < //   fMVAVar_EleHoverE = ele->HadronicOverEm();
335 < //   fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
336 < //   fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
337 < //   fMVAVar_EleFBrem = ele->FBrem();
338 < //   fMVAVar_EleEOverP = ele->ESuperClusterOverP();
339 < //   fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
340 < //   if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
341 < //   else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
342 < //   fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
343 < //   fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
344 < //   fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
345 < //   fMVAVar_EleIP3d = ele->Ip3dPV();
346 < //   fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
347 <
348 < //   Double_t mva = -9999;  
349 < //   TMVA::Reader *reader = 0;
350 < //   Int_t MVABin = -1;
351 < //   if (subdet == 0 && ptBin == 0) MVABin = 0;
352 < //   if (subdet == 1 && ptBin == 0) MVABin = 1;
353 < //   if (subdet == 2 && ptBin == 0) MVABin = 2;
354 < //   if (subdet == 0 && ptBin == 1) MVABin = 3;
355 < //   if (subdet == 1 && ptBin == 1) MVABin = 4;
292 < //   if (subdet == 2 && ptBin == 1) MVABin = 5;
293 < //   assert(MVABin >= 0 && MVABin <= 5);
294 < //   reader = fTMVAReader[MVABin];
318 >  //set all input variables
319 >  fMVAVar_MuTkNchi2              = MuTkNchi2;
320 >  fMVAVar_MuGlobalNchi2          = MuGlobalNchi2;
321 >  fMVAVar_MuNValidHits           = MuNValidHits;
322 >  fMVAVar_MuNTrackerHits         = MuNTrackerHits;
323 >  fMVAVar_MuNPixelHits           = MuNPixelHits;  
324 >  fMVAVar_MuNMatches             = MuNMatches;
325 >  fMVAVar_MuD0                   = MuD0;
326 >  fMVAVar_MuIP3d                 = MuIP3d;
327 >  fMVAVar_MuIP3dSig              = MuIP3dSig;
328 >  fMVAVar_MuTrkKink              = MuTrkKink;
329 >  fMVAVar_MuSegmentCompatibility = MuSegmentCompatibility;
330 >  fMVAVar_MuCaloCompatibility    = MuCaloCompatibility;
331 >  fMVAVar_MuHadEnergyOverPt      = MuHadEnergyOverPt;
332 >  fMVAVar_MuHoEnergyOverPt       = MuHoEnergyOverPt;
333 >  fMVAVar_MuEmEnergyOverPt       = MuEmEnergyOverPt;
334 >  fMVAVar_MuHadS9EnergyOverPt    = MuHadS9EnergyOverPt;
335 >  fMVAVar_MuHoS9EnergyOverPt     = MuHoS9EnergyOverPt;
336 >  fMVAVar_MuEmS9EnergyOverPt     = MuEmS9EnergyOverPt;
337 >  fMVAVar_MuTrkIso03OverPt       = MuTrkIso03OverPt;
338 >  fMVAVar_MuEMIso03OverPt        = MuEMIso03OverPt;
339 >  fMVAVar_MuHadIso03OverPt       = MuHadIso03OverPt;
340 >  fMVAVar_MuTrkIso05OverPt       = MuTrkIso05OverPt;
341 >  fMVAVar_MuEMIso05OverPt        = MuEMIso05OverPt;
342 >  fMVAVar_MuHadIso05OverPt       = MuHadIso05OverPt;
343 >
344 >  Double_t mva = -9999;  
345 >  TMVA::Reader *reader = 0;
346 >
347 >  Int_t MVABin = -1;
348 >  if (subdet == 0 && ptBin == 0) MVABin = 0;
349 >  if (subdet == 1 && ptBin == 0) MVABin = 1;
350 >  if (subdet == 0 && ptBin == 1) MVABin = 2;
351 >  if (subdet == 1 && ptBin == 1) MVABin = 3;
352 >  if (subdet == 0 && ptBin == 2) MVABin = 4;
353 >  if (subdet == 1 && ptBin == 2) MVABin = 5;
354 >  assert(MVABin >= 0 && MVABin <= 5);
355 >  reader = fTMVAReader[MVABin];
356                                                  
357 < //   mva = reader->EvaluateMVA( fMethodname );
357 >  mva = reader->EvaluateMVA( fMethodname );
358 >
359 >  if (printDebug) {
360 >    std::cout << "Debug Muon MVA: "
361 >         << MuPt << " " << MuEta << " --> MVABin " << MVABin << " : "    
362 >         << fMVAVar_MuTkNchi2              << " "
363 >         << fMVAVar_MuGlobalNchi2          << " "
364 >         << fMVAVar_MuNValidHits           << " "
365 >         << fMVAVar_MuNTrackerHits         << " "
366 >         << fMVAVar_MuNPixelHits           << " "  
367 >         << fMVAVar_MuNMatches             << " "
368 >         << fMVAVar_MuD0                   << " "
369 >         << fMVAVar_MuIP3d                 << " "
370 >         << fMVAVar_MuIP3dSig              << " "
371 >         << fMVAVar_MuTrkKink              << " "
372 >         << fMVAVar_MuSegmentCompatibility << " "
373 >         << fMVAVar_MuCaloCompatibility    << " "
374 >         << fMVAVar_MuHadEnergyOverPt      << " "
375 >         << fMVAVar_MuHoEnergyOverPt       << " "
376 >         << fMVAVar_MuEmEnergyOverPt       << " "
377 >         << fMVAVar_MuHadS9EnergyOverPt    << " "
378 >         << fMVAVar_MuHoS9EnergyOverPt     << " "
379 >         << fMVAVar_MuEmS9EnergyOverPt     << " "
380 >         << fMVAVar_MuTrkIso03OverPt   << " "
381 >         << fMVAVar_MuEMIso03OverPt   << " "
382 >         << fMVAVar_MuHadIso03OverPt   << " "
383 >         << fMVAVar_MuTrkIso05OverPt   << " "
384 >         << fMVAVar_MuEMIso05OverPt   << " "
385 >         << fMVAVar_MuHadIso05OverPt   << " "
386 >         << " === : === "
387 >         << mva
388 >         << std::endl;
389 >  }
390  
391 < //   return mva;
392 < // }
391 >  return mva;
392 > }
393 >
394 >
395 >
396 > //--------------------------------------------------------------------------------------------------
397 > Double_t MuonIDMVA::MVAValue(const Muon *mu, const Vertex *vertex, MuonTools *fMuonTools,
398 >                             const PFCandidateCol *PFCands,
399 >                             const PileupEnergyDensityCol *PileupEnergyDensity,
400 >                             Bool_t printDebug) {
401 >  
402 >  if (!fIsInitialized) {
403 >    std::cout << "Error: MuonIDMVA not properly initialized.\n";
404 >    return -9999;
405 >  }
406 >
407 >  const Track *muTrk=0;
408 >  if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk();    }
409 >  else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
410 >  
411 >  Double_t muNchi2 = 0.0;
412 >  if(mu->HasGlobalTrk())          { muNchi2 = mu->GlobalTrk()->RChi2();     }
413 >  else if(mu->HasStandaloneTrk()) { muNchi2 = mu->StandaloneTrk()->RChi2(); }
414 >  else if(mu->HasTrackerTrk())    { muNchi2 = mu->TrackerTrk()->RChi2();    }
415 >
416 >  Double_t ChargedIso03 = 0;
417 >  Double_t NeutralIso03_05Threshold = 0;
418 >  Double_t ChargedIso04 = 0;
419 >  Double_t NeutralIso04_05Threshold = 0;
420 >  ChargedIso03 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.3, 0.0, 0.0);
421 >  NeutralIso03_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.3, 0.0, 0.0);
422 >  ChargedIso04 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.4, 0.0, 0.0);
423 >  NeutralIso04_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.4, 0.0, 0.0);
424 >  
425 >  Double_t Rho = 0;
426 >  if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
427 >
428 >  Int_t subdet = 0;
429 >  if (fabs(muTrk->Eta()) < 1.479) subdet = 0;
430 >  else subdet = 1;
431 >  Int_t ptBin = 0;
432 >  if (muTrk->Pt() > 14.5) ptBin = 1;
433 >  if (muTrk->Pt() > 20.0) ptBin = 2;
434 >
435 >  //set all input variables
436 >  fMVAVar_MuTkNchi2              = muTrk->RChi2();
437 >  fMVAVar_MuGlobalNchi2          = muNchi2;
438 >  fMVAVar_MuNValidHits           = mu->NValidHits();
439 >  fMVAVar_MuNTrackerHits         = muTrk->NHits();
440 >  fMVAVar_MuNPixelHits           = muTrk->NPixelHits();
441 >  fMVAVar_MuNMatches             = mu->NMatches();
442 >  fMVAVar_MuD0                   = muTrk->D0Corrected(*vertex);
443 >  fMVAVar_MuIP3d                 = mu->Ip3dPV();
444 >  fMVAVar_MuIP3dSig              = mu->Ip3dPVSignificance();
445 >  fMVAVar_MuTrkKink              = mu->TrkKink();
446 >  fMVAVar_MuSegmentCompatibility = fMuonTools->GetSegmentCompatability(mu);
447 >  fMVAVar_MuCaloCompatibility    = fMuonTools->GetCaloCompatability(mu, kTRUE, kTRUE);
448 >  fMVAVar_MuHadEnergyOverPt      = (mu->HadEnergy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadEnergy,muTrk->Eta()))/muTrk->Pt();
449 >  fMVAVar_MuHoEnergyOverPt       = (mu->HoEnergy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHoEnergy,muTrk->Eta()))/muTrk->Pt();
450 >  fMVAVar_MuEmEnergyOverPt       = (mu->EmEnergy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEmEnergy,muTrk->Eta()))/muTrk->Pt();
451 >  fMVAVar_MuHadS9EnergyOverPt    = (mu->HadS9Energy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadS9Energy,muTrk->Eta()))/muTrk->Pt();
452 >  fMVAVar_MuHoS9EnergyOverPt     = (mu->HoS9Energy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHoS9Energy,muTrk->Eta()))/muTrk->Pt();
453 >  fMVAVar_MuEmS9EnergyOverPt     = (mu->EmS9Energy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEmS9Energy,muTrk->Eta()))/muTrk->Pt();
454 >  fMVAVar_MuChargedIso03OverPt   = (ChargedIso03 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuChargedIso03,muTrk->Eta()))/muTrk->Pt();
455 >  fMVAVar_MuNeutralIso03OverPt   = (NeutralIso03_05Threshold - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03,muTrk->Eta()))/muTrk->Pt();
456 >  fMVAVar_MuChargedIso04OverPt   = (ChargedIso04 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuChargedIso04,muTrk->Eta()))/muTrk->Pt();
457 >  fMVAVar_MuNeutralIso04OverPt   = (NeutralIso04_05Threshold - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso04,muTrk->Eta()))/muTrk->Pt();
458 >  fMVAVar_MuTrkIso03OverPt       = (mu->IsoR03SumPt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuTrkIso03,muTrk->Eta()))/muTrk->Pt();
459 >  fMVAVar_MuEMIso03OverPt        = (mu->IsoR03EmEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso03,muTrk->Eta()))/muTrk->Pt();
460 >  fMVAVar_MuHadIso03OverPt       = (mu->IsoR03HadEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso03,muTrk->Eta()))/muTrk->Pt();
461 >  fMVAVar_MuTrkIso05OverPt       = (mu->IsoR05SumPt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuTrkIso05,muTrk->Eta()))/muTrk->Pt();
462 >  fMVAVar_MuEMIso05OverPt        = (mu->IsoR05EmEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso05,muTrk->Eta()))/muTrk->Pt();
463 >  fMVAVar_MuHadIso05OverPt       = (mu->IsoR05HadEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso05,muTrk->Eta()))/muTrk->Pt();
464 >
465 >  Double_t mva = -9999;  
466 >  TMVA::Reader *reader = 0;
467 >
468 >  Int_t MVABin = -1;
469 >  if (subdet == 0 && ptBin == 0) MVABin = 0;
470 >  if (subdet == 1 && ptBin == 0) MVABin = 1;
471 >  if (subdet == 0 && ptBin == 1) MVABin = 2;
472 >  if (subdet == 1 && ptBin == 1) MVABin = 3;
473 >  if (subdet == 0 && ptBin == 2) MVABin = 4;
474 >  if (subdet == 1 && ptBin == 2) MVABin = 5;
475 >  assert(MVABin >= 0 && MVABin <= 5);
476 >  reader = fTMVAReader[MVABin];
477 >                                                
478 >  mva = reader->EvaluateMVA( fMethodname );
479 >
480 >  if (printDebug) {
481 >    std::cout << "Debug Muon MVA: "
482 >              << mu->Pt() << " " << mu->Eta() << " " << mu->Phi() << " : "
483 >              << muTrk->Pt() << " " << muTrk->Eta() << " --> MVABin " << MVABin << " : "    
484 >              << fMVAVar_MuTkNchi2              << " "
485 >              << fMVAVar_MuGlobalNchi2          << " "
486 >              << fMVAVar_MuNValidHits           << " "
487 >              << fMVAVar_MuNTrackerHits         << " "
488 >              << fMVAVar_MuNPixelHits           << " "  
489 >              << fMVAVar_MuNMatches             << " "
490 >              << fMVAVar_MuD0                   << " "
491 >              << fMVAVar_MuIP3d                 << " "
492 >              << fMVAVar_MuIP3dSig              << " "
493 >              << fMVAVar_MuTrkKink              << " "
494 >              << fMVAVar_MuSegmentCompatibility << " "
495 >              << fMVAVar_MuCaloCompatibility    << " "
496 >              << fMVAVar_MuHadEnergyOverPt      << " "
497 >              << fMVAVar_MuHoEnergyOverPt       << " "
498 >              << fMVAVar_MuEmEnergyOverPt       << " "
499 >              << fMVAVar_MuHadS9EnergyOverPt    << " "
500 >              << fMVAVar_MuHoS9EnergyOverPt     << " "
501 >              << fMVAVar_MuEmS9EnergyOverPt     << " "
502 >              << fMVAVar_MuChargedIso03OverPt   << " "
503 >              << fMVAVar_MuNeutralIso03OverPt   << " "
504 >              << fMVAVar_MuChargedIso04OverPt   << " "
505 >              << fMVAVar_MuNeutralIso04OverPt   << " "
506 >              << fMVAVar_MuTrkIso03OverPt   << " "
507 >              << fMVAVar_MuEMIso03OverPt   << " "
508 >              << fMVAVar_MuHadIso03OverPt   << " "
509 >              << fMVAVar_MuTrkIso05OverPt   << " "
510 >              << fMVAVar_MuEMIso05OverPt   << " "
511 >              << fMVAVar_MuHadIso05OverPt   << " "
512 >              << " === : === "
513 >              << mva
514 >              << std::endl;
515 >  }
516 >
517 >  return mva;
518 > }

Diff Legend

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