ndmspc  0.20250128.0
PointDraw.cxx
1 #include <TString.h>
2 #include <TApplication.h>
3 #include <TCanvas.h>
4 #include <TRootCanvas.h>
5 #include <TROOT.h>
6 #include <TF1.h>
7 #include <TH2.h>
8 #include <TH1D.h>
9 #include <TCanvas.h>
10 #include <string>
11 #include "PointDraw.h"
12 #include "Core.h"
13 #include "ROOT/RConfig.hxx"
14 #include "Rtypes.h"
15 #include "Utils.h"
16 
18 ClassImp(Ndmspc::PointDraw);
20 
21 namespace Ndmspc {
22 std::string PointDraw::fgEnvironment = "";
23 PointDraw::PointDraw() : TObject()
24 
25 {
29 }
30 
32 {
36 }
37 
38 int PointDraw::Draw(std::string config, std::string userConfig, std::string environment, std::string userConfigRaw)
39 {
43  TApplication app("app", nullptr, nullptr);
44 
45  std::string parameter = "";
46  std::string resultsHnSparseName = "results";
47  std::string parameterAxisName = "parameters";
48  std::string inputFile;
49 
50  fCurrentParameterName = parameter;
51 
52  TH1::AddDirectory(kFALSE);
53 
54  // INFO: Done via Results::LoadConfig
55  if (!Core::LoadConfig(config, userConfig, environment, userConfigRaw)) return 1;
56 
57  // INFO: Done via Results::LoadConfig
58  bool histogramEnabled = false;
59  if (!gCfg["ndmspc"]["data"]["histogram"]["enabled"].is_null() ||
60  gCfg["ndmspc"]["data"]["histogram"]["enabled"].is_boolean())
61  histogramEnabled = gCfg["ndmspc"]["data"]["histogram"]["enabled"].get<bool>();
62 
63  // TODO: Results path
64  std::string hostUrl = gCfg["ndmspc"]["output"]["host"].get<std::string>();
65  // if (hostUrl.empty()) {
66  // Printf("Error: gCfg[ndmspc][output][host] is empty!!!");
67  // return 2;
68  // }
69 
70  std::string path;
71  if (!hostUrl.empty()) path = hostUrl + "/";
72  path += gCfg["ndmspc"]["output"]["dir"].get<std::string>() + "/";
73 
74  path += environment + "/";
75 
76  // std::string rebinStr = "";
77  for (auto & cut : gCfg["ndmspc"]["cuts"]) {
78  if (cut["enabled"].is_boolean() && cut["enabled"].get<bool>() == false) continue;
79  // path += cut["axis"].get<std::string>() + "_";
80  // rebinStr += std::to_string(cut["rebin"].get<Int_t>()) + "_";
81  fNDimCuts++;
82  }
83  //
84  // path[path.size() - 1] = '/';
85  // path += rebinStr;
86  // path[path.size() - 1] = '/';
87  path += Utils::GetCutsPath(gCfg["ndmspc"]["cuts"]);
88 
89  if (inputFile.empty()) inputFile = path + "results.root";
90 
91  Printf("Opening file '%s' ...", inputFile.c_str());
92 
93  fIn = TFile::Open(inputFile.c_str());
94  if (!fIn) {
95  Printf("Error: Input file '%s' was not found !!!", inputFile.c_str());
96  return 2;
97  }
98 
99  fResultHnSparse = (THnSparse *)fIn->Get(resultsHnSparseName.c_str());
100 
101  if (!fResultHnSparse) {
102  Printf("Error: Results THnSparse histogram '%s' was not found !!!", resultsHnSparseName.c_str());
103  return 3;
104  }
105 
106  fMapAxesType = (TH1 *)fIn->Get("mapAxesType");
107  if (!fMapAxesType) {
108  Printf("Error: 'mapAxesType' histogram was not found !!!");
109  return 4;
110  }
111  for (int iDim = 0; iDim < fResultHnSparse->GetNdimensions(); iDim++) fParameterPoint.push_back(-1);
112 
113  if (fCurrentParameterName.empty()) {
114  int idxDefault = gCfg["ndmspc"]["result"]["parameters"]["default"].get<int>();
115  fCurrentParameterName = gCfg["ndmspc"]["result"]["parameters"]["labels"][idxDefault].get<std::string>();
116  }
117  Printf("Parameter: %s", fCurrentParameterName.c_str());
118 
119  TAxis * a = (TAxis *)fResultHnSparse->GetListOfAxes()->FindObject(parameterAxisName.c_str());
120  if (a == nullptr) {
121  return 5;
122  }
123  Int_t id = fResultHnSparse->GetListOfAxes()->IndexOf(a);
124  Int_t idBin = a->FindBin(fCurrentParameterName.c_str());
125  if (idBin < 0) {
126  Printf("Could not find bin label '%s' in '%s' axis !!!", parameterAxisName.c_str(), fCurrentParameterName.c_str());
127  return 6;
128  }
129 
130  // Printf("Axis: %d [parameters] SetRange(%d,%d)", id, idBin, idBin);
131  fParameterPoint[id] = idBin;
132  fResultHnSparse->GetAxis(id)->SetRange(idBin, idBin);
133 
134  int nAxisX = fResultHnSparse->GetNdimensions();
135  int nAxisY = fResultHnSparse->GetAxis(0)->GetNbins();
136  int pointsSize = gCfg["ndmspc"]["result"]["axes"].size() + 1;
137  if (histogramEnabled) pointsSize += gCfg["ndmspc"]["result"]["data"]["defaults"].size() + 1;
138  int points[pointsSize];
139  int iPoint = 0;
140  points[iPoint++] = nAxisY;
141  int iAxisStart = 1;
142  fMapTitle = fCurrentParameterName + " [";
143  json axesArray = gCfg["ndmspc"]["result"]["axes"];
144  int idTmp;
145  bool isDataSys = true;
146  bool hasDataMc = false;
147  for (int iAxis = iAxisStart; iAxis < fResultHnSparse->GetNdimensions(); iAxis++) {
148  idBin = 1;
149  std::string axisType = fMapAxesType->GetXaxis()->GetBinLabel(iAxis + 1);
150  // Printf("Axis: %d [%s]", iAxis, axisType.c_str());
151  if (!hasDataMc) hasDataMc = !axisType.compare("data");
152  if (!axisType.compare("proj")) {
153  isDataSys = false;
154  fProjectionAxes.push_back(iAxis);
155  }
156  else if (!axisType.compare("sys-in") || !axisType.compare("data")) {
157  if (isDataSys) {
158  idTmp = iAxis - iAxisStart;
159  // Printf("%d %d %d", iAxis, iAxisStart, idTmp);
160  idBin = gCfg["ndmspc"]["result"]["data"]["defaults"][idTmp].get<int>();
161  }
162  else {
163  idTmp = iAxis - iAxisStart - fNDimCuts;
164  if (histogramEnabled) idTmp -= gCfg["ndmspc"]["result"]["data"]["defaults"].size();
165  // Printf("%d %s", idTmp, axesArray.dump().c_str());
166  idBin = axesArray[idTmp]["default"].get<int>() + 1;
167  }
168  }
169  a = (TAxis *)fResultHnSparse->GetAxis(iAxis);
170  // Printf("Axis: %d [%s][%s] SetRange(%d,%d)", iAxis, axisType.c_str(), a->GetName(), idBin, idBin);
171  points[iAxis] = a->GetNbins();
172  fParameterPoint[iAxis] = idBin;
173  fResultHnSparse->GetAxis(iAxis)->SetRange(idBin, idBin);
174  std::string l = a->GetBinLabel(idBin);
175  if (l.empty()) {
176  fMapTitle += std::to_string(a->GetBinLowEdge(idBin));
177  }
178  else {
179  fMapTitle += l;
180  }
181  fMapTitle += " ";
182  }
183  fMapTitle[fMapTitle.size() - 1] = ']';
184 
185  // for (auto & p : fParameterPoint) {
186  // printf("%d ", p);
187  // }
188  // printf("\n");
189 
190  // Printf("fMapTitle='%s'", fMapTitle.c_str());
191 
192  auto CanvasMain = new TCanvas("CanvasMain", "CanvasMain", 0, 0, 500, 800);
193  CanvasMain->Divide(1, 2);
194  /*CanvasMain->HighlightConnect("HighlightMain(TVirtualPad*,TObject*,Int_t,Int_t)");*/
195  CanvasMain->Connect("Highlighted(TVirtualPad*,TObject*,Int_t,Int_t)", "Ndmspc::PointDraw", this,
196  "HighlightMain(TVirtualPad*,TObject*,Int_t,Int_t)");
197 
198  // // handle systematics
199  // // Printf("nAxisX=%d nAxisY=%d", nAxisX, nAxisY);
200  CanvasMain->cd(1);
201  TH1 * hParamMain = new TH1S("hParamMain", "Param Main", fResultHnSparse->GetAxis(0)->GetNbins(), 0,
202  fResultHnSparse->GetAxis(0)->GetNbins());
203 
204  for (int i = 0; i < fResultHnSparse->GetAxis(0)->GetNbins(); i++) {
205  hParamMain->GetXaxis()->SetBinLabel(i + 1, fResultHnSparse->GetAxis(0)->GetBinLabel(i + 1));
206  // hParamMain->SetBinContent(i + 1, 1, 1);
207  }
208 
209  // for (int i = 0; i < nAxisX; i++) {
210  // hParamMain->GetXaxis()->SetBinLabel(i + 1, fResultHnSparse->GetAxis(i)->GetName());
211  // for (int j = 0; j < points[i]; j++) {
212  // hParamMain->SetBinContent(i + 1, j + 1, 1);
213  // }
214  // }
215  hParamMain->SetStats(0);
216  // hParamMain->SetLabelSize(0.07);
217  // hParamMain->Print();
218  hParamMain->Draw();
219  hParamMain->SetHighlight();
220 
221  CanvasMain->cd(2);
222  if (hasDataMc) {
223  fResultHnSparse->GetAxis(1)->SetRange();
224  fResultHnSparse->GetAxis(2)->SetRange();
225  fDataId.clear();
226  fDataId.push_back(-1);
227  fData.clear();
228  fData.push_back("x");
229  fMcId.clear();
230  fMcId.push_back(-1);
231 
232  fMc.clear();
233  fMc.push_back("x");
234  for (auto & b1 : gCfg["ndmspc"]["data"]["histogram"]["bins"]) {
235  std::vector<int> b = b1;
236  // Printf("b1=[%d(%s),%d(%s),%d(%s),%d(%s)] ", b[0], fResultHnSparse->GetAxis(1)->GetBinLabel(b[0]), b[1],
237  // fResultHnSparse->GetAxis(2)->GetBinLabel(b[1]), b[2], fResultHnSparse->GetAxis(3)->GetBinLabel(b[2]),
238  // b[3], fResultHnSparse->GetAxis(4)->GetBinLabel(b[3]));
239  std::string v;
240  if (b[0] == 1) {
241  // mc
242  v += fResultHnSparse->GetAxis(2)->GetBinLabel(b[1]);
243  v += "|";
244  v += std::to_string(b[2]) + "|";
245  v += std::to_string(b[3]);
246  fMc.push_back(v);
247  fMcId.push_back(b[1]);
248  }
249  else if (b[1] == 1) {
250  // data
251  v += fResultHnSparse->GetAxis(1)->GetBinLabel(b[0]);
252  v += "|";
253  v += std::to_string(b[2]) + "|";
254  v += std::to_string(b[3]);
255  fData.push_back(v);
256  fDataId.push_back(b[0]);
257  }
258  // Printf("%s", v.c_str());
259  }
260  // Printf("%ld %ld", fData.size(), fMc.size());
261  TH1 * hDataMc = new TH2S("hDataMc", "Data vs. MC", fData.size(), 0, fData.size(), fMc.size(), 0, fMc.size());
262 
263  /*TH2 * hDataMc = fResultHnSparse->Projection(2, 1, "O");*/
264  /*hDataMc->SetNameTitle("hDataMc", "Data vs. MC");*/
265  hDataMc->SetStats(0);
266  for (int i = 0; i < fData.size(); i++) {
267  hDataMc->GetXaxis()->SetBinLabel(i + 1, fData[i].c_str());
268  }
269  for (int i = 0; i < fMc.size(); i++) {
270  hDataMc->GetYaxis()->SetBinLabel(i + 1, fMc[i].c_str());
271  }
272 
273  for (int i = 1; i < hDataMc->GetNbinsX() + 1; i++)
274  for (int j = 1; j < hDataMc->GetNbinsY() + 1; j++) {
275  if (i == 1 && j == 1) continue;
276  if (i == 1 || j == 1) hDataMc->SetBinContent(i, j, 1);
277  }
278 
279  // hDataMc->Reset();
280  // hParamMain->SetBinContent(i + 1, j + 1, 1);
281 
282  hDataMc->Draw("col");
283  hDataMc->SetHighlight();
284  }
285 
286  DrawProjections();
287  CanvasMain->Modified();
288  CanvasMain->Update();
289 
290  app.Run();
291  return 0;
292 }
293 
294 void PointDraw::DrawUser()
295 {
296  Printf("DrawUser : Getting '%s' ...", fCurrentContentPath.c_str());
297  auto CanvasUser = (TCanvas *)gROOT->GetListOfCanvases()->FindObject("CanvasUser");
298  if (!CanvasUser) {
299  CanvasUser = new TCanvas("CanvasUser", "CanvasUser", 910, 0, 400, 400);
300  // Printf("CanvasUser");
301  CanvasUser->Divide(2, 2);
302  // CanvasUser->HighlightConnect("HighlightProj(TVirtualPad*,TObject*,Int_t,Int_t)");
303  }
304  // fCurrentContentPath += "hPeak";
305  TH1 * hSigBg = (TH1 *)fIn->Get(TString::Format("%s/hSigBg", fCurrentContentPath.c_str()));
306  TH1 * hBg = (TH1 *)fIn->Get(TString::Format("%s/hBg", fCurrentContentPath.c_str()));
307  TH1 * hBgNorm = (TH1 *)fIn->Get(TString::Format("%s/hBgNorm", fCurrentContentPath.c_str()));
308  TH1 * hPeak = (TH1 *)fIn->Get(TString::Format("%s/hPeak", fCurrentContentPath.c_str()));
309  if (!hPeak) {
310  CanvasUser->Clear("D");
311  CanvasUser->Modified();
312  CanvasUser->Update();
313  // gROOT->GetListOfCanvases()->Remove(CanvasUser);
314  // SafeDelete(CanvasUser);
315  return;
316  }
317 
318  if (hBg) {
319  hBg->SetLineColor(kViolet);
320  hBg->SetMarkerColor(kViolet);
321  }
322  if (hBgNorm) {
323  hBgNorm->SetLineColor(kGreen);
324  hBgNorm->SetMarkerColor(kGreen);
325  }
326 
327  CanvasUser->cd(1);
328  if (hSigBg) hSigBg->Draw();
329  if (hBg) hBg->Draw("SAME");
330  CanvasUser->cd(2);
331  if (hSigBg) hSigBg->Draw();
332  if (hBgNorm) hBgNorm->Draw("SAME");
333  CanvasUser->cd(3);
334  if (hPeak) hPeak->Draw();
335  CanvasUser->cd(4);
336  if (hPeak) {
337 
338  TF1 * funSignal = (TF1 *)hPeak->GetListOfFunctions()->At(0);
339  if (funSignal) {
340  funSignal->Draw();
341  }
342  }
343  CanvasUser->Modified();
344  CanvasUser->Update();
345 }
346 
347 void PointDraw::UpdateRanges()
348 {
349  for (int iAxis = 0; iAxis < fResultHnSparse->GetNdimensions(); iAxis++) {
350  // Printf("Axis: %d [%s] SetRange(%d,%d)", iAxis, fResultHnSparse->GetAxis(iAxis)->GetName(),
351  // fParameterPoint[iAxis],
352  // fParameterPoint[iAxis]);
353  fResultHnSparse->GetAxis(iAxis)->SetRange(fParameterPoint[iAxis], fParameterPoint[iAxis]);
354  }
355 
356  fCurrentContentPath.clear();
357  int i = 0;
358  for (auto & p : fParameterPoint) {
359  if (fCurrentContentPath.empty()) {
360  fCurrentContentPath = "content/";
361  continue;
362  }
363  fCurrentContentPath += std::to_string(std::abs(p)) + "/";
364  }
365 }
366 
367 void PointDraw::DrawProjections(bool ignoreMapping)
368 {
369 
370  // Printf("DrawProjections %zu", fProjectionAxes.size());
371  UpdateRanges();
372 
373  if (fParameterPoint.size() == 0) return;
374 
375  int xBin = fParameterPoint[fProjectionAxes[0]];
376  int yBin = -1;
377 
378  if (fProjectionAxes.size() == 2) {
379  xBin = fParameterPoint[fProjectionAxes[1]];
380  yBin = fParameterPoint[fProjectionAxes[0]];
381  }
382 
383  double min = 1;
384  double max = 0;
385 
386  if (!gCfg["ndmspc"]["result"]["parameters"]["draw"][fCurrentParameterName].is_null()) {
387  // Printf("Apply %s %s", fCurrentParameterName.c_str(),
388  // gCfg["ndmspc"]["result"]["parameters"]["draw"][fCurrentParameterName].dump().c_str());
389  min = gCfg["ndmspc"]["result"]["parameters"]["draw"][fCurrentParameterName]["min"].get<double>();
390  max = gCfg["ndmspc"]["result"]["parameters"]["draw"][fCurrentParameterName]["max"].get<double>();
391  }
392 
393  auto CanvasProjectionMap = (TCanvas *)gROOT->GetListOfCanvases()->FindObject("CanvasProjectionMap");
394  if (!CanvasProjectionMap) {
395  CanvasProjectionMap = new TCanvas("CanvasProjectionMap", "CanvasProjectionMap", 505, 0, 400, 400);
396  // Printf("CanvasProjectionMap xBin=%d yBin=%d %zu", xBin, yBin, fProjectionAxes.size());
397  /*CanvasProjectionMap->HighlightConnect("HighlightProjectionPoint(TVirtualPad*,TObject*,Int_t,Int_t)");*/
398  CanvasProjectionMap->Connect("Highlighted(TVirtualPad*,TObject*,Int_t,Int_t)", "Ndmspc::PointDraw", this,
399  "HighlightProjectionPoint(TVirtualPad*,TObject*,Int_t,Int_t)");
400  }
401 
402  if (!ignoreMapping) {
403 
404  if (fProjectionAxes.size() == 1) {
405  CanvasProjectionMap->cd();
406  fResultHnSparse->GetAxis(fProjectionAxes[0])->SetRange();
407  TH1 * h = fResultHnSparse->Projection(fProjectionAxes[0], "O");
408  h->SetHighlight();
409  if (min < max) {
410  h->SetMinimum(min);
411  h->SetMaximum(max);
412  }
413  h->Draw();
414 
415  CanvasProjectionMap->Modified();
416  CanvasProjectionMap->Update();
417  return;
418  }
419  if (fProjectionAxes.size() == 2) {
420  CanvasProjectionMap->cd();
421  fResultHnSparse->GetAxis(fProjectionAxes[0])->SetRange();
422  fResultHnSparse->GetAxis(fProjectionAxes[1])->SetRange();
423  // fResultHnSparse->Projection(fProjectionAxes[1], fProjectionAxes[0], "O")->Draw("colz");
424  TH2 * h = fResultHnSparse->Projection(fProjectionAxes[1], fProjectionAxes[0], "O");
425  h->SetHighlight();
426  h->Draw("colz");
427  CanvasProjectionMap->Modified();
428  CanvasProjectionMap->Update();
429  }
430  }
431 
432  auto CanvasProjections = (TCanvas *)gROOT->GetListOfCanvases()->FindObject("CanvasProjections");
433  if (!CanvasProjections) {
434  CanvasProjections = new TCanvas("CanvasProjections", "CanvasProjections", 505, 445, 400, 350);
435  // Printf("CanvasProjections xBin=%d yBin=%d %zu", xBin, yBin, fProjectionAxes.size());
436  CanvasProjections->Divide(1, fProjectionAxes.size());
437  // CanvasProjections->HighlightConnect("HighlightProj(TVirtualPad*,TObject*,Int_t,Int_t)");
438  }
439 
440  TH1 * px = nullptr;
441  TH1 * py = nullptr;
442  CanvasProjections->cd(1);
443  fResultHnSparse->GetAxis(fProjectionAxes[0])->SetRange();
444  fResultHnSparse->GetAxis(fProjectionAxes[1])->SetRange(xBin, xBin);
445  px = fResultHnSparse->Projection(fProjectionAxes[0], "O");
446  if (px) {
447  if (min < max) {
448  px->SetMinimum(min);
449  px->SetMaximum(max);
450  }
451  px->Draw();
452  }
453  if (fProjectionAxes.size() == 2) {
454  CanvasProjections->cd(2);
455  if (fProjectionAxes.size() > 1) fResultHnSparse->GetAxis(fProjectionAxes[1])->SetRange();
456  if (yBin > 0) fResultHnSparse->GetAxis(fProjectionAxes[0])->SetRange(yBin, yBin);
457  py = fResultHnSparse->Projection(fProjectionAxes[1], "O");
458  if (py) {
459  if (min < max) {
460  py->SetMinimum(min);
461  py->SetMaximum(max);
462  }
463  py->Draw();
464  }
465  }
466 
467  CanvasProjections->Modified();
468  CanvasProjections->Update();
469 }
470 
471 void PointDraw::HighlightMain(TVirtualPad * pad, TObject * obj, Int_t xBin, Int_t yBin)
472 {
473  auto h = (TH1 *)obj;
474  std::string hName = h->GetName();
475  if (!hName.compare("hParamMain")) {
476  HighlightParam(pad, obj, xBin, yBin);
477  }
478  else if (!hName.compare("hDataMc")) {
479  HighlightData(pad, obj, xBin, yBin);
480  }
481 }
482 
483 void PointDraw::HighlightParam(TVirtualPad * pad, TObject * obj, Int_t xBin, Int_t yBin)
484 {
485  // Printf("HighlightParam %d %d", xBin, yBin);
486  TH1 * fParamMapHistogram = (TH1 *)obj;
487  if (!fParamMapHistogram) return;
488 
489  // double binContent = fParamMapHistogram->GetBinContent(xBin, yBin);
490  // if (binContent <= 0) return;
491  fParamMapHistogram->SetTitle(fParamMapHistogram->GetXaxis()->GetBinLabel(xBin));
492  fParameterPoint[0] = xBin;
493  fCurrentParameterName = fParamMapHistogram->GetXaxis()->GetBinLabel(xBin);
494  // Printf("%s", fCurrentParameterName.c_str());
495  DrawProjections();
496 
497  pad->Modified();
498  pad->Update();
499 }
500 
501 void PointDraw::HighlightData(TVirtualPad * pad, TObject * obj, Int_t xBin, Int_t yBin)
502 {
503  // Printf("HighlightData %d %d", xBin, yBin);
504  TH2 * hDataMc = (TH2 *)obj;
505  if (!hDataMc) return;
506 
507  if (hDataMc->GetBinContent(xBin, yBin) <= 0) {
508  hDataMc->SetTitle("Data vs. MC");
509  pad->Modified();
510  pad->Update();
511  return;
512  }
513 
514  std::string data = hDataMc->GetXaxis()->GetBinLabel(xBin);
515  std::string mc = hDataMc->GetYaxis()->GetBinLabel(yBin);
516  hDataMc->SetTitle(TString::Format("%s vs %s", data.c_str(), mc.c_str()).Data());
517  Printf("data=%s[%d] mc=%s[%d]", data.c_str(), xBin, mc.c_str(), yBin);
518  fParameterPoint[1] = xBin;
519  fParameterPoint[2] = yBin;
520 
521  if (xBin == 1 && yBin > 1) {
522  // mc
523  ptrdiff_t pos = distance(fMc.begin(), find(fMc.begin(), fMc.end(), mc));
524  fParameterPoint[2] = fMcId[int(pos)];
525  std::vector<std::string> tok = Ndmspc::Utils::Tokenize(mc, '|');
526  fParameterPoint[3] = atoi(tok[1].c_str());
527  fParameterPoint[4] = atoi(tok[2].c_str());
528  }
529  else if (yBin == 1 && xBin > 1) {
530  // data
531  ptrdiff_t pos = distance(fData.begin(), find(fData.begin(), fData.end(), data));
532  fParameterPoint[1] = fDataId[int(pos)];
533  std::vector<std::string> tok = Ndmspc::Utils::Tokenize(data, '|');
534  fParameterPoint[3] = atoi(tok[1].c_str());
535  fParameterPoint[4] = atoi(tok[2].c_str());
536  }
537  else {
538  // TODO: Handle case when mc and data are not one
539  return;
540  }
541 
542  // Printf("fParameterPoint %d %d %d %d", fParameterPoint[1], fParameterPoint[2], fParameterPoint[3],
543  // fParameterPoint[4]);
544 
545  DrawProjections();
546  DrawUser();
547  pad->Modified();
548  pad->Update();
549 }
550 
551 void PointDraw::HighlightProjectionPoint(TVirtualPad * pad, TObject * obj, Int_t xBin, Int_t yBin)
552 {
553  // Printf("HighlightProjectionPoint %d %d %d", xBin, yBin, fProjectionAxes[0]);
554  if (fProjectionAxes.size() == 1) {
555  fParameterPoint[fProjectionAxes[0]] = xBin;
556  }
557  else if (fProjectionAxes.size() == 2) {
558  fParameterPoint[fProjectionAxes[0]] = xBin;
559  fParameterPoint[fProjectionAxes[1]] = yBin;
560  }
561  // UpdateRanges();
562  DrawProjections(true);
563  DrawUser();
564  pad->Modified();
565  pad->Update();
566 }
567 
568 } // namespace Ndmspc
virtual ~PointDraw()
Definition: PointDraw.cxx:31
int Draw(std::string config="myAnalysis.json", std::string userConfig="", std::string environment="", std::string userConfigRaw="")
Definition: PointDraw.cxx:38