doc/v628/geodemo_8C_source.html

/// \file

/// \ingroup tutorial_geom

/// GUI to draw the geometry shapes.

///

/// \macro_code

///

/// \author Andrei Gheata


#include "TMath.h"

#include "TControlBar.h"

#include "TRandom3.h"

#include "TROOT.h"

#include "TSystem.h"

#include "TVirtualPad.h"

#include "TCanvas.h"

#include "TVirtualGeoPainter.h"

#include "TGeoManager.h"

#include "TGeoNode.h"

#include "TView.h"

#include "TPaveText.h"

#include "TGeoBBox.h"

#include "TGeoPara.h"

#include "TGeoTube.h"

#include "TGeoCone.h"

#include "TGeoEltu.h"

#include "TGeoSphere.h"

#include "TGeoTorus.h"

#include "TGeoTrd1.h"

#include "TGeoTrd2.h"

#include "TGeoParaboloid.h"

#include "TGeoHype.h"

#include "TGeoPcon.h"

#include "TGeoPgon.h"

#include "TGeoArb8.h"

#include "TGeoXtru.h"

#include "TGeoCompositeShape.h"

#include "TGeoTessellated.h"

#include "TGeoPhysicalNode.h"


Bool_t comments = kTRUE;

Bool_t raytracing = kFALSE;

Bool_t grotate = kFALSE;

Bool_t axis = kTRUE;


//______________________________________________________________________________

void MakePicture()

{

   TView *view = gPad->GetView();

   if (view) {

//      view->RotateView(248,66);

      if (axis) view->ShowAxis();

   }

   Bool_t is_raytracing = gGeoManager->GetTopVolume()->IsRaytracing();

   if (is_raytracing != raytracing) {

      gGeoManager->GetTopVolume()->SetVisRaytrace(raytracing);

      gPad->Modified();

      gPad->Update();

   }

}


//______________________________________________________________________________

void AddMemberInfo(TPaveText *pave, const char *datamember, Double_t value, const char *comment)

{

   TString line = datamember;

   while (line.Length() < 10) line.Append(" ");

   line.Append(TString::Format("= %5.2f  => %s", value, comment));

   TText *text = pave->AddText(line.Data());

//   text->SetTextColor(4);

   text->SetTextAlign(12);//12

}


//______________________________________________________________________________

void AddMemberInfo(TPaveText *pave, const char *datamember, Int_t value, const char *comment)

{

   TString line = datamember;

   while (line.Length() < 10) line.Append(" ");

   line.Append(TString::Format("= %5d  => %s", value, comment));

   TText *text = pave->AddText(line.Data());

//   text->SetTextColor(4);

   text->SetTextAlign(12);

}


//______________________________________________________________________________

void AddFinderInfo(TPaveText *pave, TObject *pf, Int_t iaxis)

{

   TGeoPatternFinder *finder = dynamic_cast<TGeoPatternFinder *>(pf);

   if (!pave || !pf || !iaxis) return;

   TGeoVolume *volume = finder->GetVolume();

   TGeoShape *sh = volume->GetShape();

   TText *text = pave->AddText(TString::Format("Division of %s on axis %d (%s)", volume->GetName(), iaxis, sh->GetAxisName(iaxis)));

   text->SetTextColor(3);

   text->SetTextAlign(12);

   AddMemberInfo(pave, "fNdiv", finder->GetNdiv(), "number of divisions");

   AddMemberInfo(pave, "fStart", finder->GetStart(), "start divisioning position");

   AddMemberInfo(pave, "fStep", finder->GetStep(), "division step");

}


//______________________________________________________________________________

void AddExecInfo(TPaveText *pave, const char *name = nullptr, const char *axisinfo = nullptr)

{

   if (name && axisinfo) {

      auto text = pave->AddText(TString::Format("Execute: %s(iaxis, ndiv, start, step) to divide this.", name));

      text->SetTextColor(4);

      pave->AddText(TString::Format("----- IAXIS can be %s", axisinfo));

      pave->AddText("----- NDIV must be a positive integer");

      pave->AddText("----- START must be a valid axis offset within shape range on divided axis");

      pave->AddText("----- STEP is the division step. START+NDIV*STEP must be in range also");

      pave->AddText("----- If START and STEP are omitted, all range of the axis will be divided");

      pave->SetAllWith("-----","color",2);

      pave->SetAllWith("-----","font",72);

      pave->SetAllWith("-----","size",0.04);

   } else if (name) {

      auto text = pave->AddText(TString::Format("Execute: %s()", name));

      text->SetTextColor(4);

   }


   pave->AddText(" ");

   pave->SetTextSize(0.044);

   pave->SetTextAlign(12);

}


//______________________________________________________________________________

void SavePicture(const char *name, TObject *objcanvas, TObject *objvol, Int_t iaxis, Double_t step)

{

   TCanvas *c = (TCanvas*)objcanvas;

   TGeoVolume *vol = (TGeoVolume*)objvol;

   if (!c || !vol) return;

   c->cd();

   TString fname;

   if (iaxis == 0)

      fname.Form("t_%s.gif",name);

   else if (step == 0)

      fname.Form("t_%sdiv%s.gif", name, vol->GetShape()->GetAxisName(iaxis));

   else

      fname.Form("t_%sdivstep%s.gif", name, vol->GetShape()->GetAxisName(iaxis));


   c->Print(fname.Data());

}


//______________________________________________________________________________

Int_t randomColor()

{

   Double_t color = 7.*gRandom->Rndm();

   return (1+Int_t(color));

}


//______________________________________________________________________________

void raytrace() {

   raytracing = !raytracing;

   if (gGeoManager && gPad) {

      auto top = gGeoManager->GetTopVolume();

      bool drawn = gPad->GetListOfPrimitives()->FindObject(top);

      if (drawn) top->SetVisRaytrace(raytracing);

      gPad->Modified();

      gPad->Update();

   }

}


//______________________________________________________________________________

void help() {


   auto c =(TCanvas *) gROOT->GetListOfCanvases()->FindObject("geom_help");

   if (c) {

      c->Clear();

      c->Update();

      c->cd();

   } else {

      c = new TCanvas("geom_help","Help to run demos",200,10,700,600);

   }


   TPaveText *welcome = new TPaveText(.1,.8,.9,.97);

   welcome->AddText("Welcome to the new geometry package");

   welcome->SetTextFont(32);

   welcome->SetTextColor(4);

   welcome->SetFillColor(24);

   welcome->Draw();


   TPaveText *hdemo = new TPaveText(.05,.05,.95,.7);

   hdemo->SetTextAlign(12);

   hdemo->SetTextFont(52);

   hdemo->AddText("- Demo for building TGeo basic shapes and simple geometry. Shape parameters are");

   hdemo->AddText("  displayed in the right pad");

   hdemo->AddText("- Click left mouse button to execute one demo");

   hdemo->AddText("- While pointing the mouse to the pad containing the geometry, do:");

   hdemo->AddText("- .... click-and-move to rotate");

   hdemo->AddText("- .... press j/k to zoom/unzoom");

   hdemo->AddText("- .... press l/h/u/i to move the view center around");

   hdemo->AddText("- Click Ray-trace ON/OFF to toggle ray-tracing");

   hdemo->AddText("- Use <View with x3d> from the <View> menu to get an x3d view");

   hdemo->AddText("- .... same methods to rotate/zoom/move the view");

   hdemo->AddText("- Execute box(1,8) to divide a box in 8 equal slices along X");

   hdemo->AddText("- Most shapes can be divided on X,Y,Z,Rxy or Phi :");

   hdemo->AddText("- .... root[0] <shape>(IAXIS, NDIV, START, STEP);");

   hdemo->AddText("  .... IAXIS = 1,2,3 meaning (X,Y,Z) or (Rxy, Phi, Z)");

   hdemo->AddText("  .... NDIV  = number of slices");

   hdemo->AddText("  .... START = start slicing position");

   hdemo->AddText("  .... STEP  = division step");

   hdemo->AddText("- Click Comments ON/OFF to toggle comments");

   hdemo->AddText("- Click Ideal/Align geometry to see how alignment works");

   hdemo->AddText(" ");

   hdemo->SetAllWith("....","color",2);

   hdemo->SetAllWith("....","font",72);

   hdemo->SetAllWith("....","size",0.03);


   hdemo->Draw();


   c->Update();

}


//______________________________________________________________________________

void autorotate()

{

   grotate = !grotate;

   if (!grotate) {

      gROOT->SetInterrupt(kTRUE);

      return;

   }

   if (!gPad) return;

   TView *view = gPad->GetView();

   if (!view) return;

   if (!gGeoManager) return;

   TVirtualGeoPainter *painter = gGeoManager->GetGeomPainter();

   if (!painter) return;

   Double_t longit = view->GetLongitude();

//   Double_t lat = view->GetLatitude();

//   Double_t psi = view->GetPsi();

   Double_t dphi = 1.;

   Int_t irep;

   TProcessEventTimer *timer = new TProcessEventTimer(5);

   gROOT->SetInterrupt(kFALSE);

   while (grotate) {

      if (timer->ProcessEvents()) break;

      if (gROOT->IsInterrupted()) break;

      longit += dphi;

      if (longit>360) longit -= 360.;

      if (!gPad) {

         grotate = kFALSE;

         return;

      }

      view = gPad->GetView();

      if (!view) {

         grotate = kFALSE;

         return;

      }

      view->SetView(longit,view->GetLatitude(),view->GetPsi(),irep);

      gPad->Modified();

      gPad->Update();

   }

   delete timer;

}


//______________________________________________________________________________

void axes()

{

   axis = !axis;

   TView *view = gPad ? gPad->GetView() : nullptr;

   if(view)

      view->ShowAxis();

}


//______________________________________________________________________________

TCanvas *create_canvas(const char *title)

{

   auto c = (TCanvas *) gROOT->GetListOfCanvases()->FindObject("geom_draw");

   if (c) {

      c->Clear();

      c->Update();

      c->SetTitle(title);

   } else {

      c = new TCanvas("geom_draw", title, 700,1000);

   }

   if (comments) {

      c->Divide(1,2,0,0);

      c->GetPad(2)->SetPad(0,0,1,0.4);

      c->GetPad(1)->SetPad(0,0.4,1,1);

      c->cd(1);

   }


   return c;

}


//______________________________________________________________________________

void box(Int_t iaxis=0, Int_t ndiv=8, Double_t start=0, Double_t step=0)

{

   auto c = create_canvas("A simple box");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("box", "A simple box");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakeBox("BOX",med, 20,30,40);

   vol->SetLineColor(randomColor());

   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   if ((iaxis > 0) && (iaxis < 4)) {

      TGeoVolume *slice = vol->Divide("SLICE",iaxis,ndiv,start,step);

      if (!slice) return;

      slice->SetLineColor(randomColor());

   }

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TGeoBBox *box = (TGeoBBox *) vol->GetShape();

   TText *text = pt->AddText("TGeoBBox - box class");

   text->SetTextColor(2);

   AddMemberInfo(pt, "fDX", box->GetDX(), "half length in X");

   AddMemberInfo(pt, "fDY", box->GetDY(), "half length in Y");

   AddMemberInfo(pt, "fDZ", box->GetDZ(), "half length in Z");

   AddMemberInfo(pt, "fOrigin[0]", (box->GetOrigin())[0], "box origin on X");

   AddMemberInfo(pt, "fOrigin[1]", (box->GetOrigin())[1], "box origin on Y");

   AddMemberInfo(pt, "fOrigin[2]", (box->GetOrigin())[2], "box origin on Z");

   AddFinderInfo(pt, vol->GetFinder(), iaxis);

   AddExecInfo(pt, "box", "1, 2 or 3 (X, Y, Z)");

   pt->Draw();

//   SavePicture("box",c,vol,iaxis,step);

   c->cd(1);

}


//______________________________________________________________________________

void para(Int_t iaxis=0, Int_t ndiv=8, Double_t start=0, Double_t step=0)

