| 18 |
|
fIsInitialized(kFALSE), |
| 19 |
|
fMVAType(MuonIDMVA::kUninitialized), |
| 20 |
|
fUseBinnedVersion(kTRUE), |
| 21 |
< |
fNMVABins(0) |
| 21 |
> |
fNMVABins(0), |
| 22 |
> |
fTheRhoType(RhoUtilities::DEFAULT) |
| 23 |
|
{ |
| 24 |
|
} |
| 25 |
|
|
| 34 |
|
|
| 35 |
|
//-------------------------------------------------------------------------------------------------- |
| 36 |
|
void MuonIDMVA::Initialize( std::string methodName, |
| 37 |
< |
std::string weightsfile, |
| 38 |
< |
MuonIDMVA::MVAType type) |
| 37 |
> |
std::string weightsfile, |
| 38 |
> |
MuonIDMVA::MVAType type, |
| 39 |
> |
RhoUtilities::RhoType theRhoType) |
| 40 |
|
{ |
| 41 |
|
|
| 42 |
|
std::vector<std::string> tempWeightFileVector; |
| 43 |
|
tempWeightFileVector.push_back(weightsfile); |
| 44 |
< |
Initialize(methodName,type,kFALSE,tempWeightFileVector); |
| 44 |
> |
Initialize(methodName,type,kFALSE,tempWeightFileVector,theRhoType); |
| 45 |
|
} |
| 46 |
|
|
| 47 |
|
//-------------------------------------------------------------------------------------------------- |
| 48 |
|
void MuonIDMVA::Initialize( TString methodName, |
| 49 |
< |
TString Subdet0Pt10To20Weights , |
| 50 |
< |
TString Subdet1Pt10To20Weights , |
| 51 |
< |
TString Subdet2Pt10To20Weights, |
| 52 |
< |
TString Subdet0Pt20ToInfWeights, |
| 53 |
< |
TString Subdet1Pt20ToInfWeights, |
| 54 |
< |
TString Subdet2Pt20ToInfWeights, |
| 55 |
< |
MuonIDMVA::MVAType type) { |
| 49 |
> |
TString Subdet0Pt10To20Weights , |
| 50 |
> |
TString Subdet1Pt10To20Weights , |
| 51 |
> |
TString Subdet2Pt10To20Weights, |
| 52 |
> |
TString Subdet0Pt20ToInfWeights, |
| 53 |
> |
TString Subdet1Pt20ToInfWeights, |
| 54 |
> |
TString Subdet2Pt20ToInfWeights, |
| 55 |
> |
MuonIDMVA::MVAType type, |
| 56 |
> |
RhoUtilities::RhoType theRhoType) { |
| 57 |
|
|
| 58 |
|
std::vector<std::string> tempWeightFileVector; |
| 59 |
|
tempWeightFileVector.push_back(std::string(Subdet0Pt10To20Weights.Data())); |
| 62 |
|
tempWeightFileVector.push_back(std::string(Subdet0Pt20ToInfWeights.Data())); |
| 63 |
|
tempWeightFileVector.push_back(std::string(Subdet1Pt20ToInfWeights.Data())); |
| 64 |
|
tempWeightFileVector.push_back(std::string(Subdet2Pt20ToInfWeights.Data())); |
| 65 |
< |
Initialize(std::string(methodName.Data()),type,kTRUE,tempWeightFileVector); |
| 65 |
> |
Initialize(std::string(methodName.Data()),type,kTRUE,tempWeightFileVector,theRhoType); |
| 66 |
|
|
| 67 |
|
} |
| 68 |
|
|
| 69 |
|
|
| 70 |
|
//-------------------------------------------------------------------------------------------------- |
| 71 |
< |
void MuonIDMVA::Initialize( std::string methodName, |
| 72 |
< |
MuonIDMVA::MVAType type, |
| 73 |
< |
Bool_t useBinnedVersion, |
| 74 |
< |
std::vector<std::string> weightsfiles) { |
| 71 |
> |
void MuonIDMVA::Initialize( std::string methodName, |
| 72 |
> |
MuonIDMVA::MVAType type, |
| 73 |
> |
Bool_t useBinnedVersion, |
| 74 |
> |
std::vector<std::string> weightsfiles, |
| 75 |
> |
RhoUtilities::RhoType theRhoType) { |
| 76 |
|
|
| 77 |
|
//clean up first |
| 78 |
|
for (uint i=0;i<fTMVAReader.size(); ++i) { |
| 86 |
|
fMethodname = methodName; |
| 87 |
|
fMVAType = type; |
| 88 |
|
fUseBinnedVersion = useBinnedVersion; |
| 89 |
+ |
fTheRhoType = theRhoType; |
| 90 |
|
|
| 91 |
|
//Define expected number of bins |
| 92 |
|
UInt_t ExpectedNBins = 0; |
| 93 |
|
if (!fUseBinnedVersion) { |
| 94 |
|
ExpectedNBins = 1; |
| 95 |
< |
} else if (type == kV2 |
| 96 |
< |
||type == kV3 |
| 97 |
< |
||type == kV8 |
| 98 |
< |
||type == kIDIsoCombinedDetIso) { |
| 95 |
> |
} else if (type == kV2 |
| 96 |
> |
|| type == kV3 |
| 97 |
> |
|| type == kV8 |
| 98 |
> |
|| type == kIDIsoCombinedDetIso |
| 99 |
> |
|| type == kIsoRingsV0 |
| 100 |
> |
|| type == kIDV0 |
| 101 |
> |
|| type == kIDIsoCombinedIsoRingsV0 |
| 102 |
> |
) { |
| 103 |
|
ExpectedNBins = 6; |
| 104 |
< |
} else if (type == kIDIsoCombinedIsoRingsV0) { |
| 96 |
< |
ExpectedNBins = 5; |
| 97 |
< |
} else if (type == kIsoRingsV0) { |
| 104 |
> |
} else if (type == kIsoDeltaR){ |
| 105 |
|
ExpectedNBins = 4; |
| 106 |
|
} |
| 107 |
+ |
|
| 108 |
|
fNMVABins = ExpectedNBins; |
| 109 |
|
|
| 110 |
|
//Check number of weight files given |
| 205 |
|
tmpTMVAReader->AddVariable( "HadIso05OverPt", &fMVAVar_MuHadIso05OverPt ); |
| 206 |
|
} |
| 207 |
|
|
| 208 |
+ |
if (type == kIDV0) { |
| 209 |
+ |
tmpTMVAReader->AddVariable( "TkNchi2", &fMVAVar_MuTkNchi2 ); |
| 210 |
+ |
if (i!=4) tmpTMVAReader->AddVariable( "GlobalNchi2",&fMVAVar_MuGlobalNchi2 ); |
| 211 |
+ |
if (i!=4) tmpTMVAReader->AddVariable( "NValidHits", &fMVAVar_MuNValidHits ); |
| 212 |
+ |
tmpTMVAReader->AddVariable( "NTrackerHits", &fMVAVar_MuNTrackerHits ); |
| 213 |
+ |
tmpTMVAReader->AddVariable( "NPixelHits", &fMVAVar_MuNPixelHits ); |
| 214 |
+ |
if (i!=5) tmpTMVAReader->AddVariable( "NMatches", &fMVAVar_MuNMatches ); |
| 215 |
+ |
tmpTMVAReader->AddVariable( "TrkKink", &fMVAVar_MuTrkKink ); |
| 216 |
+ |
tmpTMVAReader->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility ); |
| 217 |
+ |
tmpTMVAReader->AddVariable( "CaloCompatibility", &fMVAVar_MuCaloCompatibility ); |
| 218 |
+ |
tmpTMVAReader->AddVariable( "HadEnergy", &fMVAVar_MuHadEnergy ); |
| 219 |
+ |
tmpTMVAReader->AddVariable( "EmEnergy", &fMVAVar_MuEmEnergy ); |
| 220 |
+ |
tmpTMVAReader->AddVariable( "HadS9Energy", &fMVAVar_MuHadS9Energy ); |
| 221 |
+ |
tmpTMVAReader->AddVariable( "EmS9Energy", &fMVAVar_MuEmS9Energy ); |
| 222 |
+ |
} |
| 223 |
+ |
|
| 224 |
|
if (type == kIsoRingsV0) { |
| 225 |
|
tmpTMVAReader->AddVariable( "ChargedIso_DR0p0To0p1", &fMVAVar_ChargedIso_DR0p0To0p1 ); |
| 226 |
|
tmpTMVAReader->AddVariable( "ChargedIso_DR0p1To0p2", &fMVAVar_ChargedIso_DR0p1To0p2 ); |
| 237 |
|
tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p2To0p3", &fMVAVar_NeutralHadronIso_DR0p2To0p3 ); |
| 238 |
|
tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p3To0p4", &fMVAVar_NeutralHadronIso_DR0p3To0p4 ); |
| 239 |
|
tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p4To0p5", &fMVAVar_NeutralHadronIso_DR0p4To0p5 ); |
| 240 |
< |
tmpTMVAReader->AddSpectator("eta", &fMVAVar_MuEta); |
| 241 |
< |
tmpTMVAReader->AddSpectator("pt", &fMVAVar_MuPt); |
| 240 |
> |
} |
| 241 |
> |
|
| 242 |
> |
if (type == kIsoDeltaR) { |
| 243 |
> |
tmpTMVAReader->AddVariable("PFCharged", &fMVAVar_MuRelIsoPFCharged ); |
| 244 |
> |
tmpTMVAReader->AddVariable("PFNeutral", &fMVAVar_MuRelIsoPFNeutral ); |
| 245 |
> |
tmpTMVAReader->AddVariable("PFPhotons", &fMVAVar_MuRelIsoPFPhotons ); |
| 246 |
> |
tmpTMVAReader->AddVariable("SumDeltaR", &fMVAVar_MuDeltaRSum ); |
| 247 |
> |
tmpTMVAReader->AddVariable("DeltaRMean", &fMVAVar_MuDeltaRMean ); |
| 248 |
> |
tmpTMVAReader->AddVariable("Density", &fMVAVar_MuDensity ); |
| 249 |
|
} |
| 250 |
|
|
| 251 |
|
tmpTMVAReader->BookMVA(fMethodname , weightsfiles[i] ); |
| 281 |
|
if (pt >= 20 && fabs(eta) >= 1.5) bin = 5; |
| 282 |
|
} |
| 283 |
|
|
| 284 |
< |
if (fMVAType == MuonIDMVA::kIDIsoCombinedIsoRingsV0) { |
| 284 |
> |
if (fMVAType == MuonIDMVA::kIsoRingsV0 || fMVAType == MuonIDMVA::kIDV0 |
| 285 |
> |
|| fMVAType == MuonIDMVA::kIDIsoCombinedIsoRingsV0) { |
| 286 |
|
if (isGlobal && isTrackerMuon) { |
| 287 |
|
if (pt < 10 && fabs(eta) < 1.479) bin = 0; |
| 288 |
< |
if (pt < 10 && fabs(eta) >= 1.479) bin = 1; |
| 289 |
< |
if (pt >= 10 && fabs(eta) < 1.479) bin = 2; |
| 288 |
> |
if (pt >= 10 && fabs(eta) < 1.479) bin = 1; |
| 289 |
> |
if (pt < 10 && fabs(eta) >= 1.479) bin = 2; |
| 290 |
|
if (pt >= 10 && fabs(eta) >= 1.479) bin = 3; |
| 291 |
|
} else if (!isGlobal && isTrackerMuon) { |
| 292 |
|
bin = 4; |
| 293 |
+ |
} else if (isGlobal && !isTrackerMuon) { |
| 294 |
+ |
bin = 5; |
| 295 |
|
} else { |
| 296 |
|
std::cout << "Warning: Muon is not a tracker muon. Such muons are not supported. \n"; |
| 297 |
|
bin = 0; |
| 298 |
|
} |
| 299 |
|
} |
| 300 |
|
|
| 301 |
< |
if (fMVAType == MuonIDMVA::kIsoRingsV0) { |
| 302 |
< |
if (pt < 10 && fabs(eta) < 1.479) bin = 0; |
| 303 |
< |
if (pt < 10 && fabs(eta) >= 1.479) bin = 1; |
| 304 |
< |
if (pt >= 10 && fabs(eta) < 1.479) bin = 2; |
| 305 |
< |
if (pt >= 10 && fabs(eta) >= 1.479) bin = 3; |
| 301 |
> |
if (fMVAType == MuonIDMVA::kIsoDeltaR){ |
| 302 |
> |
if (pt < 20 && fabs(eta) < 1.479) bin = 0; |
| 303 |
> |
if (pt < 20 && fabs(eta) >= 1.479) bin = 1; |
| 304 |
> |
if (pt >= 20 && fabs(eta) < 1.479) bin = 2; |
| 305 |
> |
if (pt >= 20 && fabs(eta) >= 1.479) bin = 3; |
| 306 |
|
} |
| 307 |
|
|
| 308 |
|
return bin; |
| 507 |
|
} |
| 508 |
|
|
| 509 |
|
|
| 510 |
+ |
Double_t MuonIDMVA::MVAValue_IsoRings( Double_t MuPt, |
| 511 |
+ |
Double_t MuEta, |
| 512 |
+ |
Bool_t MuIsGlobal, |
| 513 |
+ |
Bool_t MuIsTracker, |
| 514 |
+ |
Double_t ChargedIso_DR0p0To0p1, |
| 515 |
+ |
Double_t ChargedIso_DR0p1To0p2, |
| 516 |
+ |
Double_t ChargedIso_DR0p2To0p3, |
| 517 |
+ |
Double_t ChargedIso_DR0p3To0p4, |
| 518 |
+ |
Double_t ChargedIso_DR0p4To0p5, |
| 519 |
+ |
Double_t GammaIso_DR0p0To0p1, |
| 520 |
+ |
Double_t GammaIso_DR0p1To0p2, |
| 521 |
+ |
Double_t GammaIso_DR0p2To0p3, |
| 522 |
+ |
Double_t GammaIso_DR0p3To0p4, |
| 523 |
+ |
Double_t GammaIso_DR0p4To0p5, |
| 524 |
+ |
Double_t NeutralHadronIso_DR0p0To0p1, |
| 525 |
+ |
Double_t NeutralHadronIso_DR0p1To0p2, |
| 526 |
+ |
Double_t NeutralHadronIso_DR0p2To0p3, |
| 527 |
+ |
Double_t NeutralHadronIso_DR0p3To0p4, |
| 528 |
+ |
Double_t NeutralHadronIso_DR0p4To0p5, |
| 529 |
+ |
Bool_t printDebug) { |
| 530 |
+ |
|
| 531 |
+ |
if (fMVAType != MuonIDMVA::kIsoRingsV0) { |
| 532 |
+ |
std::cout << "Error: This function is only supported for MVAType == kIsoRingsV0.\n" << std::endl; |
| 533 |
+ |
assert(kFALSE); |
| 534 |
+ |
} |
| 535 |
+ |
|
| 536 |
+ |
fMVAVar_MuPt = MuPt; |
| 537 |
+ |
fMVAVar_MuEta = MuEta; |
| 538 |
+ |
fMVAVar_ChargedIso_DR0p0To0p1 = ChargedIso_DR0p0To0p1; |
| 539 |
+ |
fMVAVar_ChargedIso_DR0p1To0p2 = ChargedIso_DR0p1To0p2; |
| 540 |
+ |
fMVAVar_ChargedIso_DR0p2To0p3 = ChargedIso_DR0p2To0p3; |
| 541 |
+ |
fMVAVar_ChargedIso_DR0p3To0p4 = ChargedIso_DR0p3To0p4; |
| 542 |
+ |
fMVAVar_ChargedIso_DR0p4To0p5 = ChargedIso_DR0p4To0p5; |
| 543 |
+ |
fMVAVar_GammaIso_DR0p0To0p1 = GammaIso_DR0p0To0p1; |
| 544 |
+ |
fMVAVar_GammaIso_DR0p1To0p2 = GammaIso_DR0p1To0p2; |
| 545 |
+ |
fMVAVar_GammaIso_DR0p2To0p3 = GammaIso_DR0p2To0p3; |
| 546 |
+ |
fMVAVar_GammaIso_DR0p3To0p4 = GammaIso_DR0p3To0p4; |
| 547 |
+ |
fMVAVar_GammaIso_DR0p4To0p5 = GammaIso_DR0p4To0p5; |
| 548 |
+ |
fMVAVar_NeutralHadronIso_DR0p0To0p1 = NeutralHadronIso_DR0p0To0p1; |
| 549 |
+ |
fMVAVar_NeutralHadronIso_DR0p1To0p2 = NeutralHadronIso_DR0p1To0p2; |
| 550 |
+ |
fMVAVar_NeutralHadronIso_DR0p2To0p3 = NeutralHadronIso_DR0p2To0p3; |
| 551 |
+ |
fMVAVar_NeutralHadronIso_DR0p3To0p4 = NeutralHadronIso_DR0p3To0p4; |
| 552 |
+ |
fMVAVar_NeutralHadronIso_DR0p4To0p5 = NeutralHadronIso_DR0p4To0p5; |
| 553 |
+ |
|
| 554 |
+ |
Double_t mva = -9999; |
| 555 |
+ |
TMVA::Reader *reader = 0; |
| 556 |
+ |
|
| 557 |
+ |
if (printDebug == kTRUE) { |
| 558 |
+ |
std::cout <<" -> BIN: " << fMVAVar_MuEta << " " << fMVAVar_MuPt << " : " |
| 559 |
+ |
<< GetMVABin( fMVAVar_MuEta , fMVAVar_MuPt, MuIsGlobal, MuIsTracker) << std::endl; |
| 560 |
+ |
} |
| 561 |
+ |
reader = fTMVAReader[GetMVABin( fMVAVar_MuEta , fMVAVar_MuPt, MuIsGlobal, MuIsTracker)]; |
| 562 |
+ |
mva = reader->EvaluateMVA( fMethodname ); |
| 563 |
+ |
|
| 564 |
+ |
if (printDebug == kTRUE) { |
| 565 |
+ |
|
| 566 |
+ |
std::cout << "Debug Muon MVA: \n"; |
| 567 |
+ |
std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " " |
| 568 |
+ |
<< fMVAVar_ChargedIso_DR0p1To0p2 << " " |
| 569 |
+ |
<< fMVAVar_ChargedIso_DR0p2To0p3 << " " |
| 570 |
+ |
<< fMVAVar_ChargedIso_DR0p3To0p4 << " " |
| 571 |
+ |
<< fMVAVar_ChargedIso_DR0p4To0p5 << " " |
| 572 |
+ |
<< fMVAVar_GammaIso_DR0p0To0p1 << " " |
| 573 |
+ |
<< fMVAVar_GammaIso_DR0p1To0p2 << " " |
| 574 |
+ |
<< fMVAVar_GammaIso_DR0p2To0p3 << " " |
| 575 |
+ |
<< fMVAVar_GammaIso_DR0p3To0p4 << " " |
| 576 |
+ |
<< fMVAVar_GammaIso_DR0p4To0p5 << " " |
| 577 |
+ |
<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " " |
| 578 |
+ |
<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " " |
| 579 |
+ |
<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " " |
| 580 |
+ |
<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " " |
| 581 |
+ |
<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " " |
| 582 |
+ |
<< std::endl; |
| 583 |
+ |
std::cout << "MVA: " << mva << " " |
| 584 |
+ |
<< std::endl; |
| 585 |
+ |
} |
| 586 |
+ |
return mva; |
| 587 |
+ |
} |
| 588 |
+ |
|
| 589 |
+ |
|
| 590 |
+ |
|
| 591 |
+ |
Double_t MuonIDMVA::MVAValue_ID( Double_t MuPt, |
| 592 |
+ |
Double_t MuEta, |
| 593 |
+ |
Bool_t MuIsGlobal, |
| 594 |
+ |
Bool_t MuIsTracker, |
| 595 |
+ |
Double_t MuTkNchi2, |
| 596 |
+ |
Double_t MuGlobalNchi2, |
| 597 |
+ |
Double_t MuNValidHits, |
| 598 |
+ |
Double_t MuNTrackerHits, |
| 599 |
+ |
Double_t MuNPixelHits, |
| 600 |
+ |
Double_t MuNMatches, |
| 601 |
+ |
Double_t MuTrkKink, |
| 602 |
+ |
Double_t MuSegmentCompatibility, |
| 603 |
+ |
Double_t MuCaloCompatibility, |
| 604 |
+ |
Double_t MuHadEnergy, |
| 605 |
+ |
Double_t MuEmEnergy, |
| 606 |
+ |
Double_t MuHadS9Energy, |
| 607 |
+ |
Double_t MuEmS9Energy, |
| 608 |
+ |
Bool_t printDebug) { |
| 609 |
+ |
|
| 610 |
+ |
if (fMVAType != MuonIDMVA::kIDV0) { |
| 611 |
+ |
std::cout << "Error: This function is only supported for MVAType == kIDV0.\n" << std::endl; |
| 612 |
+ |
assert(kFALSE); |
| 613 |
+ |
} |
| 614 |
+ |
|
| 615 |
+ |
fMVAVar_MuPt = MuPt; |
| 616 |
+ |
fMVAVar_MuEta = MuEta; |
| 617 |
+ |
|
| 618 |
+ |
fMVAVar_MuTkNchi2 = MuTkNchi2; |
| 619 |
+ |
fMVAVar_MuGlobalNchi2 = MuGlobalNchi2; |
| 620 |
+ |
fMVAVar_MuNValidHits = MuNValidHits; |
| 621 |
+ |
fMVAVar_MuNTrackerHits = MuNTrackerHits; |
| 622 |
+ |
fMVAVar_MuNPixelHits = MuNPixelHits; |
| 623 |
+ |
fMVAVar_MuNMatches = MuNMatches; |
| 624 |
+ |
fMVAVar_MuTrkKink = MuTrkKink; |
| 625 |
+ |
fMVAVar_MuSegmentCompatibility = MuSegmentCompatibility; |
| 626 |
+ |
fMVAVar_MuCaloCompatibility = MuCaloCompatibility; |
| 627 |
+ |
fMVAVar_MuHadEnergy = MuHadEnergy; |
| 628 |
+ |
fMVAVar_MuEmEnergy = MuEmEnergy; |
| 629 |
+ |
fMVAVar_MuHadS9Energy = MuHadS9Energy; |
| 630 |
+ |
fMVAVar_MuEmS9Energy = MuEmS9Energy; |
| 631 |
+ |
|
| 632 |
+ |
Double_t mva = -9999; |
| 633 |
+ |
TMVA::Reader *reader = 0; |
| 634 |
+ |
|
| 635 |
+ |
if (printDebug == kTRUE) { |
| 636 |
+ |
std::cout <<" -> BIN: " << fMVAVar_MuEta << " " << fMVAVar_MuPt << " : " |
| 637 |
+ |
<< GetMVABin( fMVAVar_MuEta , fMVAVar_MuPt, MuIsGlobal, MuIsTracker) << std::endl; |
| 638 |
+ |
} |
| 639 |
+ |
reader = fTMVAReader[GetMVABin( fMVAVar_MuEta , fMVAVar_MuPt, MuIsGlobal, MuIsTracker)]; |
| 640 |
+ |
mva = reader->EvaluateMVA( fMethodname ); |
| 641 |
+ |
|
| 642 |
+ |
if (printDebug == kTRUE) { |
| 643 |
+ |
|
| 644 |
+ |
std::cout << "Debug Muon MVA: \n"; |
| 645 |
+ |
std::cout << fMVAVar_MuTkNchi2 << " " |
| 646 |
+ |
<< fMVAVar_MuGlobalNchi2 << " " |
| 647 |
+ |
<< fMVAVar_MuNValidHits << " " |
| 648 |
+ |
<< fMVAVar_MuNTrackerHits << " " |
| 649 |
+ |
<< fMVAVar_MuNPixelHits << " " |
| 650 |
+ |
<< fMVAVar_MuNMatches << " " |
| 651 |
+ |
<< fMVAVar_MuTrkKink << " " |
| 652 |
+ |
<< fMVAVar_MuSegmentCompatibility << " " |
| 653 |
+ |
<< fMVAVar_MuCaloCompatibility << " " |
| 654 |
+ |
<< fMVAVar_MuHadEnergy << " " |
| 655 |
+ |
<< fMVAVar_MuEmEnergy << " " |
| 656 |
+ |
<< fMVAVar_MuHadS9Energy << " " |
| 657 |
+ |
<< fMVAVar_MuEmS9Energy << " " |
| 658 |
+ |
<< std::endl; |
| 659 |
+ |
std::cout << "MVA: " << mva << " " |
| 660 |
+ |
<< std::endl; |
| 661 |
+ |
} |
| 662 |
+ |
return mva; |
| 663 |
+ |
} |
| 664 |
+ |
|
| 665 |
+ |
|
| 666 |
|
|
| 667 |
|
//-------------------------------------------------------------------------------------------------- |
| 668 |
|
Double_t MuonIDMVA::MVAValue(const Muon *mu, const Vertex *vertex, MuonTools *fMuonTools, |
| 694 |
|
NeutralIso04_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.4, 0.0, 0.0); |
| 695 |
|
|
| 696 |
|
Double_t Rho = 0; |
| 697 |
< |
if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho(); |
| 698 |
< |
|
| 697 |
> |
switch(fTheRhoType) { |
| 698 |
> |
case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA: |
| 699 |
> |
Rho = PileupEnergyDensity->At(0)->Rho(); |
| 700 |
> |
break; |
| 701 |
> |
case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA: |
| 702 |
> |
Rho = PileupEnergyDensity->At(0)->RhoLowEta(); |
| 703 |
> |
break; |
| 704 |
> |
case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA: |
| 705 |
> |
Rho = PileupEnergyDensity->At(0)->RhoRandom(); |
| 706 |
> |
break; |
| 707 |
> |
case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA: |
| 708 |
> |
Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta(); |
| 709 |
> |
break; |
| 710 |
> |
case RhoUtilities::CMS_RHO_RHOKT6PFJETS: |
| 711 |
> |
Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets(); |
| 712 |
> |
break; |
| 713 |
> |
default: |
| 714 |
> |
// use the old default |
| 715 |
> |
Rho = PileupEnergyDensity->At(0)->Rho(); |
| 716 |
> |
break; |
| 717 |
> |
} |
| 718 |
|
|
| 719 |
|
//set all input variables |
| 720 |
|
fMVAVar_MuTkNchi2 = muTrk->RChi2(); |
| 826 |
|
NeutralIso04_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.4, 0.0, 0.0); |
| 827 |
|
|
| 828 |
|
Double_t Rho = 0; |
| 829 |
< |
if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho(); |
| 830 |
< |
|
| 829 |
> |
switch(fTheRhoType) { |
| 830 |
> |
case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA: |
| 831 |
> |
Rho = PileupEnergyDensity->At(0)->Rho(); |
| 832 |
> |
break; |
| 833 |
> |
case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA: |
| 834 |
> |
Rho = PileupEnergyDensity->At(0)->RhoLowEta(); |
| 835 |
> |
break; |
| 836 |
> |
case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA: |
| 837 |
> |
Rho = PileupEnergyDensity->At(0)->RhoRandom(); |
| 838 |
> |
break; |
| 839 |
> |
case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA: |
| 840 |
> |
Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta(); |
| 841 |
> |
break; |
| 842 |
> |
case RhoUtilities::CMS_RHO_RHOKT6PFJETS: |
| 843 |
> |
Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets(); |
| 844 |
> |
break; |
| 845 |
> |
default: |
| 846 |
> |
// use the old default |
| 847 |
> |
Rho = PileupEnergyDensity->At(0)->Rho(); |
| 848 |
> |
break; |
| 849 |
> |
} |
| 850 |
|
|
| 851 |
|
//set all input variables |
| 852 |
|
fMVAVar_MuPt = muTrk->Pt(); |
| 895 |
|
Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0; |
| 896 |
|
Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0; |
| 897 |
|
|
| 898 |
+ |
Double_t tmpMuDeltaRMean = 0; |
| 899 |
+ |
Double_t tmpMuDeltaRSum = 0; |
| 900 |
+ |
Double_t tmpMuDensity = 0; |
| 901 |
+ |
Double_t tmpMuNPFCand = 0; |
| 902 |
+ |
|
| 903 |
|
for (UInt_t p=0; p<PFCands->GetEntries();p++) { |
| 904 |
|
const PFCandidate *pf = PFCands->At(p); |
| 905 |
|
|
| 917 |
|
//************************************************************ |
| 918 |
|
// Lepton Footprint Removal |
| 919 |
|
//************************************************************ |
| 920 |
< |
for (UInt_t q=0; q < goodElectrons->GetEntries() ; ++q) { |
| 921 |
< |
//if pf candidate matches an electron passing ID cuts, then veto it |
| 922 |
< |
if(pf->GsfTrk() && goodElectrons->At(q)->GsfTrk() && |
| 923 |
< |
pf->GsfTrk() == goodElectrons->At(q)->GsfTrk()) IsLeptonFootprint = kTRUE; |
| 924 |
< |
if(pf->TrackerTrk() && goodElectrons->At(q)->TrackerTrk() && |
| 925 |
< |
pf->TrackerTrk() == goodElectrons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE; |
| 926 |
< |
//if pf candidate lies in veto regions of electron passing ID cuts, then veto it |
| 927 |
< |
if(pf->BestTrk() && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 |
| 928 |
< |
&& MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.015) IsLeptonFootprint = kTRUE; |
| 929 |
< |
if(pf->PFType() == PFCandidate::eGamma && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 && |
| 930 |
< |
MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.08) IsLeptonFootprint = kTRUE; |
| 920 |
> |
if(goodElectrons) { |
| 921 |
> |
for (UInt_t q=0; q < goodElectrons->GetEntries() ; ++q) { |
| 922 |
> |
//if pf candidate matches an electron passing ID cuts, then veto it |
| 923 |
> |
if(pf->GsfTrk() && goodElectrons->At(q)->GsfTrk() && |
| 924 |
> |
pf->GsfTrk() == goodElectrons->At(q)->GsfTrk()) IsLeptonFootprint = kTRUE; |
| 925 |
> |
if(pf->TrackerTrk() && goodElectrons->At(q)->TrackerTrk() && |
| 926 |
> |
pf->TrackerTrk() == goodElectrons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE; |
| 927 |
> |
//if pf candidate lies in veto regions of electron passing ID cuts, then veto it |
| 928 |
> |
if(pf->BestTrk() && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 |
| 929 |
> |
&& MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.015) IsLeptonFootprint = kTRUE; |
| 930 |
> |
if(pf->PFType() == PFCandidate::eGamma && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 && |
| 931 |
> |
MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.08) IsLeptonFootprint = kTRUE; |
| 932 |
> |
} |
| 933 |
|
} |
| 934 |
< |
for (UInt_t q=0; q < goodMuons->GetEntries() ; ++q) { |
| 935 |
< |
//if pf candidate matches an muon passing ID cuts, then veto it |
| 936 |
< |
if(pf->TrackerTrk() && goodMuons->At(q)->TrackerTrk() && |
| 937 |
< |
pf->TrackerTrk() == goodMuons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE; |
| 938 |
< |
//if pf candidate lies in veto regions of muon passing ID cuts, then veto it |
| 939 |
< |
if(pf->BestTrk() && MathUtils::DeltaR(goodMuons->At(q)->Mom(), pf->Mom()) < 0.01) IsLeptonFootprint = kTRUE; |
| 934 |
> |
if(goodMuons) { |
| 935 |
> |
for (UInt_t q=0; q < goodMuons->GetEntries() ; ++q) { |
| 936 |
> |
//if pf candidate matches an muon passing ID cuts, then veto it |
| 937 |
> |
if(pf->TrackerTrk() && goodMuons->At(q)->TrackerTrk() && |
| 938 |
> |
pf->TrackerTrk() == goodMuons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE; |
| 939 |
> |
//if pf candidate lies in veto regions of muon passing ID cuts, then veto it |
| 940 |
> |
if(pf->BestTrk() && MathUtils::DeltaR(goodMuons->At(q)->Mom(), pf->Mom()) < 0.01) IsLeptonFootprint = kTRUE; |
| 941 |
> |
} |
| 942 |
|
} |
| 943 |
|
|
| 944 |
|
if (!IsLeptonFootprint) { |
| 978 |
|
if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt(); |
| 979 |
|
if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt(); |
| 980 |
|
} |
| 981 |
+ |
|
| 982 |
+ |
if (dr < 0.5) { |
| 983 |
+ |
tmpMuNPFCand++; |
| 984 |
+ |
tmpMuDeltaRMean += dr; |
| 985 |
+ |
tmpMuDeltaRSum += dr; |
| 986 |
+ |
tmpMuDensity += pf->Pt() / dr; |
| 987 |
+ |
} |
| 988 |
|
} //not lepton footprint |
| 989 |
|
} //in 1.0 dr cone |
| 990 |
|
} //loop over PF candidates |
| 991 |
|
|
| 992 |
< |
Double_t fMVAVar_ChargedIso_DR0p0To0p1 = 0; |
| 993 |
< |
Double_t fMVAVar_ChargedIso_DR0p1To0p2 = 0; |
| 994 |
< |
Double_t fMVAVar_ChargedIso_DR0p2To0p3 = 0; |
| 995 |
< |
Double_t fMVAVar_ChargedIso_DR0p3To0p4 = 0; |
| 996 |
< |
Double_t fMVAVar_ChargedIso_DR0p4To0p5 = 0; |
| 997 |
< |
Double_t fMVAVar_GammaIso_DR0p0To0p1 = 0; |
| 998 |
< |
Double_t fMVAVar_GammaIso_DR0p1To0p2 = 0; |
| 999 |
< |
Double_t fMVAVar_GammaIso_DR0p2To0p3 = 0; |
| 1000 |
< |
Double_t fMVAVar_GammaIso_DR0p3To0p4 = 0; |
| 1001 |
< |
Double_t fMVAVar_GammaIso_DR0p4To0p5 = 0; |
| 1002 |
< |
Double_t fMVAVar_NeutralHadronIso_DR0p0To0p1 = 0; |
| 1003 |
< |
Double_t fMVAVar_NeutralHadronIso_DR0p1To0p2 = 0; |
| 1004 |
< |
Double_t fMVAVar_NeutralHadronIso_DR0p2To0p3 = 0; |
| 1005 |
< |
Double_t fMVAVar_NeutralHadronIso_DR0p3To0p4 = 0; |
| 1006 |
< |
Double_t fMVAVar_NeutralHadronIso_DR0p4To0p5 = 0; |
| 992 |
> |
// Double_t fMVAVar_ChargedIso_DR0p0To0p1 = 0; |
| 993 |
> |
// Double_t fMVAVar_ChargedIso_DR0p1To0p2 = 0; |
| 994 |
> |
// Double_t fMVAVar_ChargedIso_DR0p2To0p3 = 0; |
| 995 |
> |
// Double_t fMVAVar_ChargedIso_DR0p3To0p4 = 0; |
| 996 |
> |
// Double_t fMVAVar_ChargedIso_DR0p4To0p5 = 0; |
| 997 |
> |
// Double_t fMVAVar_GammaIso_DR0p0To0p1 = 0; |
| 998 |
> |
// Double_t fMVAVar_GammaIso_DR0p1To0p2 = 0; |
| 999 |
> |
// Double_t fMVAVar_GammaIso_DR0p2To0p3 = 0; |
| 1000 |
> |
// Double_t fMVAVar_GammaIso_DR0p3To0p4 = 0; |
| 1001 |
> |
// Double_t fMVAVar_GammaIso_DR0p4To0p5 = 0; |
| 1002 |
> |
// Double_t fMVAVar_NeutralHadronIso_DR0p0To0p1 = 0; |
| 1003 |
> |
// Double_t fMVAVar_NeutralHadronIso_DR0p1To0p2 = 0; |
| 1004 |
> |
// Double_t fMVAVar_NeutralHadronIso_DR0p2To0p3 = 0; |
| 1005 |
> |
// Double_t fMVAVar_NeutralHadronIso_DR0p3To0p4 = 0; |
| 1006 |
> |
// Double_t fMVAVar_NeutralHadronIso_DR0p4To0p5 = 0; |
| 1007 |
|
|
| 1008 |
< |
fMVAVar_ChargedIso_DR0p0To0p1 = TMath::Min((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5); |
| 1009 |
< |
fMVAVar_ChargedIso_DR0p1To0p2 = TMath::Min((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5); |
| 1008 |
> |
fMVAVar_ChargedIso_DR0p0To0p1 = TMath::Min((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5); |
| 1009 |
> |
fMVAVar_ChargedIso_DR0p1To0p2 = TMath::Min((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5); |
| 1010 |
|
fMVAVar_ChargedIso_DR0p2To0p3 = TMath::Min((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5); |
| 1011 |
|
fMVAVar_ChargedIso_DR0p3To0p4 = TMath::Min((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5); |
| 1012 |
|
fMVAVar_ChargedIso_DR0p4To0p5 = TMath::Min((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5); |
| 1020 |
|
fMVAVar_NeutralHadronIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p2To0p3, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0); |
| 1021 |
|
fMVAVar_NeutralHadronIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p3To0p4, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0); |
| 1022 |
|
fMVAVar_NeutralHadronIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p4To0p5, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0); |
| 779 |
– |
|
| 1023 |
|
|
| 1024 |
+ |
// Variables for dR MVA |
| 1025 |
+ |
fMVAVar_MuRelIsoPFCharged = 0.; |
| 1026 |
+ |
fMVAVar_MuRelIsoPFCharged += TMath::Min((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5); |
| 1027 |
+ |
fMVAVar_MuRelIsoPFCharged += TMath::Min((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5); |
| 1028 |
+ |
fMVAVar_MuRelIsoPFCharged += TMath::Min((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5); |
| 1029 |
+ |
fMVAVar_MuRelIsoPFCharged += TMath::Min((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5); |
| 1030 |
+ |
fMVAVar_MuRelIsoPFCharged += TMath::Min((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5); |
| 1031 |
+ |
|
| 1032 |
+ |
fMVAVar_MuRelIsoPFNeutral = 0.; |
| 1033 |
+ |
fMVAVar_MuRelIsoPFNeutral += TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p0To0p1 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p0To0p1, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0); |
| 1034 |
+ |
fMVAVar_MuRelIsoPFNeutral += TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p1To0p2 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p1To0p2, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0); |
| 1035 |
+ |
fMVAVar_MuRelIsoPFNeutral += TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p2To0p3, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0); |
| 1036 |
+ |
fMVAVar_MuRelIsoPFNeutral += TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p3To0p4, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0); |
| 1037 |
+ |
fMVAVar_MuRelIsoPFNeutral += TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p4To0p5, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0); |
| 1038 |
+ |
|
| 1039 |
+ |
fMVAVar_MuRelIsoPFPhotons = 0.; |
| 1040 |
+ |
fMVAVar_MuRelIsoPFPhotons += TMath::Max(TMath::Min((tmpGammaIso_DR0p0To0p1 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p0To0p1, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0); |
| 1041 |
+ |
fMVAVar_MuRelIsoPFPhotons += TMath::Max(TMath::Min((tmpGammaIso_DR0p1To0p2 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p1To0p2, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0); |
| 1042 |
+ |
fMVAVar_MuRelIsoPFPhotons += TMath::Max(TMath::Min((tmpGammaIso_DR0p2To0p3 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p2To0p3, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0); |
| 1043 |
+ |
fMVAVar_MuRelIsoPFPhotons += TMath::Max(TMath::Min((tmpGammaIso_DR0p3To0p4 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p3To0p4, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0); |
| 1044 |
+ |
fMVAVar_MuRelIsoPFPhotons += TMath::Max(TMath::Min((tmpGammaIso_DR0p4To0p5 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p4To0p5, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0); |
| 1045 |
+ |
|
| 1046 |
+ |
fMVAVar_MuDeltaRMean = tmpMuDeltaRMean/TMath::Max(1.0,tmpMuNPFCand); |
| 1047 |
+ |
fMVAVar_MuDeltaRSum = tmpMuDeltaRSum; |
| 1048 |
+ |
fMVAVar_MuDensity = tmpMuDensity; |
| 1049 |
|
|
| 1050 |
|
Double_t mva = -9999; |
| 1051 |
|
TMVA::Reader *reader = 0; |
| 1061 |
|
mva = reader->EvaluateMVA( fMethodname ); |
| 1062 |
|
|
| 1063 |
|
if (printDebug) { |
| 1064 |
< |
std::cout << "Debug Muon MVA: \n"; |
| 1064 |
> |
std::cout << "Debug Muon MVA: "; |
| 1065 |
|
std::cout << " MuTkNchi2 " << fMVAVar_MuTkNchi2 |
| 1066 |
|
<< " MuGlobalNchi2 " << fMVAVar_MuGlobalNchi2 |
| 1067 |
|
<< " MuNValidHits " << fMVAVar_MuNValidHits |
| 1079 |
|
<< " MuHadS9Energy " << fMVAVar_MuHadS9Energy |
| 1080 |
|
<< " MuEmS9Energy " << fMVAVar_MuEmS9Energy |
| 1081 |
|
<< " eta " << fMVAVar_MuEta |
| 1082 |
< |
<< " pt " << fMVAVar_MuPt << std::endl; |
| 1083 |
< |
|
| 1082 |
> |
<< " pt " << fMVAVar_MuPt |
| 1083 |
> |
<< " isoInfo: "; |
| 1084 |
|
std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " " |
| 1085 |
|
<< fMVAVar_ChargedIso_DR0p1To0p2 << " " |
| 1086 |
|
<< fMVAVar_ChargedIso_DR0p2To0p3 << " " |
| 1095 |
|
<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " " |
| 1096 |
|
<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " " |
| 1097 |
|
<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " " |
| 1098 |
< |
<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " " |
| 1099 |
< |
<< std::endl; |
| 1100 |
< |
std::cout << "MVA: " << mva |
| 1098 |
> |
<< fMVAVar_NeutralHadronIso_DR0p4To0p5; |
| 1099 |
> |
std::cout << " MuRelIsoPFCharged: " << fMVAVar_MuRelIsoPFCharged |
| 1100 |
> |
<< " MuRelIsoPFNeutral: " << fMVAVar_MuRelIsoPFNeutral |
| 1101 |
> |
<< " MuRelIsoPFPhotons: " << fMVAVar_MuRelIsoPFPhotons |
| 1102 |
> |
<< " MuDeltaRMean: " << fMVAVar_MuDeltaRMean |
| 1103 |
> |
<< " MuDeltaRMean: " << fMVAVar_MuDeltaRMean |
| 1104 |
> |
<< " MuDensity: " << fMVAVar_MuDensity; |
| 1105 |
> |
std::cout << " MVA: " << mva |
| 1106 |
|
<< std::endl; |
| 1107 |
|
} |
| 1108 |
|
|
