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

Comparing UserCode/MitPhysics/Utils/src/ElectronIDMVA.cc (file contents):
Revision 1.1 by sixie, Sun Sep 25 10:08:11 2011 UTC vs.
Revision 1.4 by sixie, Mon Oct 3 16:32:09 2011 UTC

# Line 15 | Line 15 | using namespace mithep;
15   //--------------------------------------------------------------------------------------------------
16   ElectronIDMVA::ElectronIDMVA() :
17   fMethodname("BDTG method"),
18 – fLH(0),
18   fIsInitialized(kFALSE)
19   {
20    // Constructor.
# Line 41 | Line 40 | void ElectronIDMVA::Initialize( TString
40                                  TString Subdet0Pt20ToInfWeights,
41                                  TString Subdet1Pt20ToInfWeights,
42                                  TString Subdet2Pt20ToInfWeights,
43 <                                ElectronLikelihood *LH) {
43 >                                ElectronIDMVA::MVAType type) {
44  
45    fIsInitialized = kTRUE;
46    
47    fMethodname = methodName;
49 –  fLH = LH;    
50 –  if (!fLH) { std::cout << "Error: Likelihood is not properly initialized.\n"; assert(fLH); }
48      
49    for(UInt_t i=0; i<6; ++i) {
50      if (fTMVAReader[i]) delete fTMVAReader[i];
51  
52      fTMVAReader[i] = new TMVA::Reader( "!Color:!Silent:Error" );  
53      fTMVAReader[i]->SetVerbose(kTRUE);
54 <    fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta         );
55 <    fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                );
56 <    fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                );
57 <    fTMVAReader[i]->AddVariable( "HoverE",                &fMVAVar_EleHoverE                );
58 <    fTMVAReader[i]->AddVariable( "D0",                    &fMVAVar_EleD0                    );
59 <    fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
60 <    fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                );
61 <    fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout  );
62 <    fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
63 <    fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
64 <    fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );
65 <    fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn   );
66 <    fTMVAReader[i]->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                  );
67 <    fTMVAReader[i]->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig               );
68 <    fTMVAReader[i]->AddVariable( "StandardLikelihood",    &fMVAVar_EleStandardLikelihood    );
54 >
55 >    if (type == kBaseline) {
56 >      fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta         );
57 >      fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                );
58 >      fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                );
59 >      fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
60 >      fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
61 >      fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
62 >      fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );      
63 >    }
64 >    
65 >    if (type == kV1) {
66 >      fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta         );
67 >      fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                );
68 >      fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                );
69 >      fTMVAReader[i]->AddVariable( "HoverE",                &fMVAVar_EleHoverE                );
70 >      fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
71 >      fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                );
72 >      fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout  );
73 >      fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
74 >      fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
75 >      fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );      
76 >      fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn   );
77 >    }
78 >    if (type == kV2) {
79 >      fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta         );
80 >      fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                );
81 >      fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                );
82 >      fTMVAReader[i]->AddVariable( "HoverE",                &fMVAVar_EleHoverE                );
83 >      fTMVAReader[i]->AddVariable( "D0",                    &fMVAVar_EleD0                    );
84 >      fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
85 >      fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                );
86 >      fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout  );
87 >      fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
88 >      fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
89 >      fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );      
90 >      fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn   );
91 >      fTMVAReader[i]->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                  );
92 >      fTMVAReader[i]->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig               );
93 >    }
94  
95      if (i==0) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt10To20Weights );
96      if (i==1) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt10To20Weights );
# Line 80 | Line 102 | void ElectronIDMVA::Initialize( TString
102    }
103  
104    std::cout << "Electron ID MVA Initialization\n";
105 <  std::cout << "MethodName : " << fMethodname << std::endl;
105 >  std::cout << "MethodName : " << fMethodname << " , type == " << type << std::endl;
106    std::cout << "Load weights file : " << Subdet0Pt10To20Weights << std::endl;
107    std::cout << "Load weights file : " << Subdet1Pt10To20Weights << std::endl;
108    std::cout << "Load weights file : " << Subdet2Pt10To20Weights << std::endl;
# Line 90 | Line 112 | void ElectronIDMVA::Initialize( TString
112  
113   }
114  
115 + //--------------------------------------------------------------------------------------------------
116 + Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleSCEta,
117 +                                 Double_t EleSigmaIEtaIEta,
118 +                                 Double_t EleDEtaIn,
119 +                                 Double_t EleDPhiIn,
120 +                                 Double_t EleHoverE,
121 +                                 Double_t EleD0,
122 +                                 Double_t EleDZ,
123 +                                 Double_t EleFBrem,
124 +                                 Double_t EleEOverP,
125 +                                 Double_t EleESeedClusterOverPout,
126 +                                 Double_t EleSigmaIPhiIPhi,
127 +                                 Double_t EleNBrem,
128 +                                 Double_t EleOneOverEMinusOneOverP,
129 +                                 Double_t EleESeedClusterOverPIn,
130 +                                 Double_t EleIP3d,
131 +                                 Double_t EleIP3dSig
132 +  ) {
133 +  
134 +  if (!fIsInitialized) {
135 +    std::cout << "Error: ElectronIDMVA not properly initialized.\n";
136 +    return -9999;
137 +  }
138 +
139 +  Int_t subdet = 0;
140 +  if (fabs(EleSCEta) < 1.0) subdet = 0;
141 +  else if (fabs(EleSCEta) < 1.479) subdet = 1;
142 +  else subdet = 2;
143 +  Int_t ptBin = 0;
144 +  if (ElePt > 20.0) ptBin = 1;
145 +  
146 +  //set all input variables
147 +  fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
148 +  fMVAVar_EleDEtaIn = EleDEtaIn;
149 +  fMVAVar_EleDPhiIn = EleDPhiIn;
150 +  fMVAVar_EleHoverE = EleHoverE;
151 +  fMVAVar_EleD0 = EleD0;
152 +  fMVAVar_EleDZ = EleDZ;
153 +  fMVAVar_EleFBrem = EleFBrem;
154 +  fMVAVar_EleEOverP = EleEOverP;
155 +  fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
156 +  fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
157 +  fMVAVar_EleNBrem = EleNBrem;
158 +  fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
159 +  fMVAVar_EleESeedClusterOverPIn = EleESeedClusterOverPIn;
160 +  fMVAVar_EleIP3d = EleIP3d;
161 +  fMVAVar_EleIP3dSig = EleIP3dSig;
162 +
163 +  Double_t mva = -9999;  
164 +  TMVA::Reader *reader = 0;
165 +  Int_t MVABin = -1;
166 +  if (subdet == 0 && ptBin == 0) MVABin = 0;
167 +  if (subdet == 1 && ptBin == 0) MVABin = 1;
168 +  if (subdet == 2 && ptBin == 0) MVABin = 2;
169 +  if (subdet == 0 && ptBin == 1) MVABin = 3;
170 +  if (subdet == 1 && ptBin == 1) MVABin = 4;
171 +  if (subdet == 2 && ptBin == 1) MVABin = 5;
172 +  assert(MVABin >= 0 && MVABin <= 5);
173 +  reader = fTMVAReader[MVABin];
174 +                                                
175 +  mva = reader->EvaluateMVA( fMethodname );
176 +
177 +  return mva;
178 + }
179 +
180 +
181  
182   //--------------------------------------------------------------------------------------------------
183   Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex) {
# Line 123 | Line 211 | Double_t ElectronIDMVA::MVAValue(const E
211    fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
212    fMVAVar_EleIP3d = ele->Ip3dPV();
213    fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
126 –  fMVAVar_EleStandardLikelihood = ElectronTools::Likelihood(fLH, ele);
214  
215    Double_t mva = -9999;  
216    TMVA::Reader *reader = 0;
# Line 137 | Line 224 | Double_t ElectronIDMVA::MVAValue(const E
224    assert(MVABin >= 0 && MVABin <= 5);
225    reader = fTMVAReader[MVABin];
226                                                  
140 – //   std::cout << ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << std::endl;
141 – //   std::cout <<   fMVAVar_EleSigmaIEtaIEta << " "
142 – //        <<   fMVAVar_EleDEtaIn << " "
143 – //        <<   fMVAVar_EleDPhiIn << " "
144 – //        <<   fMVAVar_EleHoverE  << " "
145 – //        <<   fMVAVar_EleD0 << " "
146 – //        <<   fMVAVar_EleDZ << " "
147 – //        <<   fMVAVar_EleFBrem  << " "
148 – //        <<   fMVAVar_EleEOverP  << " "
149 – //        <<   fMVAVar_EleESeedClusterOverPout  << " "
150 – //        <<   fMVAVar_EleSigmaIPhiIPhi  << " "
151 – //        <<   fMVAVar_EleNBrem  << " "
152 – //        <<   fMVAVar_EleOneOverEMinusOneOverP  << " "
153 – //        <<   fMVAVar_EleESeedClusterOverPIn  << " "
154 – //        <<   fMVAVar_EleIP3d  << " "
155 – //        <<   fMVAVar_EleIP3dSig  << " "
156 – //        <<   fMVAVar_EleStandardLikelihood  << " "
157 – //        << std::endl;
158 –
159 – //   std::cout << subdet << " : " << ptBin << std::endl;
160 – //   if (reader) std::cout << MVABin << " : reader is good\n";
161 –
227    mva = reader->EvaluateMVA( fMethodname );
163 –  //   std::cout << "Electron: " << el->Pt() << " " << el->Eta() << " " << el->Phi() << " : " << MVAValue << std::endl;
228  
229    return mva;
230   }

Diff Legend

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