{

   auto c = create_canvas("A parallelepiped");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("para", "A parallelepiped");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakePara("PARA",med, 20,30,40,30,15,30);

   vol->SetLineColor(randomColor());

   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   if ((iaxis > 0) && (iaxis < 4)) {

      TGeoVolume *slice = vol->Divide("SLICE",iaxis,ndiv,start,step);

      if (!slice) return;

      slice->SetLineColor(randomColor());

   } else if (iaxis) {

      printf("Wrong division axis %d. Allowed range is 1-3.\n", iaxis);

      return;

   }

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TGeoPara *para = (TGeoPara *) vol->GetShape();

   TText *text = pt->AddText("TGeoPara - parallelepiped class");

   text->SetTextColor(2);

   AddMemberInfo(pt, "fX", para->GetX(), "half length in X");

   AddMemberInfo(pt, "fY", para->GetY(), "half length in Y");

   AddMemberInfo(pt, "fZ", para->GetZ(), "half length in Z");

   AddMemberInfo(pt, "fAlpha", para->GetAlpha(), "angle about Y of the Z bases");

   AddMemberInfo(pt, "fTheta", para->GetTheta(), "inclination of para axis about Z");

   AddMemberInfo(pt, "fPhi", para->GetPhi(), "phi angle of para axis");

   AddFinderInfo(pt, vol->GetFinder(), iaxis);

   AddExecInfo(pt, "para", "1, 2 or 3 (X, Y, Z)");

   pt->Draw();

   c->cd(1);

//   SavePicture("para",c,vol,iaxis,step);

}


//______________________________________________________________________________

void tube(Int_t iaxis=0, Int_t ndiv=8, Double_t start=0, Double_t step=0)

{

   auto c = create_canvas("A tube");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("tube", "poza2");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakeTube("TUBE",med, 20,30,40);

   vol->SetLineColor(randomColor());

   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   if ((iaxis > 0) && (iaxis < 4)) {

      TGeoVolume *slice = vol->Divide("SLICE",iaxis,ndiv,start,step);

      if (!slice) return;

      slice->SetLineColor(randomColor());

   } else if (iaxis) {

      printf("Wrong division axis %d. Allowed range is 1-3.\n", iaxis);

      return;

   }

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TGeoTube *tube = (TGeoTube*)(vol->GetShape());

   TText *text = pt->AddText("TGeoTube - tube class");

   text->SetTextColor(2);

   AddMemberInfo(pt,"fRmin",tube->GetRmin(),"minimum radius");

   AddMemberInfo(pt,"fRmax",tube->GetRmax(),"maximum radius");

   AddMemberInfo(pt,"fDZ",  tube->GetDZ(),  "half length in Z");

   AddFinderInfo(pt, vol->GetFinder(), iaxis);

   AddExecInfo(pt, "tube", "1, 2 or 3 (Rxy, Phi, Z)");

   pt->Draw();

   c->cd(1);

//   SavePicture("tube",c,vol,iaxis,step);

}


//______________________________________________________________________________

void tubeseg(Int_t iaxis=0, Int_t ndiv=8, Double_t start=0, Double_t step=0)

{

   auto c = create_canvas("A tube segment");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("tubeseg", "poza3");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakeTubs("TUBESEG",med, 20,30,40,-30,270);

   vol->SetLineColor(randomColor());

   if ((iaxis > 0) && (iaxis < 4)) {

      TGeoVolume *slice = vol->Divide("SLICE",iaxis,ndiv,start,step);

      if (!slice) return;

      slice->SetLineColor(randomColor());

   } else if (iaxis) {

      printf("Wrong division axis %d. Allowed range is 1-3.\n", iaxis);

      return;

   }


   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TGeoTubeSeg *tubeseg = (TGeoTubeSeg*)(vol->GetShape());

   TText *text = pt->AddText("TGeoTubeSeg - tube segment class");

   text->SetTextColor(2);

   AddMemberInfo(pt,"fRmin",tubeseg->GetRmin(),"minimum radius");

   AddMemberInfo(pt,"fRmax",tubeseg->GetRmax(),"maximum radius");

   AddMemberInfo(pt,"fDZ",  tubeseg->GetDZ(),  "half length in Z");

   AddMemberInfo(pt,"fPhi1",tubeseg->GetPhi1(),"first phi limit");

   AddMemberInfo(pt,"fPhi2",tubeseg->GetPhi2(),"second phi limit");

   AddFinderInfo(pt, vol->GetFinder(), iaxis);

   AddExecInfo(pt, "tubeseg", "1, 2 or 3 (Rxy, Phi, Z)");

   pt->Draw();

   c->cd(1);

//   SavePicture("tubeseg",c,vol,iaxis,step);

}


//______________________________________________________________________________

void ctub(Int_t iaxis=0, Int_t ndiv=8, Double_t start=0, Double_t step=0)

{

   auto c = create_canvas("A cut tube segment");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("ctub", "poza3");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   Double_t theta = 160.*TMath::Pi()/180.;

   Double_t phi   = 30.*TMath::Pi()/180.;

   Double_t nlow[3];

   nlow[0] = TMath::Sin(theta)*TMath::Cos(phi);

   nlow[1] = TMath::Sin(theta)*TMath::Sin(phi);

   nlow[2] = TMath::Cos(theta);

   theta = 20.*TMath::Pi()/180.;

   phi   = 60.*TMath::Pi()/180.;

   Double_t nhi[3];

   nhi[0] = TMath::Sin(theta)*TMath::Cos(phi);

   nhi[1] = TMath::Sin(theta)*TMath::Sin(phi);

   nhi[2] = TMath::Cos(theta);

   TGeoVolume *vol = gGeoManager->MakeCtub("CTUB",med, 20,30,40,-30,250, nlow[0], nlow[1], nlow[2], nhi[0],nhi[1],nhi[2]);

   vol->SetLineColor(randomColor());

   if (iaxis == 1 || iaxis == 2) {

      TGeoVolume *slice = vol->Divide("SLICE",iaxis,ndiv,start,step);

      if (!slice) return;

      slice->SetLineColor(randomColor());

   } else if (iaxis) {

      printf("Wrong division axis %d. Allowed range is 1-2.\n", iaxis);

      return;

   }


   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TGeoTubeSeg *tubeseg = (TGeoTubeSeg*)(vol->GetShape());

   TText *text = pt->AddText("TGeoTubeSeg - tube segment class");

   text->SetTextColor(2);

   AddMemberInfo(pt,"fRmin",tubeseg->GetRmin(),"minimum radius");

   AddMemberInfo(pt,"fRmax",tubeseg->GetRmax(),"maximum radius");

   AddMemberInfo(pt,"fDZ",  tubeseg->GetDZ(),  "half length in Z");

   AddMemberInfo(pt,"fPhi1",tubeseg->GetPhi1(),"first phi limit");

   AddMemberInfo(pt,"fPhi2",tubeseg->GetPhi2(),"second phi limit");

   AddFinderInfo(pt, vol->GetFinder(), iaxis);

   AddExecInfo(pt, "ctub", "1 or 2");

   pt->Draw();

   c->cd(1);

//   SavePicture("tubeseg",c,vol,iaxis,step);

}


//______________________________________________________________________________

void cone(Int_t iaxis=0, Int_t ndiv=8, Double_t start=0, Double_t step=0)

{

   auto c = create_canvas("A cone");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("cone", "poza4");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakeCone("CONE",med, 40,10,20,35,45);

   vol->SetLineColor(randomColor());

   vol->SetLineWidth(2);

   if (iaxis == 2 || iaxis == 3) {

      TGeoVolume *slice = vol->Divide("SLICE",iaxis,ndiv,start,step);

      if (!slice) return;

      slice->SetLineColor(randomColor());

   } else if (iaxis) {

      printf("Wrong division axis %d. Allowed range is 2-3.\n", iaxis);

      return;

   }

   top->AddNode(vol,1);

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TGeoCone *cone = (TGeoCone*)(vol->GetShape());

   TText *text = pt->AddText("TGeoCone - cone class");

   text->SetTextColor(2);

   AddMemberInfo(pt,"fDZ",  cone->GetDZ(),    "half length in Z");

   AddMemberInfo(pt,"fRmin1",cone->GetRmin1(),"inner radius at -dz");

   AddMemberInfo(pt,"fRmax1",cone->GetRmax1(),"outer radius at -dz");

   AddMemberInfo(pt,"fRmin2",cone->GetRmin2(),"inner radius at +dz");

   AddMemberInfo(pt,"fRmax2",cone->GetRmax2(),"outer radius at +dz");

   AddFinderInfo(pt, vol->GetFinder(), iaxis);

   AddExecInfo(pt, "cone", "2 or 3 (Phi, Z)");

   pt->Draw();

   c->cd(1);

//   SavePicture("cone",c,vol,iaxis,step);

}


//______________________________________________________________________________

void coneseg(Int_t iaxis=0, Int_t ndiv=8, Double_t start=0, Double_t step=0)

{

   auto c = create_canvas("A cone segment");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("coneseg", "poza5");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakeCons("CONESEG",med, 40,30,40,10,20,-30,250);

   vol->SetLineColor(randomColor());

//   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   if (iaxis >= 2 && iaxis <= 3) {

      TGeoVolume *slice = vol->Divide("SLICE",iaxis,ndiv,start,step);

      if (!slice) return;

      slice->SetLineColor(randomColor());

   } else if (iaxis) {

      printf("Wrong division axis %d. Allowed range is 2-3.\n", iaxis);

      return;

   }

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TGeoConeSeg *coneseg = (TGeoConeSeg*)(vol->GetShape());

   TText *text = pt->AddText("TGeoConeSeg - coneseg class");

   text->SetTextColor(2);

   AddMemberInfo(pt, "fDZ", coneseg->GetDZ(), "half length in Z");

   AddMemberInfo(pt, "fRmin1", coneseg->GetRmin1(), "inner radius at -dz");

   AddMemberInfo(pt, "fRmax1", coneseg->GetRmax1(), "outer radius at -dz");

   AddMemberInfo(pt, "fRmin2", coneseg->GetRmin1(), "inner radius at +dz");

   AddMemberInfo(pt, "fRmax2", coneseg->GetRmax1(), "outer radius at +dz");

   AddMemberInfo(pt, "fPhi1", coneseg->GetPhi1(), "first phi limit");

   AddMemberInfo(pt, "fPhi2", coneseg->GetPhi2(), "second phi limit");

   AddFinderInfo(pt, vol->GetFinder(), iaxis);

   AddExecInfo(pt, "coneseg", "2 or 3 (Phi, Z)");

   pt->Draw();

   c->cd(1);

//   SavePicture("coneseg",c,vol,iaxis,step);

}


//______________________________________________________________________________

void eltu(Int_t iaxis=0, Int_t ndiv=8, Double_t start=0, Double_t step=0)

{

   auto c = create_canvas("An Elliptical tube");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("eltu", "poza6");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakeEltu("ELTU",med, 30,10,40);

   vol->SetLineColor(randomColor());

//   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   if (iaxis >= 2 && iaxis <= 3) {

      TGeoVolume *slice = vol->Divide("SLICE",iaxis,ndiv,start,step);

      if (!slice) return;

      slice->SetLineColor(randomColor());

   } else if (iaxis) {

      printf("Wrong division axis %d. Allowed range is 2-3.\n", iaxis);

      return;

   }

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TGeoEltu *eltu = (TGeoEltu*)(vol->GetShape());

   TText *text = pt->AddText("TGeoEltu - eltu class");

   text->SetTextColor(2);

   AddMemberInfo(pt,"fA",eltu->GetA(), "semi-axis along x");

   AddMemberInfo(pt,"fB",eltu->GetB(), "semi-axis along y");

   AddMemberInfo(pt,"fDZ", eltu->GetDZ(),  "half length in Z");

   AddFinderInfo(pt, vol->GetFinder(), iaxis);

   AddExecInfo(pt, "eltu", "2 or 3 (Phi, Z)");

   pt->Draw();

   c->cd(1);

//   SavePicture("eltu",c,vol,iaxis,step);

}


//______________________________________________________________________________

void sphere()

