Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
TSpider.cxx
Go to the documentation of this file.
1// @(#)root/treeviewer:$Id: 2bb6def14de16b049d4c979e73ad2b08d0936520 $
2// Author: Bastien Dalla Piazza 20/07/07
3
4/*************************************************************************
5 * Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#include "TSpider.h"
13#include "TAttFill.h"
14#include "TAttText.h"
15#include "TAttLine.h"
16#include "TGraphPolargram.h"
17#include "TPolyLine.h"
18#include "TNtuple.h"
19#include "TBranch.h"
20#include "TTreeFormula.h"
21#include "TTreeFormulaManager.h"
22#include "TList.h"
23#include "TSelectorDraw.h"
24#include "TROOT.h"
25#include "TEntryList.h"
26#include "TLatex.h"
27#include "TVirtualPad.h"
28#include "TMath.h"
29#include "TCanvas.h"
30#include "TArc.h"
31#include <cfloat>
32#include "TEnv.h"
33
34
35/** \class TSpider
36Spider class.
37
38A spider view is a handy way to visualize a set of data stored in a TTree.
39It draws as many polar axes as selected data members. For each of them, it draws
40on the axis the position of the present event between the min and max of the
41data member. Two modes are available:
42
43 - The spider view: With each points on the axes is drawn a polyline.
44 - The segment view: For each data member is drawn an arc segment with the
45 radius corresponding to the event.
46
47The spider plot is available from the treeviewer called by
48"atree->StartViewer()", or simply by calling its constructor and defining the
49variables to display.
50
51Begin_Macro(source)
52{
53 TCanvas *c1 = new TCanvas("c1","TSpider example",200,10,700,700);
54 TFile *f = new TFile("$(ROOTSYS)/tutorials/hsimple.root");
55 if (!f || f->IsZombie()) {
56 printf("Please run <ROOT location>/tutorials/hsimple.C before.");
57 return;
58 }
59 TNtuple* ntuple = (TNtuple*)f->Get("ntuple");
60 TString varexp = "px:py:pz:random:sin(px):log(px/py):log(pz)";
61 TString selectStr = "px>0 && py>0 && pz>0";
62 TString options = "average";
63 TSpider *spider = new TSpider(ntuple,varexp.Data(),selectStr.Data(),options.Data());
64 spider->Draw();
65 c1->ToggleEditor();
66 c1->Selected(c1,spider,1);
67 return c1;
68}
69End_Macro
70*/
71
72////////////////////////////////////////////////////////////////////////////////
73/// Default constructor.
74
76{
77 fDisplayAverage=false;
78 fForceDim=false;
79 fPolargram=nullptr;
80 fInput=nullptr;
81 fManager=nullptr;
82 fNcols=0;
83 fNx=3;
84 fNy=4;
85 fPolyList=nullptr;
86 fSelect=nullptr;
87 fSelector=nullptr;
88 fTree=nullptr;
89 fMax=nullptr;
90 fMin=nullptr;
91 fAve=nullptr;
92 fCanvas=nullptr;
93 fAveragePoly=nullptr;
94 fEntry=0;
95 fSuperposed=nullptr;
96 fShowRange=false;
97 fAngularLabels=false;
98 fAverageSlices=nullptr;
99 fSegmentDisplay=false;
100 fNentries=0;
101 fFirstEntry=0;
102 fArraySize=0;
103 fCurrentEntries = nullptr;
104 fFormulas = nullptr;
105}
106
107////////////////////////////////////////////////////////////////////////////////
108/// Normal constructor. Options are:
109/// - "average"
110/// - "showrange"
111/// - "segment"
112
113TSpider::TSpider(TTree* tree ,const char *varexp, const char *selection,
115 : TAttFill(2,3003), TAttLine(1,1,1)
116{
117 UInt_t ui=0;
118
119 fArraySize = 16;
120 fTree=tree;
122 fFormulas= new TList();
123 fInput= new TList();
124 fInput->Add(new TNamed("varexp",""));
125 fInput->Add(new TNamed("selection",""));
127 gROOT->GetListOfCleanups()->Add(this);
128 fNx=2;
129 fNy=2;
130 fDisplayAverage=false;
131 fSelect=nullptr;
132 fManager=nullptr;
133 fCanvas=nullptr;
134 fAveragePoly=nullptr;
136 fSuperposed=nullptr;
137 fShowRange=false;
138 fAngularLabels=true;
139 fForceDim=false;
140 fAverageSlices=nullptr;
141 fSegmentDisplay=false;
142 if (firstentry < 0 || firstentry > tree->GetEstimate()) firstentry = 0;
144 if (nentries>0) fNentries = nentries;
145 else fNentries = nentries = tree->GetEstimate()-firstentry;
146
148
149 fPolargram=nullptr;
150 fPolyList=nullptr;
151
154 for(ui=0;ui<fNx*fNy;++ui) fCurrentEntries[ui]=0;
155
156 TString opt = option;
157
158 if (opt.Contains("average")) fDisplayAverage=true;
159 if (opt.Contains("showrange")) fShowRange=true;
160 if (opt.Contains("segment")) fSegmentDisplay=true;
161
162 fNcols=8;
163
166 SyncFormulas();
168}
169
170////////////////////////////////////////////////////////////////////////////////
171/// Destructor.
172
174{
175 delete [] fCurrentEntries;
176 if(fPolyList){
177 fPolyList->Delete();
178 delete fPolyList;
179 }
181 delete [] fAverageSlices;
182 if(fFormulas){
183 fFormulas->Delete();
184 delete fFormulas;
185 }
186 if(fSelect) delete fSelect;
187 if(fSelector) delete fSelector;
188 if(fInput){
189 fInput->Delete();
190 delete fInput;
191 }
192 if(fMax) delete [] fMax;
193 if(fMin) delete [] fMin;
194 if(fAve) delete [] fAve;
195 if(fSuperposed){
197 delete fSuperposed;
198 }
199 if (fCanvas) fCanvas->cd(0);
200}
201
202////////////////////////////////////////////////////////////////////////////////
203/// Allow to superpose several spider views.
204
210
211////////////////////////////////////////////////////////////////////////////////
212/// Add a variable to the plot from its expression.
213
215{
216 if(!varexp[0]) return;
218 if(fvar->GetNdim() <= 0) return;
219
221
222 InitArrays(fNcols + 1);
223 ++fNcols;
224 SyncFormulas();
225
226 UInt_t ui=0;
228 Int_t tnumber=-1;
232 while(entriesToDisplay!=0){
234 if(entryNumber < 0) break;
236 if(localEntry < 0) break;
237 if(tnumber != fTree->GetTreeNumber()) {
240 else {
241 for(Int_t i=0;i<=fFormulas->LastIndex();++i)
242 ((TTreeFormula*)fFormulas->At(i))->UpdateFormulaLeaves();
243 }
244 }
245 Int_t ndata=1;
246 if(fForceDim){
247 if(fManager)
248 ndata = fManager->GetNdata(true);
249 else {
250 for(ui=0;ui<fNcols;++ui){
251 if(ndata<((TTreeFormula*)fFormulas->At(ui))->GetNdata())
252 ndata = ((TTreeFormula*)fFormulas->At(ui))->GetNdata();
253 }
254 if(fSelect && fSelect->GetNdata() == 0)
255 ndata = 0;
256 }
257 }
258
259 bool loaded = false;
260 bool skip = false;
261 // Loop over the instances of the selection condition
262 for(Int_t inst=0;inst<ndata;++inst){
263 if(fSelect){
264 if(fSelect->EvalInstance(inst) == 0){
265 skip = true;
266 ++entry;
267 }
268 }
269 if (!loaded) {
270 // EvalInstance(0) always needs to be called so that
271 // the proper branches are loaded.
272 ((TTreeFormula*)fFormulas->At(fNcols-1))->EvalInstance(0);
273 loaded = true;
274 } else if (inst == 0) {
275 loaded = true;
276 }
277 }
278 if(!skip){
281 if(var->EvalInstance()>fMax[fNcols-1]) fMax[fNcols-1]=var->EvalInstance();
282 if(var->EvalInstance()<fMin[fNcols-1]) fMin[fNcols-1]=var->EvalInstance();
283 fAve[fNcols-1]+=var->EvalInstance();
284 ++notSkipped;
286 ++entry;
287 }
288 }
290
291 Color_t lc;
292 Style_t lt;
293 Width_t lw;
294 Color_t fc;
295 Style_t fs;
296
297 if(fAverageSlices){
303 } else {
309 }
310
311 delete fPolargram;
312 fPolargram = nullptr;
313
314 if(fSegmentDisplay){
315 for(ui=0;ui<fNx*fNy;++ui) ((TList*)fPolyList->At(ui))->Delete();
316 if (fAverageSlices) for(ui=0;ui<fNcols-1;++ui) delete fAverageSlices[ui];
317 }
318 fPolyList->Delete();
319 delete fPolyList;
320 fPolyList = nullptr;
321 delete [] fAverageSlices;
322 fAverageSlices = nullptr;
323 delete fAveragePoly;
324 fAveragePoly = nullptr;
325
326 if (fCanvas) {
327 fCanvas->Clear();
329 }
330 Draw("");
331
332 if(fAverageSlices){
333 for(ui = 0;ui<fNcols;++ui){
339 }
340 } else {
346 }
347}
348
349////////////////////////////////////////////////////////////////////////////////
350/// Delete a variable from its expression.
351
353{
354 Int_t var=-1;
355 UInt_t ui=0;
356
357 if(fNcols == 2) return;
358 for(ui=0; ui<fNcols;++ui){
359 if(!strcmp(varexp,((TTreeFormula*)fFormulas->At(ui))->GetTitle())) var = ui;
360 }
361 if(var<0) return;
362
364 SyncFormulas();
365
366 for(ui=var+1;ui<fNcols;++ui){
367 fMin[ui-1] = fMin[ui];
368 fMax[ui-1] = fMax[ui];
369 fAve[ui-1] = fAve[ui];
370 }
371 fMin[fNcols-1] = DBL_MAX;
372 fMax[fNcols-1] = -DBL_MAX;
373 fAve[fNcols-1] = 0;
374 --fNcols;
375
376 Color_t lc;
377 Style_t lt;
378 Width_t lw;
379 Color_t fc;
380 Style_t fs;
381
382 if(fAverageSlices){
388 } else {
394 }
395
396 delete fPolargram;
397 fPolargram = nullptr;
398
399 if(fSegmentDisplay){
400 for(ui=0;ui<fNx*fNy;++ui) ((TList*)fPolyList->At(ui))->Delete();
401 if (fAverageSlices) for(ui=0;ui<=fNcols;++ui) delete fAverageSlices[ui];
402 }
403 fPolyList->Delete();
404 delete fPolyList;
405 fPolyList = nullptr;
406 delete [] fAverageSlices;
407 fAverageSlices = nullptr;
408 delete fAveragePoly;
409 fAveragePoly = nullptr;
410
411 if (fCanvas) {
412 fCanvas->Clear();
414 }
415 Draw("");
416 if(fNcols == 2) SetSegmentDisplay(true);
417
418 if(fAverageSlices){
419 for(ui = 0;ui<fNcols;++ui){
425 }
426 } else {
432 }
433}
434
435////////////////////////////////////////////////////////////////////////////////
436/// Compute the distance to the spider.
437
439{
440 if(!gPad) return 9999;
442 xx=gPad->AbsPixeltoX(px);
443 yy=gPad->AbsPixeltoY(py);
444 r2 = xx*xx + yy*yy;
445 if(r2>1 && r2<1.5)
446 return 0;
447 else return 9999;
448}
449
450////////////////////////////////////////////////////////////////////////////////
451/// Draw the spider.
452
454{
455 UInt_t ui=0;
456
457 gEnv->SetValue("Canvas.ShowEditor",1);
458 if(!gPad && !fCanvas){
459 fCanvas = new TCanvas("screen","Spider Plot",fNx*256,fNy*256);
461 } else if(!fCanvas){
462 fCanvas = (TCanvas*)gPad;
464 }
465 if(fPolargram) delete fPolargram;
466 fPolargram=new TGraphPolargram("fPolargram");
469 if (fCanvas) fCanvas->cd();
471 AppendPad(options);
472 for(ui=0;ui<fNx*fNy;++ui){
473 if (fCanvas) fCanvas->cd(ui+1);
474 fPolargram->Draw("pn");
476 if(fSegmentDisplay){
478 DrawSlices("");
479 } else {
481 DrawPoly("");
482 }
483 AppendPad();
484 }
485 if (fCanvas) fCanvas->Selected(fCanvas,this,1);
486}
487
488////////////////////////////////////////////////////////////////////////////////
489/// Paint the Polygon representing the average value of the variables.
490
492{
498
499 UInt_t ui=0;
500 Double_t slice = 2*TMath::Pi()/fNcols;
501 Double_t *x = new Double_t[fNcols+1];
502 Double_t *y = new Double_t[fNcols+1];
503
504 for(ui=0;ui<fNcols;++ui){
505 x[ui]=(fAve[ui]-fMin[ui])/(fMax[ui]-fMin[ui])*TMath::Cos(ui*slice);
506 y[ui]=(fAve[ui]-fMin[ui])/(fMax[ui]-fMin[ui])*TMath::Sin(ui*slice);
507 }
508 x[fNcols]=(fAve[0]-fMin[0])/(fMax[0]-fMin[0]);
509 y[fNcols]=0;
510
511 if(!fAveragePoly){
518 }
520 fAveragePoly->Draw("f");
521
522 delete [] x;
523 delete [] y;
524}
525
526////////////////////////////////////////////////////////////////////////////////
527/// Paint the polygon representing the current entry.
528
529void TSpider::DrawPoly(Option_t* /*options*/)
530{
531 if(!fPolyList) fPolyList = new TList();
532 Double_t *x = new Double_t[fNcols+1];
533 Double_t *y = new Double_t[fNcols+1];
534
535 Double_t slice = 2*TMath::Pi()/fNcols;
536 for(UInt_t i=0;i<fNcols;++i){
537 x[i]=(((TTreeFormula*)fFormulas->At(i))->EvalInstance()-fMin[i])/(fMax[i]-fMin[i])*TMath::Cos(i*slice);
538 y[i]=(((TTreeFormula*)fFormulas->At(i))->EvalInstance()-fMin[i])/(fMax[i]-fMin[i])*TMath::Sin(i*slice);
539 }
540 x[fNcols]=(((TTreeFormula*)fFormulas->At(0))->EvalInstance()-fMin[0])/(fMax[0]-fMin[0]);
541 y[fNcols]=0;
542
543 TPolyLine* poly= new TPolyLine(fNcols+1,x,y);
544 poly->SetFillColor(GetFillColor());
545 poly->SetFillStyle(GetFillStyle());
546 poly->SetLineWidth(GetLineWidth());
547 poly->SetLineColor(GetLineColor());
548 poly->SetLineStyle(GetLineStyle());
549 poly->Draw("f");
550 poly->Draw();
552 delete [] x;
553 delete [] y;
554}
555
556////////////////////////////////////////////////////////////////////////////////
557/// Draw the slices of the segment plot.
558
560{
561 UInt_t ui=0;
562
564 Double_t conv = 180.0/TMath::Pi();
565
566 if(!fPolyList) fPolyList = new TList;
567 TList* li = new TList();
568 for(ui=0;ui<fNcols;++ui){
569 Double_t r = (((TTreeFormula*)fFormulas->At(ui))->EvalInstance()-fMin[ui])/(fMax[ui]-fMin[ui]);
570 TArc* slice = new TArc(0,0,r,(ui-0.25)*angle*conv,(ui+0.25)*angle*conv);
571 slice->SetFillColor(GetFillColor());
572 slice->SetFillStyle(GetFillStyle());
573 slice->SetLineWidth(GetLineWidth());
574 slice->SetLineColor(GetLineColor());
575 slice->SetLineStyle(GetLineStyle());
576 li->Add(slice);
577 slice->Draw(options);
578 }
579 fPolyList->Add(li);
580}
581
582////////////////////////////////////////////////////////////////////////////////
583/// Draw the slices representing the average for the segment plot.
584
586{
587 UInt_t ui=0;
588
589 Int_t fillstyle=3002;
594
596 Double_t conv = 180.0/TMath::Pi();
597
598 if(!fAverageSlices){
599 fAverageSlices = new TArc*[fNcols];
600 for(ui=0;ui<fNcols;++ui){
601 Double_t r = (fAve[ui]-fMin[ui])/(fMax[ui]-fMin[ui]);
602 fAverageSlices[ui] = new TArc(0,0,r,(ui-0.5)*angle*conv,(ui+0.5)*angle*conv);
608 }
609 }
610 for(ui=0;ui<fNcols;++ui) fAverageSlices[ui]->Draw();
611}
612
613////////////////////////////////////////////////////////////////////////////////
614/// Get the LineStyle of the average.
615
617{
619 else if(fAveragePoly) return fAveragePoly->GetLineStyle();
620 else return 0;
621}
622
623////////////////////////////////////////////////////////////////////////////////
624/// Get the LineColor of the average.
625
627{
629 else if(fAveragePoly) return fAveragePoly->GetLineColor();
630 else return 0;
631}
632
633////////////////////////////////////////////////////////////////////////////////
634/// Get the LineWidth of the average.
635
637{
639 else if(fAveragePoly) return fAveragePoly->GetLineWidth();
640 else return 0;
641}
642
643////////////////////////////////////////////////////////////////////////////////
644/// Get the Fill Color of the average.
645
647{
649 else if(fAveragePoly) return fAveragePoly->GetFillColor();
650 else return 0;
651}
652
653////////////////////////////////////////////////////////////////////////////////
654/// Get the FillStyle of the average.
655
657{
659 else if(fAveragePoly) return fAveragePoly->GetFillStyle();
660 else return 0;
661}
662
663////////////////////////////////////////////////////////////////////////////////
664/// Execute the corresponding event.
665
666void TSpider::ExecuteEvent(Int_t /*event*/,Int_t /*px*/, Int_t /*py*/)
667{
668 if (!gPad) return;
669 gPad->SetCursor(kHand);
670}
671
672////////////////////////////////////////////////////////////////////////////////
673/// Find the alignement rule to apply for TText::SetTextAlign(Short_t).
674
676{
677 Double_t pi = TMath::Pi();
678
679 while(angle < 0 || angle > 2*pi){
680 if(angle < 0) angle+=2*pi;
681 if(angle > 2*pi) angle-=2*pi;
682 }
683 if(!fAngularLabels){
684 if(angle > 0 && angle < pi/2) return 11;
685 else if(angle > pi/2 && angle < pi) return 31;
686 else if(angle > pi && angle < 3*pi/2) return 33;
687 else if(angle > 3*pi/2 && angle < 2*pi) return 13;
688 else if(angle == 0 || angle == 2*pi) return 12;
689 else if(angle == pi/2) return 21;
690 else if(angle == pi) return 32;
691 else if(angle == 3*pi/2) return 23;
692 else return 0;
693 }
694 else{
695 if(angle >= 0 && angle < pi) return 21;
696 else if(angle >=pi && angle <= 2*pi) return 23;
697 else return 0;
698 }
699}
700
701////////////////////////////////////////////////////////////////////////////////
702/// Determine the orientation of the polar labels according to their angle.
703
705{
706 Double_t pi = TMath::Pi();
707 Double_t convraddeg = 180.0/pi;
708
709 while(angle < 0 || angle > 2*pi){
710 if(angle < 0) angle+=2*pi;
711 if(angle > 2*pi) angle-=2*pi;
712 }
713
714 if(angle >= 0 && angle <= pi/2) return angle*convraddeg - 90;
715 else if(angle > pi/2 && angle <= pi) return (angle + pi)*convraddeg + 90;
716 else if(angle > pi && angle <= 3*pi/2) return (angle - pi)*convraddeg - 90;
717 else if(angle > 3*pi/2 && angle <= 2*pi) return angle*convraddeg + 90;
718 else return 0;
719}
720
721////////////////////////////////////////////////////////////////////////////////
722/// return the number of entries to be processed
723/// this function checks that nentries is not bigger than the number
724/// of entries in the Tree or in the associated TEventlist
725
727{
729 if (lastentry > fTree->GetEntriesFriend()-1) {
732 }
733 //TEventList *elist = fTree->GetEventList();
734 //if (elist && elist->GetN() < nentries) nentries = elist->GetN();
735 TEntryList *elist = fTree->GetEntryList();
736 if (elist && elist->GetN() < nentries) nentries = elist->GetN();
737 return nentries;
738}
739
740////////////////////////////////////////////////////////////////////////////////
741/// Go to a specified entry.
742
744{
745 if(e<fFirstEntry || e+fTree->GetScanField()>=fFirstEntry + fNentries) return;
746 fEntry = e;
748}
749
750////////////////////////////////////////////////////////////////////////////////
751/// Go to the next entries.
752
759
760////////////////////////////////////////////////////////////////////////////////
761/// Go to the previous entries.
762
769
770////////////////////////////////////////////////////////////////////////////////
771/// Go to the next entry.
772
774{
775 if(fEntry + fTree->GetScanField() >= fFirstEntry + fNentries) return;
776 ++fEntry;
778}
779
780////////////////////////////////////////////////////////////////////////////////
781/// Go to the last entry.
782
784{
785 if(fEntry - 1 < fFirstEntry) return;
786 --fEntry;
788}
789
790////////////////////////////////////////////////////////////////////////////////
791/// Check if the arrays size is enough and reallocate them if not.
792
794{
796
797 Int_t i;
798 Int_t old = fArraySize;
799
800 while(fArraySize<newsize) fArraySize*=2;
801
805
806 for(i=0;i<fArraySize;++i){
807 if(i<old){
808 memmax[i] = fMax[i];
809 memmin[i] = fMin[i];
810 memave[i] = fAve[i];
811 } else {
812 memmax[i] = -DBL_MAX;
813 memmin[i] = DBL_MAX;
814 memave[i] = 0;
815 }
816 }
817
818 delete [] fMax;
819 delete [] fMin;
820 delete [] fAve;
821
822 fMax = memmax;
823 fMin = memmin;
824 fAve = memave;
825 }
826}
827
828////////////////////////////////////////////////////////////////////////////////
829/// Browse the tree to set the min, max and average value of each variable of fVar.
830
832{
833 UInt_t ui=0;
834 Int_t i;
835
836 fMax = new Double_t [fArraySize];
837 fMin= new Double_t [fArraySize];
838 fAve= new Double_t [fArraySize];
839
840 for(i=0;i<fArraySize;++i){
841 fMax[i]= -DBL_MAX;
842 fMin[i]= DBL_MAX;
843 fAve[i]=0;
844 }
845
847 Int_t tnumber=-1;
851 while(entriesToDisplay!=0){
853 if(entryNumber < 0) break;
855 if(localEntry < 0) break;
856 if(tnumber != fTree->GetTreeNumber()) {
859 else {
860 for(i=0;i<=fFormulas->LastIndex();++i)
861 ((TTreeFormula*)fFormulas->At(i))->UpdateFormulaLeaves();
862 }
863 }
864 Int_t ndata=1;
865 if(fForceDim){
866 if(fManager)
867 ndata = fManager->GetNdata(true);
868 else {
869 for(ui=0;ui<fNcols;++ui){
870 if(ndata<((TTreeFormula*)fFormulas->At(ui))->GetNdata())
871 ndata = ((TTreeFormula*)fFormulas->At(ui))->GetNdata();
872 }
873 if(fSelect && fSelect->GetNdata() == 0)
874 ndata = 0;
875 }
876 }
877 bool loaded = false;
878 bool skip = false;
879 // Loop over the instances of the selection condition
880 for(Int_t inst=0;inst<ndata;++inst){
881 if(fSelect){
882 if(fSelect->EvalInstance(inst) == 0){
883 skip = true;
884 ++entry;
885 }
886 }
887 if (!loaded) {
888 // EvalInstance(0) always needs to be called so that
889 // the proper branches are loaded.
890 for (ui=0;ui<fNcols;ui++) {
891 ((TTreeFormula*)fFormulas->At(ui))->EvalInstance(0);
892 }
893 loaded = true;
894 } else if (inst == 0) {
895 loaded = true;
896 }
897 }
898 if(!skip){
900 for(ui=0;ui<fNcols;++ui){
901 Double_t inst = ((TTreeFormula*)fFormulas->At(ui))->EvalInstance();
902 if(inst > fMax[ui]) fMax[ui] = inst;
903 if(inst < fMin[ui]) fMin[ui] = inst;
904 fAve[ui] += inst;
905 }
906 ++notSkipped;
908 ++entry;
909 }
910 }
911 if (notSkipped) {for(ui=0;ui<fNcols;++ui) fAve[ui]/=notSkipped;}
912}
913
914////////////////////////////////////////////////////////////////////////////////
915/// Paint the spider.
916
918{
919 UInt_t ui=0;
920 TString opt = options;
921
922 if(opt.Contains("n")) return;
923
924 Double_t slice = 2*TMath::Pi()/fNcols;
925 Double_t offset(1.0);
926 if (!fCanvas) {
927 if (gPad) fCanvas = gPad->GetCanvas();
928 else return;
929 }
930
931 TLatex *txt = new TLatex();
932 for(ui=0;ui<fNx*fNy;++ui){
933 txt->SetTextAlign(13);
934 if (fCanvas) fCanvas->cd(ui+1);
935 if (fCurrentEntries) {
936 txt->PaintLatex(-1.2,1.2,0,0.08,Form("#%d",(int)fCurrentEntries[ui]));
937 }
938 txt->SetTextSize(0.035);
939 for(UInt_t var=0;var<fNcols;++var){ // Print labels.
940 if(ui==0){
941 txt->SetTextAlign(FindTextAlign(var*slice));
942 offset = 1.09 + txt->GetTextSize();
943 txt->PaintLatex(offset*TMath::Cos(var*slice),offset*TMath::Sin(var*slice),
944 FindTextAngle(var*slice),0.035,fFormulas->At(var)->GetTitle());
945 offset= 1.03;
946 txt->PaintLatex(offset*TMath::Cos(var*slice),offset*TMath::Sin(var*slice),
947 FindTextAngle(var*slice),0.035,Form("[%5.3f,%5.3f]",fMin[var],fMax[var]));
948 }
949 else {
950 txt->SetTextAlign(FindTextAlign(var*slice));
951 if(var*slice >=0 && var*slice <= TMath::Pi()) offset =1.13 + txt->GetTextSize();
952 else offset = 1.09 + txt->GetTextSize();
953 txt->PaintLatex(offset*TMath::Cos(var*slice),offset*TMath::Sin(var*slice),
954 FindTextAngle(var*slice),0.035,fFormulas->At(var)->GetTitle());
955 }
956 }
957 }
958 delete txt;
959}
960
961////////////////////////////////////////////////////////////////////////////////
962/// Set the LineStyle of the average.
963
972
973////////////////////////////////////////////////////////////////////////////////
974/// Set the LineColor of the average.
975
977{
978 UInt_t ui=0;
979
980 if(fAverageSlices){
981 for(ui=0;ui<fNcols;++ui) fAverageSlices[ui]->SetLineColor(col);
982 } else if(fAveragePoly) fAveragePoly->SetLineColor(col);
983}
984
985////////////////////////////////////////////////////////////////////////////////
986/// Set the LineWidth of the average.
987
996
997////////////////////////////////////////////////////////////////////////////////
998/// Set the Fill Color of the average.
999
1001{
1002 UInt_t ui=0;
1003
1004 if(fAverageSlices){
1005 for(ui=0;ui<fNcols;++ui) fAverageSlices[ui]->SetFillColor(col);
1006 } else if(fAveragePoly) fAveragePoly->SetFillColor(col);
1007}
1008
1009////////////////////////////////////////////////////////////////////////////////
1010/// Set the FillStyle of the average.
1011
1020
1021////////////////////////////////////////////////////////////////////////////////
1022/// Display or not the average.
1023
1025{
1026 if(disp == fDisplayAverage) return;
1027
1028 UInt_t ui=0;
1029
1031 delete fAveragePoly;
1032 fAveragePoly = nullptr;
1033 if(fAverageSlices){
1034 for(ui = 0;ui<fNcols;++ui) delete fAverageSlices[ui];
1035 }
1036 delete [] fAverageSlices;
1037 fAverageSlices = nullptr;
1038
1039 for(ui=0;ui<fNx*fNy;++ui){
1040 if (fCanvas) fCanvas->cd(ui+1);
1041 gPad->Clear();
1042 }
1043
1044 for(ui = 0; ui < fNx*fNy; ++ui){
1045 if (fCanvas) fCanvas->cd(ui+1);
1046 fPolargram->Draw("pn");
1048 if(fSegmentDisplay){
1049 if(disp) DrawSlicesAverage("");
1050 DrawSlices("");
1051 } else {
1052 if(disp) DrawPolyAverage("");
1053 DrawPoly("");
1054 }
1055 AppendPad();
1056 }
1057 if (fCanvas) {
1058 fCanvas->Modified();
1059 fCanvas->Update();
1060 }
1061}
1062
1063////////////////////////////////////////////////////////////////////////////////
1064/// Set the current selected entries.
1065
1067{
1068 Int_t i;
1069 UInt_t ui=0;
1070 Int_t tnumber=-1;
1074
1076
1077 while(entriesToDisplay!=0){
1079 if(entryNumber < 0) break;
1081 if(localEntry < 0) break;
1082 if(tnumber != fTree->GetTreeNumber()) {
1085 else {
1086 for(i=0;i<=fFormulas->LastIndex();++i)
1087 ((TTreeFormula*)fFormulas->At(i))->UpdateFormulaLeaves();
1088 }
1089 }
1090 Int_t ndata=1;
1091 if(fForceDim){
1092 if(fManager)
1093 ndata = fManager->GetNdata(true);
1094 else {
1095 for(ui=0;ui<fNcols;++ui){
1096 if(ndata < ((TTreeFormula*)fFormulas->At(ui))->GetNdata())
1097 ndata = ((TTreeFormula*)fFormulas->At(ui))->GetNdata();
1098 }
1099 if(fSelect && fSelect->GetNdata() == 0)
1100 ndata = 0;
1101 }
1102 }
1103 bool loaded = false;
1104 bool skip = false;
1105 // Loop over the instances of the selection condition
1106 for(Int_t inst=0;inst<ndata;++inst){
1107 if(fSelect){
1108 if(fSelect->EvalInstance(inst) == 0){
1109 skip = true;
1110 ++entry;
1111 }
1112 }
1113 if (!loaded) {
1114 // EvalInstance(0) always needs to be called so that
1115 // the proper branches are loaded.
1116 for (ui=0;ui<fNcols;ui++) {
1117 ((TTreeFormula*)fFormulas->At(ui))->EvalInstance(0);
1118 }
1119 loaded = true;
1120 } else if (inst == 0) {
1121 loaded = true;
1122 }
1123 }
1124 if(!skip){
1127 ++entry;
1128 }
1129 }
1130 if(fPolyList) UpdateView();
1131}
1132
1133////////////////////////////////////////////////////////////////////////////////
1134/// Set line style.
1135
1137{
1138 UInt_t ui=0;
1139
1141 for(ui=0; ui<fNx*fNy;++ui){
1142 if(fSegmentDisplay){
1143 TList *li = (TList*)fPolyList->At(ui);
1144 for(UInt_t var=0;var<fNcols;++var) ((TArc*)li->At(var))->SetLineStyle(sty);
1145 } else ((TPolyLine*)fPolyList->At(ui))->SetLineStyle(sty);
1146 }
1147}
1148
1149////////////////////////////////////////////////////////////////////////////////
1150/// Set lin color.
1151
1153{
1154 UInt_t ui=0;
1155
1157 for(ui=0; ui<fNx*fNy;++ui){
1158 if(fSegmentDisplay){
1159 TList *li = (TList*)fPolyList->At(ui);
1160 for(UInt_t var=0;var<fNcols;++var) ((TArc*)li->At(var))->SetLineColor(col);
1161 } else ((TPolyLine*)fPolyList->At(ui))->SetLineColor(col);
1162 }
1163}
1164
1165////////////////////////////////////////////////////////////////////////////////
1166///Set line width.
1167
1169{
1170 UInt_t ui=0;
1171
1173 for(ui=0; ui<fNx*fNy;++ui){
1174 if(fSegmentDisplay){
1175 TList *li = (TList*)fPolyList->At(ui);
1176 for(UInt_t var=0;var<fNcols;++var) ((TArc*)li->At(var))->SetLineWidth(wid);
1177 } else ((TPolyLine*)fPolyList->At(ui))->SetLineWidth(wid);
1178 }
1179}
1180
1181////////////////////////////////////////////////////////////////////////////////
1182/// Set fill color.
1183
1185{
1186 UInt_t ui=0;
1187
1189 for(ui=0; ui<fNx*fNy;++ui){
1190 if(fSegmentDisplay){
1191 TList *li = (TList*)fPolyList->At(ui);
1192 for(UInt_t var=0;var<fNcols;++var) ((TArc*)li->At(var))->SetFillColor(col);
1193 } else ((TPolyLine*)fPolyList->At(ui))->SetFillColor(col);
1194 }
1195}
1196
1197////////////////////////////////////////////////////////////////////////////////
1198/// Set fill style.
1199
1201{
1202 UInt_t ui=0;
1203
1205 for(ui=0; ui<fNx*fNy;++ui){
1206 if(fSegmentDisplay){
1207 TList *li = (TList*)fPolyList->At(ui);
1208 for(UInt_t var=0;var<fNcols;++var) ((TArc*)li->At(var))->SetFillStyle(sty);
1209 } else ((TPolyLine*)fPolyList->At(ui))->SetFillStyle(sty);
1210 }
1211}
1212
1213////////////////////////////////////////////////////////////////////////////////
1214/// Set number of radial divisions.
1215
1217{
1218 if(fPolargram->GetNdivRadial() == ndiv) return;
1220}
1221
1222////////////////////////////////////////////////////////////////////////////////
1223/// Set the X number of sub pads.
1224
1226{
1227 if(fNx == nx || nx <= 0) return;
1229
1230 UInt_t ui=0;
1231 Color_t lc;
1232 Style_t lt;
1233 Width_t lw;
1234 Color_t fc;
1235 Style_t fs;
1236 if(fAverageSlices){
1242 } else {
1248 }
1249
1250 if(fSegmentDisplay){
1251 for(ui=0; ui<fNx*fNy;++ui) ((TList*)fPolyList->At(ui))->Delete();
1252 }
1253 fPolyList->Delete();
1254 delete fPolyList;
1255 fPolyList = nullptr;
1256 delete [] fCurrentEntries;
1257 fCurrentEntries = nullptr;
1258
1259 fNx = nx;
1260
1263 if (fCanvas) {
1264 fCanvas->Clear();
1266 }
1267
1268 for(ui=0; ui < fNx*fNy;++ui){
1269 if (fCanvas) fCanvas->cd(ui+1);
1270 fPolargram->Draw("pn");
1272 if(fSegmentDisplay){
1274 DrawSlices("");
1275 } else {
1277 DrawPoly("");
1278 }
1279 AppendPad();
1280 }
1281
1282 if(fAverageSlices){
1283 for(ui = 0;ui<fNcols;++ui){
1289 }
1290 } else {
1296 }
1297}
1298
1299////////////////////////////////////////////////////////////////////////////////
1300/// Set the Y number of sub pads.
1301
1303{
1304 if(fNy == ny || ny <= 0) return;
1306
1307 UInt_t ui=0;
1308 Color_t lc;
1309 Style_t lt;
1310 Width_t lw;
1311 Color_t fc;
1312 Style_t fs;
1313 if(fAverageSlices){
1319 } else {
1325 }
1326
1327 if(fSegmentDisplay){
1328 for(ui=0; ui<fNx*fNy;++ui) ((TList*)fPolyList->At(ui))->Delete();
1329 }
1330 fPolyList->Delete();
1331 delete fPolyList;
1332 fPolyList = nullptr;
1333 delete [] fCurrentEntries;
1334 fCurrentEntries = nullptr;
1335
1336 fNy = ny;
1337
1340 if (fCanvas) {
1341 fCanvas->Clear();
1343 }
1344
1345 for(ui=0; ui < fNx*fNy;++ui){
1346 if (fCanvas) fCanvas->cd(ui+1);
1347 fPolargram->Draw("pn");
1349 if(fSegmentDisplay){
1351 DrawSlices("");
1352 } else {
1354 DrawPoly("");
1355 }
1356 AppendPad();
1357 }
1358
1359 if(fAverageSlices){
1360 for(ui = 0;ui<fNcols;++ui){
1366 }
1367 } else {
1373 }
1374}
1375
1376////////////////////////////////////////////////////////////////////////////////
1377/// Set the segment display or not.
1378
1380{
1381 if(seg == fSegmentDisplay) return;
1382
1383 UInt_t ui=0;
1384
1385 if(fSegmentDisplay){
1386 for(ui=0;ui<fNx*fNy;++ui){
1387 ((TList*)fPolyList->At(ui))->Delete();
1388 }
1389 }
1390 fPolyList->Delete();
1391
1392 Color_t lc = 1;
1393 Style_t lt = 1;
1394 Width_t lw = 1;
1395 Color_t fc = 1;
1396 Style_t fs = 0;
1397 if(fAverageSlices){
1403 } else {
1404 if (fAveragePoly) {
1410 }
1411 }
1412
1413 delete fPolyList;
1414 fPolyList = nullptr;
1415 if(fAverageSlices){
1416 for(ui=0;ui<fNcols;++ui) delete fAverageSlices[ui];
1417 }
1418 delete [] fAverageSlices;
1419 fAverageSlices = nullptr;
1420 delete fAveragePoly;
1421 fAveragePoly = nullptr;
1422
1423 for(ui=0;ui<fNx*fNy;++ui){
1424 if (fCanvas) fCanvas->cd(ui+1);
1425 gPad->Clear();
1426 }
1427
1429
1430 for(ui=0; ui < fNx*fNy;++ui){
1431 if (fCanvas) fCanvas->cd(ui+1);
1432 fPolargram->Draw("pn");
1434 if(fSegmentDisplay){
1436 DrawSlices("");
1437 } else {
1439 DrawPoly("");
1440 }
1441 AppendPad();
1442 }
1443
1444 if(fAverageSlices){
1445 for(ui=0;ui<fNcols;++ui){
1451 }
1452 } else {
1453 if (fAveragePoly) {
1459 }
1460 }
1461 if (fCanvas) {
1462 fCanvas->Modified();
1463 fCanvas->Update();
1464 }
1465}
1466
1467////////////////////////////////////////////////////////////////////////////////
1468/// Compile selection expression if there is one.
1469
1471{
1472 if (selection && strlen(selection)) {
1473 fSelect = new TTreeFormula("Selection",selection,fTree);
1474 // if (!fSelect) return -1;
1475 // if (!fSelect->GetNdim()) { delete fSelect; return -1; }
1477 }
1478}
1479
1480////////////////////////////////////////////////////////////////////////////////
1481/// Compile the variables expression from the given string varexp.
1482
1484{
1485 Int_t nch;
1486 fNcols=8;
1487
1488 if (!varexp) return;
1490 UInt_t nleaves = leaves->GetEntriesFast();
1491 if (nleaves < fNcols) fNcols = nleaves;
1492 nch = strlen(varexp);
1493
1494 // if varexp is empty, take first 8 columns by default
1495 Int_t allvar = 0;
1496 std::vector<TString> cnames;
1497 if (!strcmp(varexp, "*")) { fNcols = nleaves; allvar = 1; }
1498 if (nch == 0 || allvar) {
1499 UInt_t ncs = fNcols;
1500 fNcols = 0;
1501 for (UInt_t ui=0;ui<ncs;++ui) {
1502 TLeaf *lf = (TLeaf*)leaves->At(ui);
1503 if (lf->GetBranch()->GetListOfBranches()->GetEntries() > 0) continue;
1504 cnames.push_back(lf->GetName());
1505 fNcols++;
1506 }
1507 // otherwise select only the specified columns
1508 } else {
1510 }
1511
1512 // Create the TreeFormula objects corresponding to each column
1513 for (UInt_t ui=0;ui<fNcols;ui++) {
1514 fFormulas->Add(new TTreeFormula("Var1",cnames[ui].Data(),fTree));
1515 }
1516}
1517
1518////////////////////////////////////////////////////////////////////////////////
1519/// Create a TreeFormulaManager to coordinate the formulas.
1520
1522{
1523 Int_t i;
1524 if (fFormulas->LastIndex()>=0) {
1525 if (fSelect) {
1526 if (fSelect->GetManager()->GetMultiplicity() > 0 ) {
1528 for(i=0;i<=fFormulas->LastIndex();i++) {
1530 }
1531 fManager->Sync();
1532 }
1533 }
1534 for(i=0;i<=fFormulas->LastIndex();i++) {
1536 switch( form->GetManager()->GetMultiplicity() ) {
1537 case 1:
1538 case 2:
1539 case -1:
1540 fForceDim = true;
1541 break;
1542 case 0:
1543 break;
1544 }
1545
1546 }
1547 }
1548}
1549
1550////////////////////////////////////////////////////////////////////////////////
1551/// Update the polylines or the arcs for the current entries.
1552
1554{
1555 Double_t slice = 2*TMath::Pi()/fNcols;
1556
1557 Double_t x,y,r;
1558
1559 for(UInt_t pad=1;pad <= fNx*fNy;++pad){
1561 for(UInt_t i=0;i<fNcols;++i){
1562 r = (((TTreeFormula*)fFormulas->At(i))->EvalInstance()-fMin[i])/(fMax[i]-fMin[i]);
1563 x=r*TMath::Cos(i*slice);
1564 y=r*TMath::Sin(i*slice);
1565 if(!fSegmentDisplay) ((TPolyLine*)fPolyList->At(pad-1))->SetPoint(i,x,y);
1566 else {
1567 ((TArc*)((TList*)fPolyList->At(pad-1))->At(i))->SetR1(r);
1568 ((TArc*)((TList*)fPolyList->At(pad-1))->At(i))->SetR2(r);
1569 }
1570 }
1571 x=(((TTreeFormula*)fFormulas->At(0))->EvalInstance()-fMin[0])/(fMax[0]-fMin[0]);
1572 y=0;
1573 if(!fSegmentDisplay) ((TPolyLine*)fPolyList->At(pad-1))->SetPoint(fNcols,x,y);
1574 }
1575}
@ kHand
Definition GuiTypes.h:374
#define e(i)
Definition RSha256.hxx:103
short Style_t
Style number (short)
Definition RtypesCore.h:96
short Color_t
Color number (short)
Definition RtypesCore.h:99
short Width_t
Line width (short)
Definition RtypesCore.h:98
long long Long64_t
Portable signed long integer 8 bytes.
Definition RtypesCore.h:83
const char Option_t
Option string (const char)
Definition RtypesCore.h:80
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
R__EXTERN TEnv * gEnv
Definition TEnv.h:170
Option_t Option_t option
Option_t Option_t SetLineWidth
Option_t Option_t SetFillStyle
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h offset
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize wid
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Option_t Option_t SetLineColor
Option_t Option_t TPoint TPoint angle
Option_t Option_t SetFillColor
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize fs
int nentries
#define gROOT
Definition TROOT.h:411
char * Form(const char *fmt,...)
Formats a string in a circular formatting buffer.
Definition TString.cxx:2495
#define gPad
Create an Arc.
Definition TArc.h:26
Fill Area Attributes class.
Definition TAttFill.h:20
virtual Color_t GetFillColor() const
Return the fill area color.
Definition TAttFill.h:31
virtual Style_t GetFillStyle() const
Return the fill area style.
Definition TAttFill.h:32
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
Definition TAttFill.h:38
virtual void SetFillStyle(Style_t fstyle)
Set the fill area style.
Definition TAttFill.h:40
Line Attributes class.
Definition TAttLine.h:20
virtual Color_t GetLineColor() const
Return the line color.
Definition TAttLine.h:35
virtual void SetLineStyle(Style_t lstyle)
Set the line style.
Definition TAttLine.h:44
virtual Width_t GetLineWidth() const
Return the line width.
Definition TAttLine.h:37
virtual void SetLineWidth(Width_t lwidth)
Set the line width.
Definition TAttLine.h:45
virtual void SetLineColor(Color_t lcolor)
Set the line color.
Definition TAttLine.h:42
virtual Style_t GetLineStyle() const
Return the line style.
Definition TAttLine.h:36
The Canvas class.
Definition TCanvas.h:23
void Clear(Option_t *option="") override
Remove all primitives from the canvas.
Definition TCanvas.cxx:735
TVirtualPad * cd(Int_t subpadnumber=0) override
Set current canvas & pad.
Definition TCanvas.cxx:717
virtual void Selected(TVirtualPad *pad, TObject *obj, Int_t event)
Emit Selected() signal.
Definition TCanvas.cxx:1637
void Update() override
Update canvas pad buffers.
Definition TCanvas.cxx:2486
void Draw(Option_t *option="") override
Draw this ellipse with its current attributes.
Definition TEllipse.cxx:168
A List of entry numbers in a TTree or TChain.
Definition TEntryList.h:26
virtual Long64_t GetN() const
Definition TEntryList.h:78
virtual void SetValue(const char *name, const char *value, EEnvLevel level=kEnvChange, const char *type=nullptr)
Set the value of a resource or create a new resource.
Definition TEnv.cxx:735
To draw polar axis.
void SetNdivPolar(Int_t Ndiv=508)
Set the number of Polar divisions: enter a number ij with 0<i<99 and 0<j<99.
void Draw(Option_t *options="") override
Draw Polargram.
void SetNdivRadial(Int_t Ndiv=508)
Set the number of radial divisions: enter a number ij with 0<i<99 and 0<j<99.
To draw Mathematical Formula.
Definition TLatex.h:18
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
Definition TLeaf.h:57
A doubly linked list.
Definition TList.h:38
void AddAfter(const TObject *after, TObject *obj) override
Insert object after object after in the list.
Definition TList.cxx:247
void Add(TObject *obj) override
Definition TList.h:81
TObject * Remove(TObject *obj) override
Remove object from the list.
Definition TList.cxx:819
void Delete(Option_t *option="") override
Remove all objects from the list AND delete all heap based objects.
Definition TList.cxx:467
TObject * At(Int_t idx) const override
Returns the object at position idx. Returns 0 if idx is out of range.
Definition TList.cxx:354
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
An array of TObjects.
Definition TObjArray.h:31
virtual void AppendPad(Option_t *option="")
Append graphics object to current pad.
Definition TObject.cxx:203
virtual void Delete(Option_t *option="")
Delete this object.
Definition TObject.cxx:267
virtual const char * GetTitle() const
Returns title of object.
Definition TObject.cxx:501
void Divide(Int_t nx=1, Int_t ny=1, Float_t xmargin=0.01, Float_t ymargin=0.01, Int_t color=0) override
Automatic pad generation by division.
Definition TPad.cxx:1258
void Modified(Bool_t flag=true) override
Mark pad modified Will be repainted when TCanvas::Update() will be called next time.
Definition TPad.cxx:7459
TCanvas * GetCanvas() const override
Definition TPad.h:263
Defined by an array on N points in a 2-D space.
Definition TPolyLine.h:23
void Draw(Option_t *option="") override
Draw this polyline with its current attributes.
A specialized TSelector for TTree::Draw.
virtual UInt_t SplitNames(const TString &varexp, std::vector< TString > &names)
Build Index array for names in varexp.
virtual void SetInputList(TList *input)
Definition TSelector.h:66
Int_t LastIndex() const
Spider class.
Definition TSpider.h:40
void SetAverageLineStyle(Style_t sty)
Set the LineStyle of the average.
Definition TSpider.cxx:964
TPolyLine * fAveragePoly
Polygon representing the average variables value.
Definition TSpider.h:55
void SetLineColor(Color_t col) override
Set lin color.
Definition TSpider.cxx:1152
void SetAverageFillColor(Color_t col)
Set the Fill Color of the average.
Definition TSpider.cxx:1000
~TSpider() override
Destructor.
Definition TSpider.cxx:173
UInt_t fNy
Number of vertical spider plots.
Definition TSpider.h:43
void Draw(Option_t *options="") override
Draw the spider.
Definition TSpider.cxx:453
TList * fInput
Used for fSelector.
Definition TSpider.h:59
void SetNx(UInt_t nx)
Set the X number of sub pads.
Definition TSpider.cxx:1225
Double_t * fAve
[fNcols] Average value of each variable.
Definition TSpider.h:50
Style_t GetAverageLineStyle() const
Get the LineStyle of the average.
Definition TSpider.cxx:616
void GotoPrevious()
Go to the previous entries.
Definition TSpider.cxx:763
void SetFillStyle(Style_t sty) override
Set fill style.
Definition TSpider.cxx:1200
TList * fSuperposed
Superposed spider plots.
Definition TSpider.h:53
void DrawSlices(Option_t *options)
Draw the slices of the segment plot.
Definition TSpider.cxx:559
Long64_t fFirstEntry
First entry.
Definition TSpider.h:48
void SetDisplayAverage(bool disp)
Display or not the average.
Definition TSpider.cxx:1024
void UpdateView()
Update the polylines or the arcs for the current entries.
Definition TSpider.cxx:1553
TTree * fTree
Pointer to the TTree to represent.
Definition TSpider.h:54
bool fSegmentDisplay
True if displaying a segment plot.
Definition TSpider.h:68
Int_t DistancetoPrimitive(Int_t px, Int_t py) override
Compute the distance to the spider.
Definition TSpider.cxx:438
void SetSegmentDisplay(bool seg)
Set the segment display or not.
Definition TSpider.cxx:1379
void SetNdivRadial(Int_t div)
Set number of radial divisions.
Definition TSpider.cxx:1216
void SetCurrentEntries()
Set the current selected entries.
Definition TSpider.cxx:1066
void AddVariable(const char *varexp)
Add a variable to the plot from its expression.
Definition TSpider.cxx:214
UInt_t fNcols
Number of variables.
Definition TSpider.h:44
bool fShowRange
Show range of variables or not.
Definition TSpider.h:69
void DrawPoly(Option_t *options)
Paint the polygon representing the current entry.
Definition TSpider.cxx:529
bool fAngularLabels
True if the labels are oriented according to their axis.
Definition TSpider.h:65
void DrawSlicesAverage(Option_t *options)
Draw the slices representing the average for the segment plot.
Definition TSpider.cxx:585
void GotoEntry(Long64_t e)
Go to a specified entry.
Definition TSpider.cxx:743
TCanvas * fCanvas
! Pointer to the mother pad.
Definition TSpider.h:57
Int_t fArraySize
Actual size of the arrays.
Definition TSpider.h:45
void SetAverageLineColor(Color_t col)
Set the LineColor of the average.
Definition TSpider.cxx:976
TArc ** fAverageSlices
! Average slices.
Definition TSpider.h:56
void SetSelectionExpression(const char *selexp)
Compile selection expression if there is one.
Definition TSpider.cxx:1470
Long64_t fEntry
Present entry number in fTree.
Definition TSpider.h:46
void DeleteVariable(const char *varexp)
Delete a variable from its expression.
Definition TSpider.cxx:352
void SetAverageLineWidth(Width_t wid)
Set the LineWidth of the average.
Definition TSpider.cxx:988
TTreeFormulaManager * fManager
Coordinator for the formulas.
Definition TSpider.h:60
Width_t GetAverageLineWidth() const
Get the LineWidth of the average.
Definition TSpider.cxx:636
void SetLineWidth(Width_t wid) override
Set line width.
Definition TSpider.cxx:1168
TList * fFormulas
List of all formulas to represent.
Definition TSpider.h:58
void SetLineStyle(Style_t sty) override
Set line style.
Definition TSpider.cxx:1136
void ExecuteEvent(Int_t event, Int_t px, Int_t py) override
Execute the corresponding event.
Definition TSpider.cxx:666
Color_t GetAverageLineColor() const
Get the LineColor of the average.
Definition TSpider.cxx:626
TTreeFormula * fSelect
Selection condition.
Definition TSpider.h:63
void InitVariables(Long64_t firstentry, Long64_t nentries)
Browse the tree to set the min, max and average value of each variable of fVar.
Definition TSpider.cxx:831
Int_t FindTextAlign(Double_t theta)
Find the alignement rule to apply for TText::SetTextAlign(Short_t).
Definition TSpider.cxx:675
void SetVariablesExpression(const char *varexp)
Compile the variables expression from the given string varexp.
Definition TSpider.cxx:1483
void SetAverageFillStyle(Style_t sty)
Set the FillStyle of the average.
Definition TSpider.cxx:1012
TSelectorDraw * fSelector
! Selector.
Definition TSpider.h:64
TSpider()
Default constructor.
Definition TSpider.cxx:75
Double_t FindTextAngle(Double_t theta)
Determine the orientation of the polar labels according to their angle.
Definition TSpider.cxx:704
Color_t GetAverageFillColor() const
Get the Fill Color of the average.
Definition TSpider.cxx:646
void SyncFormulas()
Create a TreeFormulaManager to coordinate the formulas.
Definition TSpider.cxx:1521
void AddSuperposed(TSpider *sp)
Allow to superpose several spider views.
Definition TSpider.cxx:205
void SetFillColor(Color_t col) override
Set fill color.
Definition TSpider.cxx:1184
Double_t * fMax
[fNcols] Maximum value of the variables.
Definition TSpider.h:51
Double_t * fMin
[fNcols] Minimum value of the variables.
Definition TSpider.h:52
UInt_t fNx
Number of horizontal spider plots.
Definition TSpider.h:42
void SetNy(UInt_t ny)
Set the Y number of sub pads.
Definition TSpider.cxx:1302
bool fForceDim
Force dimension.
Definition TSpider.h:67
void Paint(Option_t *options) override
Paint the spider.
Definition TSpider.cxx:917
void InitArrays(Int_t newsize)
Check if the arrays size is enough and reallocate them if not.
Definition TSpider.cxx:793
Long64_t fNentries
Number of entries.
Definition TSpider.h:47
Style_t GetAverageFillStyle() const
Get the FillStyle of the average.
Definition TSpider.cxx:656
TGraphPolargram * fPolargram
Polar graph.
Definition TSpider.h:61
void GotoNext()
Go to the next entries.
Definition TSpider.cxx:753
void DrawPolyAverage(Option_t *options)
Paint the Polygon representing the average value of the variables.
Definition TSpider.cxx:491
Long64_t * fCurrentEntries
![fNx*fNy] current selected entries;
Definition TSpider.h:49
TList * fPolyList
Polygons representing the variables.
Definition TSpider.h:62
void GotoPreceding()
Go to the last entry.
Definition TSpider.cxx:783
bool fDisplayAverage
Display or not the average.
Definition TSpider.h:66
Long64_t GetEntriesToProcess(Long64_t firstentry, Long64_t nentries) const
return the number of entries to be processed this function checks that nentries is not bigger than th...
Definition TSpider.cxx:726
void GotoFollowing()
Go to the next entry.
Definition TSpider.cxx:773
Basic string class.
Definition TString.h:138
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition TString.h:640
Used to coordinate one or more TTreeFormula objects.
virtual void UpdateFormulaLeaves()
This function could be called TTreePlayer::UpdateFormulaLeaves, itself called by TChain::LoadTree whe...
virtual Int_t GetNdata(bool forceLoadDim=false)
Return number of available instances in the formulas.
virtual void Add(TTreeFormula *)
Add a new formula to the list of formulas managed The manager of the formula will be changed and the ...
virtual bool Sync()
Synchronize all the formulae.
virtual Int_t GetMultiplicity() const
Used to pass a selection expression to the Tree drawing routine.
TTreeFormulaManager * GetManager() const
T EvalInstance(Int_t i=0, const char *stringStack[]=nullptr)
Evaluate this treeformula.
virtual Int_t GetNdata()
Return number of available instances in the formula.
A TTree represents a columnar dataset.
Definition TTree.h:89
virtual Int_t GetScanField() const
Definition TTree.h:590
virtual TObjArray * GetListOfLeaves()
Definition TTree.h:568
virtual TEntryList * GetEntryList()
Returns the entry list assigned to this tree.
Definition TTree.cxx:5934
virtual Long64_t GetEntryNumber(Long64_t entry) const
Return entry number corresponding to entry.
Definition TTree.cxx:5945
virtual Long64_t LoadTree(Long64_t entry)
Set current entry.
Definition TTree.cxx:6554
virtual Long64_t GetEntriesFriend() const
Returns a number corresponding to:
Definition TTree.cxx:5590
virtual Int_t GetTreeNumber() const
Definition TTree.h:598
virtual void SetScanField(Int_t n=50)
Sets the default maximum number of lines to be shown before <CR> when calling Scan().
Definition TTree.h:730
void Clear(Option_t *option="") override=0
Double_t y[n]
Definition legend1.C:17
Double_t x[n]
Definition legend1.C:17
Double_t Cos(Double_t)
Returns the cosine of an angle of x radians.
Definition TMath.h:605
constexpr Double_t Pi()
Definition TMath.h:40
Double_t Sin(Double_t)
Returns the sine of an angle of x radians.
Definition TMath.h:599
th1 Draw()