https://github.com/root-project/root
Tip revision: 5153ead12e7d7e5c691ee5a0cfd1c9b8b660bfb0 authored by Fons Rademakers on 10 May 2013, 13:33:36 UTC
Port from svn to git. Also fix some compile issues of this old version on OSX.
Port from svn to git. Also fix some compile issues of this old version on OSX.
Tip revision: 5153ead
stressGraphics.cxx
// @(#)root/test:$name: $:$id: stressGraphics.cxx,v 1.0 exp $
// Author: O.Couet
//
// ROOT Graphics test suite and benchmarks.
//
// The suite of programs below tests many elements of the graphics classes
//
// The test can be run as a standalone program or with the interpreter.
//
// To run as a standalone program:
//
// make stressGraphics
// stressGraphics
//
// To get a short help:
// stressGraphics -h
//
// To run interactively, do
// root
// Root > .L stressGraphics.cxx
// Root > stressGraphics()
#ifndef __CINT__
#include <stdlib.h>
#include <Riostream.h>
#include <time.h>
#include <TString.h>
#include <TROOT.h>
#include <TError.h>
#include <TRandom.h>
#include <TBenchmark.h>
#include <TSystem.h>
#include <TApplication.h>
#include <TDatime.h>
#include <TFile.h>
#include <TF1.h>
#include "TF2.h"
#include <TF3.h>
#include <TH2.h>
#include <TNtuple.h>
#include <TProfile.h>
#include <TStyle.h>
#include <TCanvas.h>
#include <TColor.h>
#include <TFrame.h>
#include <TPostScript.h>
#include <TPDF.h>
#include <TLine.h>
#include <TMarker.h>
#include <TPolyLine.h>
#include <TLatex.h>
#include <TEllipse.h>
#include <TCurlyArc.h>
#include <TArc.h>
#include <TPaveText.h>
#include <TPaveStats.h>
#include <TPaveLabel.h>
#include <TGaxis.h>
#include <TGraph.h>
#include <TGraphErrors.h>
#include <TGraphAsymmErrors.h>
#include <TGraphBentErrors.h>
#include <TMultiGraph.h>
#include <TGraph2D.h>
#include <TImage.h>
#include <TMath.h>
#include <TSystem.h>
void stressGraphics (Int_t verbose);
Int_t StatusPrint (TString &filename, Int_t id, const TString &title, Int_t res, Int_t ref, Int_t err);
Int_t AnalysePS (const TString &filename);
Int_t FileSize (char *filename);
TCanvas *StartTest (Int_t w, Int_t h);
void TestReport1 (TCanvas *C, const TString &title);
void TestReport2 ();
void DoCcode (TCanvas *C);
// Tests functions.
void tline ();
void tmarker ();
void tpolyline ();
void patterns ();
void ttext1 ();
void ttext2 ();
void tlatex1 ();
void tlatex2 ();
void tlatex3 ();
void tlatex4 ();
void tlatex5 ();
void kerning ();
void itbf ();
void transpad ();
void statfitparam ();
void tgaxis1 ();
void tgaxis2 ();
void tgaxis3 ();
void tgaxis4 ();
void labels1 ();
void tellipse ();
void feynman ();
void tgraph1 ();
void tgraph2 ();
void tgraph3 ();
void tmultigraph1 ();
void tmultigraph2 ();
void options2d1 ();
void options2d2 ();
void options2d3 ();
void options2d4 ();
void options2d5 ();
void earth ();
void tgraph2d1 ();
void tgraph2d2 ();
void tgraph2d3 ();
void ntuple1 ();
void quarks ();
void timage ();
void zoomtf1 ();
void zoomfit ();
void parallelcoord ();
void clonepad ();
void waves ();
// Auxiliary functions
void patterns_box (Int_t pat, Double_t x1, Double_t y1, Double_t x2, Double_t y2);
void tmarker_draw (Double_t x, Double_t y, Int_t mt, Double_t d);
Double_t interference (Double_t *x, Double_t *par);
Double_t result (Double_t *x, Double_t *par);
void cleanup ();
#endif
// Global variables.
Int_t gVerbose;
Int_t gTestNum;
Int_t gPS1RefNb[50];
Int_t gPS1ErrNb[50];
Int_t gPDFRefNb[50];
Int_t gPDFErrNb[50];
Int_t gGIFRefNb[50];
Int_t gGIFErrNb[50];
Int_t gJPGRefNb[50];
Int_t gJPGErrNb[50];
Int_t gPNGRefNb[50];
Int_t gPNGErrNb[50];
Int_t gPS2RefNb[50];
Int_t gPS2ErrNb[50];
Bool_t gOptionR;
Bool_t gOptionK;
TH2F *gH2;
TFile *gLocalFile;
char gCfile[16];
char outfile[16];
char gLine[80];
#ifndef __CINT__
//______________________________________________________________________________
int main(int argc, char *argv[])
{
TApplication theApp("App", &argc, argv);
gBenchmark = new TBenchmark();
TString opt;
Int_t verbose = 0;
if (argc > 1) verbose = atoi(argv[1]);
opt = argv[1];
if (opt.Contains("-h")) {
printf("Usage: stressGraphics [-h] [-r] [-k]\n");
printf("Options:\n");
printf(" -r : Generate de reference output.\n");
printf(" Redirect the output in the file \"stressGraphics.ref\"\n");
printf(" to redefine the reference file.\n");
printf("\n");
printf(" -k : Keep the PS files even for passed tests.\n");
printf(" By default PS files for passed tests are deleted.\n");
printf("\n");
printf(" -h : Print usage\n");
return 0;
}
if (opt.Contains("-r")) {
gOptionR = kTRUE;
} else {
gOptionR = kFALSE;
}
if (opt.Contains("-k")) {
gOptionK = kTRUE;
} else {
gOptionK = kFALSE;
}
stressGraphics(verbose);
cleanup();
return 0;
}
#endif
//______________________________________________________________________________
void stressGraphics(Int_t verbose = 0)
{
// Run all graphics stress tests.
gErrorIgnoreLevel = 9999;
gROOT->SetBatch();
gROOT->SetStyle("Classic");
// Check if $ROOTSYS/tutorials/hsimple.root exists
gLocalFile = new TFile("$(ROOTSYS)/tutorials/hsimple.root");
if (gLocalFile->IsZombie()) {
delete gLocalFile;
gLocalFile = new TFile("hsimple.root");
if (gLocalFile->IsZombie()) {
delete gLocalFile;
printf("Create $(ROOTSYS)/tutorials/hsimple.root\n");
gROOT->Macro("$(ROOTSYS)/tutorials/hsimple.C");
gLocalFile = new TFile("$(ROOTSYS)/tutorials/hsimple.root");
if (gLocalFile->IsZombie()) {
delete gLocalFile;
printf("Could not create $(ROOTSYS)/tutorials/hsimple.root\n");
return;
}
}
}
gErrorIgnoreLevel = 0;
// Read the reference file "stressGraphics.ref"
FILE *sg = fopen("stressGraphics.ref","r");
char line[160];
Int_t i = -1;
while (fgets(line,160,sg)) {
if (i>=0) {
sscanf(&line[8] ,"%d",&gPS1RefNb[i]);
sscanf(&line[18] ,"%d",&gPS1ErrNb[i]);
sscanf(&line[28] ,"%d",&gPDFRefNb[i]);
sscanf(&line[38] ,"%d",&gPDFErrNb[i]);
sscanf(&line[48] ,"%d",&gGIFRefNb[i]);
sscanf(&line[58] ,"%d",&gGIFErrNb[i]);
sscanf(&line[68] ,"%d",&gJPGRefNb[i]);
sscanf(&line[78] ,"%d",&gJPGErrNb[i]);
sscanf(&line[88] ,"%d",&gPNGRefNb[i]);
sscanf(&line[98] ,"%d",&gPNGErrNb[i]);
sscanf(&line[108],"%d",&gPS2RefNb[i]);
sscanf(&line[118],"%d",&gPS2ErrNb[i]);
}
i++;
}
fclose(sg);
gRandom->SetSeed(65539);
if (gOptionR) {
cout << "Test# PS1Ref# PS1Err# PDFRef# PDFErr# GIFRef# GIFErr# JPGRef# JPGErr# PNGRef# PNGErr# PS2Ref# PS2Err#" <<endl;
} else {
cout << "**********************************************************************" <<endl;
cout << "* Starting Graphics - S T R E S S suite *" <<endl;
cout << "**********************************************************************" <<endl;
}
gVerbose = verbose;
gTestNum = 0;
gBenchmark->Start("stressGraphics");
if (!gOptionR) {
cout << "* Starting Basic Graphics - S T R E S S *" <<endl;
cout << "**********************************************************************" <<endl;
}
tline ();
tmarker ();
tpolyline ();
patterns ();
ttext1 ();
ttext2 ();
tlatex1 ();
tlatex2 ();
tlatex3 ();
tlatex4 ();
tlatex5 ();
kerning ();
itbf ();
transpad ();
statfitparam ();
if (!gOptionR) {
cout << "**********************************************************************" <<endl;
cout << "* Starting High Level 2D Primitives - S T R E S S *" <<endl;
cout << "**********************************************************************" <<endl;
}
tgaxis1 ();
tgaxis2 ();
tgaxis3 ();
tgaxis4 ();
labels1 ();
tellipse ();
feynman ();
tgraph1 ();
tgraph2 ();
tgraph3 ();
tmultigraph1 ();
tmultigraph2 ();
waves ();
if (!gOptionR) {
cout << "**********************************************************************" <<endl;
cout << "* Starting High Level 3D Primitives - S T R E S S *" <<endl;
cout << "**********************************************************************" <<endl;
}
options2d1 ();
options2d2 ();
options2d3 ();
options2d4 ();
options2d5 ();
earth ();
tgraph2d1 ();
tgraph2d2 ();
tgraph2d3 ();
if (!gOptionR) {
cout << "**********************************************************************" <<endl;
cout << "* Starting complex drawing and TPad - S T R E S S *" <<endl;
cout << "**********************************************************************" <<endl;
}
ntuple1 ();
quarks ();
timage ();
zoomtf1 ();
zoomfit ();
parallelcoord();
///clonepad ();
if (!gOptionR) {
cout << "**********************************************************************" <<endl;
gBenchmark->Stop("stressGraphics");
//Print table with results
Bool_t UNIX = strcmp(gSystem->GetName(), "Unix") == 0;
if (UNIX) {
TString sp = gSystem->GetFromPipe("uname -a");
sp.Resize(60);
printf("* SYS: %s\n",sp.Data());
if (strstr(gSystem->GetBuildNode(),"Linux")) {
sp = gSystem->GetFromPipe("lsb_release -d -s");
printf("* SYS: %s\n",sp.Data());
}
if (strstr(gSystem->GetBuildNode(),"Darwin")) {
sp = gSystem->GetFromPipe("sw_vers -productVersion");
sp += " Mac OS X ";
printf("* SYS: %s\n",sp.Data());
}
} else {
const Char_t *os = gSystem->Getenv("OS");
if (!os) printf("* SYS: Windows 95\n");
else printf("* SYS: %s %s \n",os,gSystem->Getenv("PROCESSOR_IDENTIFIER"));
}
printf("**********************************************************************\n");
printf("* ");
gBenchmark->Print("stressGraphics");
Double_t ct = gBenchmark->GetCpuTime("stressGraphics");
//normalize at 860 rootmarks on pcbrun4
const Double_t rootmarks = 860*(47.12/ct);
printf("**********************************************************************\n");
printf("* ROOTMARKS =%6.1f * Root%-8s %d/%d\n",rootmarks,gROOT->GetVersion(),
gROOT->GetVersionDate(),gROOT->GetVersionTime());
printf("**********************************************************************\n");
}
}
//______________________________________________________________________________
Int_t StatusPrint(TString &filename, Int_t id, const TString &title,
Int_t res, Int_t ref, Int_t err)
{
// Print test program number and its title
if (!gOptionR) {
if (id>0) {
sprintf(gLine,"Test %2d: %s",id,title.Data());
} else {
sprintf(gLine," %s",title.Data());
}
const Int_t nch = strlen(gLine);
if (TMath::Abs(res-ref)<=err) {
cout << gLine;
for (Int_t i = nch; i < 67; i++) cout << ".";
cout << " OK" << endl;
if (!gOptionK) gSystem->Unlink(filename.Data());
} else {
cout << gLine;
Int_t ndots = 60;
Int_t w = 3;
if (gTestNum < 10) { ndots++; w--;}
for (Int_t i = nch; i < ndots; i++) cout << ".";
cout << setw(w) << gTestNum << " FAILED" << endl;
cout << " Result = " << res << endl;
cout << " Reference = " << ref << endl;
cout << " Error = " << TMath::Abs(res-ref)
<< " (was " << err << ")"<< endl;
return 1;
}
} else {
if (id>0) printf("%5d%10d%10d",id,res,err);
if (id==0) printf("%10d%10d",res,err);
if (id<0) printf("%10d%10d\n",res,err);
}
return 0;
}
//______________________________________________________________________________
Int_t FileSize (char *filename)
{
// Return the size of filename
FileStat_t fs;
gSystem->GetPathInfo(filename, fs);
return (Int_t)fs.fSize;
}
//______________________________________________________________________________
Int_t AnalysePS(const TString &filename)
{
// Analyse the PS file "filename" and return the number of character in the
// meaningful part of the file. The variable part (date etc..) are not
// counted.
Bool_t counting = kFALSE;
Int_t count = 0;
char *line = new char[251];
TString l;
FILE *fp;
Int_t status;
if ((fp=fopen(filename.Data(), "r"))==NULL) {
printf("ERROR1 : File can not open !..\n");
return 0;
}
while((status=fscanf(fp, "%s", line)) != EOF) {
l = line;
if (l.Contains("%!PS-Adobe")) counting = kFALSE;
if (l.Contains("%%EndProlog")) counting = kTRUE;
if (counting) count = count+l.Length();
}
if (gVerbose==1) printf(">>>>>>>>> Number of characters found in %s: %d\n",filename.Data(),count);
return count;
}
//______________________________________________________________________________
TCanvas *StartTest(Int_t w, Int_t h)
{
// Start Test:
// Open the TCanvas C and set the acceptable error (number of characters)
gTestNum++;
gStyle->Reset();
TCanvas *old = (TCanvas*)gROOT->GetListOfCanvases()->FindObject("C");
if (old) {
if (old->IsOnHeap()) delete old;
}
TCanvas *C = new TCanvas("C","C",0,0,w,h);
return C;
}
//______________________________________________________________________________
void TestReport1(TCanvas *C, const TString &title)
{
// Report 1:
// Draw the canvas generate as PostScript, count the number of characters in
// the PS file and compare the result with the reference value.
gErrorIgnoreLevel = 9999;
sprintf(outfile,"sg1_%2.2d.ps",gTestNum);
TPostScript *ps1 = new TPostScript(outfile, 111);
C->Draw();
ps1->Close();
TString psfile = outfile;
StatusPrint(psfile, gTestNum, title, AnalysePS(outfile) ,
gPS1RefNb[gTestNum-1],
gPS1ErrNb[gTestNum-1]);
sprintf(outfile,"sg%2.2d.pdf",gTestNum);
C->cd(0);
TPDF *pdf = new TPDF(outfile,111);
C->Draw();
pdf->Close();
TString pdffile = outfile;
StatusPrint(pdffile, 0, " PDF output", FileSize(outfile),
gPDFRefNb[gTestNum-1],
gPDFErrNb[gTestNum-1]);
sprintf(outfile,"sg%2.2d.gif",gTestNum);
C->cd(0);
C->SaveAs(outfile);
TString giffile = outfile;
StatusPrint(giffile, 0, " GIF output", FileSize(outfile),
gGIFRefNb[gTestNum-1],
gGIFErrNb[gTestNum-1]);
sprintf(outfile,"sg%2.2d.jpg",gTestNum);
C->cd(0);
C->SaveAs(outfile);
TString jpgfile = outfile;
StatusPrint(jpgfile, 0, " JPG output", FileSize(outfile),
gJPGRefNb[gTestNum-1],
gJPGErrNb[gTestNum-1]);
sprintf(outfile,"sg%2.2d.png",gTestNum);
C->cd(0);
C->SaveAs(outfile);
TString pngfile = outfile;
StatusPrint(pngfile, 0, " PNG output", FileSize(outfile),
gPNGRefNb[gTestNum-1],
gPNGErrNb[gTestNum-1]);
gErrorIgnoreLevel = 0;
return;
}
//______________________________________________________________________________
void DoCcode(TCanvas *C)
{
// Generate the C code conresponding to the canvas C.
gErrorIgnoreLevel = 9999;
sprintf(gCfile,"sg%2.2d.C",gTestNum);
C->SaveAs(gCfile);
if (C) {delete C; C = 0;}
gErrorIgnoreLevel = 0;
return;
}
//______________________________________________________________________________
void TestReport2()
{
// Report 2:
// Draw the canvas generate as .C, generate the corresponding PostScript
// file (using gPad), count the number of characters in it and compare the
// result with the reference value.
sprintf(outfile,"sg2_%2.2d.ps",gTestNum);
gErrorIgnoreLevel = 9999;
sprintf(gCfile,".x sg%2.2d.C",gTestNum);
gROOT->ProcessLine(gCfile);
gPad->SaveAs(outfile);
gErrorIgnoreLevel = 0;
TString psfile = outfile;
Int_t i = StatusPrint(psfile,-1, " C file result", AnalysePS(outfile),
gPS2RefNb[gTestNum-1],
gPS2ErrNb[gTestNum-1]);
sprintf(gCfile,"sg%2.2d.C",gTestNum);
if (!gOptionK && !i) gSystem->Unlink(gCfile);
return;
}
//______________________________________________________________________________
void tline()
{
// Test TLine.
TCanvas *C = StartTest(800,800);
TLine *l1 = new TLine(0.1,0.1,0.9,0.1);
l1->SetLineColor(1); l1->SetLineWidth(1) ; l1->SetLineStyle(1) ; l1->Draw();
TLine *l2 = new TLine(0.1,0.2,0.9,0.2);
l2->SetLineColor(2); l2->SetLineWidth(2) ; l2->SetLineStyle(2) ; l2->Draw();
TLine *l3 = new TLine(0.1,0.3,0.9,0.3);
l3->SetLineColor(3); l3->SetLineWidth(3) ; l3->SetLineStyle(3) ; l3->Draw();
TLine *l4 = new TLine(0.1,0.4,0.9,0.4);
l4->SetLineColor(4); l4->SetLineWidth(4) ; l4->SetLineStyle(4) ; l4->Draw();
TLine *l5 = new TLine(0.1,0.5,0.9,0.5);
l5->SetLineColor(5); l5->SetLineWidth(5) ; l5->SetLineStyle(5) ; l5->Draw();
TLine *l6 = new TLine(0.1,0.6,0.9,0.6);
l6->SetLineColor(6); l6->SetLineWidth(6) ; l6->SetLineStyle(6) ; l6->Draw();
TLine *l7 = new TLine(0.1,0.7,0.9,0.7);
l7->SetLineColor(7); l7->SetLineWidth(7) ; l7->SetLineStyle(7) ; l7->Draw();
TLine *l8 = new TLine(0.1,0.8,0.9,0.8);
l8->SetLineColor(8); l8->SetLineWidth(8) ; l8->SetLineStyle(8) ; l8->Draw();
TLine *l9 = new TLine(0.1,0.9,0.9,0.9);
l9->SetLineColor(9); l9->SetLineWidth(9) ; l9->SetLineStyle(9) ; l9->Draw();
TestReport1(C, "TLine");
DoCcode(C);
TestReport2();
};
//______________________________________________________________________________
void tmarker()
{
// Test TMarker
TCanvas *C = StartTest(100,800);
C->Range(0,0,1,1);
C->SetFillColor(0);
C->SetBorderSize(2);
int i;
Double_t x = 0.5;
Double_t y = 0.1;
Double_t dy = 0.04;
for (i = 1; i<=7; i++) {
tmarker_draw(x, y, i, dy);
y = y+dy;
}
for (i = 20; i<=34; i++) {
tmarker_draw(x, y, i, dy);
y = y+dy;
}
TestReport1(C, "TMarker");
DoCcode(C);
TestReport2();
};
//______________________________________________________________________________
void tmarker_draw(Double_t x, Double_t y, Int_t mt, Double_t d)
{
// Auxiliary function used by "tmarker"
double dy=d/3;
TMarker *m = new TMarker(x+0.1, y, mt);
TText *t = new TText(x-0.1, y, Form("%d",mt));
TLine *l1 = new TLine(0,y,1,y);
TLine *l2 = new TLine(0,y+dy,1,y+dy);
TLine *l3 = new TLine(0,y-dy,1,y-dy);
l2->SetLineStyle(2);
l3->SetLineStyle(2);
m->SetMarkerSize(3.6);
m->SetMarkerColor(kRed);
t->SetTextAlign(32);
t->SetTextSize(0.3);
t->Draw();
l1->Draw();
l2->Draw();
l3->Draw();
m->Draw();
}
//______________________________________________________________________________
void tpolyline()
{
// Test TPolyLine
TCanvas *C = StartTest(700,500);
C->Range(0,30,11,650);
Double_t x[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Double_t y[10] = {200, 300, 300, 200, 200, 100, 10, 580, 10, 600};
TPolyLine *p = new TPolyLine(10,x,y);
p->SetLineWidth(3);
p->SetLineColor(2);
p->Draw("F");
p->Draw("");
TestReport1(C, "TPolyLine");
DoCcode(C);
TestReport2();
};
//______________________________________________________________________________
void patterns()
{
// Test Patterns
TCanvas *C = StartTest(700,900);
C->Range(0,0,1,1);
C->SetBorderSize(2);
C->SetFrameFillColor(0);
Double_t bh = 0.059;
Double_t db = 0.01;
Double_t y = 0.995;
Int_t i,j=3001;
for (i=1; i<=5; i++) {
patterns_box(j++, 0.01, y-bh, 0.19, y);
patterns_box(j++, 0.21, y-bh, 0.39, y);
patterns_box(j++, 0.41, y-bh, 0.59, y);
patterns_box(j++, 0.61, y-bh, 0.79, y);
patterns_box(j++, 0.81, y-bh, 0.99, y);
y = y-bh-db;
}
y = y-3*db;
gStyle->SetHatchesSpacing(2.0);
gStyle->SetHatchesLineWidth(3);
Int_t j1 = 3144;
Int_t j2 = 3305;
Int_t j3 = 3350;
Int_t j4 = 3490;
Int_t j5 = 3609;
for (i=1; i<=9; i++) {
if (i==6) {j2 += 10; j3 += 1; j4 += 1; j5 += 10;}
if (i==5) {j4 -= 10; j5 -= 1;}
patterns_box(j1, 0.01, y-bh, 0.19, y);
patterns_box(j2, 0.21, y-bh, 0.39, y);
patterns_box(j3, 0.41, y-bh, 0.59, y);
patterns_box(j4, 0.61, y-bh, 0.79, y);
patterns_box(j5, 0.81, y-bh, 0.99, y);
j1 += 100;
j2 += 10;
j3 += 1;
j4 -= 9;
j5 += 9;
y = y-bh-db;
}
TestReport1(C, "Fill patterns");
DoCcode(C);
TestReport2();
};
//______________________________________________________________________________
void patterns_box(Int_t pat, Double_t x1, Double_t y1, Double_t x2, Double_t y2)
{
// Auxiliary function used by "patterns"
TBox b;
b.SetFillColor(1);
b.SetFillStyle(pat);
b.DrawBox(x1,y1,x2,y2);
b.SetFillStyle(0);
b.DrawBox(x1,y1,x2,y2);
b.SetFillColor(0);
b.SetFillStyle(1000);
Double_t dx = (x2-x1)/3;
Double_t dy = (y2-y1)/3;
Double_t h = (y2-y1)/3;
b.DrawBox(x1+dx, y1+dy, x2-dx, y2-dy);
b.SetFillStyle(0);
b.DrawBox(x1+dx, y1+dy, x2-dx, y2-dy);
TLatex l;
l.SetTextAlign(22);
l.SetTextSize(h);
l.DrawLatex((x1+x2)/2, (y1+y2)/2, Form("%d",pat));
}
//______________________________________________________________________________
void ttext1()
{
// 1st TText test.
TCanvas *C = StartTest(900,500);
C->Range(0,0,1,1);
C->SetBorderSize(2);
C->SetFrameFillColor(0);
TLine *lv = new TLine(0.5,0.0,0.5,1.0);
lv->Draw();
for (float s=0.1; s<1.0 ; s+=0.1) {
TLine *lh = new TLine(0.,s,1.,s);
lh->Draw();
}
TText *tex1b = new TText(0.02,0.4,"jgabcdefhiklmnopqrstuvwxyz_{}");
// 161 is not a valid text font. This tests if the protection against
// invalid text font is working.
tex1b->SetTextFont(161);
tex1b->SetTextColor(2);
tex1b->SetTextAngle(0);
tex1b->SetTextAlign(11);
tex1b->SetTextSize(0.1);
tex1b->Draw();
TText *tex1 = new TText(0.5,0.1,"j0al {&`ag}_:^)Jj");
tex1->SetTextFont(41);
tex1->SetTextColor(2);
tex1->SetTextAngle( 0);
tex1->SetTextAlign(21);
tex1->SetTextSize(0.15);
tex1->Draw();
TText *tex2 = new TText(0.5,0.5,"j0Al {&`ag}_:^)Jj");
tex2->SetTextColor(3);
tex2->SetTextFont(21);
tex2->SetTextAlign(21);
tex2->SetTextSize(0.1);
tex2->Draw();
TText *tex3 = new TText(0.5,0.3,"j0Al {&`ag}_:^)Jj");
tex3->SetTextColor(4);
tex3->SetTextFont(31);
tex3->SetTextAlign(31);
tex3->SetTextSize(0.1);
tex3->Draw();
TText *tex4 = new TText(0.5,0.8,"j0Al {&`ag}_:^)Jj");
tex4->SetTextColor(5);
tex4->SetTextFont(71);
tex4->SetTextAlign(22);
tex4->SetTextSize(0.07);
tex4->Draw();
TText *tex5 = new TText(0.5,0.7,"13 j0Al {&`ag}_:^)Jj");
tex5->SetTextColor(6);
tex5->SetTextFont(51);
tex5->SetTextAlign(13);
tex5->SetTextSize(0.1);
tex5->Draw();
TestReport1(C, "TText 1 (Text attributes)");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void ttext2()
{
// 2nd TText test. A very long text string.
TCanvas *C = StartTest(600,600);
TText t(0.001,0.5,"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");
t.SetTextFont(42); t.SetTextSize(0.02);
t.Draw();
TestReport1(C, "TText 2 (A very long text string)");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void tlatex1()
{
// 1st TLatex test.
TCanvas *C = StartTest(600,700);
TLatex l;
l.SetTextAlign(12);
l.SetTextSize(0.04);
l.DrawLatex(0.1,0.9,"1) C(x) = d #sqrt{#frac{2}{#lambdaD}} #int^{x}_{0}cos(#frac{#pi}{2}t^{2})dt");
l.DrawLatex(0.1,0.7,"2) C(x) = d #sqrt{#frac{2}{#lambdaD}} #int^{x}cos(#frac{#pi}{2}t^{2})dt");
l.DrawLatex(0.1,0.5,"3) R = |A|^{2} = #frac{1}{2}#left(#[]{#frac{1}{2}+C(V)}^{2}+#[]{#frac{1}{2}+S(V)}^{2}#right)");
l.DrawLatex(0.1,0.3,"4) F(t) = #sum_{i=-#infty}^{#infty}A(i)cos#[]{#frac{i}{t+i}}");
l.DrawLatex(0.1,0.1,"5) {}_{3}^{7}Li");
TestReport1(C, "TLatex 1");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void tlatex2()
{
// 2nd TLatex test.
TCanvas *C = StartTest(700,500);
TLatex l;
l.SetTextAlign(23);
l.SetTextSize(0.1);
l.DrawLatex(0.5,0.95,"e^{+}e^{-}#rightarrowZ^{0}#rightarrowI#bar{I}, q#bar{q}");
l.DrawLatex(0.5,0.75,"|#vec{a}#bullet#vec{b}|=#Sigmaa^{i}_{jk}+b^{bj}_{i}");
l.DrawLatex(0.5,0.5,"i(#partial_{#mu}#bar{#psi}#gamma^{#mu}+m#bar{#psi})=0#Leftrightarrow(#Box+m^{2})#psi=0");
l.DrawLatex(0.5,0.3,"L_{em}=eJ^{#mu}_{em}A_{#mu} , ^{}J^{#mu}_{em}=#bar{I}#gamma_{#mu}I , M^{j}_{i}=#SigmaA_{#alpha}#tau^{#alphaj}_{i}");
TestReport1(C, "TLatex 2");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void tlatex3()
{
// 3rd TLatex test.
TCanvas *C = StartTest(700,500);
TPaveText pt(.05,.1,.95,.8);
pt.AddText("#frac{2s}{#pi#alpha^{2}} #frac{d#sigma}{dcos#theta} (e^{+}e^{-} #rightarrow f#bar{f} ) = \
#left| #frac{1}{1 - #Delta#alpha} #right|^{2} (1+cos^{2}#theta)");
pt.AddText("+ 4 Re #left{ #frac{2}{1 - #Delta#alpha} #chi(s) #[]{#hat{g}_{#nu}^{e}#hat{g}_{#nu}^{f} \
(1 + cos^{2}#theta) + 2 #hat{g}_{a}^{e}#hat{g}_{a}^{f} cos#theta) } #right}");
pt.AddText("+ 16#left|#chi(s)#right|^{2}\
#left[(#hat{g}_{a}^{e}^{2} + #hat{g}_{v}^{e}^{2})\
(#hat{g}_{a}^{f}^{2} + #hat{g}_{v}^{f}^{2})(1+cos^{2}#theta)\
+ 8 #hat{g}_{a}^{e} #hat{g}_{a}^{f} #hat{g}_{v}^{e} #hat{g}_{v}^{f}cos#theta#right] ");
pt.SetLabel("Born equation");
pt.Draw();
TestReport1(C, "TLatex 3 (TLatex in TPaveText)");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void tlatex4()
{
// 4th TLatex test.
TCanvas *C = StartTest(600,700);
TLatex l;
l.SetTextSize(0.03);
l.SetTextAlign(22);
l.DrawLatex(0.165, 0.95, "Lower case");
l.DrawLatex(0.495, 0.95, "Upper case");
l.DrawLatex(0.825, 0.95, "Variations");
l.SetTextAlign(12);
float y, x1, x2;
y = 0.90; x1 = 0.07; x2 = x1+0.2;
l.DrawLatex(x1, y, "alpha : ") ; l.DrawLatex(x2, y, "#alpha");
y -= 0.0375 ; l.DrawLatex(x1, y, "beta : ") ; l.DrawLatex(x2, y, "#beta");
y -= 0.0375 ; l.DrawLatex(x1, y, "gamma : ") ; l.DrawLatex(x2, y, "#gamma");
y -= 0.0375 ; l.DrawLatex(x1, y, "delta : ") ; l.DrawLatex(x2, y, "#delta");
y -= 0.0375 ; l.DrawLatex(x1, y, "epsilon : ") ; l.DrawLatex(x2, y, "#epsilon");
y -= 0.0375 ; l.DrawLatex(x1, y, "zeta : ") ; l.DrawLatex(x2, y, "#zeta");
y -= 0.0375 ; l.DrawLatex(x1, y, "eta : ") ; l.DrawLatex(x2, y, "#eta");
y -= 0.0375 ; l.DrawLatex(x1, y, "theta : ") ; l.DrawLatex(x2, y, "#theta");
y -= 0.0375 ; l.DrawLatex(x1, y, "iota : ") ; l.DrawLatex(x2, y, "#iota");
y -= 0.0375 ; l.DrawLatex(x1, y, "kappa : ") ; l.DrawLatex(x2, y, "#kappa");
y -= 0.0375 ; l.DrawLatex(x1, y, "lambda : ") ; l.DrawLatex(x2, y, "#lambda");
y -= 0.0375 ; l.DrawLatex(x1, y, "mu : ") ; l.DrawLatex(x2, y, "#mu");
y -= 0.0375 ; l.DrawLatex(x1, y, "nu : ") ; l.DrawLatex(x2, y, "#nu");
y -= 0.0375 ; l.DrawLatex(x1, y, "xi : ") ; l.DrawLatex(x2, y, "#xi");
y -= 0.0375 ; l.DrawLatex(x1, y, "omicron : ") ; l.DrawLatex(x2, y, "#omicron");
y -= 0.0375 ; l.DrawLatex(x1, y, "pi : ") ; l.DrawLatex(x2, y, "#pi");
y -= 0.0375 ; l.DrawLatex(x1, y, "rho : ") ; l.DrawLatex(x2, y, "#rho");
y -= 0.0375 ; l.DrawLatex(x1, y, "sigma : ") ; l.DrawLatex(x2, y, "#sigma");
y -= 0.0375 ; l.DrawLatex(x1, y, "tau : ") ; l.DrawLatex(x2, y, "#tau");
y -= 0.0375 ; l.DrawLatex(x1, y, "upsilon : ") ; l.DrawLatex(x2, y, "#upsilon");
y -= 0.0375 ; l.DrawLatex(x1, y, "phi : ") ; l.DrawLatex(x2, y, "#phi");
y -= 0.0375 ; l.DrawLatex(x1, y, "chi : ") ; l.DrawLatex(x2, y, "#chi");
y -= 0.0375 ; l.DrawLatex(x1, y, "psi : ") ; l.DrawLatex(x2, y, "#psi");
y -= 0.0375 ; l.DrawLatex(x1, y, "omega : ") ; l.DrawLatex(x2, y, "#omega");
y = 0.90; x1 = 0.40; x2 = x1+0.2;
l.DrawLatex(x1, y, "Alpha : ") ; l.DrawLatex(x2, y, "#Alpha");
y -= 0.0375 ; l.DrawLatex(x1, y, "Beta : ") ; l.DrawLatex(x2, y, "#Beta");
y -= 0.0375 ; l.DrawLatex(x1, y, "Gamma : ") ; l.DrawLatex(x2, y, "#Gamma");
y -= 0.0375 ; l.DrawLatex(x1, y, "Delta : ") ; l.DrawLatex(x2, y, "#Delta");
y -= 0.0375 ; l.DrawLatex(x1, y, "Epsilon : ") ; l.DrawLatex(x2, y, "#Epsilon");
y -= 0.0375 ; l.DrawLatex(x1, y, "Zeta : ") ; l.DrawLatex(x2, y, "#Zeta");
y -= 0.0375 ; l.DrawLatex(x1, y, "Eta : ") ; l.DrawLatex(x2, y, "#Eta");
y -= 0.0375 ; l.DrawLatex(x1, y, "Theta : ") ; l.DrawLatex(x2, y, "#Theta");
y -= 0.0375 ; l.DrawLatex(x1, y, "Iota : ") ; l.DrawLatex(x2, y, "#Iota");
y -= 0.0375 ; l.DrawLatex(x1, y, "Kappa : ") ; l.DrawLatex(x2, y, "#Kappa");
y -= 0.0375 ; l.DrawLatex(x1, y, "Lambda : ") ; l.DrawLatex(x2, y, "#Lambda");
y -= 0.0375 ; l.DrawLatex(x1, y, "Mu : ") ; l.DrawLatex(x2, y, "#Mu");
y -= 0.0375 ; l.DrawLatex(x1, y, "Nu : ") ; l.DrawLatex(x2, y, "#Nu");
y -= 0.0375 ; l.DrawLatex(x1, y, "Xi : ") ; l.DrawLatex(x2, y, "#Xi");
y -= 0.0375 ; l.DrawLatex(x1, y, "Omicron : ") ; l.DrawLatex(x2, y, "#Omicron");
y -= 0.0375 ; l.DrawLatex(x1, y, "Pi : ") ; l.DrawLatex(x2, y, "#Pi");
y -= 0.0375 ; l.DrawLatex(x1, y, "Rho : ") ; l.DrawLatex(x2, y, "#Rho");
y -= 0.0375 ; l.DrawLatex(x1, y, "Sigma : ") ; l.DrawLatex(x2, y, "#Sigma");
y -= 0.0375 ; l.DrawLatex(x1, y, "Tau : ") ; l.DrawLatex(x2, y, "#Tau");
y -= 0.0375 ; l.DrawLatex(x1, y, "Upsilon : ") ; l.DrawLatex(x2, y, "#Upsilon");
y -= 0.0375 ; l.DrawLatex(x1, y, "Phi : ") ; l.DrawLatex(x2, y, "#Phi");
y -= 0.0375 ; l.DrawLatex(x1, y, "Chi : ") ; l.DrawLatex(x2, y, "#Chi");
y -= 0.0375 ; l.DrawLatex(x1, y, "Psi : ") ; l.DrawLatex(x2, y, "#Psi");
y -= 0.0375 ; l.DrawLatex(x1, y, "Omega : ") ; l.DrawLatex(x2, y, "#Omega");
x1 = 0.73; x2 = x1+0.2;
y = 0.7500 ; l.DrawLatex(x1, y, "varepsilon : ") ; l.DrawLatex(x2, y, "#varepsilon");
y = 0.6375 ; l.DrawLatex(x1, y, "vartheta : ") ; l.DrawLatex(x2, y, "#vartheta");
y = 0.2625 ; l.DrawLatex(x1, y, "varsigma : ") ; l.DrawLatex(x2, y, "#varsigma");
y = 0.1875 ; l.DrawLatex(x1, y, "varUpsilon : ") ; l.DrawLatex(x2, y, "#varUpsilon");
y = 0.1500 ; l.DrawLatex(x1, y, "varphi : ") ; l.DrawLatex(x2, y, "#varphi");
y = 0.0375 ; l.DrawLatex(x1, y, "varomega : ") ; l.DrawLatex(x2, y, "#varomega");
TestReport1(C, "TLatex 4 (Greek letters)");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void tlatex5()
{
// 5th TLatex test.
TCanvas *C = StartTest(600,600);
TLatex l;
l.SetTextSize(0.03);
l.SetTextAlign(12);
float y, step, x1, x2;
y = 0.96; step = 0.0465; x1 = 0.02; x2 = x1+0.04;
l.DrawLatex(x1, y, "#club") ; l.DrawText(x2, y, "#club");
y -= step ; l.DrawLatex(x1, y, "#voidn") ; l.DrawText(x2, y, "#voidn");
y -= step ; l.DrawLatex(x1, y, "#leq") ; l.DrawText(x2, y, "#leq");
y -= step ; l.DrawLatex(x1, y, "#approx") ; l.DrawText(x2, y, "#approx");
y -= step ; l.DrawLatex(x1, y, "#in") ; l.DrawText(x2, y, "#in");
y -= step ; l.DrawLatex(x1, y, "#supset") ; l.DrawText(x2, y, "#supset");
y -= step ; l.DrawLatex(x1, y, "#cap") ; l.DrawText(x2, y, "#cap");
y -= step ; l.DrawLatex(x1, y, "#ocopyright") ; l.DrawText(x2, y, "#ocopyright");
y -= step ; l.DrawLatex(x1, y, "#trademark") ; l.DrawText(x2, y, "#trademark");
y -= step ; l.DrawLatex(x1, y, "#times") ; l.DrawText(x2, y, "#times");
y -= step ; l.DrawLatex(x1, y, "#bullet") ; l.DrawText(x2, y, "#bullet");
y -= step ; l.DrawLatex(x1, y, "#voidb") ; l.DrawText(x2, y, "#voidb");
y -= step ; l.DrawLatex(x1, y, "#doublequote") ; l.DrawText(x2, y, "#doublequote");
y -= step ; l.DrawLatex(x1, y, "#lbar") ; l.DrawText(x2, y, "#lbar");
y -= step ; l.DrawLatex(x1, y, "#arcbottom") ; l.DrawText(x2, y, "#arcbottom");
y -= step ; l.DrawLatex(x1, y, "#downarrow") ; l.DrawText(x2, y, "#downarrow");
y -= step ; l.DrawLatex(x1, y, "#leftrightarrow") ; l.DrawText(x2, y, "#leftrightarrow");
y -= step ; l.DrawLatex(x1, y, "#Downarrow") ; l.DrawText(x2, y, "#Downarrow");
y -= step ; l.DrawLatex(x1, y, "#Leftrightarrow") ; l.DrawText(x2, y, "#Leftrightarrow");
y -= step ; l.DrawLatex(x1, y, "#void8") ; l.DrawText(x2, y, "#void8");
y -= step ; l.DrawLatex(x1, y, "#hbar") ; l.DrawText(x2, y, "#hbar");
y = 0.96; step = 0.0465; x1 = 0.27; x2 = x1+0.04;
l.DrawLatex(x1, y, "#diamond") ; l.DrawText(x2, y, "#diamond");
y -= step ; l.DrawLatex(x1, y, "#aleph") ; l.DrawText(x2, y, "#aleph");
y -= step ; l.DrawLatex(x1, y, "#geq") ; l.DrawText(x2, y, "#geq");
y -= step ; l.DrawLatex(x1, y, "#neq") ; l.DrawText(x2, y, "#neq");
y -= step ; l.DrawLatex(x1, y, "#notin") ; l.DrawText(x2, y, "#notin");
y -= step ; l.DrawLatex(x1, y, "#subseteq") ; l.DrawText(x2, y, "#subseteq");
y -= step ; l.DrawLatex(x1, y, "#cup") ; l.DrawText(x2, y, "#cup");
y -= step ; l.DrawLatex(x1, y, "#copyright") ; l.DrawText(x2, y, "#copyright");
y -= step ; l.DrawLatex(x1, y, "#void3") ; l.DrawText(x2, y, "#void3");
y -= step ; l.DrawLatex(x1, y, "#divide") ; l.DrawText(x2, y, "#divide");
y -= step ; l.DrawLatex(x1, y, "#circ") ; l.DrawText(x2, y, "#circ");
y -= step ; l.DrawLatex(x1, y, "#infty") ; l.DrawText(x2, y, "#infty");
y -= step ; l.DrawLatex(x1, y, "#angle") ; l.DrawText(x2, y, "#angle");
y -= step ; l.DrawLatex(x1, y, "#cbar") ; l.DrawText(x2, y, "#cbar");
y -= step ; l.DrawLatex(x1, y, "#arctop") ; l.DrawText(x2, y, "#arctop");
y -= step ; l.DrawLatex(x1, y, "#leftarrow") ; l.DrawText(x2, y, "#leftarrow");
y -= step ; l.DrawLatex(x1, y, "#otimes") ; l.DrawText(x2, y, "#otimes");
y -= step ; l.DrawLatex(x1, y, "#Leftarrow") ; l.DrawText(x2, y, "#Leftarrow");
y -= step ; l.DrawLatex(x1, y, "#prod") ; l.DrawText(x2, y, "#prod");
y -= step ; l.DrawLatex(x1, y, "#Box") ; l.DrawText(x2, y, "#Box");
y -= step ; l.DrawLatex(x1, y, "#parallel") ; l.DrawText(x2, y, "#parallel");
y = 0.96; step = 0.0465; x1 = 0.52; x2 = x1+0.04;
l.DrawLatex(x1, y, "#heart") ; l.DrawText(x2, y, "#heart");
y -= step ; l.DrawLatex(x1, y, "#Jgothic") ; l.DrawText(x2, y, "#Jgothic");
y -= step ; l.DrawLatex(x1, y, "#LT") ; l.DrawText(x2, y, "#LT");
y -= step ; l.DrawLatex(x1, y, "#equiv") ; l.DrawText(x2, y, "#equiv");
y -= step ; l.DrawLatex(x1, y, "#subset") ; l.DrawText(x2, y, "#subset");
y -= step ; l.DrawLatex(x1, y, "#supseteq") ; l.DrawText(x2, y, "#supseteq");
y -= step ; l.DrawLatex(x1, y, "#wedge") ; l.DrawText(x2, y, "#wedge");
y -= step ; l.DrawLatex(x1, y, "#oright") ; l.DrawText(x2, y, "#oright");
y -= step ; l.DrawLatex(x1, y, "#AA") ; l.DrawText(x2, y, "#AA");
y -= step ; l.DrawLatex(x1, y, "#pm") ; l.DrawText(x2, y, "#pm");
y -= step ; l.DrawLatex(x1, y, "#3dots") ; l.DrawText(x2, y, "#3dots");
y -= step ; l.DrawLatex(x1, y, "#nabla") ; l.DrawText(x2, y, "#nabla");
y -= step ; l.DrawLatex(x1, y, "#downleftarrow") ; l.DrawText(x2, y, "#downleftarrow");
y -= step ; l.DrawLatex(x1, y, "#topbar") ; l.DrawText(x2, y, "#topbar");
y -= step ; l.DrawLatex(x1, y, "#arcbar") ; l.DrawText(x2, y, "#arcbar");
y -= step ; l.DrawLatex(x1, y, "#uparrow") ; l.DrawText(x2, y, "#uparrow");
y -= step ; l.DrawLatex(x1, y, "#oplus") ; l.DrawText(x2, y, "#oplus");
y -= step ; l.DrawLatex(x1, y, "#Uparrow") ; l.DrawText(x2, y, "#Uparrow");
y -= step ; l.DrawLatex(x1, y-0.01, "#sum") ; l.DrawText(x2, y, "#sum");
y -= step ; l.DrawLatex(x1, y, "#perp") ; l.DrawText(x2, y, "#perp");
y = 0.96; step = 0.0465; x1 = 0.77; x2 = x1+0.04;
l.DrawLatex(x1, y, "#spade") ; l.DrawText(x2, y, "#spade");
y -= step ; l.DrawLatex(x1, y, "#Rgothic") ; l.DrawText(x2, y, "#Rgothic");
y -= step ; l.DrawLatex(x1, y, "#GT") ; l.DrawText(x2, y, "#GT");
y -= step ; l.DrawLatex(x1, y, "#propto") ; l.DrawText(x2, y, "#propto");
y -= step ; l.DrawLatex(x1, y, "#notsubset") ; l.DrawText(x2, y, "#notsubset");
y -= step ; l.DrawLatex(x1, y, "#oslash") ; l.DrawText(x2, y, "#oslash");
y -= step ; l.DrawLatex(x1, y, "#vee") ; l.DrawText(x2, y, "#vee");
y -= step ; l.DrawLatex(x1, y, "#void1") ; l.DrawText(x2, y, "#void1");
y -= step ; l.DrawLatex(x1, y, "#aa") ; l.DrawText(x2, y, "#aa");
y -= step ; l.DrawLatex(x1, y, "#/") ; l.DrawText(x2, y, "#/");
y -= step ; l.DrawLatex(x1, y, "#upoint") ; l.DrawText(x2, y, "#upoint");
y -= step ; l.DrawLatex(x1, y, "#partial") ; l.DrawText(x2, y, "#partial");
y -= step ; l.DrawLatex(x1, y, "#corner") ; l.DrawText(x2, y, "#corner");
y -= step ; l.DrawLatex(x1, y, "#ltbar") ; l.DrawText(x2, y, "#ltbar");
y -= step ; l.DrawLatex(x1, y, "#bottombar") ; l.DrawText(x2, y, "#bottombar");
y -= step ; l.DrawLatex(x1, y, "#rightarrow") ; l.DrawText(x2, y, "#rightarrow");
y -= step ; l.DrawLatex(x1, y, "#surd") ; l.DrawText(x2, y, "#surd");
y -= step ; l.DrawLatex(x1, y, "#Rightarrow") ; l.DrawText(x2, y, "#Rightarrow");
y -= step ; l.DrawLatex(x1, y-0.015, "#int") ; l.DrawText(x2, y, "#int");
y -= step ; l.DrawLatex(x1, y, "#odot") ; l.DrawText(x2, y, "#odot");
TestReport1(C, "TLatex 5 (Mathematical Symbols)");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void kerning()
{
// Text kerning.
TCanvas *C = StartTest(1000, 700);
for (Int_t i = 0;i < 25;i++) {
TLine *ln = new TLine(0, 0.04 * (i - 0.2), 1, 0.04 * (i - 0.2));
ln->Draw();
Float_t sz = 0.0016 * i;
TLatex *l = new TLatex(0.10, 0.04 * i, "AVAVAVAVAVAVAVAVAVAVAVAVAVAVAVAVAVAVA#color[2]{X}");
l->SetTextSize(sz);
l->Draw();
TLatex *l1 = new TLatex(0.05, 0.04 * i, Form("%g", sz));
l1->SetTextSize(0.02);
l1->Draw();
}
TestReport1(C, "Text kerning");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void itbf()
{
// TLatex commands #kern, #lower, #it and #bf
TCanvas *C = StartTest(700, 500);
gStyle->SetTextFont(132);
(new TLatex(0.01, 0.9, "Positive k#kern[0.3]{e}#kern[0.3]{r}#kern[0.3]{n}#kern[0.3]{i}#kern[0.3]{n}#kern[0.3]{g} with #^{}kern[0.3]"))->Draw();
(new TLatex(0.01, 0.7, "Negative k#kern[-0.3]{e}#kern[-0.3]{r}#kern[-0.3]{n}#kern[-0.3]{i}#kern[-0.3]{n}#kern[-0.3]{g} with #^{}kern[-0.3]"))->Draw();
(new TLatex(0.01, 0.5, "Vertical a#lower[0.2]{d}#lower[0.4]{j}#lower[0.1]{u}#lower[-0.1]{s}#lower[-0.3]{t}#lower[-0.4]{m}#lower[-0.2]{e}#lower[0.1]{n}t with #^{}lower[-0.4...+0.4]"))->Draw();
(new TLatex(0.01, 0.3, "Font styles: #^{}bf{#bf{bold}}, #^{}it{#it{italic}}, #^{}bf{#^{}it{#bf{#it{bold italic}}}}, #^{}bf{#^{}bf{#bf{#bf{unbold}}}}"))->Draw();
(new TLatex(0.01, 0.1, "Font styles: abc#alpha#beta#gamma, #^{}it{#it{abc#alpha#beta#gamma}}, #^{}it{#^{}it{#it{#it{abc#alpha#beta#gamma}}}}"))->Draw();
TestReport1(C, "TLatex commands #kern, #lower, #it and #bf");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void transpad()
{
// Transparent pad.
TCanvas *C = StartTest(700,500);
TPad *pad1 = new TPad("pad1","",0,0,1,1);
TPad *pad2 = new TPad("pad2","",0,0,1,1);
pad2->SetFillStyle(4000); //will be transparent
pad1->Draw();
pad1->cd();
TH1F *ht1 = new TH1F("ht1","ht1",100,-3,3);
TH1F *ht2 = new TH1F("ht2","ht2",100,-3,3);
TRandom r;
for (Int_t i=0;i<100000;i++) {
Double_t x1 = r.Gaus(-1,0.5);
Double_t x2 = r.Gaus(1,1.5);
if (i <1000) ht1->Fill(x1);
ht2->Fill(x2);
}
ht1->Draw();
pad1->Update(); //this will force the generation of the "stats" box
TPaveStats *ps1 = (TPaveStats*)ht1->GetListOfFunctions()->FindObject("stats");
ps1->SetX1NDC(0.4); ps1->SetX2NDC(0.6);
pad1->Modified();
C->cd();
//compute the pad range with suitable margins
Double_t ymin = 0;
Double_t ymax = 2000;
Double_t dy = (ymax-ymin)/0.8; //10 per cent margins top and bottom
Double_t xmin = -3;
Double_t xmax = 3;
Double_t dx = (xmax-xmin)/0.8; //10 per cent margins left and right
pad2->Range(xmin-0.1*dx,ymin-0.1*dy,xmax+0.1*dx,ymax+0.1*dy);
pad2->Draw();
pad2->cd();
ht2->SetLineColor(kRed);
ht2->Draw("][sames");
pad2->Update();
TPaveStats *ps2 = (TPaveStats*)ht2->GetListOfFunctions()->FindObject("stats");
ps2->SetX1NDC(0.65); ps2->SetX2NDC(0.85);
ps2->SetTextColor(kRed);
// draw axis on the right side of the pad
TGaxis *axis = new TGaxis(xmax,ymin,xmax,ymax,ymin,ymax,50510,"+L");
axis->SetLabelColor(kRed);
axis->Draw();
TestReport1(C, "Transparent pad");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void statfitparam ()
{
// Stat and fit parameters with errors.
TCanvas *C = StartTest(800,500);
C->Divide(3,2);
gStyle->SetOptFit(1111);
gStyle->SetOptStat(111111);
gStyle->SetStatW(0.43);
gStyle->SetStatH(0.35);
TH1 *hsf1 = new TH1F("hsf1","hsf1", 2,0.,1.);
TH1 *hsf2 = new TH1F("hsf2","hsf2", 2,0.,1.);
TH1 *hsf3 = new TH1F("hsf3","hsf3", 2,0.,1.);
TH1 *hsf4 = new TH1F("hsf4","hsf4", 2,0.,1.);
TH1 *hsf5 = new TH1F("hsf5","hsf5", 2,0.,1.);
C->cd(1);
hsf1->SetBinContent (1, 5.3E5); hsf1->SetBinError (1, 0.9);
hsf1->SetBinContent (2, 5.3E5); hsf1->SetBinError (2, 0.1);
hsf1->Fit("pol0","Q");
C->cd(2);
hsf2->SetBinContent (1, 5.0E15); hsf2->SetBinError (1, 4.9E15);
hsf2->SetBinContent (2, 5.0E15); hsf2->SetBinError (2, 4.9E11);
hsf2->Fit("pol0","Q");
C->cd(3);
hsf3->SetBinContent (1, 5.0E-15); hsf3->SetBinError (1, 4.9E-15);
hsf3->SetBinContent (2, 5.0E-15); hsf3->SetBinError (2, 4.9E-11);
hsf3->Fit("pol0","Q");
C->cd(4);
hsf4->SetBinContent (1, 5); hsf4->SetBinError (1, 3);
hsf4->SetBinContent (2, 5); hsf4->SetBinError (2, 1);
hsf4->Fit("pol0","Q");
C->cd(5);
hsf5->SetBinContent (1, 5.3); hsf5->SetBinError (1, 0.9);
hsf5->SetBinContent (2, 5.3); hsf5->SetBinError (2, 0.1);
hsf5->Fit("pol0","Q");
C->cd(6);
TPaveText *pt = new TPaveText(0.02,0.2,0.98,0.8,"brNDC");
pt->SetFillColor(18);
pt->SetTextAlign(12);
pt->AddText("This example test all the possible cases");
pt->AddText("handled by ThistPainter::GetBestFormat.");
pt->AddText("This method returns the best format to");
pt->AddText("paint the fit parameters errors.");
pt->Draw();
TestReport1(C, "Stat and fit parameters with errors");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void tgaxis1()
{
// 1st TGaxis test.
TCanvas *C = StartTest(700,500);
C->Range(-10,-1,10,1);
TGaxis *axis1 = new TGaxis(-4.5,-0.2,5.5,-0.2,-6,8,510,"");
axis1->SetName("axis1");
axis1->Draw();
TGaxis *axis2 = new TGaxis(-4.5,0.2,5.5,0.2,0.001,10000,510,"G");
axis2->SetName("axis2");
axis2->Draw();
TGaxis *axis3 = new TGaxis(-9,-0.8,-9,0.8,-8,8,50510,"");
axis3->SetName("axis3");
axis3->SetTitle("axis3");
axis3->SetTitleOffset(0.5);
axis3->Draw();
TGaxis *axis4 = new TGaxis(-7,-0.8,-7,0.8,1,10000,50510,"G");
axis4->SetName("axis4");
axis4->SetTitle("axis4");
axis4->Draw();
TGaxis *axis5 = new TGaxis(-4.5,-0.6,5.5,-0.6,1.2,1.32,80506,"-+");
axis5->SetName("axis5");
axis5->SetLabelSize(0.03);
axis5->SetTextFont(72);
axis5->Draw();
TGaxis *axis6 = new TGaxis(-4.5,0.5,5.5,0.5,100,900,50510,"-");
axis6->SetName("axis6");
axis6->Draw();
TGaxis *axis6a = new TGaxis(-5.5,0.85,5.5,0.85,0,4.3e-6,510,"");
axis6a->SetName("axis6a");
axis6a->Draw();
TGaxis *axis7 = new TGaxis(8,-0.8,8,0.8,0,9000,50510,"+L");
axis7->SetName("axis7");
axis7->Draw();
TGaxis *axis8 = new TGaxis(6.5,0.8,6.499,-0.8,0,90,50510,"-");
axis8->SetName("axis8");
axis8->Draw();
TestReport1(C, "TGaxis 1");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void tgaxis2()
{
// 2nd TGaxis test.
TCanvas *C = StartTest(600,700);
C->Range(-10,-1,10,1);
TGaxis *axis1 = new TGaxis(-5,-0.2,6,-0.2,-6,8,510,"");
axis1->SetName("axis1");
axis1->Draw();
TGaxis *axis2 = new TGaxis(-5,0.2,6,0.2,0.001,10000,510,"G");
axis2->SetName("axis2");
axis2->Draw();
TGaxis *axis3 = new TGaxis(-9,-0.8,-9,0.8,-8,8,50510,"");
axis3->SetName("axis3");
axis3->Draw();
TGaxis *axis4 = new TGaxis(-7,-0.8,-7,0.8,1,10000,50510,"G");
axis4->SetName("axis4");
axis4->Draw();
TGaxis *axis5 = new TGaxis(-5,-0.6,6,-0.6,1.2,1.32,80506,"-+");
axis5->SetName("axis5");
axis5->SetLabelSize(0.03);
axis5->SetTextFont(72);
axis5->SetLabelOffset(0.025);
axis5->Draw();
TGaxis *axis6 = new TGaxis(-5,0.6,6,0.6,100,900,50510,"-");
axis6->SetName("axis6");
axis6->Draw();
TGaxis *axis7 = new TGaxis(8,-0.8,8,0.8,0,9000,50510,"+L");
axis7->SetName("axis7");
axis7->SetLabelOffset(0.01);
axis7->Draw();
TestReport1(C, "TGaxis 2");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void tgaxis3()
{
// 3rd TGaxis test.
TCanvas *C = StartTest(700,900);
time_t script_time;
script_time = time(0);
script_time = 3600*(int)(script_time/3600);
gStyle->SetTimeOffset(script_time);
C->Divide(1,3);
C->SetFillColor(28);
int i;
gStyle->SetTitleH(0.08);
float noise;
TH1F *ht = new TH1F("ht","Love at first sight",3000,0.,2000.);
for (i=1;i<3000;i++) {
noise = gRandom->Gaus(0,120);
if (i>700) {
noise += 1000*sin((i-700)*6.28/30)*exp((double)(700-i)/300);
}
ht->SetBinContent(i,noise);
}
C->cd(1);
ht->SetLineColor(2);
ht->GetXaxis()->SetLabelSize(0.05);
ht->Draw();
ht->GetXaxis()->SetTimeDisplay(1);
float x[100], t[100];
for (i=0;i<100;i++) {
x[i] = sin(i*4*3.1415926/50)*exp(-(double)i/20);
t[i] = 6000+(double)i/20;
}
TGraph *gt = new TGraph(100,t,x);
gt->SetTitle("Politics");
C->cd(2);
gt->SetFillColor(19);
gt->SetLineColor(5);
gt->SetLineWidth(2);
gt->Draw("AL");
gt->GetXaxis()->SetLabelSize(0.05);
gt->GetXaxis()->SetTimeDisplay(1);
gPad->Modified();
float x2[10], t2[10];
for (i=0;i<10;i++) {
x2[i] = gRandom->Gaus(500,100)*i;
t2[i] = i*365*86400;
}
TGraph *gt2 = new TGraph(10,t2,x2);
gt2->SetTitle("Number of monkeys on the moon");
C->cd(3);
gt2->SetFillColor(19);
gt2->SetMarkerColor(4);
gt2->SetMarkerStyle(29);
gt2->SetMarkerSize(1.3);
gt2->Draw("AP");
gt2->GetXaxis()->SetLabelSize(0.05);
gt2->GetXaxis()->SetTimeDisplay(1);
gt2->GetXaxis()->SetTimeFormat("y. %Y");
TestReport1(C, "TGaxis 3 (Time on axis)");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void tgaxis4()
{
// 4th TGaxis test.
TCanvas *C = StartTest(600,700);
TDatime T0(2003,1,1,0,0,0);
int X0 = T0.Convert();
gStyle->SetTimeOffset(X0);
TDatime T1(2002,9,23,0,0,0);
int X1 = T1.Convert()-X0;
TDatime T2(2003,3,7,0,0,0);
int X2 = T2.Convert()-X0;
TH1F * h1 = new TH1F("h1","test",100,X1,X2);
TRandom r;
for (Int_t i=0;i<30000;i++) {
Double_t noise = r.Gaus(0.5*(X1+X2),0.1*(X2-X1));
h1->Fill(noise);
}
h1->GetXaxis()->SetTimeDisplay(1);
h1->GetXaxis()->SetLabelSize(0.03);
h1->GetXaxis()->SetTimeFormat("%Y:%m:%d");
h1->Draw();
TestReport1(C, "TGaxis 4 (Time on axis)");
DoCcode(C);
TestReport2();
delete h1;
}
//______________________________________________________________________________
void labels1()
{
// Alphanumeric labels in a 1-d histogram
TCanvas *C = StartTest(900,500);
const Int_t nx = 20;
C->SetGrid();
C->SetBottomMargin(0.15);
TH1F *hlab1 = new TH1F("hlab1","hlab1",nx,0,nx);
hlab1->SetFillColor(38);
for (Int_t i=0;i<5000;i++) {
hlab1->Fill(gRandom->Gaus(0.5*nx,0.2*nx));
}
hlab1->SetStats(0);
TAxis *xa = hlab1->GetXaxis();
xa->SetBinLabel( 1, "Jean");
xa->SetBinLabel( 2, "Pierre");
xa->SetBinLabel( 3, "Marie");
xa->SetBinLabel( 4, "Odile");
xa->SetBinLabel( 5, "Sebastien");
xa->SetBinLabel( 6, "Fons");
xa->SetBinLabel( 7, "Rene");
xa->SetBinLabel( 8, "Nicolas");
xa->SetBinLabel( 9, "Xavier");
xa->SetBinLabel(10, "Greg");
xa->SetBinLabel(11, "Bjarne");
xa->SetBinLabel(12, "Anton");
xa->SetBinLabel(13, "Otto");
xa->SetBinLabel(14, "Eddy");
xa->SetBinLabel(15, "Peter");
xa->SetBinLabel(16, "Pasha");
xa->SetBinLabel(17, "Philippe");
xa->SetBinLabel(18, "Suzanne");
xa->SetBinLabel(19, "Jeff");
xa->SetBinLabel(20, "Valery");
hlab1->Draw();
TPaveText *pt = new TPaveText(0.6,0.7,0.98,0.98,"brNDC");
pt->SetFillColor(18);
pt->SetTextAlign(12);
pt->AddText("Use the axis Context Menu LabelsOption");
pt->AddText(" \"a\" to sort by alphabetic order");
pt->AddText(" \">\" to sort by decreasing vakues");
pt->AddText(" \"<\" to sort by increasing vakues");
pt->Draw();
TestReport1(C, "Alphanumeric labels in a 1-d histogram");
DoCcode(C);
TestReport2();
delete hlab1;
}
//______________________________________________________________________________
void tellipse()
{
// TEllipse test.
TCanvas *C = StartTest(700,800);
C->Range(0,0,1,1);
TPaveLabel pel(0.1,0.8,0.9,0.95,"Examples of Ellipses");
pel.SetFillColor(42);
pel.Draw();
TEllipse el1(0.25,0.25,.1,.2);
el1.Draw();
el1.SetFillStyle(0);
TEllipse el2(0.25,0.6,.2,.1);
el2.SetFillColor(6);
el2.SetFillStyle(3008);
el2.Draw();
TEllipse el3(0.75,0.6,.2,.1,45,315);
el3.SetFillColor(2);
el3.SetFillStyle(1001);
el3.SetLineColor(4);
el3.Draw();
TEllipse el4(0.75,0.25,.2,.15,45,315,62);
el4.SetFillColor(5);
el4.SetFillStyle(1001);
el4.SetLineColor(4);
el4.SetLineWidth(6);
el4.Draw();
TestReport1(C, "TEllipse");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void feynman()
{
// Feynman diagrams test.
TCanvas *C = StartTest(600,300);
C->Range(0, 0, 140, 60);
Int_t linsav = gStyle->GetLineWidth();
gStyle->SetLineWidth(3);
TLatex t;
t.SetTextAlign(22);
t.SetTextSize(0.1);
TLine * l;
l = new TLine(10, 10, 30, 30); l->Draw();
l = new TLine(10, 50, 30, 30); l->Draw();
TCurlyArc *ginit = new TCurlyArc(30, 30, 12.5*TMath::Sqrt(2), 135, 225);
ginit->SetWavy();
ginit->Draw();
t.DrawLatex(7,6,"e^{-}");
t.DrawLatex(7,55,"e^{+}");
t.DrawLatex(7,30,"#gamma");
TCurlyLine *gamma = new TCurlyLine(30, 30, 55, 30);
gamma->SetWavy();
gamma->Draw();
t.DrawLatex(42.5,37.7,"#gamma");
TArc *a = new TArc(70, 30, 15);
a->Draw();
a->SetFillStyle(0);
t.DrawLatex(55, 45,"#bar{q}");
t.DrawLatex(85, 15,"q");
TCurlyLine *gluon = new TCurlyLine(70, 45, 70, 15);
gluon->Draw();
t.DrawLatex(77.5,30,"g");
TCurlyLine *z0 = new TCurlyLine(85, 30, 110, 30);
z0->SetWavy();
z0->Draw();
t.DrawLatex(100, 37.5,"Z^{0}");
l = new TLine(110, 30, 130, 10); l->Draw();
l = new TLine(110, 30, 130, 50); l->Draw();
TCurlyArc *gluon1 = new TCurlyArc(110, 30, 12.5*TMath::Sqrt(2), 315, 45);
gluon1->Draw();
t.DrawLatex(135,6,"#bar{q}");
t.DrawLatex(135,55,"q");
t.DrawLatex(135,30,"g");
C->Update();
gStyle->SetLineWidth(linsav);
TestReport1(C, "Feynman diagrams");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void tgraph1()
{
// 1st TGraph test.
TCanvas *C = StartTest(700,500);
C->SetFillColor(42);
C->SetGrid();
const Int_t n = 20;
Double_t x[n], y[n];
for (Int_t i=0;i<n;i++) {
x[i] = i*0.1;
y[i] = 10*sin(x[i]+0.2);
}
TGraph *gr = new TGraph(n,x,y);
gr->SetLineColor(2);
gr->SetLineWidth(4);
gr->SetMarkerColor(4);
gr->SetMarkerStyle(21);
gr->SetTitle("a simple graph");
gr->GetXaxis()->SetTitle("X title");
gr->GetYaxis()->SetTitle("Y title");
gr->Draw("ACP");
C->Update();
C->GetFrame()->SetFillColor(21);
C->GetFrame()->SetBorderSize(12);
TestReport1(C, "TGraph 1");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void tgraph2()
{
// 2nd TGraph test.
TCanvas *C = StartTest(700,500);
C->SetGrid();
TMultiGraph *mg = new TMultiGraph();
mg->SetTitle("Exclusion graphs");
const Int_t n = 35;
Double_t x1[n], x2[n], x3[n], y1[n], y2[n], y3[n];
for (Int_t i=0;i<n;i++) {
x1[i] = i*0.1;
x2[i] = x1[i];
x3[i] = x1[i]+.5;
y1[i] = 10*sin(x1[i]);
y2[i] = 10*cos(x1[i]);
y3[i] = 10*sin(x1[i])-2;
}
TGraph *gr1 = new TGraph(n,x1,y1);
gr1->SetLineColor(2);
gr1->SetLineWidth(1504);
gr1->SetFillStyle(3005);
TGraph *gr2 = new TGraph(n,x2,y2);
gr2->SetLineColor(4);
gr2->SetLineWidth(-2002);
gr2->SetFillStyle(3004);
gr2->SetFillColor(9);
TGraph *gr3 = new TGraph(n,x3,y3);
gr3->SetLineColor(5);
gr3->SetLineWidth(-802);
gr3->SetFillStyle(3002);
gr3->SetFillColor(2);
mg->Add(gr1);
mg->Add(gr2);
mg->Add(gr3);
mg->Draw("AC");
TestReport1(C, "TGraph 2 (Exclusion Zone)");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void tgraph3()
{
// 3rd TGraph test.
TCanvas *C = StartTest(800,400);
C->Divide(2,1);
TGraph *g1 = new TGraph();
g1->SetPoint(0, 1e-4, 1);
g1->SetPoint(1, 1e-2, 2);
g1->SetPoint(2, 1e-1, 3);
g1->SetPoint(3, 1, 4);
g1->SetPoint(4, 1e1, 5);
g1->SetPoint(5, 1e2, 5);
g1->SetPoint(6, 1e3, 4);
g1->SetPoint(7, 1e4, 3);
g1->SetPoint(8, 1e5, 2);
g1->SetPoint(9, 1e6, 1);
g1->SetTitle("10 blue circles should be visible");
g1->SetMarkerStyle(kFullCircle);
g1->SetMarkerSize(1.0);
g1->SetMarkerColor(kBlue);
g1->SetLineColor(kBlue);
C->cd(1);
g1->Fit("gaus","Q");
g1->Draw("AP");
gPad->SetLogx();
C->cd(2);
gPad->SetLogx();
gPad->SetLogy();
TGraph* g2 = new TGraph();
for (int i = 0; i < 10; i++) g2->SetPoint(i, i + 1, i + 1);
g2->SetTitle("2 log scales from 1e-2 to 1e2;x;y");
g2->GetXaxis()->SetLimits(1e-2, 1e2);
g2->GetHistogram()->SetMinimum(1e-2);
g2->GetHistogram()->SetMaximum(1e2);
g2->GetXaxis()->CenterTitle();
g2->GetYaxis()->CenterTitle();
g2->Draw("a*");
TestReport1(C, "TGraph 3 (Fitting and log scales)");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void tmultigraph1()
{
// TMultigraph and TGraphErrors test
TCanvas *C = StartTest(700,500);
gStyle->SetOptFit();
C->SetGrid();
TMultiGraph *mg = new TMultiGraph();
Int_t n1 = 10;
Double_t x1[] = {-0.1, 0.05, 0.25, 0.35, 0.5, 0.61,0.7,0.85,0.89,0.95};
Double_t y1[] = {-1,2.9,5.6,7.4,9,9.6,8.7,6.3,4.5,1};
Double_t ex1[] = {.05,.1,.07,.07,.04,.05,.06,.07,.08,.05};
Double_t ey1[] = {.8,.7,.6,.5,.4,.4,.5,.6,.7,.8};
TGraphErrors *gr1 = new TGraphErrors(n1,x1,y1,ex1,ey1);
gr1->SetMarkerColor(kBlue);
gr1->SetMarkerStyle(21);
gr1->Fit("pol6","q ex0");
mg->Add(gr1);
Int_t n2 = 10;
Float_t x2[] = {-0.28, 0.005, 0.19, 0.29, 0.45, 0.56,0.65,0.80,0.90,1.01};
Float_t y2[] = {2.1,3.86,7,9,10,10.55,9.64,7.26,5.42,2};
Float_t ex2[] = {.04,.12,.08,.06,.05,.04,.07,.06,.08,.04};
Float_t ey2[] = {.6,.8,.7,.4,.3,.3,.4,.5,.6,.7};
TGraphErrors *gr2 = new TGraphErrors(n2,x2,y2,ex2,ey2);
gr2->SetMarkerColor(kRed);
gr2->SetMarkerStyle(20);
gr2->Fit("pol5","q ex0");
mg->Add(gr2);
mg->Draw("ap");
C->Update();
TPaveStats *stats1 = (TPaveStats*)gr1->GetListOfFunctions()->FindObject("stats");
TPaveStats *stats2 = (TPaveStats*)gr2->GetListOfFunctions()->FindObject("stats");
stats1->SetTextColor(kBlue);
stats2->SetTextColor(kRed);
stats1->SetX1NDC(0.12); stats1->SetX2NDC(0.32); stats1->SetY1NDC(0.75);
stats2->SetX1NDC(0.72); stats2->SetX2NDC(0.92); stats2->SetY1NDC(0.78);
C->Modified();
TestReport1(C, "TMultigraph and TGraphErrors");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void tmultigraph2()
{
// All Kind of TMultigraph test
TCanvas *C = StartTest(800,800);
gStyle->SetOptFit();
C->SetGrid();
C->Divide(2,2);
// Draw a frame to define the range
TMultiGraph *mg1 = new TMultiGraph();
TMultiGraph *mg2 = new TMultiGraph();
TMultiGraph *mg3 = new TMultiGraph();
TMultiGraph *mg4 = new TMultiGraph();
// Vectors used to build the graphs
Int_t n1 = 10;
Double_t x1[] = {-0.1, 0.05, 0.25, 0.35, 0.5, 0.61,0.7,0.85,0.89,0.95};
Double_t y1[] = {-1,2.9,5.6,7.4,9,9.6,8.7,6.3,4.5,1};
Double_t exl1[] = {.05,.1,.07,.07,.04,.05,.06,.07,.08,.05};
Double_t eyl1[] = {.8,.7,.6,.5,.4,.4,.5,.6,.7,.8};
Double_t exh1[] = {.02,.08,.05,.05,.03,.03,.04,.05,.06,.03};
Double_t eyh1[] = {.6,.5,.4,.3,.2,.2,.3,.4,.5,.6};
Double_t exld1[] = {.0,.0,.0,.0,.0,.0,.0,.0,.0,.0};
Double_t eyld1[] = {.0,.0,.05,.0,.0,.0,.0,.0,.0,.0};
Double_t exhd1[] = {.0,.0,.0,.0,.0,.0,.0,.0,.0,.0};
Double_t eyhd1[] = {.0,.0,.0,.0,.0,.0,.0,.0,.05,.0};
Int_t n2 = 10;
Float_t x2[] = {-0.28, 0.005, 0.19, 0.29, 0.45, 0.56,0.65,0.80,0.90,1.01};
Float_t y2[] = {2.1,3.86,7,9,10,10.55,9.64,7.26,5.42,2};
Float_t exl2[] = {.04,.12,.08,.06,.05,.04,.07,.06,.08,.04};
Float_t eyl2[] = {.6,.8,.7,.4,.3,.3,.4,.5,.6,.7};
Float_t exh2[] = {.02,.08,.05,.05,.03,.03,.04,.05,.06,.03};
Float_t eyh2[] = {.6,.5,.4,.3,.2,.2,.3,.4,.5,.6};
Float_t exld2[] = {.0,.0,.0,.0,.0,.0,.0,.0,.0,.0};
Float_t eyld2[] = {.0,.0,.05,.0,.0,.0,.0,.0,.0,.0};
Float_t exhd2[] = {.0,.0,.0,.0,.0,.0,.0,.0,.0,.0};
Float_t eyhd2[] = {.0,.0,.0,.0,.0,.0,.0,.0,.05,.0};
// Create 1st multigraph
C->cd(1);
TGraph *gr11 = new TGraph(n1,x1,y1);
gr11->SetMarkerColor(kBlue);
gr11->SetMarkerStyle(20);
TGraph *gr12 = new TGraph(n2,x2,y2);
gr12->SetMarkerColor(kRed);
gr12->SetMarkerStyle(23);
mg1->Add(gr11,"pc");
mg1->Add(gr12);
mg1->Draw("ap");
TLatex *tex1 = new TLatex(-0.3,10.0,"TGraph");
tex1->Draw();
// Create 2nd multigraph
C->cd(2);
TGraphErrors *gr21 = new TGraphErrors(n1,x1,y1,exl1,eyl1);
gr21->SetMarkerColor(kBlue+1);
gr21->SetMarkerStyle(21);
TGraphErrors *gr22 = new TGraphErrors(n2,x2,y2,exl2,eyl2);
gr22->SetMarkerColor(kRed+1);
gr22->SetMarkerStyle(20);
gr22->Fit("pol3","q ex0");
mg2->Add(gr21,"pl");
mg2->Add(gr22);
mg2->Draw("ap");
TLatex *tex2 = new TLatex(-0.3,10.0,"TGraphErrors");
tex2->Draw();
// Create 3rd multigraph
C->cd(3);
TGraphAsymmErrors *gr31 = new TGraphAsymmErrors(n1,x1,y1,exl1,exh1,eyl1,eyh1);
gr31->SetMarkerColor(kBlue-1);
gr31->SetMarkerStyle(21);
TGraphAsymmErrors *gr32 = new TGraphAsymmErrors(n2,x2,y2,exl2,exh2,eyl2,eyh2);
gr32->SetMarkerColor(kRed-1);
gr32->SetMarkerStyle(20);
gr32->Fit("pol4","q ex0");
mg3->Add(gr31,"pl");
mg3->Add(gr32);
mg3->Draw("ap");
TLatex *tex3 = new TLatex(-0.3,10.0,"TGraphAsymmErrors");
tex3->Draw();
// Create 4th multigraph
C->cd(4);
TGraphBentErrors *gr41 = new TGraphBentErrors(n1,x1,y1,exl1,exh1,eyl1,eyh1,exld1,exhd1,eyld1,eyhd1);
gr41->SetMarkerColor(kGreen);
gr41->SetMarkerStyle(21);
TGraphBentErrors *gr42 = new TGraphBentErrors(n2,x2,y2,exl2,exh2,eyl2,eyh2,exld2,exhd2,eyld2,eyhd2);
gr42->SetMarkerColor(kViolet);
gr42->SetMarkerStyle(20);
gr42->Fit("pol5","q ex0");
mg4->Add(gr41,"pc");
mg4->Add(gr42);
mg4->Draw("ap");
TLatex *tex4 = new TLatex(-0.3,10.0,"TGraphBentErrors");
tex4->Draw();
C->Modified();
TestReport1(C, "All Kind of TMultigraph");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void options2d1()
{
// 1st 2D options Test
TCanvas *C = StartTest(800,600);
gStyle->SetOptStat(0);
gStyle->SetPalette(1);
gStyle->SetCanvasColor(33);
gStyle->SetFrameFillColor(18);
TF2 *f2 = new TF2("f2","xygaus + xygaus(5) + xylandau(10)",-4,4,-4,4);
Double_t params[] = {130,-1.4,1.8,1.5,1, 150,2,0.5,-2,0.5, 3600,-2,0.7,-3,0.3};
f2->SetParameters(params);
gH2 = new TH2F("h2","xygaus + xygaus(5) + xylandau(10)",20,-4,4,20,-4,4);
gH2->SetFillColor(46);
gH2->FillRandom("f2",40000);
TPaveLabel pl1;
Float_t x1=0.67, y1=0.875, x2=0.85, y2=0.95;
C->Divide(2,2);
C->SetFillColor(17);
C->cd(1);
gH2->Draw(); pl1.DrawPaveLabel(x1,y1,x2,y2,"SCAT","brNDC");
C->cd(2);
gH2->Draw("box"); pl1.DrawPaveLabel(x1,y1,x2,y2,"BOX","brNDC");
C->cd(3);
gH2->Draw("arr"); pl1.DrawPaveLabel(x1,y1,x2,y2,"ARR","brNDC");
C->cd(4);
gH2->Draw("colz"); pl1.DrawPaveLabel(x1,y1,x2,y2,"COLZ","brNDC");
TestReport1(C, "Basic 2D options");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void options2d2()
{
// 2nd 2D options Test
TCanvas *C = StartTest(800,600);
TPaveLabel pl2;
Float_t x1=0.67, y1=0.875, x2=0.85, y2=0.95;
gPad->SetGrid();
C->SetFillColor(17);
C->SetGrid();
gH2->Draw("text"); pl2.DrawPaveLabel(x1,y1,x2,y2,"TEXT","brNDC");
TestReport1(C, "Text option");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void options2d3()
{
// 3rd 2D options Test
TCanvas *C = StartTest(800,600);
TPaveLabel pl3;
Float_t x1=0.67, y1=0.875, x2=0.85, y2=0.95;
C->Divide(2,2);
gPad->SetGrid();
C->SetFillColor(17);
C->cd(1);
gH2->Draw("contz"); pl3.DrawPaveLabel(x1,y1,x2,y2,"CONTZ","brNDC");
C->cd(2);
gPad->SetGrid();
gH2->Draw("cont1"); pl3.DrawPaveLabel(x1,y1,x2,y2,"CONT1","brNDC");
C->cd(3);
gPad->SetGrid();
gH2->Draw("cont2"); pl3.DrawPaveLabel(x1,y1,x2,y2,"CONT2","brNDC");
C->cd(4);
gPad->SetGrid();
gH2->Draw("cont3"); pl3.DrawPaveLabel(x1,y1,x2,y2,"CONT3","brNDC");
TestReport1(C, "Contour options");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void options2d4()
{
// 4th 2D options Test
TCanvas *C = StartTest(800,600);
TPaveLabel pl4;
Float_t x1=0.67, y1=0.875, x2=0.85, y2=0.95;
C->Divide(2,2);
C->SetFillColor(17);
C->cd(1);
gH2->Draw("lego"); pl4.DrawPaveLabel(x1,y1,x2,y2,"LEGO","brNDC");
C->cd(2);
gH2->Draw("lego1"); pl4.DrawPaveLabel(x1,y1,x2,y2,"LEGO1","brNDC");
C->cd(3);
gPad->SetTheta(61); gPad->SetPhi(-82);
gH2->Draw("surf1pol"); pl4.DrawPaveLabel(x1,y1,x2+0.05,y2,"SURF1POL","brNDC");
C->cd(4);
gPad->SetTheta(21); gPad->SetPhi(-90);
gH2->Draw("surf1cyl"); pl4.DrawPaveLabel(x1,y1,x2+0.05,y2,"SURF1CYL","brNDC");
TestReport1(C, "Lego options");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void options2d5()
{
// 5th 2D options Test
TCanvas *C = StartTest(800,600);
TPaveLabel pl5;
Float_t x1=0.67, y1=0.875, x2=0.85, y2=0.95;
C->Divide(2,2);
C->SetFillColor(17);
C->cd(1);
gH2->Draw("surf1"); pl5.DrawPaveLabel(x1,y1,x2,y2,"SURF1","brNDC");
C->cd(2);
gH2->Draw("surf2z"); pl5.DrawPaveLabel(x1,y1,x2,y2,"SURF2Z","brNDC");
C->cd(3);
gH2->Draw("surf3"); pl5.DrawPaveLabel(x1,y1,x2,y2,"SURF3","brNDC");
C->cd(4);
gH2->Draw("surf4"); pl5.DrawPaveLabel(x1,y1,x2,y2,"SURF4","brNDC");
TestReport1(C, "Surface options");
DoCcode(C);
TestReport2();
delete gH2;
}
//______________________________________________________________________________
void earth()
{
// 5th 2D options Test
TCanvas *C = StartTest(1000,800);
gStyle->SetPalette(1);
gStyle->SetOptTitle(1);
gStyle->SetOptStat(0);
C->Divide(2,2);
TH2F *h1 = new TH2F("h01","Aitoff", 50, -180, 180, 50, -89.5, 89.5);
TH2F *h2 = new TH2F("h02","Mercator", 50, -180, 180, 50, -80.5, 80.5);
TH2F *h3 = new TH2F("h03","Sinusoidal",50, -180, 180, 50, -90.5, 90.5);
TH2F *h4 = new TH2F("h04","Parabolic", 50, -180, 180, 50, -90.5, 90.5);
ifstream in;
in.open("../tutorials/graphics/earth.dat");
if (!in) {
in.clear();
in.open("earth.dat");
}
if (!in)
printf("Cannot find earth.dat!\n");
Float_t x,y;
while (1) {
in >> x >> y;
if (!in.good()) break;
h1->Fill(x,y, 1);
h2->Fill(x,y, 1);
h3->Fill(x,y, 1);
h4->Fill(x,y, 1);
}
in.close();
C->cd(1); h1->Draw("z aitoff");
C->cd(2); h2->Draw("z mercator");
C->cd(3); h3->Draw("z sinusoidal");
C->cd(4); h4->Draw("z parabolic");
TestReport1(C, "Special contour options (AITOFF etc.)");
DoCcode(C);
TestReport2();
delete h1;
delete h2;
delete h3;
delete h4;
}
//______________________________________________________________________________
void tgraph2d1()
{
// 1st TGraph2D Test
TCanvas *C = StartTest(600,600);
Double_t P = 5.;
Int_t npx = 20 ;
Int_t npy = 20 ;
Double_t x = -P;
Double_t y = -P;
Double_t z;
Int_t k = 0;
Double_t dx = (2*P)/npx;
Double_t dy = (2*P)/npy;
TGraph2D *dt = new TGraph2D(npx*npy);
dt->SetName("Graph2DA");
dt->SetNpy(41);
dt->SetNpx(40);
for (Int_t i=0; i<npx; i++) {
for (Int_t j=0; j<npy; j++) {
z = sin(sqrt(x*x+y*y))+1;
dt->SetPoint(k,x,y,z);
k++;
y = y+dy;
}
x = x+dx;
y = -P;
}
gStyle->SetPalette(1);
dt->SetFillColor(0);
dt->SetLineColor(1);
dt->SetMarkerSize(1);
dt->Draw("tri2p0Z ");
TestReport1(C, "TGraph2D 1 (TRI2 and P0)");
DoCcode(C);
TObject *old = (TObject*)gDirectory->GetList()->FindObject(dt->GetName());
if (old) gDirectory->GetList()->Remove(old);
TestReport2();
delete dt;
}
//______________________________________________________________________________
void tgraph2d2()
{
// 2nd TGraph2D Test
TCanvas *C = StartTest(600,600);
gStyle->SetPadBorderMode(0);
gStyle->SetFrameBorderMode(0);
gStyle->SetCanvasBorderMode(0);
Double_t Px = 6.;
Double_t Py = 6.;
Int_t np = 1000;
Double_t *rx=0, *ry=0, *rz=0;
rx = new Double_t[np];
ry = new Double_t[np];
rz = new Double_t[np];
TRandom *r = new TRandom();
for (Int_t N=0; N<np; N++) {
rx[N]=2*Px*(r->Rndm(N))-Px;
ry[N]=2*Py*(r->Rndm(N))-Py;
rz[N]=sin(sqrt(rx[N]*rx[N]+ry[N]*ry[N]))+1;
}
gStyle->SetPalette(1);
TGraph2D *dt = new TGraph2D( np, rx, ry, rz);
dt->SetName("Graph2DA");
dt->SetFillColor(0);
dt->SetMarkerStyle(20);
dt->Draw("PCOL");
TestReport1(C, "TGraph2D 2 (COL and P)");
DoCcode(C);
TObject *old = (TObject*)gDirectory->GetList()->FindObject(dt->GetName());
if (old) gDirectory->GetList()->Remove(old);
TestReport2();
delete dt;
}
//______________________________________________________________________________
void tgraph2d3()
{
// 3rd TGraph2D Test
TCanvas *C = StartTest(600,600);
gStyle->SetPadBorderMode(0);
gStyle->SetFrameBorderMode(0);
gStyle->SetCanvasBorderMode(0);
Double_t Px = 6.;
Double_t Py = 6.;
Int_t np = 200;
Double_t *rx=0, *ry=0, *rz=0;
rx = new Double_t[np];
ry = new Double_t[np];
rz = new Double_t[np];
TRandom *r = new TRandom();
for (Int_t N=0; N<np; N++) {
rx[N]=2*Px*(r->Rndm(N))-Px;
ry[N]=2*Py*(r->Rndm(N))-Py;
rz[N]=sin(sqrt(rx[N]*rx[N]+ry[N]*ry[N]))+1;
}
gStyle->SetPalette(1);
TGraph2D *dt = new TGraph2D( np, rx, ry, rz);
dt->SetName("Graph2DA");
dt->SetFillColor(0);
dt->Draw("CONT5 ");
TestReport1(C, "TGraph2D 3 (CONT5)");
DoCcode(C);
TObject *old = (TObject*)gDirectory->GetList()->FindObject(dt->GetName());
if (old) gDirectory->GetList()->Remove(old);
TestReport2();
delete dt;
}
//______________________________________________________________________________
void ntuple1()
{
// 1st complex drawing and TPad test
TCanvas *C = StartTest(700,780);
TPad *pad1 = new TPad("pad1","This is pad1",0.02,0.52,0.48,0.98,21);
TPad *pad2 = new TPad("pad2","This is pad2",0.52,0.52,0.98,0.98,21);
TPad *pad3 = new TPad("pad3","This is pad3",0.02,0.02,0.48,0.48,21);
TPad *pad4 = new TPad("pad4","This is pad4",0.52,0.02,0.98,0.48,1);
pad1->Draw();
pad2->Draw();
pad3->Draw();
pad4->Draw();
gStyle->SetStatW(0.30);
gStyle->SetStatH(0.20);
gStyle->SetStatColor(42);
pad1->cd();
pad1->SetGrid();
pad1->SetLogy();
pad1->GetFrame()->SetFillColor(15);
TNtuple *ntuple = (TNtuple*)gLocalFile->Get("ntuple");
ntuple->SetLineColor(1);
ntuple->SetFillStyle(1001);
ntuple->SetFillColor(45);
ntuple->Draw("3*px+2","px**2+py**2>1");
ntuple->SetFillColor(38);
ntuple->Draw("2*px+2","pz>2","same");
ntuple->SetFillColor(5);
ntuple->Draw("1.3*px+2","(px^2+py^2>4) && py>0","same");
pad1->RedrawAxis();
pad2->cd();
pad2->SetGrid();
pad2->GetFrame()->SetFillColor(32);
ntuple->Draw("pz:px>>hprofs","","goffprofs");
TProfile *hprofs = (TProfile*)gDirectory->Get("hprofs");
hprofs->SetMarkerColor(5);
hprofs->SetMarkerSize(0.7);
hprofs->SetMarkerStyle(21);
hprofs->Fit("pol2","q");
TF1 *fpol2 = hprofs->GetFunction("pol2");
fpol2->SetLineWidth(4);
fpol2->SetLineColor(2);
pad3->cd();
pad3->GetFrame()->SetFillColor(38);
pad3->GetFrame()->SetBorderSize(8);
ntuple->SetMarkerColor(1);
ntuple->Draw("py:px","pz>1");
ntuple->SetMarkerColor(2);
ntuple->Draw("py:px","pz<1","same");
pad4->cd();
ntuple->Draw("pz:py:px","(pz<10 && pz>6)+(pz<4 && pz>3)");
ntuple->SetMarkerColor(4);
ntuple->Draw("pz:py:px","pz<6 && pz>4","same");
ntuple->SetMarkerColor(5);
ntuple->Draw("pz:py:px","pz<4 && pz>3","same");
TPaveText *l4 = new TPaveText(-0.9,0.5,0.9,0.95);
l4->SetFillColor(42);
l4->SetTextAlign(12);
l4->AddText("You can interactively rotate this view in 2 ways:");
l4->AddText(" - With the RotateCube in clicking in this pad");
l4->AddText(" - Selecting View with x3d in the View menu");
l4->Draw();
gStyle->SetStatColor(19);
TestReport1(C, "Ntuple drawing and TPad");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void quarks()
{
// 2nd complex drawing and TPad test
TCanvas *C = StartTest(630,760);
C->SetFillColor(kBlack);
Int_t quarkColor = 50;
Int_t leptonColor = 16;
Int_t forceColor = 38;
Int_t titleColor = kYellow;
Int_t border = 8;
TLatex *texf = new TLatex(0.90,0.455,"Force Carriers");
texf->SetTextColor(forceColor);
texf->SetTextAlign(22); texf->SetTextSize(0.07); texf->SetTextAngle(90);
texf->Draw();
TLatex *texl = new TLatex(0.11,0.288,"Leptons");
texl->SetTextColor(leptonColor);
texl->SetTextAlign(22); texl->SetTextSize(0.07); texl->SetTextAngle(90);
texl->Draw();
TLatex *texq = new TLatex(0.11,0.624,"Quarks");
texq->SetTextColor(quarkColor);
texq->SetTextAlign(22); texq->SetTextSize(0.07); texq->SetTextAngle(90);
texq->Draw();
TLatex tex1(0.5,0.5,"u");
tex1.SetTextColor(titleColor); tex1.SetTextFont(32); tex1.SetTextAlign(22);
tex1.SetTextSize(0.14); tex1.DrawLatex(0.5,0.93,"Elementary");
tex1.SetTextSize(0.12); tex1.DrawLatex(0.5,0.84,"Particles");
tex1.SetTextSize(0.05); tex1.DrawLatex(0.5,0.067,"Three Generations of Matter");
tex1.SetTextColor(kBlack); tex1.SetTextSize(0.8);
TPad *pad = new TPad("pad", "pad",0.15,0.11,0.85,0.79);
pad->Draw();
pad->cd();
pad->Divide(4,4,0.0003,0.0003);
pad->cd(1); gPad->SetFillColor(quarkColor); gPad->SetBorderSize(border);
tex1.DrawLatex(.5,.5,"u");
pad->cd(2); gPad->SetFillColor(quarkColor); gPad->SetBorderSize(border);
tex1.DrawLatex(.5,.5,"c");
pad->cd(3); gPad->SetFillColor(quarkColor); gPad->SetBorderSize(border);
tex1.DrawLatex(.5,.5,"t");
pad->cd(4); gPad->SetFillColor(forceColor); gPad->SetBorderSize(border);
tex1.DrawLatex(.5,.55,"#gamma");
pad->cd(5); gPad->SetFillColor(quarkColor); gPad->SetBorderSize(border);
tex1.DrawLatex(.5,.5,"d");
pad->cd(6); gPad->SetFillColor(quarkColor); gPad->SetBorderSize(border);
tex1.DrawLatex(.5,.5,"s");
pad->cd(7); gPad->SetFillColor(quarkColor); gPad->SetBorderSize(border);
tex1.DrawLatex(.5,.5,"b");
pad->cd(8); gPad->SetFillColor(forceColor); gPad->SetBorderSize(border);
tex1.DrawLatex(.5,.55,"g");
pad->cd(9); gPad->SetFillColor(leptonColor); gPad->SetBorderSize(border);
tex1.DrawLatex(.5,.5,"#nu_{e}");
pad->cd(10); gPad->SetFillColor(leptonColor); gPad->SetBorderSize(border);
tex1.DrawLatex(.5,.5,"#nu_{#mu}");
pad->cd(11); gPad->SetFillColor(leptonColor); gPad->SetBorderSize(border);
tex1.DrawLatex(.5,.5,"#nu_{#tau}");
pad->cd(12); gPad->SetFillColor(forceColor); gPad->SetBorderSize(border);
tex1.DrawLatex(.5,.5,"Z");
pad->cd(13); gPad->SetFillColor(leptonColor); gPad->SetBorderSize(border);
tex1.DrawLatex(.5,.5,"e");
pad->cd(14); gPad->SetFillColor(leptonColor); gPad->SetBorderSize(border);
tex1.DrawLatex(.5,.56,"#mu");
pad->cd(15); gPad->SetFillColor(leptonColor); gPad->SetBorderSize(border);
tex1.DrawLatex(.5,.5,"#tau");
pad->cd(16); gPad->SetFillColor(forceColor); gPad->SetBorderSize(border);
tex1.DrawLatex(.5,.5,"W");
C->cd();
TestReport1(C, "Divided pads and TLatex");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void timage()
{
// TImage test
TCanvas *C = StartTest(800,800);
TImage *img = TImage::Open("$(ROOTSYS)/tutorials/image/rose512.jpg");
if (!img) {
printf("Could not create an image... exit\n");
return;
}
TImage *i1 = TImage::Open("$(ROOTSYS)/tutorials/image/rose512.jpg");
i1->SetConstRatio(kFALSE);
i1->Flip(90);
TImage *i2 = TImage::Open("$(ROOTSYS)/tutorials/image/rose512.jpg");
i2->SetConstRatio(kFALSE);
i2->Flip(180);
TImage *i3 = TImage::Open("$(ROOTSYS)/tutorials/image/rose512.jpg");
i3->SetConstRatio(kFALSE);
i3->Flip(270);
TImage *i4 = TImage::Open("$(ROOTSYS)/tutorials/image/rose512.jpg");
i4->SetConstRatio(kFALSE);
i4->Mirror(kTRUE);
float d = 0.40;
TPad *p1 = new TPad("i1", "i1", 0.05, 0.55, 0.05+d*i1->GetWidth()/i1->GetHeight(), 0.95);
TPad *p2 = new TPad("i2", "i2", 0.55, 0.55, 0.95, 0.55+d*i2->GetHeight()/i2->GetWidth());
TPad *p3 = new TPad("i3", "i3", 0.55, 0.05, 0.55+d*i3->GetWidth()/i3->GetHeight(), 0.45);
TPad *p4 = new TPad("i4", "i4", 0.05, 0.05, 0.45, 0.05+d*i4->GetHeight()/i4->GetWidth());
p1->Draw();
p1->cd();
i1->Draw();
C->cd();
p2->Draw();
p2->cd();
i2->Draw();
C->cd();
p3->Draw();
p3->cd();
i3->Draw();
C->cd();
p4->Draw();
p4->cd();
i4->Draw();
C->cd();
TestReport1(C, "TImage");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
double fg(double *x, double *p) {return sin((*p)*(*x));}
void zoomtf1()
{
// Zoom/UnZoom a collection of TF1
TCanvas *C = StartTest(800,800);
TF1* f[6];
for (int i=0;i<6;++i) {
f[i]=new TF1(Form("f%d",i),fg, 0,2, 1);
f[i]->SetParameter(0,i+1);
f[i]->SetLineColor(i+1);
f[i]->Draw(i?"same":"");
}
f[0]->GetXaxis()->SetRangeUser(.1,.3);
gPad->Update();
f[0]->GetXaxis()->UnZoom();
gPad->Modified();
TestReport1(C, "Zoom/UnZoom a collection of TF1");
if (gOptionR) {
DoCcode(C);
TestReport2();
}
}
//______________________________________________________________________________
void zoomfit()
{
// Zoom/UnZoom a fitted histogram
TCanvas *C = StartTest(800,800);
TH1 *hpx = (TH1*)gLocalFile->Get("hpx");
hpx->Fit("gaus","q");
hpx->GetXaxis()->SetRangeUser(.1,.3);
gPad->Modified();
gPad->Update();
hpx->GetXaxis()->UnZoom();
gPad->Modified();
gPad->Update();
TestReport1(C, "Zoom/UnZoom a fitted histogram");
DoCcode(C);
TestReport2();
}
//______________________________________________________________________________
void parallelcoord()
{
// Parallel Coordinates
TCanvas *C = StartTest(800,700);
TNtuple *ntuple = (TNtuple*)gLocalFile->Get("ntuple");
C->Divide(1,2);
C->cd(1);
ntuple->Draw("px:py:pz:random:px*py*pz","","para");
C->cd(2);
ntuple->Draw("px:py:pz:random:px*py*pz","","candle");
TestReport1(C, "Parallel Coordinates");
if (gOptionR) {
DoCcode(C);
TestReport2();
}
}
//______________________________________________________________________________
void clonepad()
{
// Draw a pad and clone it
TCanvas *C = StartTest(700,500);
TH1 *hpxpy = (TH1*)gLocalFile->Get("hpxpy");
hpxpy->Draw();
TCanvas *C2 = (TCanvas*)C->DrawClone();
TestReport1(C2, "Draw a pad and clone it");
}
//______________________________________________________________________________
Double_t interference( Double_t *x, Double_t *par)
{
// Needed for the "waves" test
Double_t x_p2 = x[0] * x[0];
Double_t d_2 = 0.5 * par[2];
Double_t ym_p2 = (x[1] - d_2) * (x[1] - d_2);
Double_t yp_p2 = (x[1] + d_2) * (x[1] + d_2);
Double_t tpi_l = TMath::Pi() / par[1];
Double_t amplitude = par[0] * (cos(tpi_l * sqrt(x_p2 + ym_p2))
+ par[3] * cos(tpi_l * sqrt(x_p2 + yp_p2)));
return amplitude * amplitude;
}
//______________________________________________________________________________
Double_t result( Double_t *x, Double_t *par)
{
// Needed for the "waves" test
Double_t xint[2];
Double_t maxintens = 0, xcur = 14;
Double_t dlambda = 0.1 * par[1];
for(Int_t i=0; i<10; i++){
xint[0] = xcur;
xint[1] = x[1];
Double_t intens = interference(xint, par);
if(intens > maxintens) maxintens = intens;
xcur -= dlambda;
}
return maxintens;
}
//______________________________________________________________________________
void waves()
{
// TGraph, TArc, TPalette and TColor
TF2 * finter;
Double_t d = 3;
Double_t lambda = 1;
Double_t amp = 10;
TCanvas *C = StartTest(1004, 759);
C->Range(0, -10, 30, 10);
C->SetFillColor(0);
TPad *pad = new TPad("pr","pr", 0.5, 0 , 1., 1);
pad->Range(0, -10, 15, 10);
pad->Draw();
const Int_t colNum = 30;
Int_t palette[colNum];
Int_t color_offset = 1001;
for (Int_t i=0;i<colNum;i++) {
new TColor(color_offset+i
, pow(i/((colNum)*1.0),0.3)
, pow(i/((colNum)*1.0),0.3)
,0.5*(i/((colNum)*1.0)),"");
palette[i] = color_offset+i;
}
gStyle->SetPalette(colNum,palette);
C->cd();
TF2 * f0 = new TF2("ray_source",interference, 0.02, 15, -8, 8, 4);
f0->SetParameters(amp, lambda, 0, 0);
f0->SetNpx(200);
f0->SetNpy(200);
f0->SetContour(colNum-2);
f0->Draw("samecolz");
TLatex title;
title.DrawLatex(1.6, 8.5, "A double slit experiment");
TGraph *graph = new TGraph(4);
graph->SetFillColor(0);
graph->SetFillStyle(1001);
graph->SetLineWidth(0);
graph->SetPoint(0, 0., 0.1);
graph->SetPoint(1, 14.8, 8);
graph->SetPoint(2, 0, 8);
graph->SetPoint(3, 0, 0.1);
graph->Draw("F");
graph = new TGraph(4);
graph->SetFillColor(0);
graph->SetFillStyle(1001);
graph->SetLineWidth(0);
graph->SetPoint(0, 0, -0.1);
graph->SetPoint(1, 14.8, -8);
graph->SetPoint(2, 0, -8);
graph->SetPoint(3, 0, -0.1);
graph->Draw("F");
TLine * line;
line = new TLine(15,-10, 15, 0 - 0.5*d -0.2);
line->SetLineWidth(10); line->Draw();
line = new TLine(15, 0 - 0.5*d +0.2 ,15, 0 + 0.5*d -0.2);
line->SetLineWidth(10); line->Draw();
line = new TLine(15,0 + 0.5*d + 0.2,15, 10);
line->SetLineWidth(10); line->Draw();
pad ->cd();
finter = new TF2("interference",interference, 0.01, 14, -10, 10, 4);
finter->SetParameters(amp, lambda, d, 1);
finter->SetNpx(200);
finter->SetNpy(200);
finter->SetContour(colNum-2);
finter->Draw("samecolorz");
TArc *arc = new TArc();;
arc->SetFillStyle(0);
arc->SetLineWidth(2);
arc->SetLineColor(5);
Float_t r = 0.5 * lambda, dr = lambda;
for (Int_t i = 0; i < 15; i++) {
arc->DrawArc(0, 0.5*d, r, 0., 360., "only");
arc->DrawArc(0, -0.5*d, r, 0., 360., "only");
r += dr;
}
pad ->cd();
TF2 * fresult = new TF2("result",result, 14, 15, -10, 10, 4);
fresult->SetParameters(amp, lambda, d, 1);
fresult->SetNpx(300);
fresult->SetNpy(300);
fresult->SetContour(colNum-2);
fresult->Draw("samecolor");
line = new TLine(13.8,-10, 14, 10);
line->SetLineWidth(10); line->SetLineColor(0); line->Draw();
TestReport1(C, "TGraph, TArc, TPalette and TColor");
///DoCcode(C);
///TestReport2();
if (gOptionR) printf("\n");
}
//______________________________________________________________________________
void cleanup()
{
}