{

   auto c = create_canvas("A spherical sector");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("sphere", "poza7");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakeSphere("SPHERE",med, 30,40,60,120,30,240);

   vol->SetLineColor(randomColor());

   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TGeoSphere *sphere = (TGeoSphere*)(vol->GetShape());

   TText *text = pt->AddText("TGeoSphere- sphere class");

   text->SetTextColor(2);

   AddMemberInfo(pt, "fRmin", sphere->GetRmin(), "inner radius");

   AddMemberInfo(pt, "fRmax", sphere->GetRmax(), "outer radius");

   AddMemberInfo(pt, "fTheta1", sphere->GetTheta1(), "lower theta limit");

   AddMemberInfo(pt, "fTheta2", sphere->GetTheta2(), "higher theta limit");

   AddMemberInfo(pt, "fPhi1", sphere->GetPhi1(), "lower phi limit");

   AddMemberInfo(pt, "fPhi2", sphere->GetPhi2(), "higher phi limit");

   AddExecInfo(pt, "sphere");

   pt->Draw();

   c->cd(1);

//   SavePicture("sphere",c,vol,iaxis,step);

}


//______________________________________________________________________________

void torus()

{

   auto c = create_canvas("A toroidal segment");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("torus", "poza2");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakeTorus("TORUS",med, 40,20,25,0,270);

   vol->SetLineColor(randomColor());

   top->AddNode(vol,1);

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TGeoTorus *tor = (TGeoTorus*)(vol->GetShape());

   TText *text = pt->AddText("TGeoTorus - torus class");

   text->SetTextColor(2);

   AddMemberInfo(pt, "fR", tor->GetR(), "radius of the ring");

   AddMemberInfo(pt, "fRmin", tor->GetRmin(), "minimum radius");

   AddMemberInfo(pt, "fRmax", tor->GetRmax(), "maximum radius");

   AddMemberInfo(pt, "fPhi1", tor->GetPhi1(), "starting phi angle");

   AddMemberInfo(pt, "fDphi", tor->GetDphi(), "phi range");

   AddExecInfo(pt, "torus");

   pt->Draw();

   c->cd(1);

}


//______________________________________________________________________________

void trd1(Int_t iaxis=0, Int_t ndiv=8, Double_t start=0, Double_t step=0)

{

   auto c = create_canvas("A trapezoid with dX varying");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("trd1", "poza8");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakeTrd1("Trd1",med, 10,20,30,40);

   vol->SetLineColor(randomColor());

   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   if (iaxis == 2 || iaxis == 3) {

      TGeoVolume *slice = vol->Divide("SLICE",iaxis,ndiv,start,step);

      if (!slice) return;

      slice->SetLineColor(randomColor());

   } else if (iaxis) {

      printf("Wrong division axis %d. Allowed range is 2-3.\n", iaxis);

      return;

   }

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TGeoTrd1 *trd1 = (TGeoTrd1 *) vol->GetShape();

   TText *text = pt->AddText("TGeoTrd1 - Trd1 class");

   text->SetTextColor(2);

   AddMemberInfo(pt,"fDx1",trd1->GetDx1(),"half length in X at lower Z surface(-dz)");

   AddMemberInfo(pt,"fDx2",trd1->GetDx2(),"half length in X at higher Z surface(+dz)");

   AddMemberInfo(pt,"fDy",trd1->GetDy(),"half length in Y");

   AddMemberInfo(pt,"fDz",trd1->GetDz(),"half length in Z");

   AddFinderInfo(pt, vol->GetFinder(), iaxis);

   AddExecInfo(pt, "trd1", "2 or 3 (Y, Z)");

   pt->Draw();

   c->cd(1);

//   SavePicture("trd1",c,vol,iaxis,step);

}


//______________________________________________________________________________

void parab()

{

   auto c = create_canvas("A paraboloid segment");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("parab", "paraboloid");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakeParaboloid("PARAB",med,0, 40, 50);

   TGeoParaboloid *par = (TGeoParaboloid*)vol->GetShape();

   vol->SetLineColor(randomColor());

   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TText *text = pt->AddText("TGeoParaboloid - Paraboloid class");

   text->SetTextColor(2);

   AddMemberInfo(pt,"fRlo",par->GetRlo(),"radius at Z=-dz");

   AddMemberInfo(pt,"fRhi",par->GetRhi(),"radius at Z=+dz");

   AddMemberInfo(pt,"fDz",par->GetDz(),"half-length on Z axis");

   pt->AddText("----- A paraboloid is described by the equation:");

   pt->AddText("-----    z = a*r*r + b;   where: r = x*x + y*y");

   pt->AddText("----- Create with:    TGeoParaboloid *parab = new TGeoParaboloid(rlo, rhi, dz);");

   pt->AddText("-----    dz:  half-length in Z (range from -dz to +dz");

   pt->AddText("-----    rlo: radius at z=-dz given by: -dz = a*rlo*rlo + b");

   pt->AddText("-----    rhi: radius at z=+dz given by:  dz = a*rhi*rhi + b");

   pt->AddText("-----      rlo != rhi; both >= 0");

   AddExecInfo(pt, "parab");

   pt->Draw();

   c->cd(1);

}


//______________________________________________________________________________

void hype()

{

   auto c = create_canvas("A hyperboloid");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("hype", "hyperboloid");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakeHype("HYPE",med,10, 45 ,20,45,40);

   TGeoHype *hype = (TGeoHype*)vol->GetShape();

   vol->SetLineColor(randomColor());

   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TText *text = pt->AddText("TGeoHype - Hyperboloid class");

   text->SetTextColor(2);

   AddMemberInfo(pt, "fRmin", hype->GetRmin(), "minimum inner radius");

   AddMemberInfo(pt, "fStIn", hype->GetStIn(), "inner surface stereo angle [deg]");

   AddMemberInfo(pt, "fRmax", hype->GetRmax(), "minimum outer radius");

   AddMemberInfo(pt, "fStOut",hype->GetStOut(),"outer surface stereo angle [deg]");

   AddMemberInfo(pt, "fDz",   hype->GetDz(),   "half-length on Z axis");

   pt->AddText("----- A hyperboloid is described by the equation:");

   pt->AddText("-----    r^2 - (tan(stereo)*z)^2 = rmin^2;   where: r = x*x + y*y");

   pt->AddText("----- Create with:    TGeoHype *hype = new TGeoHype(rin, stin, rout, stout, dz);");

   pt->AddText("-----      rin < rout; rout > 0");

   pt->AddText("-----      rin = 0; stin > 0 => inner surface conical");

   pt->AddText("-----      stin/stout = 0 => corresponding surface cylindrical");

   AddExecInfo(pt, "hype");

   pt->Draw();

   c->cd(1);

}


//______________________________________________________________________________

void pcon(Int_t iaxis=0, Int_t ndiv=8, Double_t start=0, Double_t step=0)

{

   auto c = create_canvas("A polycone");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("pcon", "poza10");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakePcon("PCON",med, -30.0,300,4);

   TGeoPcon *pcon = (TGeoPcon*)(vol->GetShape());

   pcon->DefineSection(0,0,15,20);

   pcon->DefineSection(1,20,15,20);

   pcon->DefineSection(2,20,15,25);

   pcon->DefineSection(3,50,15,20);

   vol->SetLineColor(randomColor());

   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   if (iaxis == 2 || iaxis == 3) {

      TGeoVolume *slice = vol->Divide("SLICE",iaxis,ndiv,start,step);

      if (!slice) return;

      slice->SetLineColor(randomColor());

   } if (iaxis) {

      printf("Wrong division axis %d. Allowed range is 2-3.\n", iaxis);

      return;

   }

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TText *text = pt->AddText("TGeoPcon - pcon class");

   text->SetTextColor(2);

   AddMemberInfo(pt,"fPhi1",pcon->GetPhi1(),"lower phi limit");

   AddMemberInfo(pt,"fDphi",pcon->GetDphi(),"phi range");

   AddMemberInfo(pt,"fNz",pcon->GetNz(),"number of z planes");

   for (Int_t j=0; j<pcon->GetNz(); j++) {

      auto line = TString::Format(

            "fZ[%i]=%5.2f  fRmin[%i]=%5.2f  fRmax[%i]=%5.2f",

            j,pcon->GetZ()[j],j,pcon->GetRmin()[j],j,pcon->GetRmax()[j]);

      text = pt->AddText(line.Data());

      text->SetTextColor(4);

      text->SetTextAlign(12);

   }

   AddFinderInfo(pt, vol->GetFinder(), iaxis);

   AddExecInfo(pt, "pcon", "2 or 3 (Phi, Z)");

   pt->Draw();

   c->cd(1);

//   SavePicture("pcon",c,vol,iaxis,step);

}


//______________________________________________________________________________

void pgon(Int_t iaxis=0, Int_t ndiv=8, Double_t start=0, Double_t step=0)

{

   auto c = create_canvas("A polygone");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("pgon", "poza11");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,150,150,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakePgon("PGON",med, -45.0,270.0,4,4);

   TGeoPgon *pgon = (TGeoPgon*)(vol->GetShape());

   pgon->DefineSection(0,-70,45,50);

   pgon->DefineSection(1,0,35,40);

   pgon->DefineSection(2,0,30,35);

   pgon->DefineSection(3,70,90,100);

   vol->SetLineColor(randomColor());

   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   if (iaxis == 2 || iaxis == 3) {

      TGeoVolume *slice = vol->Divide("SLICE",iaxis,ndiv,start,step);

      if (!slice) return;

      slice->SetLineColor(randomColor());

   } if (iaxis) {

      printf("Wrong division axis %d. Allowed range is 2-3.\n", iaxis);

      return;

   }

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TText *text = pt->AddText("TGeoPgon - pgon class");

   text->SetTextColor(2);

   AddMemberInfo(pt, "fPhi1",  pgon->GetPhi1(),  "lower phi limit");

   AddMemberInfo(pt, "fDphi",  pgon->GetDphi(),  "phi range");

   AddMemberInfo(pt, "fNedges",pgon->GetNedges(),"number of edges");

   AddMemberInfo(pt, "fNz",    pgon->GetNz(),    "number of z planes");

   for (Int_t j=0; j<pgon->GetNz(); j++) {

      auto line = TString::Format(

          "fZ[%i]=%5.2f  fRmin[%i]=%5.2f  fRmax[%i]=%5.2f",

          j,pgon->GetZ()[j],j,pgon->GetRmin()[j],j,pgon->GetRmax()[j]);

      text = pt->AddText(line.Data());

      text->SetTextColor(4);

      text->SetTextAlign(12);

   }

   AddFinderInfo(pt, vol->GetFinder(), iaxis);

   AddExecInfo(pt, "pgon", "2 or 3 (Phi, Z)");

   pt->Draw();

   c->cd(1);

//   SavePicture("pgon",c,vol,iaxis,step);

}


//______________________________________________________________________________

void arb8()

{

   auto c = create_canvas("An arbitrary polyhedron");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("arb8", "poza12");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoArb8 *arb = new TGeoArb8(20);

   arb->SetVertex(0,-30,-25);

   arb->SetVertex(1,-25,25);

   arb->SetVertex(2,5,25);

   arb->SetVertex(3,25,-25);

   arb->SetVertex(4,-28,-23);

   arb->SetVertex(5,-23,27);

   arb->SetVertex(6,-23,27);

   arb->SetVertex(7,13,-27);

   TGeoVolume *vol = new TGeoVolume("ARB8",arb,med);

   vol->SetLineColor(randomColor());

   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TText *text = pt->AddText("TGeoArb8 - arb8 class");

   text->SetTextColor(2);

   AddMemberInfo(pt,"fDz",arb->GetDz(),"Z half length");

   Double_t *vert = arb->GetVertices();

   text = pt->AddText("Vertices on lower Z plane:");

   text->SetTextColor(3);

   for (Int_t i=0; i<4; i++) {

      text = pt->AddText(TString::Format("   fXY[%d] = (%5.2f, %5.2f)", i, vert[2*i], vert[2*i+1]));

      text->SetTextSize(0.043);

      text->SetTextColor(4);

   }

   text = pt->AddText("Vertices on higher Z plane:");

   text->SetTextColor(3);

   for (Int_t i=4; i<8; i++) {

      text = pt->AddText(TString::Format("   fXY[%d] = (%5.2f, %5.2f)", i, vert[2*i], vert[2*i+1]));

      text->SetTextSize(0.043);

      text->SetTextColor(4);

   }


   AddExecInfo(pt, "arb8");

   pt->Draw();

   c->cd(1);

//   SavePicture("arb8",c,vol,iaxis,step);

}


