//_______________________________________________________________________________________
void MakeFourView(TVirtualPad *pad=0)
{
// Creates 4 pads view of the pad (or qPad)
// ------------------------------
// | | |
// | | |
// | | |
// | Front | Top |
// | view | view |
// | | |
// | | |
// | | |
// ---------------+-------------
// | | |
// | | |
// | | |
// | Side | Spacial |
// | view | view |
// | | |
// | | |
// | | |
// ------------------------------
// begin_html <P ALIGN=CENTER> <IMG SRC="gif/FourStarView.gif" ></P> end_html
//
TVirtualPad *thisPad = pad;
if (!thisPad) thisPad = qPad();
TView *view = 0;
TList *thisPrimitives = 0;
if (thisPad && (thisPrimitives = thisPad->GetListOfPrimitives()) && (view = thisPad->GetView()) )
{
Double_t min[3],max[3];
view->GetRange(min,max);
Int_t system = view->GetSystem();
TCanvas *c = new TCanvas(" 4 views", thisPad->GetTitle(),600,600);
c->Divide(2,2);
TIter *next= new TIter(thisPrimitives);
for (int i =1; i <= 4; i++) {
c->cd(i);
TList *newPrimitives = qPad()->GetListOfPrimitives();
TObject *obj = 0;
while (obj = next->Next()) newPrimitives->Add(obj);
TView *newView = new TView(system);
newView->SetRange(min,max);
next->Reset();
}
delete next;
// set separate view;
// Fron view
Int_t j = 1;
c->cd(j++); FrontView();
c->cd(j++); TopView();
c->cd(j++); SideView();
c->cd(j++); RotateView(-30.0,60.0,0);
c->Modified();
c->Update();
}
}
void pl3() {
TCanvas *c1 = new TCanvas("c1");
TView *view = TView::CreateView(1);
view->SetRange(0,0,0,2,2,2);
const Int_t n = 100;
TPolyLine3D *l = new TPolyLine3D(n);
for (Int_t i=0;i<n;i++) {
Double_t x = 2*gRandom->Rndm();
Double_t y = 2*gRandom->Rndm();
Double_t z = 2*gRandom->Rndm();
l->SetPoint(i,x,y,z);
}
l->Draw();
}
void drawing_pion_decay(){
double Pi_lifetime = 0.26033e-6; //s
double c = 3e8;//m/s
TCanvas *c1 = new TCanvas("test", "test");
TRandom *r = new TRandom();
TView *view = TView::CreateView(1, 0, 0);
view->ShowAxis();
view->SetRange(-5, -5, 0, 5, 5, 10);
for (int i = 0; i < 100; ++i)
{
double px = 0.3;
double py = 0.3;
double pz = -1; // GeV
double energy = sqrt(px*px+py*py+pz*pz+M_pion*M_pion);
//life time
double t = r->Exp(Pi_lifetime);
//decay length
double gamma = energy/M_pion;
double length = c*t*gamma/1e3;
// decay position
double vx = 0;
double vy = 0;
double vz = 10 - length;
TLorentzVector pion(px, py, pz, energy);
double decay_particle_mass[2] = {M_muon, M_neu};
TGenPhaseSpace event;
event.SetDecay(pion, 2, decay_particle_mass);
event.Generate();
TLorentzVector Muon = *(event.GetDecay(0));
TLorentzVector Neu = *(event.GetDecay(1));
plot_particle(Muon, vx, vy, vz, 2);
plot_particle(Neu, vx, vy, vz, 4);
}
}
//_______________________________________________________________________________________
static void Inscrease3DScale()
{
TVirtualPad *thisPad = qPad();
if (thisPad) {
TView *view = thisPad->GetView();
if (!view) return;
Double_t min[3],max[3];
view->GetRange(min,max);
int i;
for (i=0;i<3; i++) {max[i] *= 0.8; min[i]=max[i]*0.1;}
view->SetRange(min,max);
thisPad->Modified();
thisPad->Update();
}
}
//_______________________________________________________________________________________
static void Centered3DImages()
{
// This macro prints out the sizes of the sekected 3d pad
TVirtualPad *thisPad = qPad();
if (thisPad) {
TView *view = thisPad->GetView();
if (!view) return;
Double_t min[3],max[3];
view->GetRange(min,max);
int i;
for (i=0;i<3; i++) min[i]=-max[i];
view->SetRange(min,max);
thisPad->Modified();
thisPad->Update();
}
}
//_______________________________________________________________________________________
static void AdjustScales()
{
TVirtualPad *thisPad = qPad();
if (thisPad) {
TView *view = thisPad->GetView();
if (!view) return;
Double_t min[3],max[3];
view->GetRange(min,max);
int i;
Double_t maxSide = 0;
// Find the largest side
for (i=0;i<3; i++) maxSide = TMath::Max(maxSide,max[i]-min[i]);
//Adjust scales:
for (i=0;i<3; i++) max[i] += maxSide - (max[i]-min[i]);
view->SetRange(min,max);
thisPad->Modified();
thisPad->Update();
}
}
void spheres(Int_t nspheres=20, Int_t npoints=100000) {
// generate random points uniformly distributed over the surface
// of spheres generated at random positions.
TCanvas *c1 = new TCanvas("c1","spheres",600,600);
c1->SetFillColor(kBlack);
TView *view = new TView(1);
Double_t k=0.8;
view->SetRange( -k, -k, -k, k, k, k);
//generate sphere coordinates and radius
TRandom r;
if (nspheres <=0) nspheres = 10;
Double_t *xs = new Double_t[nspheres];
Double_t *ys = new Double_t[nspheres];
Double_t *zs = new Double_t[nspheres];
Double_t *rs = new Double_t[nspheres];
Int_t i;
for (i=0;i<nspheres;i++) {
xs[i] = r.Uniform(-1,1);
ys[i] = r.Uniform(-1,1);
zs[i] = r.Uniform(-1,1);
rs[i] = r.Uniform(0.05,0.25);
}
//generate points
TPolyMarker3D *pm = new TPolyMarker3D(npoints);
pm->SetMarkerColor(kRed);
Double_t x,y,z;
for (Int_t j=0;j<npoints;j++) {
i = (Int_t)r.Uniform(0,nspheres); //choose sphere
r.Sphere(x,y,z,rs[i]);
pm->SetPoint(j,xs[i]+x, ys[i]+y,zs[i]+z);
}
delete [] xs;
delete [] ys;
delete [] zs;
delete [] rs;
pm->Draw();
}
void RootWImage::setCanvas(TCanvas* myCanvas) {
if (myCanvas_) delete myCanvas_;
myCanvas_ = (TCanvas*)myCanvas->DrawClone();
std::ostringstream canvasName("");
//int myNumber = imageNameCounter_[name_]++; //##########
canvasName << "canvas" << setfill('0') << setw(3) << imageCounter_;
myCanvas_->SetName(canvasName.str().c_str());
TView* myView = myCanvas->GetView();
if (myView) {
TView* newView = myCanvas_->GetView();
if (newView) {
double min[3], max[3];
Int_t irep;
newView->SetView(myView->GetLongitude(),
myView->GetLatitude(),
myView->GetPsi(), irep);
myView->GetRange(min, max);
newView->SetRange(min, max);
}
}
}
void sphere()
{
/********************/
/*Mpi initialization*/
/********************/
ROOT::Mpi::TEnvironment env(gApplication->Argc(), gApplication->Argv());
ROOT::Mpi::TIntraCommunicator world;
/*********************************/
/*Error control, need 4 processes*/
/*********************************/
if(world.Size()!=4)
{
std::cout<<"Error: You need run with 4 processes exactly, the sphere was spplitted in four regions. \nExample: mpirun -np 4 root -l sphere.C\n";
std::cout.flush();
world.Abort(ROOT::Mpi::ERR_SIZE);
}
/*********************************************************************/
/*Section to calculate volume with parallel multimensional integrator*/
/*********************************************************************/
//integrator creation root's style
ROOT::Math::Functor1D function(&sphere_function);
ROOT::Math::Integrator integrator;
integrator.SetFunction(function);
//Mpi's integrator wrapper, integrator from ROOT in one dimension
ROOT::Mpi::Math::TIntegratorWrapper MpiIntegrator(&integrator);
//integrate in parallel and send the result to rank zero, intervar [0,radius]
MpiIntegrator.Integrate(0, 0, radius);
/*****************************************************************************************/
/*this is the root process,calculate the surface z=+qsrt(1−(x2+b2)) for x∈[−1,0],y∈[−1,1]*/
/*and recv the other surface regions in TPolyMarker3D object from others ranks */
/*****************************************************************************************/
if (world.Rank() == 0) {
gBenchmark->Start("sphere");
// create and open a canvas
TCanvas *canvas = new TCanvas("sphere", "sphere", 300, 10, 700, 500);
canvas->SetFillColor(14);
// creating view
TView *view = TView::CreateView(1, 0, 0);
view->RotateView(90,-10);
view->SetRange(-radius*2, -radius*2, -2*radius, 2*radius, 2*radius, 2*radius);
// create a PolyMarker3D for region/segment 1 calculate in rank 0(this rank)
TPolyMarker3D *surfaceSeg13d = new TPolyMarker3D();
for (theta = 0; theta <0.5*M_PI ; theta+= delta) {
for (phi = 0; phi <M_PI; phi += delta) {
x=radius*cos(theta)*sin(phi);
y=radius*sin(theta)*sin(phi);
z=radius*cos(phi);
// set points
surfaceSeg13d->SetPoint(point, x, y, z);
point++;
}
}
// set marker size, color & style
surfaceSeg13d->SetMarkerSize(1);
surfaceSeg13d->SetMarkerColor(world.Rank() + world.Size());
surfaceSeg13d->SetMarkerStyle(1);
//drawing region 1
surfaceSeg13d->Draw();
//getting region 2 from rank 1
TPolyMarker3D *surfaceSeg23d = new TPolyMarker3D;
world.RecvObject(1, 1, *surfaceSeg23d);
surfaceSeg23d->Draw();
//getting region 3 from rank 2
TPolyMarker3D *surfaceSeg33d = new TPolyMarker3D;
world.RecvObject(2, 1, *surfaceSeg33d);
surfaceSeg33d->Draw();
//getting region 4 from rank 3
TPolyMarker3D *surfaceSeg43d = new TPolyMarker3D;
world.RecvObject(3, 1, *surfaceSeg43d);
surfaceSeg43d->Draw();
Char_t timeStr[60];
Char_t pointsStr[100];
Char_t radiusStr[100];
Char_t deltaStr[100];
gBenchmark->Show("sphere");
Float_t ct = gBenchmark->GetCpuTime("sphere");
sprintf(timeStr, "Execution time: %g sec.", ct);
sprintf(radiusStr, "Radius : %g", radius);
sprintf(deltaStr, "Delta : %g", delta);
sprintf(pointsStr, "Total surface points : %g", point*4);
TPaveText *text = new TPaveText(0.1, 0.6, 0.9, 0.99);
text->SetFillColor(42);
text->AddText("ROOTMpi example: sphere.C");
text->AddText(timeStr);
text->AddText(radiusStr);
text->AddText(deltaStr);
text->AddText(pointsStr);
text->Draw();
//sphere volume V=(4/3)*pi*r3
//and compare the result integration's volume
Char_t volumeStr[100];
Double_t volume= MpiIntegrator.Result();
Double_t volumeTeo=(4/3.0)*M_PI*(radius*radius*radius);
sprintf(volumeStr, "Volumen with integration = %.15g \nVolumen with (4/3)*pi*r3 = %.15g", volume,volumeTeo);
TPaveText *volumeText = new TPaveText(-0.1, -0.81, -0.9, -0.97);
volumeText->SetFillColor(41);
volumeText->SetTextAlign(11);
volumeText->AddText(volumeStr);
volumeText->Draw();
}
/*************************************************************************/
/*this rank calculate the surface for theta ∈[0.5pi,pi] and phi ∈[0,pi] */
/*and send the surface regions in TPolyMarker3D object to rank root zero */
/*************************************************************************/
if (world.Rank() == 1) {
TPolyMarker3D *surfaceSeg23d = new TPolyMarker3D();
for (theta = 0.5*M_PI; theta <M_PI ; theta+= delta) {
for (phi = 0; phi <M_PI; phi += delta) {
x=radius*cos(theta)*sin(phi);
y=radius*sin(theta)*sin(phi);
z=radius*cos(phi);
// set points
surfaceSeg23d->SetPoint(point, x, y, z);
point++;
}
}
// set marker size, color & style
surfaceSeg23d->SetMarkerSize(1);
surfaceSeg23d->SetMarkerColor(world.Rank() + world.Size());
surfaceSeg23d->SetMarkerStyle(1);
//send surface points to root process
world.SendObject(0, 1, *surfaceSeg23d);
}
/*************************************************************************/
/*this rank calculate the surface for theta ∈[pi,1.5pi] and phi ∈[0,pi] */
/*and send the surface regions in TPolyMarker3D object to rank root zero */
/*************************************************************************/
if (world.Rank() == 2) {
TPolyMarker3D *surfaceSeg33d = new TPolyMarker3D();
for (theta = M_PI; theta <1.5*M_PI ; theta+= delta) {
for (phi = 0; phi <M_PI; phi += delta) {
x=radius*cos(theta)*sin(phi);
y=radius*sin(theta)*sin(phi);
z=radius*cos(phi);
// set points
surfaceSeg33d->SetPoint(point, x, y, z);
point++;
}
}
// set marker size, color & style
surfaceSeg33d->SetMarkerSize(1);
surfaceSeg33d->SetMarkerColor(world.Rank() + world.Size());
surfaceSeg33d->SetMarkerStyle(1);
//send surface points to root process
world.SendObject(0, 1, *surfaceSeg33d);
}
/*************************************************************************/
/*this rank calculate the surface for theta ∈[1.5pi,2pi] and phi ∈[0,pi] */
/*and send the surface regions in TPolyMarker3D object to rank root zero */
/*************************************************************************/
if (world.Rank() == 3) {
TPolyMarker3D *surfaceSeg43d = new TPolyMarker3D();
for (theta = 1.5*M_PI; theta <2*M_PI ; theta+= delta) {
for (phi = 0; phi <M_PI; phi += delta) {
x=radius*cos(theta)*sin(phi);
y=radius*sin(theta)*sin(phi);
z=radius*cos(phi);
// set points
surfaceSeg43d->SetPoint(point, x, y, z);
point++;
}
}
// set marker size, color & style
surfaceSeg43d->SetMarkerSize(1);
surfaceSeg43d->SetMarkerColor(world.Rank() + world.Size());
surfaceSeg43d->SetMarkerStyle(1);
//send surface points to root process
world.SendObject(0, 1, *surfaceSeg43d);
}
}
//_____________________________________________________________________________
Int_t AliTRDdisplayDigits3D(Int_t event = 0, Int_t thresh = 4
, Bool_t sdigits = kFALSE)
{
//
// TRD digits display
//
// Input parameter:
// <event> : Event number
// <thresh> : Threshold to suppress the noise
// <sdigits> : If kTRUE it will display summable digits, normal digits otherwise.
// The signal event is displayed in yellow.
//
Char_t *inputFile = "galice.root";
// Define the objects
AliTRDv1 *trd;
AliTRDgeometry *geo;
TString evfoldname = AliConfig::GetDefaultEventFolderName();
AliRunLoader *runLoader = AliRunLoader::GetRunLoader(evfoldname);
if (!runLoader) {
runLoader = AliRunLoader::Open(inputFile
,AliConfig::GetDefaultEventFolderName()
,"UPDATE");
}
if (!runLoader) {
printf("Can not open session for file %s.",inputFile);
return kFALSE;
}
if (!runLoader->GetAliRun()) {
runLoader->LoadgAlice();
}
gAlice = runLoader->GetAliRun();
if (!gAlice) {
printf("Could not find AliRun object.\n");
return kFALSE;
}
runLoader->GetEvent(event);
AliLoader *loader = runLoader->GetLoader("TRDLoader");
if (!loader) {
printf("Can not get TRD loader from Run Loader");
}
loader->LoadDigits();
// Get the pointer to the detector object
trd = (AliTRDv1*) gAlice->GetDetector("TRD");
// Get the pointer to the geometry object
if (trd) {
geo = trd->GetGeometry();
}
else {
printf("Cannot find the geometry\n");
return 1;
}
AliCDBManager *cdbManager = AliCDBManager::Instance();
cdbManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
AliTRDcalibDB *calibration = AliTRDcalibDB::Instance();
calibration->SetRun(0);
TCanvas *c1 = new TCanvas("digits","TRD digits display",0,0,700,730);
TView *v = new TView(1);
v->SetRange(-430,-560,-430,430,560,1710);
v->SetParallel();
c1->Clear();
c1->SetFillColor(1);
c1->SetTheta(90.0);
c1->SetPhi(0.0);
Int_t markerColorSignal = 2;
Int_t markerColorBgnd = 7;
Int_t markerColorMerged = 5;
Int_t mask = 10000000;
// Create the digits manager
AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager();
digitsManager->SetSDigits(sdigits);
// Read the digits from the file
if (sdigits) {
digitsManager->ReadDigits(loader->TreeS());
}
else {
if (!loader->TreeD()) {
printf("mist\n");
return kFALSE;
}
digitsManager->ReadDigits(loader->TreeD());
}
Int_t totalsignal = 0;
Int_t totalbgnd = 0;
Int_t totalmerged = 0;
Int_t timeMax = calibration->GetNumberOfTimeBins();
// Loop through all detectors
for (Int_t idet = 0; idet < geo->Ndet(); idet++) {
printf("<AliTRDdisplayDigits3D> Loading detector %d\n",idet);
AliTRDdataArrayI *digits = digitsManager->GetDigits(idet);
digits->Expand();
Int_t isec = geo->GetSector(idet);
Int_t icha = geo->GetChamber(idet);
Int_t ipla = geo->GetPlane(idet);
AliTRDpadPlane *padPlane = new AliTRDpadPlane(ipla,icha);
Int_t rowMax = padPlane->GetNrows();
Int_t colMax = padPlane->GetNcols();
Int_t ndigits = digits->GetOverThreshold(thresh);
if (ndigits > 0) {
TPolyMarker3D *pmSignal = new TPolyMarker3D(ndigits);
Int_t isignal = 0;
for (Int_t time = 0; time < timeMax; time++) {
for (Int_t col = 0; col < colMax; col++) {
for (Int_t row = 0; row < rowMax; row++) {
Int_t amp = digits->GetDataUnchecked(row,col,time);
if (amp > thresh) {
Double_t glb[3];
Double_t loc[3];
loc[0] = row;
loc[1] = col;
loc[2] = time;
geo->Local2Global(idet,loc,glb);
Double_t x = glb[0];
Double_t y = glb[1];
Double_t z = glb[2];
pmSignal->SetPoint(isignal,x,y,z);
isignal++;
totalsignal++;
}
}
}
}
digits->Compress(1,0);
pmSignal->SetMarkerSize(1);
pmSignal->SetMarkerColor(markerColorSignal);
pmSignal->SetMarkerStyle(1);
pmSignal->Draw();
}
}
delete padPlane;
TGeometry *geoAlice = gAlice->GetGeometry();
TNode *main = (TNode *) ((geoAlice->GetListOfNodes())->First());
TIter next(main->GetListOfNodes());
TNode *module = 0;
while ((module = (TNode *) next())) {
Char_t ch[100];
sprintf(ch,"%s\n",module->GetTitle());
if ((ch[0] == 'T') && ((ch[1] == 'R') || (ch[1] == 'P'))) {
module->SetVisibility( 3);
}
else {
module->SetVisibility(-1);
}
}
geoAlice->Draw("same");
c1->Modified();
c1->Update();
return 0;
}
void tornado() {
//Show 3-d polymarkers
// To see the output of this macro, click begin_html <a href="gif/tornado.gif" >here</a> end_html
//Author: Rene Brun
gBenchmark->Start("tornado");
double PI = 3.141592653;
int d = 16;
int numberOfPoints=200;
int numberOfCircles=40;
// create and open a canvas
TCanvas *sky = new TCanvas( "sky", "Tornado", 300, 10, 700, 500 );
sky->SetFillColor(14);
// creating view
TView *view = TView::CreateView(1,0,0);
float range = numberOfCircles*d;
view->SetRange( 0, 0, 0, 4.0*range, 2.0*range, range );
for( int j = d; j < numberOfCircles*d; j += d ) {
// create a PolyMarker3D
TPolyMarker3D *pm3d = new TPolyMarker3D( numberOfPoints );
float x, y, z;
// set points
for( int i = 1; i < numberOfPoints; i++ ) {
float csin = sin(2*PI / (double)numberOfPoints * (double)i) + 1;
float ccos = cos(2*PI / (double)numberOfPoints * (double)i) + 1;
float esin = sin(2*PI / (double)(numberOfCircles*d) * (double)j) + 1;
x = j * ( csin + esin );
y = j * ccos;
z = j;
pm3d->SetPoint( i, x, y, z );
}
// set marker size, color & style
pm3d->SetMarkerSize( 1 );
pm3d->SetMarkerColor( 2 + ( d == ( j & d ) ) );
pm3d->SetMarkerStyle( 3 );
//draw
pm3d->Draw();
}
char timeStr[60];
gBenchmark->Show("tornado");
Float_t ct = gBenchmark->GetCpuTime("tornado");
sprintf( timeStr, "Execution time: %g sec.", ct);
TPaveText *text = new TPaveText( 0.1, 0.81, 0.9, 0.97 );
text->SetFillColor( 42 );
text->AddText("ROOT example: tornado.C");
text->AddText(timeStr);
text->Draw();
sky->Update();
}
void xtruSamples()
{
// Draw a sample of TXTRU shapes some convex, concave (and possibly malformed)
// Change Bool_t's to test alternative specifications
// Author: Robert Hatcher ([email protected]) 2000.09.06
// One normally specifies the x-y points in counter-clockwise order;
// flip this to TRUE to test that it doesn't matter.
Bool_t makecw = kFALSE;
// One normally specifies the z points in increasing z order;
// flip this to TRUE to test that it doesn't matter.
Bool_t reversez = kFALSE;
// One shouldn't be creating malformed polygons
// but to test what happens when one does here's a flag.
// The effect will be only apparent in solid rendering mode
Bool_t domalformed = kFALSE;
// domalformed = kTRUE;
c1 = new TCanvas("c1","sample TXTRU Shapes",200,10,640,640);
// Create a new geometry
TGeometry* geom = new TGeometry("sample","sample");
geom->cd();
// Define the complexity of the drawing
Float_t zseg = 6; // either 2 or 6
Int_t extravis = 0; // make extra z "arrow" visible
Float_t unit = 1;
// Create a large BRIK to embed things into
Float_t bigdim = 12.5*unit;
TBRIK* world = new TBRIK("world","world","void",bigdim,bigdim,bigdim);
// Create the main node, make it invisible
TNode* worldnode = new TNode("worldnode","world node",world);
worldnode->SetVisibility(0);
worldnode->cd();
// Canonical shape ... gets further modified by scale factors
// to create convex (and malformed) versions
Float_t x[] = { -0.50, -1.20, 1.20, 0.50, 0.50, 1.20, -1.20, -0.50 };
Float_t y[] = { -0.75, -2.00, -2.00, -0.75, 0.75, 2.00, 2.00, 0.75 };
Float_t z[] = { -0.50, -1.50, -1.50, 1.50, 1.50, 0.50 };
Float_t s[] = { 0.50, 1.00, 1.50, 1.50, 1.00, 0.50 };
Int_t nxy = sizeof(x)/sizeof(Float_t);
Float_t convexscale[] = { 7.0, -1.0, 1.5 };
Int_t icolor[] = { 1, 2, 3, 2, 2, 2, 4, 2, 6 };
// xycase and zcase: 0=convex, 1=malformed, 2=concave
// this will either create a 2x2 matrix of shapes
// or a 3x3 array (if displaying malformed versions)
for (Int_t zcase = 0; zcase<3; zcase++) {
if (zcase == 1 && !domalformed) continue;
for (Int_t xycase = 0; xycase<3; xycase++) {
if (xycase == 1 && !domalformed) continue;
Char_t *name = "txtruXYZ";
sprintf(name,"txtru%1d%1d%1d",xycase,zcase,zseg);
TXTRU* mytxtru = new TXTRU(name,name,"void",8,2);
Int_t i, j;
Float_t xsign = (makecw) ? -1 : 1;
Float_t zsign = (reversez) ? -1 : 1;
// set the vertex points
for (i=0; i<nxy; i++) {
Float_t xtmp = x[i]*xsign;
Float_t ytmp = y[i];
if (i==0||i==3||i==4||i==7) xtmp *= convexscale[xycase];
if (xycase==2) xtmp *=2;
mytxtru->DefineVertex(i,xtmp,ytmp);
}
// set the z segment positions and scales
for (i=0, j=0; i<zseg; i++) {
Float_t ztmp = z[i]*zsign;
if (i==0||i==5) ztmp *= convexscale[zcase];
if (zcase==2) ztmp *= 2.5;
if (zseg>2 && zcase!=2 && (i==1||i==4)) continue;
mytxtru->DefineSection(j,ztmp,s[i]);
j++;
}
TNode* txtrunode = new TNode(name,name,mytxtru);
txtrunode->SetLineColor(icolor[3*zcase+xycase]);
Float_t pos_scale = (domalformed) ? 10 : 6;
Float_t xpos = (xycase-1)*pos_scale*unit;
Float_t ypos = (zcase-1)*pos_scale*unit;
txtrunode->SetPosition(xpos,ypos,0.);
}
}
// Some extra shapes to show the direction of "z"
Float_t zhalf = 0.5*bigdim;
Float_t rmax = 0.03*bigdim;
TCONE* zcone = new TCONE("zcone","zcone","void",zhalf,0.,rmax,0.,0.);
zcone->SetVisibility(extravis);
TNode* zconenode = new TNode("zconenode","zconenode",zcone);
zconenode->SetLineColor(3);
Float_t dzstub = 2*rmax;
TBRIK* zbrik = new TBRIK("zbrik","zbrik","void",rmax,rmax,dzstub);
zbrik->SetVisibility(extravis);
TNode* zbriknode = new TNode("zbriknode","zbriknode",zbrik);
zbriknode->SetPosition(0.,0.,zhalf+dzstub);
zbriknode->SetLineColor(3);
// geom->ls();
geom->Draw();
// Tweak the pad so that it displays the entire geometry undistorted
TVirtualPad *thisPad = gPad;
if (thisPad) {
TView *view = thisPad->GetView();
if (!view) return;
Double_t min[3],max[3],center[3];
view->GetRange(min,max);
int i;
// Find the boxed center
for (i=0;i<3; i++) center[i] = 0.5*(max[i]+min[i]);
Double_t maxSide = 0;
// Find the largest side
for (i=0;i<3; i++) maxSide = TMath::Max(maxSide,max[i]-center[i]);
file://Adjust scales:
for (i=0;i<3; i++) {
max[i] = center[i] + maxSide;
min[i] = center[i] - maxSide;
}
view->SetRange(min,max);
thisPad->Modified();
thisPad->Update();
}
}
