Jpp master_rocky-44-g75b7c4f75
the software that should make you happy
Loading...
Searching...
No Matches
JPlot2D.cc
Go to the documentation of this file.
1#include <string>
2#include <iostream>
3#include <vector>
4#include <set>
5#include <cmath>
6
7#include "TROOT.h"
8#include "TFile.h"
9#include "TClass.h"
10#include "TApplication.h"
11#include "TCanvas.h"
12#include "TKey.h"
13#include "TStyle.h"
14#include "TAttMarker.h"
15#include "TAttLine.h"
16#include "TH2.h"
17#include "TH3.h"
18#include "TH2D.h"
19#include "TGraph.h"
20#include "TGraphErrors.h"
21#include "TGraph2D.h"
22#include "TGraph2DErrors.h"
23#include "TEllipse.h"
24#include "TLine.h"
25#include "TF2.h"
26#include "TString.h"
27#include "TRegexp.h"
28#include "TText.h"
29
30#include "JTools/JRange.hh"
31#include "JLang/JEquals.hh"
32#include "JROOT/JStyle.hh"
33#include "JROOT/JCanvas.hh"
34#include "JROOT/JMarkerAttributes.hh"
35#include "JGizmo/JRootObjectID.hh"
36#include "JGizmo/JRootObject.hh"
37#include "JGizmo/JGizmoToolkit.hh"
38
39#include "Jeep/JProperties.hh"
40#include "Jeep/JParser.hh"
41#include "Jeep/JMessage.hh"
42
43namespace {
44
45 /**
46 * Set x of object to logarithmic.
47 *
48 * \param object pointer to object
49 * \return true if set; else false
50 */
51 template<class T>
52 inline bool setLogX(TObject* object)
53 {
54 using namespace JPP;
55
56 T* p = dynamic_cast<T*>(object);
57
58 if (p != NULL) {
59
60 setLogarithmicX(p);
61
62 return true;
63 }
64
65 return false;
66 }
67
68 /**
69 * Set y of object to logarithmic.
70 *
71 * \param object pointer to object
72 * \return true if set; else false
73 */
74 template<class T>
75 inline bool setLogY(TObject* object)
76 {
77 using namespace JPP;
78
79 T* p = dynamic_cast<T*>(object);
80
81 if (p != NULL) {
82
83 setLogarithmicY(p);
84
85 return true;
86 }
87
88 return false;
89 }
90
91 const std::string MASTER = "__H__"; //!< Name of prototype
92
93 const char* const JName_t = "?"; //!< Draw histogram name as title of plot
94 const char* const JTitle_t = "%"; //!< Draw histogram title as title of plot
95
96
97 /**
98 * Auxiliary data structure for master from TH2 or TGraph.
99 */
100 struct JMaster :
101 public JLANG::JEquals<JMaster, TObject*>
102 {
103 JMaster() :
104 h2(NULL),
105 g2(NULL)
106 {}
107
108 bool equals(const JMaster& master) const
109 {
110 return (this->h2 == master.h2 &&
111 this->g2 == master.g2);
112 }
113
114 bool equals(const TObject* p) const
115 {
116 return (this->h2 == dynamic_cast<const TH2*>(p) &&
117 this->g2 == dynamic_cast<const TGraph2D*>(p));
118 }
119
120 JMaster* operator->()
121 {
122 return this;
123 }
124
125 void operator=(TObject* p)
126 {
127 h2 = dynamic_cast<TH2*> (p);
128 g2 = dynamic_cast<TGraph2D*>(p);
129 }
130
131 const char* GetName() const
132 {
133 return (h2 != NULL ? h2->GetName() :
134 g2 != NULL ? g2->GetName() :
135 NULL);
136 }
137
138 void SetTitle(const char* title)
139 {
140 if (h2 != NULL) { h2->SetTitle(title); }
141 if (g2 != NULL) { g2->SetTitle(title); }
142 }
143
144 void SetStats(const Bool_t stats)
145 {
146 if (h2 != NULL) { h2->SetStats(stats); }
147 }
148
149 void SetMaximum(Double_t maximum)
150 {
151 if (h2 != NULL) { h2->SetMaximum(maximum); }
152 if (g2 != NULL) { g2->SetMaximum(maximum); }
153 }
154
155 void SetMinimum(Double_t minimum)
156 {
157 if (h2 != NULL) { h2->SetMinimum(minimum); }
158 if (g2 != NULL) { g2->SetMinimum(minimum); }
159 }
160
161 void SetNdivisions(Int_t n, Option_t *axis)
162 {
163 if (h2 != NULL) { h2->SetNdivisions(n, axis); }
164 }
165
166 TAxis* GetXaxis()
167 {
168 return (h2 != NULL ? h2->GetXaxis() :
169 g2 != NULL ? g2->GetXaxis() :
170 NULL);
171 }
172
173 TAxis* GetYaxis()
174 {
175 return (h2 != NULL ? h2->GetYaxis() :
176 g2 != NULL ? g2->GetYaxis() :
177 NULL);
178 }
179
180 TAxis* GetZaxis()
181 {
182 return (h2 != NULL ? h2->GetZaxis() :
183 g2 != NULL ? g2->GetZaxis() :
184 NULL);
185 }
186
187 void Draw(Option_t *option="")
188 {
189 if (h2 != NULL) { h2->Draw(option); }
190 if (g2 != NULL) { g2->Draw(option); }
191 }
192
193 void setLogarithmicX()
194 {
195 if (h2 != NULL) { JGIZMO::setLogarithmicX(h2); }
196 if (g2 != NULL) { JGIZMO::setLogarithmicX(g2); }
197 }
198
199 void setLogarithmicY()
200 {
201 if (h2 != NULL) { JGIZMO::setLogarithmicY(h2); }
202 if (g2 != NULL) { JGIZMO::setLogarithmicY(g2); }
203 }
204
205 private:
206 TH2* h2;
207 TGraph2D* g2;
208 };
209
210 inline void setLogarithmicX(JMaster& master) { master.setLogarithmicX(); }
211 inline void setLogarithmicY(JMaster& master) { master.setLogarithmicY(); }
212}
213
214
215/**
216 * \file
217 * General purpose plot program for 2D ROOT objects.
218 * The option <tt>-f</tt> corresponds to <tt><file name>:<object name></tt>.
219 * \author mdejong
220 */
221int main(int argc, char **argv)
222{
223 using namespace std;
224 using namespace JPP;
225
226 typedef JRange<double> JRange_t;
227
228 vector<JRootObjectID> inputFile;
229 string outputFile;
230 JCanvas canvas;
231 JStyle::JParameters parameters;
232 int stats;
233 JRange_t X;
234 JRange_t Y;
235 JRange_t Z;
236 JCounter logx;
237 JCounter logy;
238 bool logz;
239 string project;
240 string xLabel;
241 string yLabel;
242 string zLabel;
243 double markerSize;
244 string option;
245 set<char> grid;
246 bool batch;
247 string title;
248 map<string, int> Ndivisions;
249 int palette;
250 int debug;
251
252 try {
253
254 JProperties properties = parameters.getProperties();
255
256 JParser<> zap("General purpose plot program for 2D ROOT objects.");
257
258 zap['f'] = make_field(inputFile, "<input file>:<object name>");
259 zap['o'] = make_field(outputFile, "graphics output") = "";
260 zap['w'] = make_field(canvas, "size of canvas <nx>x<ny> [pixels]") = JCanvas(500, 500);
261 zap['@'] = make_field(properties) = JPARSER::initialised();
262 zap['s'] = make_field(stats) = -1;
263 zap['x'] = make_field(X, "x-abscissa range") = JRange_t::DEFAULT_RANGE();
264 zap['y'] = make_field(Y, "y-abscissa range") = JRange_t::DEFAULT_RANGE();
265 zap['z'] = make_field(Z, "ordinate range") = JRange_t::DEFAULT_RANGE();
266 zap['X'] = make_field(logx, "logarithmic x-axis (-XX log10 axis)");
267 zap['Y'] = make_field(logy, "logarithmic y-axis (-YY log10 axis)");
268 zap['Z'] = make_field(logz, "logarithmic z-axis");
269 zap['P'] = make_field(project, "projection") = "", "xy", "yx", "xz", "zx", "yz", "zy";
270 zap['>'] = make_field(xLabel, "x-axis label") = "";
271 zap['<'] = make_field(yLabel, "y-axis label") = "";
272 zap['^'] = make_field(zLabel, "z-axis label") = "";
273 zap['S'] = make_field(markerSize, "marker size") = 1.0;
274 zap['O'] = make_field(option, "plotting option") = "";
275 zap['G'] = make_field(grid, "grid lines [X][Y]") = JPARSER::initialised();
276 zap['B'] = make_field(batch, "batch processing");
277 zap['T'] = make_field(title, "graphics title ("
278 << "\"" << JName_t << "\" -> ROOT name; "
279 << "\"" << JTitle_t << "\" -> ROOT title)") = "KM3NeT preliminary";
280 zap['N'] = make_field(Ndivisions, "axis divisioning (e.g. \"X 505\")") = JPARSER::initialised();
281 zap['p'] = make_field(palette, "palette") = -1;
282 zap['d'] = make_field(debug) = 0;
283
284 zap(argc, argv);
285 }
286 catch(const exception &error) {
287 FATAL(error.what() << endl);
288 }
289
290
291 gROOT->SetBatch(batch);
292
293 TApplication* tp = new TApplication("user", NULL, NULL);
294 TCanvas* cv = new TCanvas("c1", "c1", canvas.x, canvas.y);
295
296 unique_ptr<TStyle> gStyle(new JStyle("gplot", cv->GetWw(), cv->GetWh(), parameters));
297
298 if (palette != -1) {
299 gStyle->SetPalette(palette);
300 }
301
302 gROOT->SetStyle("gplot");
303 gROOT->ForceStyle();
304
305
306 cv->SetFillStyle(4000);
307 cv->SetFillColor(kWhite);
308 cv->Divide(1,1);
309 cv->cd(1);
310
311 JMarkerAttributes::getInstance().setMarkerSize(markerSize);
312
313 Double_t xmin = numeric_limits<double>::max();
314 Double_t xmax = numeric_limits<double>::lowest();
315 Double_t ymin = numeric_limits<double>::max();
316 Double_t ymax = numeric_limits<double>::lowest();
317 Double_t zmin = numeric_limits<double>::max();
318 Double_t zmax = numeric_limits<double>::lowest();
319
320 vector<JRootObject> listOfObjects;
321
322 //TH2* master = NULL;
323 JMaster master;
324
325 for (vector<JRootObjectID>::const_iterator input = inputFile.begin(); input != inputFile.end(); ++input) {
326
327 DEBUG("Input: " << *input << endl);
328
329 TDirectory* dir = getDirectory(*input);
330
331 if (dir == NULL) {
332 ERROR("File: " << input->getFullFilename() << " not opened." << endl);
333 continue;
334 }
335
336 const TRegexp regexp(input->getObjectName());
337
338 TIter iter(dir->GetListOfKeys());
339
340 for (TKey* key; (key = (TKey*) iter.Next()) != NULL; ) {
341
342 const TString tag(key->GetName());
343
344 DEBUG("Key: " << tag << " match = " << tag.Contains(regexp) << endl);
345
346 // option match
347
348 if (tag.Contains(regexp) && isTObject(key)) {
349
350 if (title == JName_t) {
351 title = key->GetName();
352 } else if (title == JTitle_t) {
353 title = key->GetTitle();
354 }
355
356 JRootObject object(key->ReadObj());
357
358 try {
359
360 TH3& h3 = dynamic_cast<TH3&>(*object);
361
362 object = h3.Project3D(project.c_str());
363 }
364 catch(exception&) {}
365
366 try {
367
368 TH2& h2 = dynamic_cast<TH2&>(*object);
369
370 h2.SetStats(stats != -1);
371
372 xmin = min(xmin, h2.GetXaxis()->GetXmin());
373 xmax = max(xmax, h2.GetXaxis()->GetXmax());
374 ymin = min(ymin, h2.GetYaxis()->GetXmin());
375 ymax = max(ymax, h2.GetYaxis()->GetXmax());
376 zmin = min(zmin, logz ? h2.GetMinimum(0.0) : h2.GetMinimum());
377 zmax = max(zmax, h2.GetMaximum());
378 }
379 catch(exception&) {}
380
381 try {
382
383 TGraph& g1 = dynamic_cast<TGraph&>(*object);
384
385 for (Int_t i = 0; i != g1.GetN(); ++i) {
386 xmin = min(xmin, g1.GetX()[i] - numeric_limits<float>::epsilon());
387 xmax = max(xmax, g1.GetX()[i] + numeric_limits<float>::epsilon());
388 ymin = min(ymin, g1.GetY()[i] - numeric_limits<float>::epsilon());
389 ymax = max(ymax, g1.GetY()[i] + numeric_limits<float>::epsilon());
390 }
391
392 int ng = 0;
393
394 for (vector<JRootObject>::iterator i = listOfObjects.begin(); i != listOfObjects.end(); ++i) {
395 if (dynamic_cast<TGraph*>(i->get()) != NULL) {
396 ++ng;
397 }
398 }
399
400 static_cast<TAttMarker&>(g1) = JMarkerAttributes::getInstance().get(ng);
401 }
402 catch(exception&) {}
403
404 try {
405
406 TGraph2D& g2 = dynamic_cast<TGraph2D&>(*object);
407
408 for (Int_t i = 0; i != g2.GetN(); ++i) {
409 if (!logz || g2.GetZ()[i] > 0.0) {
410 xmin = min(xmin, g2.GetX()[i]);
411 xmax = max(xmax, g2.GetX()[i]);
412 ymin = min(ymin, g2.GetY()[i]);
413 ymax = max(ymax, g2.GetY()[i]);
414 zmin = min(zmin, g2.GetZ()[i]);
415 zmax = max(zmax, g2.GetZ()[i]);
416 }
417 }
418
419 if (Z.is_valid()) {
420 g2.SetMinimum(Z.getLowerLimit());
421 g2.SetMaximum(Z.getUpperLimit());
422 }
423 }
424 catch(exception&) {}
425
426 try {
427
428 TF2& f2 = dynamic_cast<TF2&>(*object);
429
430 f2.SetLineColor(kRed);
431 f2.SetTitle((title + ";" + xLabel + ";" + yLabel + ";" + zLabel).c_str());
432
433 double __xmin;
434 double __xmax;
435 double __ymin;
436 double __ymax;
437
438 f2.GetRange(__xmin, __ymin, __xmax, __ymax);
439
440 xmin = min(xmin, __xmin);
441 xmax = max(xmax, __xmax);
442 ymin = min(ymin, __ymin);
443 ymax = max(ymax, __ymax);
444 zmin = min(zmin, f2.GetMinimum());
445 zmax = max(zmax, f2.GetMaximum());
446 }
447 catch(exception&) {}
448
449 // label
450
451 for (TString buffer[] = { object.getLabel(), input->getFilename().c_str(), "" }, *i = buffer; *i != ""; ++i) {
452
453 *i = (*i)(TRegexp("\\[.*\\]"));
454
455 if ((*i).Length() > 2) {
456 object.setLabel((*i)(1, (*i).Length() - 2));
457 }
458 }
459
460 if (dynamic_cast<TH2*> (object.get()) != NULL ||
461 dynamic_cast<TGraph*> (object.get()) != NULL ||
462 dynamic_cast<TGraph2D*>(object.get()) != NULL ||
463 dynamic_cast<TEllipse*>(object.get()) != NULL ||
464 dynamic_cast<TLine*> (object.get()) != NULL ||
465 dynamic_cast<TText*> (object.get()) != NULL ||
466 dynamic_cast<TF2*> (object.get()) != NULL) {
467
468 DEBUG("Add object: " << tag << " with label <" << object.getLabel() << ">" << endl);
469
470 if (master == NULL) {
471 //master = dynamic_cast<TH2*>(object.get());
472 master = object.get();
473 }
474
475 listOfObjects.push_back(object);
476
477 } else {
478 ERROR("For other objects than 2D histograms, use JPlot1D" << endl);
479 }
480 }
481 }
482 }
483
484 if (listOfObjects.empty()) {
485 ERROR("Nothing to draw." << endl);
486 }
487
488 // plot frame
489
490 cv->cd(1);
491
492 if (option.find("COLZ") != string::npos ||
493 option.find("colz") != string::npos) {
494 gPad->SetRightMargin(0.20);
495 }
496
497 if (X.is_valid()) {
498 xmin = X.getLowerLimit();
499 xmax = X.getUpperLimit();
500 }
501
502 if (Y.is_valid()) {
503 ymin = Y.getLowerLimit();
504 ymax = Y.getUpperLimit();
505 }
506
507 if (Z.is_valid()) {
508 zmin = Z.getLowerLimit();
509 zmax = Z.getUpperLimit();
510 } else if (zmax > zmin) {
511 setRange(zmin, zmax, logz);
512 }
513
514 if (!listOfObjects.empty()) {
515
516 if (master == NULL) {
517
518 master = new TH2D(MASTER.c_str(), NULL,
519 100, xmin, xmax,
520 100, ymin, ymax);
521
522 master->SetStats(kFALSE);
523 }
524 }
525
526 if (master == NULL) {
527
528 TText* p = new TText(0.5, 0.5, "No data");
529
530 p->SetTextAlign(21);
531 p->SetTextAngle(45);
532 p->Draw();
533
534 } else {
535
536 if (logx) { gPad->SetLogx(); }
537 if (logy) { gPad->SetLogy(); }
538 if (logz) { gPad->SetLogz(); }
539
540 master->SetTitle(title.c_str());
541
542 master->GetXaxis()->SetRangeUser(xmin, xmax);
543 master->GetYaxis()->SetRangeUser(ymin, ymax);
544
545 if (logx > 1) { setLogarithmicX(master); }
546 if (logy > 1) { setLogarithmicY(master); }
547
548 if (logx > 2) { master->GetXaxis()->SetNoExponent(); }
549 if (logy > 2) { master->GetYaxis()->SetNoExponent(); }
550
551 master->SetMinimum(zmin);
552 master->SetMaximum(zmax);
553
554 if (xLabel != "") { master->GetXaxis()->SetTitle(xLabel.c_str()); master->GetXaxis()->CenterTitle(true); }
555 if (yLabel != "") { master->GetYaxis()->SetTitle(yLabel.c_str()); master->GetYaxis()->CenterTitle(true); }
556 if (zLabel != "") { master->GetZaxis()->SetTitle(zLabel.c_str()); master->GetZaxis()->CenterTitle(true); }
557
558 master->GetXaxis()->SetMoreLogLabels((logx == 1 && log10(xmax/xmin) < 2) ||
559 (logx > 1 && xmax-xmin < 2));
560 master->GetYaxis()->SetMoreLogLabels((logy == 1 && log10(ymax/ymin) < 2) ||
561 (logy > 1 && ymax-ymin < 2));
562
563 for (map<string, int>::const_iterator i = Ndivisions.begin(); i != Ndivisions.end(); ++i) {
564 master->SetNdivisions(i->second, i->first.c_str());
565 }
566
567 DEBUG("Draw " << master->GetName() << ' ' << option << endl);
568
569 master->Draw(option.c_str());
570 }
571
572 if (logx > 1 || logy > 1) {
573 for (vector<JRootObject>::iterator i = listOfObjects.begin(); i != listOfObjects.end(); ++i) {
574 if (dynamic_cast<TH2*>(i->get()) != master) {
575 if (logx > 1) {
576 if (setLogX<TH2> (i->get())) {}
577 else if (setLogX<TF2> (i->get())) {}
578 else if (setLogX<TGraph2DErrors>(i->get())) {}
579 else if (setLogX<TGraph2D> (i->get())) {}
580 else if (setLogX<TGraphErrors> (i->get())) {}
581 else if (setLogX<TGraph> (i->get())) {}
582 else if (setLogX<TLine> (i->get())) {}
583 else if (setLogX<TEllipse> (i->get())) {}
584 }
585 if (logy > 1) {
586 if (setLogY<TH2> (i->get())) {}
587 else if (setLogY<TF2> (i->get())) {}
588 else if (setLogY<TGraph2DErrors>(i->get())) {}
589 else if (setLogY<TGraph2D> (i->get())) {}
590 else if (setLogY<TGraphErrors> (i->get())) {}
591 else if (setLogY<TGraph> (i->get())) {}
592 else if (setLogY<TLine> (i->get())) {}
593 else if (setLogY<TEllipse> (i->get())) {}
594 }
595 }
596 }
597 }
598
599 if (grid.count('x') || grid.count('X')) { gPad->SetGridx(); }
600 if (grid.count('y') || grid.count('Y')) { gPad->SetGridy(); }
601
602 if (stats != -1)
603 gStyle->SetOptStat(stats);
604 else
605 gStyle->SetOptFit(kFALSE);
606
607
608 for (vector<JRootObject>::iterator i = listOfObjects.begin(); i != listOfObjects.end(); ++i) {
609
610 if (i->get() != master) {
611
612 DEBUG("Draw " << (*i)->GetName() << ' ' << (*i)->GetTitle() << endl);
613
614 string buffer(option);
615
616 buffer += "SAME";
617
618 try {
619
620 TH2& h2 = dynamic_cast<TH2&>(*(*i));
621
622 h2.SetMinimum(zmin);
623 h2.SetMaximum(zmax);
624 }
625 catch(exception&) {}
626
627 try {
628
629 TGraph& g1 = dynamic_cast<TGraph&>(*(*i));
630
631 buffer = "P";
632 }
633 catch(exception&) {}
634
635 try {
636
637 TGraph2D& g2 = dynamic_cast<TGraph2D&>(*(*i));
638
639 g2.SetMinimum(zmin);
640 g2.SetMaximum(zmax);
641 }
642 catch(exception&) {}
643
644 try {
645
646 TF2& f2 = dynamic_cast<TF2&>(*(*i));
647
648 f2.SetNpx(1000);
649 f2.SetNpy(1000);
650 /*
651 f2.SetRange(xmin, ymin, zmin,
652 xmax, ymax, zmax);
653 */
654 }
655 catch(exception&) {}
656
657 (*i)->Draw(buffer.c_str());
658 }
659 }
660
661 //gPad->RedrawAxis();
662
663 cv->Update();
664
665 if (outputFile != "") {
666 cv->SaveAs(outputFile.c_str());
667 }
668
669 if (!batch) {
670 tp->Run();
671 }
672
673 return (master != NULL ? 0 : 1);
674}
outputFile
string outputFile
Definition JDAQTimesliceSelector.cc:37
JMessage.hh
General purpose messaging.
DEBUG
#define DEBUG(A)
Message macros.
Definition JMessage.hh:62
ERROR
#define ERROR(A)
Definition JMessage.hh:66
FATAL
#define FATAL(A)
Definition JMessage.hh:67
debug
int debug
debug level
Definition JSirene.cc:69
JParser.hh
Utility class to parse command line options.
make_field
#define make_field(A,...)
macro to convert parameter to JParserTemplateElement object
Definition JParser.hh:2142
main
int main(int argc, char **argv)
Definition JPlot2D.cc:221
JProperties.hh
Utility class to parse parameter values.
g1
Double_t g1(const Double_t x)
Function.
Definition JQuantiles.cc:25
JRange.hh
Auxiliary class to define a range between two values.
JEEP::JProperties
Utility class to parse parameter values.
Definition JProperties.hh:501
JGIZMO::JRootObject
Auxiliary data structure for TObject with a user defined label.
Definition JRootObject.hh:31
JPARSER::JCounter
Auxiliary class to handle multiple boolean-like I/O.
Definition JParser.hh:423
JPARSER::JParser
Utility class to parse command line options.
Definition JParser.hh:1698
JROOT::JCanvas
Data structure for size of TCanvas.
Definition JCanvas.hh:26
JROOT::JCanvas::y
int y
number of pixels in Y
Definition JCanvas.hh:99
JROOT::JCanvas::x
int x
number of pixels in X
Definition JCanvas.hh:98
JROOT::JStyle
Wrapper class around ROOT TStyle.
Definition JStyle.hh:24
JTOOLS::JRange
Range of values.
Definition JRange.hh:42
JGIZMO::setLogarithmicX
void setLogarithmicX(TList *list)
Make x-axis of objects in list logarithmic (e.g. after using log10()).
Definition JGizmoToolkit.hh:977
JGIZMO::setLogarithmicY
void setLogarithmicY(TList *list)
Make y-axis of objects in list logarithmic (e.g. after using log10()).
Definition JGizmoToolkit.hh:991
JMATH::equals
bool equals(const JFirst_t &first, const JSecond_t &second, const double precision=std::numeric_limits< double >::min())
Check equality.
Definition JMathToolkit.hh:87
JPP
This name space includes all other name spaces (except KM3NETDAQ, KM3NET and ANTARES).
Definition JAAnetToolkit.hh:43
JLANG::JEquals
Template definition of auxiliary base class for comparison of data structures.
Definition JEquals.hh:84
JPARSER::initialised
Empty structure for specification of parser element that is initialised (i.e. does not require input)...
Definition JParser.hh:68
JROOT::JStyle::JParameters::getProperties
JProperties getProperties()
Get properties of this class.
Definition JStyle.hh:44
Generated by doxygen 1.12.0