//______________________________________________________________________________

void trd2(Int_t iaxis=0, Int_t ndiv=8, Double_t start=0, Double_t step=0)

{

   auto c = create_canvas("A trapezoid with dX and dY varying with Z");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("trd2", "poza9");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakeTrd2("Trd2",med, 10,20,30,10,40);

   vol->SetLineColor(randomColor());

   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   if (iaxis == 3) {

      TGeoVolume *slice = vol->Divide("SLICE",iaxis,ndiv,start,step);

      if (!slice) return;

      slice->SetLineColor(randomColor());

   } else if (iaxis) {

      printf("Wrong division axis %d. Allowed is only 3.\n", iaxis);

      return;

   }

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TGeoTrd2 *trd2 = (TGeoTrd2*)(vol->GetShape());

   TText *text = pt->AddText("TGeoTrd2 - Trd2 class");

   text->SetTextColor(2);

   AddMemberInfo(pt,"fDx1",trd2->GetDx1(),"half length in X at lower Z surface(-dz)");

   AddMemberInfo(pt,"fDx2",trd2->GetDx2(),"half length in X at higher Z surface(+dz)");

   AddMemberInfo(pt,"fDy1",trd2->GetDy1(),"half length in Y at lower Z surface(-dz)");

   AddMemberInfo(pt,"fDy2",trd2->GetDy2(),"half length in Y at higher Z surface(-dz)");

   AddMemberInfo(pt,"fDz",trd2->GetDz(),"half length in Z");

   AddFinderInfo(pt, vol->GetFinder(), iaxis);

   AddExecInfo(pt, "trd2", "only 3 (Z)");

   pt->Draw();

   c->cd(1);

//   SavePicture("trd2",c,vol,iaxis,step);

}


//______________________________________________________________________________

void trap(Int_t iaxis=0, Int_t ndiv=8, Double_t start=0, Double_t step=0)

{

   auto c = create_canvas("A more general trapezoid");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("trap", "poza10");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakeTrap("Trap",med, 30,15,30,20,10,15,0,20,10,15,0);

   vol->SetLineColor(randomColor());

   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   if (iaxis == 3) {

      TGeoVolume *slice = vol->Divide("SLICE",iaxis,ndiv,start,step);

      if (!slice) return;

      slice->SetLineColor(randomColor());

   } else if (iaxis) {

      printf("Wrong division axis %d. Allowed is only 3.\n", iaxis);

      return;

   }

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TGeoTrap *trap = (TGeoTrap*)(vol->GetShape());

   TText *text = pt->AddText("TGeoTrap - Trapezoid class");

   text->SetTextColor(2);

   AddMemberInfo(pt,"fDz",trap->GetDz(),"half length in Z");

   AddMemberInfo(pt,"fTheta",trap->GetTheta(),"theta angle of trapezoid axis");

   AddMemberInfo(pt,"fPhi",trap->GetPhi(),"phi angle of trapezoid axis");

   AddMemberInfo(pt,"fH1",trap->GetH1(),"half length in y at -fDz");

   AddMemberInfo(pt,"fAlpha1",trap->GetAlpha1(),"angle between centers of x edges and y axis at -fDz");

   AddMemberInfo(pt,"fBl1",trap->GetBl1(),"half length in x at -dZ and y=-fH1");

   AddMemberInfo(pt,"fTl1",trap->GetTl1(),"half length in x at -dZ and y=+fH1");

   AddMemberInfo(pt,"fH2",trap->GetH2(),"half length in y at +fDz");

   AddMemberInfo(pt,"fBl2",trap->GetBl2(),"half length in x at +dZ and y=-fH1");

   AddMemberInfo(pt,"fTl2",trap->GetTl2(),"half length in x at +dZ and y=+fH1");

   AddMemberInfo(pt,"fAlpha2",trap->GetAlpha2(),"angle between centers of x edges and y axis at +fDz");

   AddFinderInfo(pt, vol->GetFinder(), iaxis);

   AddExecInfo(pt, "trap", "only 3 (Z)");

   pt->Draw();

   c->cd(1);

//   SavePicture("trap",c,vol,iaxis,step);

}


//______________________________________________________________________________

void gtra(Int_t iaxis=0, Int_t ndiv=8, Double_t start=0, Double_t step=0)

{

   auto c = create_canvas("A twisted trapezoid");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("gtra", "poza11");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakeGtra("Gtra",med, 30,15,30,30,20,10,15,0,20,10,15,0);

   vol->SetLineColor(randomColor());

   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   if (iaxis == 3) {

      TGeoVolume *slice = vol->Divide("SLICE",iaxis,ndiv,start,step);

      if (!slice) return;

      slice->SetLineColor(randomColor());

   } else if (iaxis) {

      printf("Wrong division axis %d. Allowed is only 3.\n", iaxis);

      return;

   }

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TGeoGtra *trap = (TGeoGtra*)(vol->GetShape());

   TText *text = pt->AddText("TGeoGtra - Twisted trapezoid class");

   text->SetTextColor(2);

   AddMemberInfo(pt,"fDz",trap->GetDz(),"half length in Z");

   AddMemberInfo(pt,"fTheta",trap->GetTheta(),"theta angle of trapezoid axis");

   AddMemberInfo(pt,"fPhi",trap->GetPhi(),"phi angle of trapezoid axis");

   AddMemberInfo(pt,"fTwist",trap->GetTwistAngle(), "twist angle");

   AddMemberInfo(pt,"fH1",trap->GetH1(),"half length in y at -fDz");

   AddMemberInfo(pt,"fAlpha1",trap->GetAlpha1(),"angle between centers of x edges and y axis at -fDz");

   AddMemberInfo(pt,"fBl1",trap->GetBl1(),"half length in x at -dZ and y=-fH1");

   AddMemberInfo(pt,"fTl1",trap->GetTl1(),"half length in x at -dZ and y=+fH1");

   AddMemberInfo(pt,"fH2",trap->GetH2(),"half length in y at +fDz");

   AddMemberInfo(pt,"fBl2",trap->GetBl2(),"half length in x at +dZ and y=-fH1");

   AddMemberInfo(pt,"fTl2",trap->GetTl2(),"half length in x at +dZ and y=+fH1");

   AddMemberInfo(pt,"fAlpha2",trap->GetAlpha2(),"angle between centers of x edges and y axis at +fDz");

   AddFinderInfo(pt, vol->GetFinder(), iaxis);

   AddExecInfo(pt, "gtra", "only 3 (Z)");

   pt->Draw();

   c->cd(1);

//   SavePicture("gtra",c,vol,iaxis,step);

}


//______________________________________________________________________________

void xtru()

{

   auto c = create_canvas("A twisted trapezoid");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("xtru", "poza12");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *vol = gGeoManager->MakeXtru("XTRU",med,4);

   TGeoXtru *xtru = (TGeoXtru*)vol->GetShape();

   Double_t x[8] = {-30,-30,30,30,15,15,-15,-15};

   Double_t y[8] = {-30,30,30,-30,-30,15,15,-30};

   xtru->DefinePolygon(8,x,y);

   xtru->DefineSection(0,-40, -20., 10., 1.5);

   xtru->DefineSection(1, 10, 0., 0., 0.5);

   xtru->DefineSection(2, 10, 0., 0., 0.7);

   xtru->DefineSection(3, 40, 10., 20., 0.9);

   vol->SetLineColor(randomColor());

   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TText *text = pt->AddText("TGeoXtru - Polygonal extrusion class");

   text->SetTextColor(2);

   AddMemberInfo(pt,"fNvert",xtru->GetNvert(),"number of polygone vertices");

   AddMemberInfo(pt,"fNz",xtru->GetNz(),"number of Z sections");

   pt->AddText("----- Any Z section is an arbitrary polygone");

   pt->AddText("----- The shape can have an arbitrary number of Z sections, as for pcon/pgon");

   pt->AddText("----- Create with:    TGeoXtru *xtru = new TGeoXtru(nz);");

   pt->AddText("----- Define the blueprint polygon :");

   pt->AddText("-----                 Double_t x[8] = {-30,-30,30,30,15,15,-15,-15};");

   pt->AddText("-----                 Double_t y[8] = {-30,30,30,-30,-30,15,15,-30};");

   pt->AddText("-----                 xtru->DefinePolygon(8,x,y);");

   pt->AddText("----- Define translations/scales of the blueprint for Z sections :");

   pt->AddText("-----                 xtru->DefineSection(i, Zsection, x0, y0, scale);");

   pt->AddText("----- Sections have to be defined in increasing Z order");

   pt->AddText("----- 2 sections can be defined at same Z (not for first/last sections)");

   AddExecInfo(pt, "xtru");

   pt->Draw();

   c->cd(1);

}


//______________________________________________________________________________

void tessellated()

{

   // Create a [triacontahedron solid](https://en.wikipedia.org/wiki/Rhombic_triacontahedron)


   auto c = create_canvas("A tessellated shape");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("tessellated", "tessellated");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,10,10,10);

   gGeoManager->SetTopVolume(top);

   TGeoTessellated *tsl = new TGeoTessellated("triaconthaedron", 30);

   const Double_t sqrt5 = TMath::Sqrt(5.);

   std::vector<Tessellated::Vertex_t> vert;

   vert.reserve(120);

   vert.emplace_back(0, 0.5 * (1 + sqrt5), -1); vert.emplace_back(0, 0.5 * (-1 + sqrt5), 0.5 * (-1 - sqrt5)); vert.emplace_back(-1, 0, 0.5 * (-1 - sqrt5)); vert.emplace_back(-1, 1, -1);

   vert.emplace_back(1, 1, -1); vert.emplace_back(0, 0.5 * (1 + sqrt5), -1); vert.emplace_back(0, 0.5 * (-1 + sqrt5), 0.5 * (-1 - sqrt5)); vert.emplace_back(1, 0, 0.5 * (-1 - sqrt5));

   vert.emplace_back(1, 1, -1); vert.emplace_back(0, 0.5 * (1 + sqrt5), -1); vert.emplace_back(0.5 * (-1 + sqrt5),  0.5 * (1 + sqrt5), 0); vert.emplace_back(0.5 * (1 + sqrt5), 1, 0);

   vert.emplace_back(0.5 * (1 - sqrt5), 0.5 * (1 + sqrt5), 0); vert.emplace_back(0, 0.5 * (1 + sqrt5), -1); vert.emplace_back(0.5 * (-1 + sqrt5), 0.5 * (1 + sqrt5), 0); vert.emplace_back(0, 0.5 * (1 + sqrt5), 1);

   vert.emplace_back(0.5 * (1 - sqrt5), 0.5 * (1 + sqrt5), 0); vert.emplace_back(0, 0.5 * (1 + sqrt5), -1); vert.emplace_back(-1, 1, -1); vert.emplace_back(0.5 * (-1 - sqrt5), 1, 0);

   vert.emplace_back(1, 1, -1); vert.emplace_back(0.5 * (1 + sqrt5), 1, 0); vert.emplace_back(0.5 * (1 + sqrt5), 0, 0.5 * (1 - sqrt5)); vert.emplace_back(1, 0, 0.5 * (-1 - sqrt5));

   vert.emplace_back(0.5 * (1 + sqrt5), 0, 0.5 * (1 - sqrt5)); vert.emplace_back(0.5 * (1 + sqrt5), -1, 0); vert.emplace_back(1, -1, -1); vert.emplace_back(1, 0, 0.5 * (-1 - sqrt5));

   vert.emplace_back(1, -1, -1); vert.emplace_back(0, 0.5 * (-1 - sqrt5), -1); vert.emplace_back(0, 0.5 * (1 - sqrt5), 0.5 * (-1 - sqrt5)); vert.emplace_back(1, 0, 0.5 * (-1 - sqrt5));

   vert.emplace_back(1, 0, 0.5 * (-1 - sqrt5)); vert.emplace_back(0, 0.5 * (-1 + sqrt5), 0.5 * (-1 - sqrt5)); vert.emplace_back(-1, 0, 0.5 * (-1 - sqrt5)); vert.emplace_back(0, 0.5 * (1 - sqrt5), 0.5 * (-1 - sqrt5));

   vert.emplace_back(0.5 * (-1 + sqrt5), 0.5 * (1 + sqrt5), 0); vert.emplace_back(0.5 * (1 + sqrt5), 1, 0); vert.emplace_back(1, 1, 1); vert.emplace_back(0, 0.5 * (1 + sqrt5), 1);

   vert.emplace_back(0.5 * (1 + sqrt5), 1, 0); vert.emplace_back(1, 1, 1); vert.emplace_back(1, 0, 0.5 * (1 + sqrt5)); vert.emplace_back(0.5 * (1 + sqrt5), 0, 0.5 * (-1 + sqrt5));

   vert.emplace_back(0.5 * (1 + sqrt5), 0, 0.5 * (1 - sqrt5)); vert.emplace_back(0.5 * (1 + sqrt5), 1, 0); vert.emplace_back(0.5 * (1 + sqrt5), 0, 0.5 * (-1 + sqrt5)); vert.emplace_back(0.5 * (1 + sqrt5), -1, 0);

   vert.emplace_back(0.5 * (1 - sqrt5), 0.5 * (1 + sqrt5), 0); vert.emplace_back(0, 0.5 * (1 + sqrt5), 1); vert.emplace_back(-1, 1, 1); vert.emplace_back(0.5 * (-1 - sqrt5), 1, 0);

   vert.emplace_back(0, 0.5 * (1 + sqrt5), 1); vert.emplace_back(0, 0.5 * (-1 + sqrt5), 0.5 * (1 + sqrt5)); vert.emplace_back(-1, 0, 0.5 * (1 + sqrt5)); vert.emplace_back(-1, 1, 1);

   vert.emplace_back(1, 1, 1); vert.emplace_back(0, 0.5 * (1 + sqrt5), 1); vert.emplace_back(0, 0.5 * (-1 + sqrt5), 0.5 * (1 + sqrt5)); vert.emplace_back(1, 0, 0.5 * (1 + sqrt5));

   vert.emplace_back(0, 0.5 * (1 - sqrt5), 0.5 * (1 + sqrt5)); vert.emplace_back(-1, 0, 0.5 * (1 + sqrt5)); vert.emplace_back(0, 0.5 * (-1 + sqrt5), 0.5 * (1 + sqrt5)); vert.emplace_back(1, 0, 0.5 * (1 + sqrt5));

   vert.emplace_back(0, 0.5 * (1 - sqrt5), 0.5 * (1 + sqrt5)); vert.emplace_back(1, 0, 0.5 * (1 + sqrt5)); vert.emplace_back(1, -1, 1); vert.emplace_back(0, 0.5 * (-1 - sqrt5), 1);

   vert.emplace_back(0.5 * (1 + sqrt5), 0, 0.5 * (-1 + sqrt5)); vert.emplace_back(0.5 * (1 + sqrt5), -1, 0); vert.emplace_back(1, -1, 1); vert.emplace_back(1, 0, 0.5 * (1 + sqrt5));

   vert.emplace_back(-1, 0, 0.5 * (1 + sqrt5)); vert.emplace_back(-1, 1, 1); vert.emplace_back(0.5 * (-1 - sqrt5), 1, 0); vert.emplace_back(0.5 * (-1 - sqrt5), 0, 0.5 * (-1 + sqrt5));

   vert.emplace_back(-1, -1, 1); vert.emplace_back(-1, 0, 0.5 * (1 + sqrt5)); vert.emplace_back(0.5 * (-1 - sqrt5), 0, 0.5 * (-1 + sqrt5)); vert.emplace_back(0.5 * (-1 - sqrt5), -1, 0);

   vert.emplace_back(0, 0.5 * (1 - sqrt5), 0.5 * (1 + sqrt5)); vert.emplace_back(-1, 0, 0.5 * (1 + sqrt5)); vert.emplace_back(-1, -1, 1); vert.emplace_back(0, 0.5 * (-1 - sqrt5), 1);

   vert.emplace_back(0.5 * (-1 - sqrt5), -1, 0); vert.emplace_back(0.5 * (-1 - sqrt5), 0, 0.5 * (1 - sqrt5)); vert.emplace_back(0.5 * (-1 - sqrt5), 1, 0); vert.emplace_back(0.5 * (-1 - sqrt5), 0, 0.5 * (-1 + sqrt5));

   vert.emplace_back(0.5 * (-1 - sqrt5), -1, 0); vert.emplace_back(0.5 * (-1 - sqrt5), 0, 0.5 * (1 - sqrt5)); vert.emplace_back(-1, 0, 0.5 * (-1 - sqrt5)); vert.emplace_back(-1, -1, -1);

   vert.emplace_back(0, 0.5 * (-1 - sqrt5), -1); vert.emplace_back(0.5 * (1 - sqrt5), 0.5 * (-1 - sqrt5), 0); vert.emplace_back(0.5 * (-1 - sqrt5), -1, 0); vert.emplace_back(-1, -1, -1);

   vert.emplace_back(0.5 * (1 - sqrt5), 0.5 * (-1 - sqrt5), 0); vert.emplace_back(0.5 * (-1 - sqrt5), -1, 0); vert.emplace_back(-1, -1, 1); vert.emplace_back(0, 0.5 * (-1 - sqrt5), 1);

   vert.emplace_back(-1, 1, -1); vert.emplace_back(-1, 0, 0.5 * (-1 - sqrt5)); vert.emplace_back(0.5 * (-1 - sqrt5), 0, 0.5 * (1 - sqrt5)); vert.emplace_back(0.5 * (-1 - sqrt5), 1, 0);

   vert.emplace_back(0, 0.5 * (-1 - sqrt5), -1); vert.emplace_back(0, 0.5 * (1 - sqrt5), 0.5 * (-1 - sqrt5)); vert.emplace_back(-1, 0, 0.5 * (-1 - sqrt5)); vert.emplace_back(-1, -1, -1);

   vert.emplace_back(0, 0.5 * (-1 - sqrt5), -1); vert.emplace_back(0.5 * (1 - sqrt5), 0.5 * (-1 - sqrt5), 0); vert.emplace_back(0, 0.5 * (-1 - sqrt5), 1); vert.emplace_back(0.5 * (-1 + sqrt5), 0.5 * (-1 - sqrt5), 0);

   vert.emplace_back(1, -1, -1); vert.emplace_back(0.5 * (1 + sqrt5), -1, 0); vert.emplace_back(0.5 * (-1 + sqrt5), 0.5 * (-1 - sqrt5), 0); vert.emplace_back(0, 0.5 * (-1 - sqrt5), -1);

   vert.emplace_back(0.5 * (1 + sqrt5), -1, 0); vert.emplace_back(1, -1, 1); vert.emplace_back(0, 0.5 * (-1 - sqrt5), 1); vert.emplace_back(0.5 * (-1 + sqrt5), 0.5 * (-1 - sqrt5), 0);


   tsl->AddFacet(vert[0], vert[1], vert[2], vert[3]);

   tsl->AddFacet(vert[4], vert[7], vert[6], vert[5]);

   tsl->AddFacet(vert[8], vert[9], vert[10], vert[11]);

   tsl->AddFacet(vert[12], vert[15], vert[14], vert[13]);

   tsl->AddFacet(vert[16], vert[17], vert[18], vert[19]);

   tsl->AddFacet(vert[20], vert[21], vert[22], vert[23]);

   tsl->AddFacet(vert[24], vert[25], vert[26], vert[27]);

   tsl->AddFacet(vert[28], vert[29], vert[30], vert[31]);

   tsl->AddFacet(vert[32], vert[35], vert[34], vert[33]);

   tsl->AddFacet(vert[36], vert[39], vert[38], vert[37]);

   tsl->AddFacet(vert[40], vert[41], vert[42], vert[43]);

   tsl->AddFacet(vert[44], vert[45], vert[46], vert[47]);

   tsl->AddFacet(vert[48], vert[51], vert[50], vert[49]);

   tsl->AddFacet(vert[52], vert[55], vert[54], vert[53]);

   tsl->AddFacet(vert[56], vert[57], vert[58], vert[59]);

   tsl->AddFacet(vert[60], vert[63], vert[62], vert[61]);

   tsl->AddFacet(vert[64], vert[67], vert[66], vert[65]);

   tsl->AddFacet(vert[68], vert[71], vert[70], vert[69]);

   tsl->AddFacet(vert[72], vert[73], vert[74], vert[75]);

   tsl->AddFacet(vert[76], vert[77], vert[78], vert[79]);

   tsl->AddFacet(vert[80], vert[81], vert[82], vert[83]);

   tsl->AddFacet(vert[84], vert[87], vert[86], vert[85]);

   tsl->AddFacet(vert[88], vert[89], vert[90], vert[91]);

   tsl->AddFacet(vert[92], vert[93], vert[94], vert[95]);

   tsl->AddFacet(vert[96], vert[99], vert[98], vert[97]);

   tsl->AddFacet(vert[100], vert[101], vert[102], vert[103]);

   tsl->AddFacet(vert[104], vert[107], vert[106], vert[105]);

   tsl->AddFacet(vert[108], vert[111], vert[110], vert[109]);

   tsl->AddFacet(vert[112], vert[113], vert[114], vert[115]);

   tsl->AddFacet(vert[116], vert[117], vert[118], vert[119]);


   TGeoVolume *vol = new TGeoVolume("TRIACONTHAEDRON", tsl, med);

   vol->SetLineColor(randomColor());

   vol->SetLineWidth(2);

   top->AddNode(vol,1);

   gGeoManager->CloseGeometry();


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TText *text = pt->AddText("TGeoTessellated - Tessellated shape class");

   text->SetTextColor(2);

   AddMemberInfo(pt,"fNfacets",tsl->GetNfacets(),"number of facets");

   AddMemberInfo(pt,"fNvertices",tsl->GetNvertices(),"number of vertices");

   pt->AddText("----- A tessellated shape is defined by the number of facets");

   pt->AddText("-----    facets can be added using AddFacet");

   pt->AddText("----- Create with:    TGeoTessellated *tsl = new TGeoTessellated(nfacets);");

   AddExecInfo(pt, "tessellated");

   pt->Draw();

   c->cd(1);

}


//______________________________________________________________________________

void composite()

{

   auto c = create_canvas("A Boolean shape composition");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("xtru", "poza12");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,100);

   gGeoManager->SetTopVolume(top);

   // define shape components with names

   TGeoPgon *pgon = new TGeoPgon("pg",0.,360.,6,2);

   pgon->DefineSection(0,0,0,20);

   pgon->DefineSection(1, 30,0,20);

   new TGeoSphere("sph", 40., 45.);

   // define named geometrical transformations with names

   TGeoTranslation *tr = new TGeoTranslation(0., 0., 45.);

   tr->SetName("tr");

   // register all used transformations

   tr->RegisterYourself();

   // create the composite shape based on a Boolean expression

   TGeoCompositeShape *cs = new TGeoCompositeShape("mir", "sph:tr*pg");

   TGeoVolume *vol = new TGeoVolume("COMP",cs);

   vol->SetLineColor(randomColor());

   top->AddNode(vol,1);

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(100);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TText *text = pt->AddText("TGeoCompositeShape - composite shape class");

   text->SetTextColor(2);

   pt->AddText("----- Define the shape components and don't forget to name them");

   pt->AddText("----- Define geometrical transformations that apply to shape components");

   pt->AddText("----- Name all transformations and register them");

   pt->AddText("----- Define the composite shape based on a Boolean expression");

   pt->AddText("                TGeoCompositeShape(\"someName\", \"expression\")");

   pt->AddText("----- Expression is made of <shapeName:transfName> components related by Boolean operators");

   pt->AddText("----- Boolean operators can be: (+) union, (-) subtraction and (*) intersection");

   pt->AddText("----- Use parenthesis in the expression to force precedence");

   AddExecInfo(pt, "composite");

   pt->Draw();

   c->cd(1);

}


//______________________________________________________________________________

void ideal()

{

// This is an ideal geometry. In real life, some geometry pieces are moved/rotated

// with respect to their ideal positions. This is called alignment. Alignment

// operations can be handled by TGeo starting from a CLOSED geometry (applied a posteriori)

// Alignment is handled by PHYSICAL NODES, representing an unique object in geometry.

//

// Creating physical nodes:

// 1. TGeoPhysicalNode *node = gGeoManager->MakePhysicalNode(const char *path)

//   - creates a physical node represented by path

//   - path can be : TOP_1/A_2/B_3

//   - B_3 is the 'final node' e.g. the logical node represented by this physical node

// 2. TGeoPhysicalNode *node = gGeoManager->MakePhysicalNode()

//   - creates a physical node representing the current modeller state


// Setting visualisation options for TGeoPhysicalNode *node:

// 1.   node->SetVisibility(Bool_t flag); // set node visible(*) or invisible

// 2.   node->SetIsVolAtt(Bool_t flag);   // set line attributes to match the ones of the volumes in the branch

//    - default - TRUE

//    - when called with FALSE - the attributes defined for the physical node will be taken

//       node->SetLineColor(color);

//       node->SetLineWidth(width);

//       node->SetLineStyle(style);

// 3.   node->SetVisibleFull(Bool_t flag); // not only last node in the branch is visible (default)

//

// Activating/deactivating physical nodes drawing - not needed in case of alignment


// Aligning physical nodes

//==========================

//      node->Align(TGeoMatrix *newmat, TGeoShape *newshape, Bool_t check=kFALSE);

//   newmat = new matrix to replace final node LOCAL matrix

//   newshape = new shape to replace final node shape

//   check = optional check if the new aligned node is overlapping

// gGeoManager->SetDrawExtraPaths(Bool_t flag)


   auto c = create_canvas("Ideal geometry");


   if (gGeoManager) delete gGeoManager;

   new TGeoManager("alignment", "Ideal geometry");

   TGeoMaterial *mat = new TGeoMaterial("Al", 26.98,13,2.7);

   TGeoMedium *med = new TGeoMedium("MED",1,mat);

   TGeoVolume *top = gGeoManager->MakeBox("TOP",med,100,100,10);

   gGeoManager->SetTopVolume(top);

   TGeoVolume *slicex = top->Divide("SX",1,10,-100,10);

   TGeoVolume *slicey = slicex->Divide("SY",2,10,-100,10);

   TGeoVolume *vol = gGeoManager->MakePgon("CELL",med,0.,360.,6,2);

   TGeoPgon *pgon = (TGeoPgon*)(vol->GetShape());

   pgon->DefineSection(0,-5,0.,2.);

   pgon->DefineSection(1,5,0.,2.);

   vol->SetLineColor(randomColor());

   slicey->AddNode(vol,1);

   gGeoManager->CloseGeometry();

   gGeoManager->SetNsegments(80);


   top->Draw();


   MakePicture();

   if (!comments) return;

   c->cd(2);

   TPaveText *pt = new TPaveText(0.01,0.01,0.99,0.99);

   pt->SetLineColor(1);

   TText *text = pt->AddText("Ideal / Aligned geometry");

   text->SetTextColor(2);

   pt->AddText("-- Create physical nodes for the objects you want to align");

   pt->AddText("-- You must start from a valid CLOSED geometry");

   pt->AddText("    TGeoPhysicalNode *node = gGeoManager->MakePhysicalNode(const char *path)");

   pt->AddText("    + creates a physical node represented by path, e.g. TOP_1/A_2/B_3");

   pt->AddText("    node->Align(TGeoMatrix *newmat, TGeoShape *newshape, Bool_t check=kFALSE)");

   pt->AddText("    + newmat = new matrix to replace final node LOCAL matrix");

   pt->AddText("    + newshape = new shape to replace final node shape");

   pt->AddText("    + check = optional check if the new aligned node is overlapping");

   pt->AddText(" ");

   pt->SetAllWith("--","color",4);

   pt->SetAllWith("--","font",72);

   pt->SetAllWith("--","size",0.04);

   pt->SetAllWith("+","color",2);

   pt->SetAllWith("+","font",72);

   pt->SetAllWith("+","size",0.04);

   pt->SetTextAlign(12);

   pt->SetTextSize(0.044);

   pt->Draw();

   c->cd(1);

}


//______________________________________________________________________________

void align()

{

   if (!gGeoManager) return;

   if (strcmp(gGeoManager->GetName(),"alignment")) {

      printf("Click: <Ideal geometry> first\n");

      return;

   }

   TObjArray *list = gGeoManager->GetListOfPhysicalNodes();

   for (Int_t i=1; i<=10; i++) {

      for (Int_t j=1; j<=10; j++) {

         TGeoPhysicalNode *node = nullptr;

         auto name = TString::Format("TOP_1/SX_%d/SY_%d/CELL_1",i,j);

         if (list) node = (TGeoPhysicalNode*)list->At(10*(i-1)+j-1);

         if (!node) node = gGeoManager->MakePhysicalNode(name.Data());

         TGeoTranslation *tr;

         if (node->IsAligned()) {

            tr = (TGeoTranslation*)node->GetNode()->GetMatrix();

            tr->SetTranslation(2.*gRandom->Rndm(), 2.*gRandom->Rndm(),0.);

         } else {

            tr = new TGeoTranslation(2.*gRandom->Rndm(), 2.*gRandom->Rndm(),0.);

         }

         node->Align(tr);

      }

   }

   if (gPad) {

      gPad->Modified();

      gPad->Update();

   }

}


//______________________________________________________________________________

void geodemo ()

{

// root[0] .x geodemo.C

// root[1] box();   //draw a TGeoBBox with description

//

// The box can be divided on one axis.

//

// root[2] box(iaxis, ndiv, start, step);

//

// where: iaxis = 1,2 or 3, meaning (X,Y,Z) or (Rxy, phi, Z) depending on shape type

//        ndiv  = number of slices

//        start = starting position (must be in shape range)

//        step  = division step

// If step=0, all range of a given axis will be divided

//

// The same can procedure can be performed for visualizing other shapes.

// When drawing one shape after another, the old geometry/canvas will be deleted.

   TControlBar *bar = new TControlBar("vertical", "TGeo shapes",10,10);

   bar->AddButton("How to run  ","help()","Instructions for running this macro");

   bar->AddButton("Arb8        ","arb8()","An arbitrary polyhedron defined by vertices (max 8) sitting on 2 parallel planes");

   bar->AddButton("Box         ","box()","A box shape.");

   bar->AddButton("Composite   ","composite()","A composite shape");

   bar->AddButton("Cone        ","cone()","A conical tube");

   bar->AddButton("Cone segment","coneseg()","A conical segment");

   bar->AddButton("Cut tube    ","ctub()","A cut tube segment");

   bar->AddButton("Elliptical tube","eltu()","An elliptical tube");

   bar->AddButton("Extruded poly","xtru()","A general polygone extrusion");

   bar->AddButton("Hyperboloid  ","hype()","A hyperboloid");

   bar->AddButton("Paraboloid  ","parab()","A paraboloid");

   bar->AddButton("Polycone    ","pcon()","A polycone shape");

   bar->AddButton("Polygone    ","pgon()","A polygone");

   bar->AddButton("Parallelepiped","para()","A parallelepiped shape");

   bar->AddButton("Sphere      ","sphere()","A spherical sector");

   bar->AddButton("Trd1        ","trd1()","A trapezoid with dX varying with Z");

   bar->AddButton("Trd2        ","trd2()","A trapezoid with both dX and dY varying with Z");

   bar->AddButton("Trapezoid   ","trap()","A general trapezoid");

   bar->AddButton("Torus       ","torus()","A toroidal segment");

   bar->AddButton("Tube        ","tube()","A tube with inner and outer radius");

   bar->AddButton("Tube segment","tubeseg()","A tube segment");

   bar->AddButton("Twisted trap","gtra()","A twisted trapezoid");

   bar->AddButton("Tessellated ","tessellated()","A tessellated shape");

   bar->AddButton("Aligned (ideal)","ideal()","An ideal (un-aligned) geometry");

   bar->AddButton("Un-aligned","align()","Some alignment operation");

   bar->AddButton("RAY-TRACE ON/OFF","raytrace()","Toggle ray-tracing mode");

   bar->AddButton("COMMENTS  ON/OFF","comments = !comments;","Toggle explanations pad ON/OFF");

   bar->AddButton("AXES ON/OFF","axes()","Toggle axes ON/OFF");

   bar->AddButton("AUTOROTATE ON/OFF","autorotate()","Toggle autorotation ON/OFF");

   bar->Show();

   gROOT->SaveContext();

   gRandom = new TRandom3();

}

c
#define c(i)
Definition RSha256.hxx:101

Bool_t
bool Bool_t
Definition RtypesCore.h:63

Int_t
int Int_t
Definition RtypesCore.h:45

kFALSE
constexpr Bool_t kFALSE
Definition RtypesCore.h:101

Double_t
double Double_t
Definition RtypesCore.h:59

kTRUE
constexpr Bool_t kTRUE
Definition RtypesCore.h:100

TCanvas.h

TControlBar.h

value
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Definition TGWin32VirtualXProxy.cxx:142

text
Option_t Option_t TPoint TPoint const char text
Definition TGWin32VirtualXProxy.cxx:68

name
char name[80]
Definition TGX11.cxx:110

TGeoArb8.h

TGeoBBox.h

TGeoCompositeShape.h

TGeoCone.h

TGeoEltu.h

TGeoHype.h

TGeoManager.h

gGeoManager
R__EXTERN TGeoManager * gGeoManager
Definition TGeoManager.h:602

TGeoNode.h

TGeoPara.h

TGeoParaboloid.h

TGeoPcon.h

TGeoPgon.h

TGeoPhysicalNode.h

TGeoSphere.h

TGeoTessellated.h

TGeoTorus.h

TGeoTrd1.h

TGeoTrd2.h

TGeoTube.h

TGeoXtru.h

TMath.h

TPaveText.h

TROOT.h

gROOT
#define gROOT
Definition TROOT.h:405

TRandom3.h

gRandom
R__EXTERN TRandom * gRandom
Definition TRandom.h:62

TSystem.h

TView.h

TVirtualGeoPainter.h

TVirtualPad.h

gPad
#define gPad
Definition TVirtualPad.h:303

TAttFill::SetFillColor
virtual void SetFillColor(Color_t fcolor)
Set the fill area color.
Definition TAttFill.h:37

TAttLine::SetLineColor
virtual void SetLineColor(Color_t lcolor)
Set the line color.
Definition TAttLine.h:40

TAttText::SetTextAlign
virtual void SetTextAlign(Short_t align=11)
Set the text alignment.
Definition TAttText.h:42

TAttText::SetTextColor
virtual void SetTextColor(Color_t tcolor=1)
Set the text color.
Definition TAttText.h:44

TAttText::SetTextFont
virtual void SetTextFont(Font_t tfont=62)
Set the text font.
Definition TAttText.h:46

TAttText::SetTextSize
virtual void SetTextSize(Float_t tsize=1)
Set the text size.
Definition TAttText.h:47

TCanvas
The Canvas class.
Definition TCanvas.h:23

TControlBar
A Control Bar is a fully user configurable tool which provides fast access to frequently used operati...
Definition TControlBar.h:26

TControlBar::Show
void Show()
Show control bar.
Definition TControlBar.cxx:317

TControlBar::AddButton
void AddButton(TControlBarButton *button)
Add button.
Definition TControlBar.cxx:141

TGeoArb8
An arbitrary trapezoid with less than 8 vertices standing on two parallel planes perpendicular to Z a...
Definition TGeoArb8.h:18

TGeoArb8::SetVertex
virtual void SetVertex(Int_t vnum, Double_t x, Double_t y)
Set values for a given vertex.
Definition TGeoArb8.cxx:1243

TGeoArb8::GetDz
Double_t GetDz() const
Definition TGeoArb8.h:65

TGeoArb8::GetVertices
Double_t * GetVertices()
Definition TGeoArb8.h:69

TGeoAtt::SetVisRaytrace
void SetVisRaytrace(Bool_t flag=kTRUE)
Definition TGeoAtt.h:70

TGeoBBox
Box class.
Definition TGeoBBox.h:18

TGeoBBox::GetDZ
virtual Double_t GetDZ() const
Definition TGeoBBox.h:76

TGeoCompositeShape
Composite shapes are Boolean combinations of two or more shape components.
Definition TGeoCompositeShape.h:28

TGeoConeSeg
A cone segment is a cone having a range in phi.
Definition TGeoCone.h:102

TGeoConeSeg::GetPhi1
Double_t GetPhi1() const
Definition TGeoCone.h:163

TGeoConeSeg::GetPhi2
Double_t GetPhi2() const
Definition TGeoCone.h:164

TGeoCone
The cones are defined by 5 parameters:
Definition TGeoCone.h:18

TGeoCone::GetRmax2
virtual Double_t GetRmax2() const
Definition TGeoCone.h:79

TGeoCone::GetRmin2
virtual Double_t GetRmin2() const
Definition TGeoCone.h:78

TGeoCone::GetRmin1
virtual Double_t GetRmin1() const
Definition TGeoCone.h:76

TGeoCone::GetRmax1
virtual Double_t GetRmax1() const
Definition TGeoCone.h:77

TGeoEltu
An elliptical tube is defined by the two semi-axes A and B.
Definition TGeoEltu.h:18

TGeoEltu::GetA
virtual Double_t GetA() const
Definition TGeoEltu.h:46

TGeoEltu::GetB
virtual Double_t GetB() const
Definition TGeoEltu.h:47

TGeoGtra
A twisted trapezoid.
Definition TGeoArb8.h:146

TGeoGtra::GetTwistAngle
Double_t GetTwistAngle() const
Definition TGeoArb8.h:168

TGeoHype
A hyperboloid is represented as a solid limited by two planes perpendicular to the Z axis (top and bo...
Definition TGeoHype.h:18

TGeoHype::GetStIn
Double_t GetStIn() const
Definition TGeoHype.h:71

TGeoHype::GetStOut
Double_t GetStOut() const
Definition TGeoHype.h:72

TGeoManager
The manager class for any TGeo geometry.
Definition TGeoManager.h:45

TGeoManager::MakeCone
TGeoVolume * MakeCone(const char *name, TGeoMedium *medium, Double_t dz, Double_t rmin1, Double_t rmax1, Double_t rmin2, Double_t rmax2)
Make in one step a volume pointing to a cone shape with given medium.
Definition TGeoManager.cxx:3025

TGeoManager::MakeXtru
TGeoVolume * MakeXtru(const char *name, TGeoMedium *medium, Int_t nz)
Make a TGeoXtru-shaped volume with nz planes.
Definition TGeoManager.cxx:3105

TGeoManager::MakePcon
TGeoVolume * MakePcon(const char *name, TGeoMedium *medium, Double_t phi, Double_t dphi, Int_t nz)
Make in one step a volume pointing to a polycone shape with given medium.
Definition TGeoManager.cxx:3046

TGeoManager::MakeTube
TGeoVolume * MakeTube(const char *name, TGeoMedium *medium, Double_t rmin, Double_t rmax, Double_t dz)
Make in one step a volume pointing to a tube shape with given medium.
Definition TGeoManager.cxx:2968

TGeoManager::MakeCons
TGeoVolume * MakeCons(const char *name, TGeoMedium *medium, Double_t dz, Double_t rmin1, Double_t rmax1, Double_t rmin2, Double_t rmax2, Double_t phi1, Double_t phi2)
Make in one step a volume pointing to a cone segment shape with given medium.
Definition TGeoManager.cxx:3035

TGeoManager::GetGeomPainter
TVirtualGeoPainter * GetGeomPainter()
Make a default painter if none present. Returns pointer to it.
Definition TGeoManager.cxx:2697

TGeoManager::MakePara
TGeoVolume * MakePara(const char *name, TGeoMedium *medium, Double_t dx, Double_t dy, Double_t dz, Double_t alpha, Double_t theta, Double_t phi)
Make in one step a volume pointing to a parallelepiped shape with given medium.
Definition TGeoManager.cxx:2939

TGeoManager::MakePhysicalNode
TGeoPhysicalNode * MakePhysicalNode(const char *path=nullptr)
Makes a physical node corresponding to a path.
Definition TGeoManager.cxx:3270

TGeoManager::MakeTorus
TGeoVolume * MakeTorus(const char *name, TGeoMedium *medium, Double_t r, Double_t rmin, Double_t rmax, Double_t phi1=0, Double_t dphi=360)
Make in one step a volume pointing to a torus shape with given medium.
Definition TGeoManager.cxx:2959

TGeoManager::CloseGeometry
void CloseGeometry(Option_t *option="d")
Closing geometry implies checking the geometry validity, fixing shapes with negative parameters (run-...
Definition TGeoManager.cxx:1360

TGeoManager::MakeTrd2
TGeoVolume * MakeTrd2(const char *name, TGeoMedium *medium, Double_t dx1, Double_t dx2, Double_t dy1, Double_t dy2, Double_t dz)
Make in one step a volume pointing to a TGeoTrd2 shape with given medium.
Definition TGeoManager.cxx:3073

TGeoManager::MakeGtra
TGeoVolume * MakeGtra(const char *name, TGeoMedium *medium, Double_t dz, Double_t theta, Double_t phi, Double_t twist, Double_t h1, Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Double_t bl2, Double_t tl2, Double_t alpha2)
Make in one step a volume pointing to a twisted trapezoid shape with given medium.
Definition TGeoManager.cxx:3094

TGeoManager::MakeBox
TGeoVolume * MakeBox(const char *name, TGeoMedium *medium, Double_t dx, Double_t dy, Double_t dz)
Make in one step a volume pointing to a box shape with given medium.
Definition TGeoManager.cxx:2930

TGeoManager::MakeTrd1
TGeoVolume * MakeTrd1(const char *name, TGeoMedium *medium, Double_t dx1, Double_t dx2, Double_t dy, Double_t dz)
Make in one step a volume pointing to a TGeoTrd1 shape with given medium.
Definition TGeoManager.cxx:3064

TGeoManager::MakeSphere
TGeoVolume * MakeSphere(const char *name, TGeoMedium *medium, Double_t rmin, Double_t rmax, Double_t themin=0, Double_t themax=180, Double_t phimin=0, Double_t phimax=360)
Make in one step a volume pointing to a sphere shape with given medium.
Definition TGeoManager.cxx:2949

TGeoManager::SetTopVolume
void SetTopVolume(TGeoVolume *vol)
Set the top volume and corresponding node as starting point of the geometry.
Definition TGeoManager.cxx:3409

TGeoManager::MakeCtub
TGeoVolume * MakeCtub(const char *name, TGeoMedium *medium, Double_t rmin, Double_t rmax, Double_t dz, Double_t phi1, Double_t phi2, Double_t lx, Double_t ly, Double_t lz, Double_t tx, Double_t ty, Double_t tz)
Make in one step a volume pointing to a tube segment shape with given medium.
Definition TGeoManager.cxx:3015

TGeoManager::MakePgon
TGeoVolume * MakePgon(const char *name, TGeoMedium *medium, Double_t phi, Double_t dphi, Int_t nedges, Int_t nz)
Make in one step a volume pointing to a polygone shape with given medium.
Definition TGeoManager.cxx:3055

TGeoManager::MakeTrap
TGeoVolume * MakeTrap(const char *name, TGeoMedium *medium, Double_t dz, Double_t theta, Double_t phi, Double_t h1, Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Double_t bl2, Double_t tl2, Double_t alpha2)
Make in one step a volume pointing to a trapezoid shape with given medium.
Definition TGeoManager.cxx:3083

TGeoManager::SetNsegments
void SetNsegments(Int_t nseg)
Set number of segments for approximating circles in drawing.
Definition TGeoManager.cxx:3351

TGeoManager::GetTopVolume
TGeoVolume * GetTopVolume() const
Definition TGeoManager.h:532

TGeoManager::GetListOfPhysicalNodes
TObjArray * GetListOfPhysicalNodes()
Definition TGeoManager.h:488

TGeoManager::MakeHype
TGeoVolume * MakeHype(const char *name, TGeoMedium *medium, Double_t rin, Double_t stin, Double_t rout, Double_t stout, Double_t dz)
Make in one step a volume pointing to a tube shape with given medium.
Definition TGeoManager.cxx:2997

TGeoManager::MakeParaboloid
TGeoVolume * MakeParaboloid(const char *name, TGeoMedium *medium, Double_t rlo, Double_t rhi, Double_t dz)
Make in one step a volume pointing to a tube shape with given medium.
Definition TGeoManager.cxx:3006

TGeoManager::MakeTubs
TGeoVolume * MakeTubs(const char *name, TGeoMedium *medium, Double_t rmin, Double_t rmax, Double_t dz, Double_t phi1, Double_t phi2)
Make in one step a volume pointing to a tube segment shape with given medium.
Definition TGeoManager.cxx:2978

TGeoManager::MakeEltu
TGeoVolume * MakeEltu(const char *name, TGeoMedium *medium, Double_t a, Double_t b, Double_t dz)
Make in one step a volume pointing to a tube shape with given medium.
Definition TGeoManager.cxx:2988

TGeoMaterial
Base class describing materials.
Definition TGeoMaterial.h:36

TGeoMatrix::RegisterYourself
virtual void RegisterYourself()
Register the matrix in the current manager, which will become the owner.
Definition TGeoMatrix.cxx:526

TGeoMedium
Media are used to store properties related to tracking and which are useful only when using geometry ...
Definition TGeoMedium.h:24

TGeoNode::GetMatrix
virtual TGeoMatrix * GetMatrix() const =0

TGeoPara
Parallelepiped class.
Definition TGeoPara.h:18

TGeoPara::GetZ
Double_t GetZ() const
Definition TGeoPara.h:66

TGeoPara::GetPhi
Double_t GetPhi() const
Definition TGeoPara.h:69

TGeoPara::GetAlpha
Double_t GetAlpha() const
Definition TGeoPara.h:67

TGeoPara::GetX
Double_t GetX() const
Definition TGeoPara.h:64

TGeoPara::GetY
Double_t GetY() const
Definition TGeoPara.h:65

TGeoPara::GetTheta
Double_t GetTheta() const
Definition TGeoPara.h:68

TGeoParaboloid
A paraboloid is defined by the revolution surface generated by a parabola and is bounded by two plane...
Definition TGeoParaboloid.h:18

TGeoParaboloid::GetDz
Double_t GetDz() const
Definition TGeoParaboloid.h:57

TGeoParaboloid::GetRhi
Double_t GetRhi() const
Definition TGeoParaboloid.h:56

TGeoParaboloid::GetRlo
Double_t GetRlo() const
Definition TGeoParaboloid.h:55

TGeoPatternFinder
Base finder class for patterns.
Definition TGeoPatternFinder.h:32

TGeoPatternFinder::GetNdiv
Int_t GetNdiv() const
Definition TGeoPatternFinder.h:86

TGeoPatternFinder::GetVolume
TGeoVolume * GetVolume() const
Definition TGeoPatternFinder.h:92

TGeoPatternFinder::GetStep
Double_t GetStep() const
Definition TGeoPatternFinder.h:90

TGeoPatternFinder::GetStart
Double_t GetStart() const
Definition TGeoPatternFinder.h:89

TGeoPcon
A polycone is represented by a sequence of tubes/cones, glued together at defined Z planes.
Definition TGeoPcon.h:18

TGeoPcon::GetRmax
Double_t * GetRmax() const
Definition TGeoPcon.h:81

TGeoPcon::GetDphi
Double_t GetDphi() const
Definition TGeoPcon.h:76

TGeoPcon::DefineSection
virtual void DefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax)
Defines z position of a section plane, rmin and rmax at this z.
Definition TGeoPcon.cxx:615

TGeoPcon::GetZ
Double_t * GetZ() const
Definition TGeoPcon.h:83

TGeoPcon::GetNz
Int_t GetNz() const
Definition TGeoPcon.h:77

TGeoPcon::GetRmin
Double_t * GetRmin() const
Definition TGeoPcon.h:79

TGeoPcon::GetPhi1
Double_t GetPhi1() const
Definition TGeoPcon.h:75

TGeoPgon
Polygons are defined in the same way as polycones, the difference being just that the segments betwee...
Definition TGeoPgon.h:21

TGeoPgon::GetNedges
Int_t GetNedges() const
Definition TGeoPgon.h:86

TGeoPhysicalNode
Physical nodes are the actual 'touchable' objects in the geometry, representing a path of positioned ...
Definition TGeoPhysicalNode.h:37

TGeoPhysicalNode::IsAligned
Bool_t IsAligned() const
Definition TGeoPhysicalNode.h:77

TGeoPhysicalNode::GetNode
TGeoNode * GetNode(Int_t level=-1) const
Return node in branch at LEVEL. If not specified, return last leaf.
Definition TGeoPhysicalNode.cxx:379

TGeoPhysicalNode::Align
Bool_t Align(TGeoMatrix *newmat=nullptr, TGeoShape *newshape=nullptr, Bool_t check=kFALSE, Double_t ovlp=0.001)
Align a physical node with a new relative matrix/shape.
Definition TGeoPhysicalNode.cxx:133

TGeoShape
Base abstract class for all shapes.
Definition TGeoShape.h:26

TGeoShape::GetAxisName
virtual const char * GetAxisName(Int_t iaxis) const =0

TGeoSphere
TGeoSphere are not just balls having internal and external radii, but sectors of a sphere having defi...
Definition TGeoSphere.h:18

TGeoSphere::GetPhi1
Double_t GetPhi1() const
Definition TGeoSphere.h:74

TGeoSphere::GetPhi2
Double_t GetPhi2() const
Definition TGeoSphere.h:75

TGeoSphere::GetRmin
virtual Double_t GetRmin() const
Definition TGeoSphere.h:70

TGeoSphere::GetTheta2
Double_t GetTheta2() const
Definition TGeoSphere.h:73

TGeoSphere::GetRmax
virtual Double_t GetRmax() const
Definition TGeoSphere.h:71

TGeoSphere::GetTheta1
Double_t GetTheta1() const
Definition TGeoSphere.h:72

TGeoTessellated
Tessellated solid class.
Definition TGeoTessellated.h:105

TGeoTessellated::GetNvertices
int GetNvertices() const
Definition TGeoTessellated.h:140

TGeoTessellated::AddFacet
bool AddFacet(const Vertex_t &pt0, const Vertex_t &pt1, const Vertex_t &pt2)
Adding a triangular facet from vertex positions in absolute coordinates.
Definition TGeoTessellated.cxx:219

TGeoTessellated::GetNfacets
int GetNfacets() const
Definition TGeoTessellated.h:138

TGeoTorus
The torus is defined by its axial radius, its inner and outer radius.
Definition TGeoTorus.h:18

TGeoTorus::GetRmax
Double_t GetRmax() const
Definition TGeoTorus.h:73

TGeoTorus::GetRmin
Double_t GetRmin() const
Definition TGeoTorus.h:72

TGeoTorus::GetR
Double_t GetR() const
Definition TGeoTorus.h:71

TGeoTorus::GetPhi1
Double_t GetPhi1() const
Definition TGeoTorus.h:74

TGeoTorus::GetDphi
Double_t GetDphi() const
Definition TGeoTorus.h:75

TGeoTranslation
Class describing translations.
Definition TGeoMatrix.h:122

TGeoTranslation::SetTranslation
void SetTranslation(Double_t dx, Double_t dy, Double_t dz)
Set translation components.
Definition TGeoMatrix.cxx:751

TGeoTrap
A general trapezoid.
Definition TGeoArb8.h:92

TGeoTrap::GetTl1
Double_t GetTl1() const
Definition TGeoArb8.h:130

TGeoTrap::GetPhi
Double_t GetPhi() const
Definition TGeoArb8.h:127

TGeoTrap::GetAlpha2
Double_t GetAlpha2() const
Definition TGeoArb8.h:135

TGeoTrap::GetTheta
Double_t GetTheta() const
Definition TGeoArb8.h:126

TGeoTrap::GetAlpha1
Double_t GetAlpha1() const
Definition TGeoArb8.h:131

TGeoTrap::GetBl2
Double_t GetBl2() const
Definition TGeoArb8.h:133

TGeoTrap::GetTl2
Double_t GetTl2() const
Definition TGeoArb8.h:134

TGeoTrap::GetH1
Double_t GetH1() const
Definition TGeoArb8.h:128

TGeoTrap::GetH2
Double_t GetH2() const
Definition TGeoArb8.h:132

TGeoTrap::GetBl1
Double_t GetBl1() const
Definition TGeoArb8.h:129

TGeoTrd1
A trapezoid with only X varying with Z.
Definition TGeoTrd1.h:18

TGeoTrd1::GetDy
Double_t GetDy() const
Definition TGeoTrd1.h:59

TGeoTrd1::GetDx2
Double_t GetDx2() const
Definition TGeoTrd1.h:58

TGeoTrd1::GetDz
Double_t GetDz() const
Definition TGeoTrd1.h:60

TGeoTrd1::GetDx1
Double_t GetDx1() const
Definition TGeoTrd1.h:57

TGeoTrd2
A trapezoid with only X varying with Z.
Definition TGeoTrd2.h:18

TGeoTrd2::GetDy2
Double_t GetDy2() const
Definition TGeoTrd2.h:61

TGeoTrd2::GetDy1
Double_t GetDy1() const
Definition TGeoTrd2.h:60

TGeoTrd2::GetDx2
Double_t GetDx2() const
Definition TGeoTrd2.h:59

TGeoTrd2::GetDz
Double_t GetDz() const
Definition TGeoTrd2.h:62

TGeoTrd2::GetDx1
Double_t GetDx1() const
Definition TGeoTrd2.h:58

TGeoTubeSeg
A tube segment is a tube having a range in phi.
Definition TGeoTube.h:92

TGeoTubeSeg::GetPhi2
Double_t GetPhi2() const
Definition TGeoTube.h:152

TGeoTubeSeg::GetPhi1
Double_t GetPhi1() const
Definition TGeoTube.h:151

TGeoTube
Cylindrical tube class.
Definition TGeoTube.h:18

TGeoTube::GetRmin
virtual Double_t GetRmin() const
Definition TGeoTube.h:69

TGeoTube::GetDz
virtual Double_t GetDz() const
Definition TGeoTube.h:71

TGeoTube::GetRmax
virtual Double_t GetRmax() const
Definition TGeoTube.h:70

TGeoVolume
TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes.
Definition TGeoVolume.h:49

TGeoVolume::cd
virtual void cd(Int_t inode) const
Actualize matrix of node indexed <inode>
Definition TGeoVolume.cxx:923

TGeoVolume::AddNode
virtual TGeoNode * AddNode(TGeoVolume *vol, Int_t copy_no, TGeoMatrix *mat=nullptr, Option_t *option="")
Add a TGeoNode to the list of nodes.
Definition TGeoVolume.cxx:932

TGeoVolume::GetFinder
TGeoPatternFinder * GetFinder() const
Definition TGeoVolume.h:176

TGeoVolume::GetShape
TGeoShape * GetShape() const
Definition TGeoVolume.h:189

TGeoVolume::Draw
virtual void Draw(Option_t *option="")
draw top volume according to option
Definition TGeoVolume.cxx:1147

TGeoVolume::Divide
virtual TGeoVolume * Divide(const char *divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option="")
Division a la G3.
Definition TGeoVolume.cxx:1051

TGeoVolume::IsRaytracing
Bool_t IsRaytracing() const
Check if the painter is currently ray-tracing the content of this volume.
Definition TGeoVolume.cxx:821

TGeoVolume::SetLineWidth
virtual void SetLineWidth(Width_t lwidth)
Set the line width.
Definition TGeoVolume.cxx:2049

TGeoVolume::SetLineColor
virtual void SetLineColor(Color_t lcolor)
Set the line color.
Definition TGeoVolume.cxx:2033

TGeoXtru
A TGeoXtru shape is represented by the extrusion of an arbitrary polygon with fixed outline between s...
Definition TGeoXtru.h:23

TGeoXtru::GetNvert
Int_t GetNvert() const
Definition TGeoXtru.h:95

TGeoXtru::DefinePolygon
Bool_t DefinePolygon(Int_t nvert, const Double_t *xv, const Double_t *yv)
Creates the polygon representing the blueprint of any Xtru section.
Definition TGeoXtru.cxx:691

TGeoXtru::DefineSection
virtual void DefineSection(Int_t snum, Double_t z, Double_t x0=0., Double_t y0=0., Double_t scale=1.)
defines z position of a section plane, rmin and rmax at this z.
Definition TGeoXtru.cxx:724

TGeoXtru::GetNz
Int_t GetNz() const
Definition TGeoXtru.h:94

TNamed::GetName
const char * GetName() const override
Returns name of object.
Definition TNamed.h:47

TNamed::SetName
virtual void SetName(const char *name)
Set the name of the TNamed.
Definition TNamed.cxx:140

TObjArray
An array of TObjects.
Definition TObjArray.h:31

TObjArray::At
TObject * At(Int_t idx) const override
Definition TObjArray.h:164

TObject
Mother of all ROOT objects.
Definition TObject.h:41

TObject::Clear
virtual void Clear(Option_t *="")
Definition TObject.h:119

TObject::FindObject
virtual TObject * FindObject(const char *name) const
Must be redefined in derived classes.
Definition TObject.cxx:403

TPad::FindObject
TObject * FindObject(const char *name) const override
Search if object named name is inside this pad or in pads inside this pad.
Definition TPad.cxx:2595

TPaveText
A Pave (see TPave) with text, lines or/and boxes inside.
Definition TPaveText.h:21

TPaveText::AddText
virtual TText * AddText(Double_t x1, Double_t y1, const char *label)
Add a new Text line to this pavetext at given coordinates.
Definition TPaveText.cxx:189

TPaveText::SetAllWith
virtual void SetAllWith(const char *text, Option_t *option, Double_t value)
Set attribute option for all lines containing string text.
Definition TPaveText.cxx:824

TPaveText::Draw
void Draw(Option_t *option="") override
Draw this pavetext with its current attributes.
Definition TPaveText.cxx:240

TProcessEventTimer
Definition TSystem.h:257

TProcessEventTimer::ProcessEvents
Bool_t ProcessEvents()
Process events if timer did time out.
Definition TSystem.cxx:91

TRandom3
Random number generator class based on M.
Definition TRandom3.h:27

TRandom::Rndm
Double_t Rndm() override
Machine independent random number generator.
Definition TRandom.cxx:552

TString
Basic string class.
Definition TString.h:139

TString::Data
const char * Data() const
Definition TString.h:380

TString::Format
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
Definition TString.cxx:2356

TString::Form
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Definition TString.cxx:2334

TText
Base class for several text objects.
Definition TText.h:22

TView
See TView3D.
Definition TView.h:25

TView::GetPsi
virtual Double_t GetPsi()=0

TView::GetLongitude
virtual Double_t GetLongitude()=0

TView::ShowAxis
virtual void ShowAxis()=0

TView::GetLatitude
virtual Double_t GetLatitude()=0

TView::SetView
virtual void SetView(Double_t longitude, Double_t latitude, Double_t psi, Int_t &irep)=0

TVirtualGeoPainter
Abstract class for geometry painters.
Definition TVirtualGeoPainter.h:32

pt
TPaveText * pt
Definition entrylist_figure1.C:7

line
TLine * line
Definition entrylistblock_figure1.C:235

box
void box(Int_t pat, Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Definition fillpatterns.C:1

y
Double_t y[n]
Definition legend1.C:17

x
Double_t x[n]
Definition legend1.C:17

TMath::Sqrt
Double_t Sqrt(Double_t x)
Returns the square root of x.
Definition TMath.h:660

TMath::Cos
Double_t Cos(Double_t)
Returns the cosine of an angle of x radians.
Definition TMath.h:592

TMath::Pi
constexpr Double_t Pi()
Definition TMath.h:37

TMath::Sin
Double_t Sin(Double_t)
Returns the sine of an angle of x radians.
Definition TMath.h:586