TGeoBBox.cxx

Go to the documentation of this file.

// @(#)root/geom:$Id$// Author: Andrei Gheata   24/10/01
 
// Contains() and DistFromOutside/Out() implemented by Mihaela Gheata
 
/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/
 
/** \class TGeoBBox
\ingroup Shapes_classes
\brief Box class.
 
  - [Building boxes](\ref GEOB00)
  - [Creation of boxes](\ref GEOB01)
  - [Divisions of boxes](\ref GEOB02)
 
All shape primitives inherit from this, their
  constructor filling automatically the parameters of the box that bounds
  the given shape. Defined by 6 parameters :
 
```
TGeoBBox(Double_t dx,Double_t dy,Double_t dz,Double_t *origin=0);
```
 
  - `fDX`, `fDY`, `fDZ` : half lengths on X, Y and Z axis
  - `fOrigin[3]`        : position of box origin
 
\anchor GEOB00
### Building boxes
 
Normally a box has to be built only with 3 parameters: `DX,DY,DZ`
representing the half-lengths on X, Y and Z-axes. In this case, the
origin of the box will match the one of its reference frame and the box
will range from: `-DX` to `DX` on X-axis, from `-DY` to `DY` on Y and
from `-DZ` to `DZ` on Z. On the other hand, any other shape needs to
compute and store the parameters of their minimal bounding box. The
bounding boxes are essential to optimize navigation algorithms.
Therefore all other primitives derive from **`TGeoBBox`**. Since the
minimal bounding box is not necessary centered in the origin, any box
allows an origin translation `(Ox`,`Oy`,`Oz)`. All primitive
constructors automatically compute the bounding box parameters. Users
should be aware that building a translated box that will represent a
primitive shape by itself would affect any further positioning of other
shapes inside. Therefore it is highly recommendable to build
non-translated boxes as primitives and translate/rotate their
corresponding volumes only during positioning stage.
 
\anchor GEOB01
#### Creation of boxes
 
```
   TGeoBBox *box = new TGeoBBox("BOX", 20, 30, 40);
```
 
Begin_Macro
{
   TCanvas *c = new TCanvas("c", "c",0,0,600,600);
   new TGeoManager("box", "poza1");
   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->SetLineWidth(2);
   top->AddNode(vol,1);
   gGeoManager->CloseGeometry();
   gGeoManager->SetNsegments(80);
   top->Draw();
   TView *view = gPad->GetView();
   if (view) view->ShowAxis();
}
End_Macro
 
A volume having a box shape can be built in one step:
 
```
   TGeoVolume *vbox = gGeoManager->MakeBox("vbox", ptrMed, 20,30,40);
```
 
\anchor GEOB02
#### Divisions of boxes
 
  Volumes having box shape can be divided with equal-length slices on
X, Y or Z axis. The following options are supported:
 
  - Dividing the full range of one axis in N slices
```
   TGeoVolume *divx = vbox->Divide("SLICEX", 1, N);
```
here `1` stands for the division axis (1-X, 2-Y, 3-Z)
 
Begin_Macro
{
   TCanvas *c = new TCanvas("c", "c",0,0,600,600);
   new TGeoManager("box", "poza1");
   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->SetLineWidth(2);
   top->AddNode(vol,1);
   TGeoVolume *divx = vol->Divide("SLICE",1,8,0,0);
   gGeoManager->CloseGeometry();
   gGeoManager->SetNsegments(80);
   top->Draw();
   TView *view = gPad->GetView();
   if (view) view->ShowAxis();
}
End_Macro
 
  - Dividing in a limited range - general case.
```
   TGeoVolume *divy = vbox->Divide("SLICEY",2,N,start,step);
```
    - start = starting offset within (-fDY, fDY)
    - step  = slicing step
 
Begin_Macro
{
   TCanvas *c = new TCanvas("c", "c",0,0,600,600);
   new TGeoManager("box", "poza1");
   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->SetLineWidth(2);
   top->AddNode(vol,1);
   TGeoVolume *divx = vol->Divide("SLICE",2,8,2,3);
   gGeoManager->CloseGeometry();
   gGeoManager->SetNsegments(80);
   top->Draw();
   TView *view = gPad->GetView();
   if (view) view->ShowAxis();
}
End_Macro
 
Both cases are supported by all shapes.
See also class TGeoShape for utility methods provided by any particular shape.
*/
 
#include <iostream>
 
#include "TGeoManager.h"
#include "TGeoMatrix.h"
#include "TGeoVolume.h"
#include "TVirtualGeoPainter.h"
#include "TGeoBBox.h"
#include "TBuffer3D.h"
#include "TBuffer3DTypes.h"
#include "TMath.h"
#include "TRandom.h"
 
////////////////////////////////////////////////////////////////////////////////
/// Default constructor
 
TGeoBBox::TGeoBBox()
{
   SetShapeBit(TGeoShape::kGeoBox);
   fDX = fDY = fDZ = 0;
   fOrigin[0] = fOrigin[1] = fOrigin[2] = 0.0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Constructor where half-lengths are provided.
 
TGeoBBox::TGeoBBox(Double_t dx, Double_t dy, Double_t dz, Double_t *origin) : TGeoShape("")
{
   SetShapeBit(TGeoShape::kGeoBox);
   fOrigin[0] = fOrigin[1] = fOrigin[2] = 0.0;
   SetBoxDimensions(dx, dy, dz, origin);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Constructor with shape name.
 
TGeoBBox::TGeoBBox(const char *name, Double_t dx, Double_t dy, Double_t dz, Double_t *origin) : TGeoShape(name)
{
   SetShapeBit(TGeoShape::kGeoBox);
   fOrigin[0] = fOrigin[1] = fOrigin[2] = 0.0;
   SetBoxDimensions(dx, dy, dz, origin);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Constructor based on the array of parameters.
///  - param[0] - half-length in x
///  - param[1] - half-length in y
///  - param[2] - half-length in z
 
TGeoBBox::TGeoBBox(Double_t *param) : TGeoShape("")
{
   SetShapeBit(TGeoShape::kGeoBox);
   fOrigin[0] = fOrigin[1] = fOrigin[2] = 0.0;
   SetDimensions(param);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Destructor
 
TGeoBBox::~TGeoBBox() {}
 
////////////////////////////////////////////////////////////////////////////////
/// Computes capacity of the shape in [length^3].
 
Double_t TGeoBBox::Capacity() const
{
   return (8. * fDX * fDY * fDZ);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Computes normal to closest surface from POINT.
 
void TGeoBBox::ComputeNormal(const Double_t *point, const Double_t *dir, Double_t *norm) const
{
   memset(norm, 0, 3 * sizeof(Double_t));
   Double_t saf[3];
   Int_t i;
   saf[0] = TMath::Abs(TMath::Abs(point[0] - fOrigin[0]) - fDX);
   saf[1] = TMath::Abs(TMath::Abs(point[1] - fOrigin[1]) - fDY);
   saf[2] = TMath::Abs(TMath::Abs(point[2] - fOrigin[2]) - fDZ);
   i = TMath::LocMin(3, saf);
   norm[i] = (dir[i] > 0) ? 1 : (-1);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Decides fast if the bounding box could be crossed by a vector.
 
Bool_t TGeoBBox::CouldBeCrossed(const Double_t *point, const Double_t *dir) const
{
   Double_t mind = fDX;
   if (fDY < mind)
      mind = fDY;
   if (fDZ < mind)
      mind = fDZ;
   Double_t dx = fOrigin[0] - point[0];
   Double_t dy = fOrigin[1] - point[1];
   Double_t dz = fOrigin[2] - point[2];
   Double_t do2 = dx * dx + dy * dy + dz * dz;
   if (do2 <= (mind * mind))
      return kTRUE;
   Double_t rmax2 = fDX * fDX + fDY * fDY + fDZ * fDZ;
   if (do2 <= rmax2)
      return kTRUE;
   // inside bounding sphere
   Double_t doct = dx * dir[0] + dy * dir[1] + dz * dir[2];
   // leaving ray
   if (doct <= 0)
      return kFALSE;
   Double_t dirnorm = dir[0] * dir[0] + dir[1] * dir[1] + dir[2] * dir[2];
   if ((doct * doct) >= (do2 - rmax2) * dirnorm)
      return kTRUE;
   return kFALSE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Compute closest distance from point px,py to each corner.
 
Int_t TGeoBBox::DistancetoPrimitive(Int_t px, Int_t py)
{
   const Int_t numPoints = 8;
   return ShapeDistancetoPrimitive(numPoints, px, py);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Divide this box shape belonging to volume "voldiv" into ndiv equal volumes
/// called divname, from start position with the given step. Returns pointer
/// to created division cell volume. In case a wrong division axis is supplied,
/// returns pointer to volume to be divided.
 
TGeoVolume *
TGeoBBox::Divide(TGeoVolume *voldiv, const char *divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step)
{
   TGeoShape *shape;          //--- shape to be created
   TGeoVolume *vol;           //--- division volume to be created
   TGeoVolumeMulti *vmulti;   //--- generic divided volume
   TGeoPatternFinder *finder; //--- finder to be attached
   TString opt = "";          //--- option to be attached
   Double_t end = start + ndiv * step;
   switch (iaxis) {
   case 1: //--- divide on X
      shape = new TGeoBBox(step / 2., fDY, fDZ);
      finder = new TGeoPatternX(voldiv, ndiv, start, end);
      opt = "X";
      break;
   case 2: //--- divide on Y
      shape = new TGeoBBox(fDX, step / 2., fDZ);
      finder = new TGeoPatternY(voldiv, ndiv, start, end);
      opt = "Y";
      break;
   case 3: //--- divide on Z
      shape = new TGeoBBox(fDX, fDY, step / 2.);
      finder = new TGeoPatternZ(voldiv, ndiv, start, end);
      opt = "Z";
      break;
   default: Error("Divide", "Wrong axis type for division"); return nullptr;
   }
   vol = new TGeoVolume(divname, shape, voldiv->GetMedium());
   vmulti = gGeoManager->MakeVolumeMulti(divname, voldiv->GetMedium());
   vmulti->AddVolume(vol);
   voldiv->SetFinder(finder);
   finder->SetDivIndex(voldiv->GetNdaughters());
   for (Int_t ic = 0; ic < ndiv; ic++) {
      voldiv->AddNodeOffset(vol, ic, start + step / 2. + ic * step, opt.Data());
      ((TGeoNodeOffset *)voldiv->GetNodes()->At(voldiv->GetNdaughters() - 1))->SetFinder(finder);
   }
   return vmulti;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Compute bounding box - nothing to do in this case.
 
void TGeoBBox::ComputeBBox() {}
 
////////////////////////////////////////////////////////////////////////////////
/// Test if point is inside this shape.
 
Bool_t TGeoBBox::Contains(const Double_t *point) const
{
   if (TMath::Abs(point[2] - fOrigin[2]) > fDZ)
      return kFALSE;
   if (TMath::Abs(point[0] - fOrigin[0]) > fDX)
      return kFALSE;
   if (TMath::Abs(point[1] - fOrigin[1]) > fDY)
      return kFALSE;
   return kTRUE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Static method to check if point[3] is located inside a box of having dx, dy, dz
/// as half-lengths.
 
Bool_t TGeoBBox::Contains(const Double_t *point, Double_t dx, Double_t dy, Double_t dz, const Double_t *origin)
{
   if (TMath::Abs(point[2] - origin[2]) > dz)
      return kFALSE;
   if (TMath::Abs(point[0] - origin[0]) > dx)
      return kFALSE;
   if (TMath::Abs(point[1] - origin[1]) > dy)
      return kFALSE;
   return kTRUE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Compute distance from inside point to surface of the box.
/// Boundary safe algorithm.
 
Double_t
TGeoBBox::DistFromInside(const Double_t *point, const Double_t *dir, Int_t iact, Double_t step, Double_t *safe) const
{
   Double_t s, smin, saf[6];
   Double_t newpt[3];
   Int_t i;
   for (i = 0; i < 3; i++)
      newpt[i] = point[i] - fOrigin[i];
   saf[0] = fDX + newpt[0];
   saf[1] = fDX - newpt[0];
   saf[2] = fDY + newpt[1];
   saf[3] = fDY - newpt[1];
   saf[4] = fDZ + newpt[2];
   saf[5] = fDZ - newpt[2];
   if (iact < 3 && safe) {
      smin = saf[0];
      // compute safe distance
      for (i = 1; i < 6; i++)
         if (saf[i] < smin)
            smin = saf[i];
      *safe = smin;
      if (smin < 0)
         *safe = 0.0;
      if (iact == 0)
         return TGeoShape::Big();
      if (iact == 1 && step < *safe)
         return TGeoShape::Big();
   }
   // compute distance to surface
   smin = TGeoShape::Big();
   for (i = 0; i < 3; i++) {
      if (dir[i] != 0) {
         s = (dir[i] > 0) ? (saf[(i << 1) + 1] / dir[i]) : (-saf[i << 1] / dir[i]);
         if (s < 0)
            return 0.0;
         if (s < smin)
            smin = s;
      }
   }
   return smin;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Compute distance from inside point to surface of the box.
/// Boundary safe algorithm.
 
Double_t TGeoBBox::DistFromInside(const Double_t *point, const Double_t *dir, Double_t dx, Double_t dy, Double_t dz,
                                  const Double_t *origin, Double_t /*stepmax*/)
{
   Double_t s, smin, saf[6];
   Double_t newpt[3];
   Int_t i;
   for (i = 0; i < 3; i++)
      newpt[i] = point[i] - origin[i];
   saf[0] = dx + newpt[0];
   saf[1] = dx - newpt[0];
   saf[2] = dy + newpt[1];
   saf[3] = dy - newpt[1];
   saf[4] = dz + newpt[2];
   saf[5] = dz - newpt[2];
   // compute distance to surface
   smin = TGeoShape::Big();
   for (i = 0; i < 3; i++) {
      if (dir[i] != 0) {
         s = (dir[i] > 0) ? (saf[(i << 1) + 1] / dir[i]) : (-saf[i << 1] / dir[i]);
         if (s < 0)
            return 0.0;
         if (s < smin)
            smin = s;
      }
   }
   return smin;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Compute distance from outside point to surface of the box.
/// Boundary safe algorithm.
 
Double_t
TGeoBBox::DistFromOutside(const Double_t *point, const Double_t *dir, Int_t iact, Double_t step, Double_t *safe) const
{
   Bool_t in = kTRUE;
   Double_t saf[3];
   Double_t par[3];
   Double_t newpt[3];
   Int_t i, j;
   for (i = 0; i < 3; i++)
      newpt[i] = point[i] - fOrigin[i];
   par[0] = fDX;
   par[1] = fDY;
   par[2] = fDZ;
   for (i = 0; i < 3; i++) {
      saf[i] = TMath::Abs(newpt[i]) - par[i];
      if (saf[i] >= step)
         return TGeoShape::Big();
      if (in && saf[i] > 0)
         in = kFALSE;
   }
   if (iact < 3 && safe) {
      // compute safe distance
      if (in) {
         *safe = 0.0;
      } else {
         *safe = saf[0];
         if (saf[1] > *safe)
            *safe = saf[1];
         if (saf[2] > *safe)
            *safe = saf[2];
      }
      if (iact == 0)
         return TGeoShape::Big();
      if (iact == 1 && step < *safe)
         return TGeoShape::Big();
   }
   // compute distance from point to box
   // protection in case point is actually inside box
   if (in) {
      j = 0;
      Double_t ss = saf[0];
      if (saf[1] > ss) {
         ss = saf[1];
         j = 1;
      }
      if (saf[2] > ss)
         j = 2;
      if (newpt[j] * dir[j] > 0)
         return TGeoShape::Big(); // in fact exiting
      return 0.0;
   }
   for (i = 0; i < 3; i++) {
      if (saf[i] < 0)
         continue;
      if (newpt[i] * dir[i] >= 0)
         continue;
      Double_t snxt = saf[i] / TMath::Abs(dir[i]);
      Int_t ibreak = 0;
      for (j = 0; j < 3; j++) {
         if (j == i)
            continue;
         Double_t coord = newpt[j] + snxt * dir[j];
         if (TMath::Abs(coord) > par[j]) {
            ibreak = 1;
            break;
         }
      }
      if (!ibreak)
         return snxt;
   }
   return TGeoShape::Big();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Compute distance from outside point to surface of the box.
/// Boundary safe algorithm.
 
Double_t TGeoBBox::DistFromOutside(const Double_t *point, const Double_t *dir, Double_t dx, Double_t dy, Double_t dz,
                                   const Double_t *origin, Double_t stepmax)
{
   Bool_t in = kTRUE;
   Double_t saf[3];
   Double_t par[3];
   Double_t newpt[3];
   Int_t i, j;
   for (i = 0; i < 3; i++)
      newpt[i] = point[i] - origin[i];
   par[0] = dx;
   par[1] = dy;
   par[2] = dz;
   for (i = 0; i < 3; i++) {
      saf[i] = TMath::Abs(newpt[i]) - par[i];
      if (saf[i] >= stepmax)
         return TGeoShape::Big();
      if (in && saf[i] > 0)
         in = kFALSE;
   }
   // In case point is inside return ZERO
   if (in)
      return 0.0;
   Double_t coord, snxt = TGeoShape::Big();
   Int_t ibreak = 0;
   for (i = 0; i < 3; i++) {
      if (saf[i] < 0)
         continue;
      if (newpt[i] * dir[i] >= 0)
         continue;
      snxt = saf[i] / TMath::Abs(dir[i]);
      ibreak = 0;
      for (j = 0; j < 3; j++) {
         if (j == i)
            continue;
         coord = newpt[j] + snxt * dir[j];
         if (TMath::Abs(coord) > par[j]) {
            ibreak = 1;
            break;
         }
      }
      if (!ibreak)
         return snxt;
   }
   return TGeoShape::Big();
}
 
////////////////////////////////////////////////////////////////////////////////
/// Returns name of axis IAXIS.
 
const char *TGeoBBox::GetAxisName(Int_t iaxis) const
{
   switch (iaxis) {
   case 1: return "X";
   case 2: return "Y";
   case 3: return "Z";
   default: return "UNDEFINED";
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Get range of shape for a given axis.
 
Double_t TGeoBBox::GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const
{
   xlo = 0;
   xhi = 0;
   Double_t dx = 0;
   switch (iaxis) {
   case 1:
      xlo = fOrigin[0] - fDX;
      xhi = fOrigin[0] + fDX;
      dx = 2 * fDX;
      return dx;
   case 2:
      xlo = fOrigin[1] - fDY;
      xhi = fOrigin[1] + fDY;
      dx = 2 * fDY;
      return dx;
   case 3:
      xlo = fOrigin[2] - fDZ;
      xhi = fOrigin[2] + fDZ;
      dx = 2 * fDZ;
      return dx;
   }
   return dx;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Fill vector param[4] with the bounding cylinder parameters. The order
/// is the following : Rmin, Rmax, Phi1, Phi2
 
void TGeoBBox::GetBoundingCylinder(Double_t *param) const
{
   param[0] = 0.;                    // Rmin
   param[1] = fDX * fDX + fDY * fDY; // Rmax
   param[2] = 0.;                    // Phi1
   param[3] = 360.;                  // Phi2
}
 
////////////////////////////////////////////////////////////////////////////////
/// Get area in internal units of the facet with a given index.
/// Possible index values:
///   - 0 - all facets together
///   - 1 to 6 - facet index from bottom to top Z
 
Double_t TGeoBBox::GetFacetArea(Int_t index) const
{
   Double_t area = 0.;
   switch (index) {
   case 0: area = 8. * (fDX * fDY + fDX * fDZ + fDY * fDZ); return area;
   case 1:
   case 6: area = 4. * fDX * fDY; return area;
   case 2:
   case 4: area = 4. * fDX * fDZ; return area;
   case 3:
   case 5: area = 4. * fDY * fDZ; return area;
   }
   return area;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Fills array with n random points located on the surface of indexed facet.
/// The output array must be provided with a length of minimum 3*npoints. Returns
/// true if operation succeeded.
/// Possible index values:
///   - 0 - all facets together
///   - 1 to 6 - facet index from bottom to top Z
 
Bool_t TGeoBBox::GetPointsOnFacet(Int_t index, Int_t npoints, Double_t *array) const
{
   if (index < 0 || index > 6)
      return kFALSE;
   Double_t surf[6];
   Double_t area = 0.;
   if (index == 0) {
      for (Int_t isurf = 0; isurf < 6; isurf++) {
         surf[isurf] = TGeoBBox::GetFacetArea(isurf + 1);
         if (isurf > 0)
            surf[isurf] += surf[isurf - 1];
      }
      area = surf[5];
   }
 
   for (Int_t i = 0; i < npoints; i++) {
      // Generate randomly a surface index if needed.
      Double_t *point = &array[3 * i];
      Int_t surfindex = index;
      if (surfindex == 0) {
         Double_t val = area * gRandom->Rndm();
         surfindex = 2 + TMath::BinarySearch(6, surf, val);
         if (surfindex > 6)
            surfindex = 6;
      }
      switch (surfindex) {
      case 1:
         point[0] = -fDX + 2 * fDX * gRandom->Rndm();
         point[1] = -fDY + 2 * fDY * gRandom->Rndm();
         point[2] = -fDZ;
         break;
      case 2:
         point[0] = -fDX + 2 * fDX * gRandom->Rndm();
         point[1] = -fDY;
         point[2] = -fDZ + 2 * fDZ * gRandom->Rndm();
         break;
      case 3:
         point[0] = -fDX;
         point[1] = -fDY + 2 * fDY * gRandom->Rndm();
         point[2] = -fDZ + 2 * fDZ * gRandom->Rndm();
         break;
      case 4:
         point[0] = -fDX + 2 * fDX * gRandom->Rndm();
         point[1] = fDY;
         point[2] = -fDZ + 2 * fDZ * gRandom->Rndm();
         break;
      case 5:
         point[0] = fDX;
         point[1] = -fDY + 2 * fDY * gRandom->Rndm();
         point[2] = -fDZ + 2 * fDZ * gRandom->Rndm();
         break;
      case 6:
         point[0] = -fDX + 2 * fDX * gRandom->Rndm();
         point[1] = -fDY + 2 * fDY * gRandom->Rndm();
         point[2] = fDZ;
         break;
      }
   }
   return kTRUE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Fills array with n random points located on the line segments of the shape mesh.
/// The output array must be provided with a length of minimum 3*npoints. Returns
/// true if operation is implemented.
 
Bool_t TGeoBBox::GetPointsOnSegments(Int_t npoints, Double_t *array) const
{
   if (!array || npoints <= 0)
      return kFALSE;
 
   auto buff = this->MakeBuffer3D();
   if (!buff)
      return kFALSE;
 
   const Int_t npnts = (Int_t)buff->NbPnts();
   const Int_t nsegs = (Int_t)buff->NbSegs();
   if (npnts <= 0 || nsegs <= 0 || !buff->fPnts || !buff->fSegs) {
      delete buff;
      return kFALSE;
   }
 
   // Fill only points on segments into `array`
   Int_t remaining = npoints;
   Int_t icrt = 0; // <--- start at 0, output-only buffer
 
   Int_t nperseg = TMath::Max((Int_t)(Double_t(remaining) / nsegs), 1);
 
   for (Int_t i = 0; i < nsegs && remaining > 0; i++) {
      const Int_t i0 = buff->fSegs[3 * i + 1];
      const Int_t i1 = buff->fSegs[3 * i + 2];
 
      if (i0 < 0 || i0 >= npnts || i1 < 0 || i1 >= npnts) {
         delete buff;
         Error("GetPointsOnSegments", "Segment index out of range: (%d,%d) npnts=%d", i0, i1, npnts);
         return kFALSE;
      }
      const Double_t *p0 = &buff->fPnts[3 * i0];
      const Double_t *p1 = &buff->fPnts[3 * i1];
 
      if (i == (nsegs - 1))
         nperseg = remaining;
 
      const Double_t dx = (p1[0] - p0[0]) / (nperseg + 1);
      const Double_t dy = (p1[1] - p0[1]) / (nperseg + 1);
      const Double_t dz = (p1[2] - p0[2]) / (nperseg + 1);
 
      for (Int_t j = 0; j < nperseg && remaining > 0; ++j) {
         array[icrt++] = p0[0] + (j + 1) * dx;
         array[icrt++] = p0[1] + (j + 1) * dy;
         array[icrt++] = p0[2] + (j + 1) * dz;
         --remaining;
      }
   }
   delete buff;
 
   if (remaining > 0) {
      Error("GetPointsOnSegments", "Could not fill %d points (%d missing)", npoints, remaining);
      return kFALSE;
   }
   return kTRUE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Fills real parameters of a positioned box inside this one. Returns 0 if successful.
 
Int_t TGeoBBox::GetFittingBox(const TGeoBBox *parambox, TGeoMatrix *mat, Double_t &dx, Double_t &dy, Double_t &dz) const
{
   dx = dy = dz = 0;
   if (mat->IsRotation()) {
      Error("GetFittingBox", "cannot handle parametrized rotated volumes");
      return 1; // ### rotation not accepted ###
   }
   //--> translate the origin of the parametrized box to the frame of this box.
   Double_t origin[3];
   mat->LocalToMaster(parambox->GetOrigin(), origin);
   if (!Contains(origin)) {
      Error("GetFittingBox", "wrong matrix - parametrized box is outside this");
      return 1; // ### wrong matrix ###
   }
   //--> now we have to get the valid range for all parametrized axis
   Double_t xlo = 0, xhi = 0;
   Double_t dd[3];
   dd[0] = parambox->GetDX();
   dd[1] = parambox->GetDY();
   dd[2] = parambox->GetDZ();
   for (Int_t iaxis = 0; iaxis < 3; iaxis++) {
      if (dd[iaxis] >= 0)
         continue;
      TGeoBBox::GetAxisRange(iaxis + 1, xlo, xhi);
      //-> compute best fitting parameter
      dd[iaxis] = TMath::Min(origin[iaxis] - xlo, xhi - origin[iaxis]);
      if (dd[iaxis] < 0) {
         Error("GetFittingBox", "wrong matrix");
         return 1;
      }
   }
   dx = dd[0];
   dy = dd[1];
   dz = dd[2];
   return 0;
}
 
////////////////////////////////////////////////////////////////////////////////
/// In case shape has some negative parameters, these has to be computed
/// in order to fit the mother
 
TGeoShape *TGeoBBox::GetMakeRuntimeShape(TGeoShape *mother, TGeoMatrix *mat) const
{
   if (!TestShapeBit(kGeoRunTimeShape))
      return nullptr;
   Double_t dx, dy, dz;
   Int_t ierr = mother->GetFittingBox(this, mat, dx, dy, dz);
   if (ierr) {
      Error("GetMakeRuntimeShape", "cannot fit this to mother");
      return nullptr;
   }
   return (new TGeoBBox(dx, dy, dz));
}
 
////////////////////////////////////////////////////////////////////////////////
/// Returns numbers of vertices, segments and polygons composing the shape mesh.
 
void TGeoBBox::GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t &npols) const
{
   nvert = 8;
   nsegs = 12;
   npols = 6;
}
 
////////////////////////////////////////////////////////////////////////////////
/// @brief Compute the world-space center of a placed TGeoBBox.
///
/// A TGeoBBox does not necessarily have its center at local coordinates (0,0,0).
/// Instead, its local center is given by TGeoBBox::GetOrigin().
///
/// @param[in] m   Pointer to the placement TGeoMatrix.
/// @return        World-space center of the box.
 
ROOT::Math::XYZVector TGeoBBox::GetWorldCenter(const TGeoMatrix *m) const
{
   Double_t w[3];
   m->LocalToMaster(fOrigin, w);
   return ROOT::Math::XYZVector(w[0], w[1], w[2]);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Prints shape parameters
 
void TGeoBBox::InspectShape() const
{
   printf("*** Shape %s: TGeoBBox ***\n", GetName());
   printf("    dX = %11.5f\n", fDX);
   printf("    dY = %11.5f\n", fDY);
   printf("    dZ = %11.5f\n", fDZ);
   printf("    origin: x=%11.5f y=%11.5f z=%11.5f\n", fOrigin[0], fOrigin[1], fOrigin[2]);
}
 
////////////////////////////////////////////////////////////////////////////////
/// @brief Test whether a given axis is a separating axis for two oriented boxes.
///
/// The test is based on the Separating Axis Theorem (SAT). The boxes are projected
/// onto the axis L using a center-plus-radius formulation, avoiding explicit
/// vertex enumeration.
///
/// Tolerance handling:
///   Two boxes that only touch (face, edge, or corner contact) within
///   TGeoShape::Tolerance() are considered NON-intersecting.
///
/// Formally, the axis separates the boxes if:
///
///   |(oB - oA) · L| >= rA(L) + rB(L) - tol
///
/// where rA and rB are the projection radii of each box onto L.
///
/// @param[in] L   Candidate separating axis in world coordinates.
/// @param[in] D   Vector from center of box A to center of box B (oB - oA).
/// @param[in] Ax  World-space X axis of box A.
/// @param[in] Ay  World-space Y axis of box A.
/// @param[in] Az  World-space Z axis of box A.
/// @param[in] Bx  World-space X axis of box B.
/// @param[in] By  World-space Y axis of box B.
/// @param[in] Bz  World-space Z axis of box B.
/// @param[in] dA  Half-length vector of box A.
/// @param[in] dB  Half-length vector of box B.
/// @param[in] tol Geometric tolerance (typically TGeoShape::Tolerance()).
///
/// @return true  If L is a separating axis (boxes do NOT intersect).
/// @return false If L does not separate the boxes or is degenerate.
 
Bool_t TGeoBBox::IsSeparatingAxis(const ROOT::Math::XYZVector &L, const ROOT::Math::XYZVector &D,
                                  const ROOT::Math::XYZVector &Ax, const ROOT::Math::XYZVector &Ay,
                                  const ROOT::Math::XYZVector &Az, const ROOT::Math::XYZVector &Bx,
                                  const ROOT::Math::XYZVector &By, const ROOT::Math::XYZVector &Bz,
                                  const ROOT::Math::XYZVector &dA, const ROOT::Math::XYZVector &dB, Double_t tol)
{
   // Degenerate axes can arise from cross products of nearly parallel axes.
   const Double_t eps = 1e-18;
   if (L.Mag2() < eps)
      return false;
 
   const Double_t dist = std::fabs(D.Dot(L));
   const Double_t rA = TMath::Abs(dA.x() * Ax.Dot(L)) + TMath::Abs(dA.y() * Ay.Dot(L)) + TMath::Abs(dA.z() * Az.Dot(L));
   const Double_t rB = TMath::Abs(dB.x() * Bx.Dot(L)) + TMath::Abs(dB.y() * By.Dot(L)) + TMath::Abs(dB.z() * Bz.Dot(L));
 
   // Touching within tolerance is treated as non-intersecting
   return dist >= (rA + rB - tol);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Creates a TBuffer3D describing *this* shape.
/// Coordinates are in local reference frame.
 
TBuffer3D *TGeoBBox::MakeBuffer3D() const
{
   Int_t npnts = 0, nsegs = 0, npols = 0;
   this->GetMeshNumbers(npnts, nsegs, npols);
   if (npnts <= 0 || nsegs <= 0)
      return nullptr;
   TBuffer3D *buff = new TBuffer3D(TBuffer3DTypes::kGeneric, npnts, 3 * npnts, nsegs, 3 * nsegs, npols, 6 * npols);
   this->SetPoints(buff->fPnts);
   this->SetSegsAndPols(*buff);
   return buff;
}
 
////////////////////////////////////////////////////////////////////////////////
/// @brief Fast "may-intersect" test for two placed TGeoBBox objects.
///
/// This method implements a broad-phase oriented bounding box (OBB) intersection
/// test using the Separating Axis Theorem (SAT).
///
/// The test is optimized for fast rejection:
///   - bounding-sphere early exit,
///   - face-normal axes tested first,
///   - cross-product axes tested only if needed.
///
/// Geometry and tolerance semantics:
///   - Boxes are treated as oriented bounding boxes defined by their half-lengths
///     and placement matrices.
///   - TGeoBBox::GetOrigin() is fully taken into account.
///   - Boxes that only touch within TGeoShape::Tolerance() are considered
///     NON-intersecting.
///
/// Intended usage:
///   - Broad-phase culling in navigation or overlap checks.
///   - Conservative test: returning true means the boxes MAY intersect.
///
/// @param[in] boxA Pointer to the first TGeoBBox shape.
/// @param[in] mA   Placement matrix of the first box.
/// @param[in] boxB Pointer to the second TGeoBBox shape.
/// @param[in] mB   Placement matrix of the second box.
///
/// @return true  If the boxes MAY intersect.
/// @return false If the boxes are guaranteed NOT to intersect
///               (or only touch within tolerance).
 
bool TGeoBBox::MayIntersect(const TGeoBBox *boxA, const TGeoMatrix *mA, const TGeoBBox *boxB, const TGeoMatrix *mB)
{
   const Double_t tol = TGeoShape::Tolerance();
 
   // Half-lengths vectors
   const ROOT::Math::XYZVector dA = boxA->GetDimensions();
   const ROOT::Math::XYZVector dB = boxB->GetDimensions();
 
   // Correct world-space centers (including TGeoBBox origin)
   const ROOT::Math::XYZVector oA = boxA->GetWorldCenter(mA);
   const ROOT::Math::XYZVector oB = boxB->GetWorldCenter(mB);
   const ROOT::Math::XYZVector D = oB - oA;
 
   // Very cheap early rejection using bounding spheres
   const Double_t rA = TMath::Sqrt(dA.Mag2());
   const Double_t rB = TMath::Sqrt(dB.Mag2());
   const Double_t dmax = rA + rB - tol;
 
   // Touching within tolerance is treated as non-intersecting
   if (D.Mag2() >= dmax * dmax)
      return kFALSE;
 
   // World-space box axes
   ROOT::Math::XYZVector Ax, Ay, Az;
   ROOT::Math::XYZVector Bx, By, Bz;
   mA->GetWorldAxes(Ax, Ay, Az);
   mB->GetWorldAxes(Bx, By, Bz);
 
   // SAT: face-normal axes (6 tests)
   if (IsSeparatingAxis(Ax, D, Ax, Ay, Az, Bx, By, Bz, dA, dB, tol))
      return kFALSE;
   if (IsSeparatingAxis(Ay, D, Ax, Ay, Az, Bx, By, Bz, dA, dB, tol))
      return kFALSE;
   if (IsSeparatingAxis(Az, D, Ax, Ay, Az, Bx, By, Bz, dA, dB, tol))
      return kFALSE;
 
   if (IsSeparatingAxis(Bx, D, Ax, Ay, Az, Bx, By, Bz, dA, dB, tol))
      return kFALSE;
   if (IsSeparatingAxis(By, D, Ax, Ay, Az, Bx, By, Bz, dA, dB, tol))
      return kFALSE;
   if (IsSeparatingAxis(Bz, D, Ax, Ay, Az, Bx, By, Bz, dA, dB, tol))
      return kFALSE;
 
   // SAT: cross-product axes (9 tests)
   const ROOT::Math::XYZVector Aaxes[3] = {Ax, Ay, Az};
   const ROOT::Math::XYZVector Baxes[3] = {Bx, By, Bz};
 
   for (int i = 0; i < 3; ++i) {
      for (int j = 0; j < 3; ++j) {
         const ROOT::Math::XYZVector L = Aaxes[i].Cross(Baxes[j]);
         if (IsSeparatingAxis(L, D, Ax, Ay, Az, Bx, By, Bz, dA, dB, tol))
            return kFALSE;
      }
   }
 
   // No separating axis found: boxes MAY intersect
   return kTRUE;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Fills TBuffer3D structure for segments and polygons.
 
void TGeoBBox::SetSegsAndPols(TBuffer3D &buff) const
{
   Int_t c = GetBasicColor();
 
   buff.fSegs[0] = c;
   buff.fSegs[1] = 0;
   buff.fSegs[2] = 1;
   buff.fSegs[3] = c + 1;
   buff.fSegs[4] = 1;
   buff.fSegs[5] = 2;
   buff.fSegs[6] = c + 1;
   buff.fSegs[7] = 2;
   buff.fSegs[8] = 3;
   buff.fSegs[9] = c;
   buff.fSegs[10] = 3;
   buff.fSegs[11] = 0;
   buff.fSegs[12] = c + 2;
   buff.fSegs[13] = 4;
   buff.fSegs[14] = 5;
   buff.fSegs[15] = c + 2;
   buff.fSegs[16] = 5;
   buff.fSegs[17] = 6;
   buff.fSegs[18] = c + 3;
   buff.fSegs[19] = 6;
   buff.fSegs[20] = 7;
   buff.fSegs[21] = c + 3;
   buff.fSegs[22] = 7;
   buff.fSegs[23] = 4;
   buff.fSegs[24] = c;
   buff.fSegs[25] = 0;
   buff.fSegs[26] = 4;
   buff.fSegs[27] = c + 2;
   buff.fSegs[28] = 1;
   buff.fSegs[29] = 5;
   buff.fSegs[30] = c + 1;
   buff.fSegs[31] = 2;
   buff.fSegs[32] = 6;
   buff.fSegs[33] = c + 3;
   buff.fSegs[34] = 3;
   buff.fSegs[35] = 7;
 
   buff.fPols[0] = c;
   buff.fPols[1] = 4;
   buff.fPols[2] = 0;
   buff.fPols[3] = 9;
   buff.fPols[4] = 4;
   buff.fPols[5] = 8;
   buff.fPols[6] = c + 1;
   buff.fPols[7] = 4;
   buff.fPols[8] = 1;
   buff.fPols[9] = 10;
   buff.fPols[10] = 5;
   buff.fPols[11] = 9;
   buff.fPols[12] = c;
   buff.fPols[13] = 4;
   buff.fPols[14] = 2;
   buff.fPols[15] = 11;
   buff.fPols[16] = 6;
   buff.fPols[17] = 10;
   buff.fPols[18] = c + 1;
   buff.fPols[19] = 4;
   buff.fPols[20] = 3;
   buff.fPols[21] = 8;
   buff.fPols[22] = 7;
   buff.fPols[23] = 11;
   buff.fPols[24] = c + 2;
   buff.fPols[25] = 4;
   buff.fPols[26] = 0;
   buff.fPols[27] = 3;
   buff.fPols[28] = 2;
   buff.fPols[29] = 1;
   buff.fPols[30] = c + 3;
   buff.fPols[31] = 4;
   buff.fPols[32] = 4;
   buff.fPols[33] = 5;
   buff.fPols[34] = 6;
   buff.fPols[35] = 7;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Computes the closest distance from given point to this shape.
 
Double_t TGeoBBox::Safety(const Double_t *point, Bool_t in) const
{
   Double_t safe, safy, safz;
   if (in) {
      safe = fDX - TMath::Abs(point[0] - fOrigin[0]);
      safy = fDY - TMath::Abs(point[1] - fOrigin[1]);
      safz = fDZ - TMath::Abs(point[2] - fOrigin[2]);
      if (safy < safe)
         safe = safy;
      if (safz < safe)
         safe = safz;
   } else {
      safe = -fDX + TMath::Abs(point[0] - fOrigin[0]);
      safy = -fDY + TMath::Abs(point[1] - fOrigin[1]);
      safz = -fDZ + TMath::Abs(point[2] - fOrigin[2]);
      if (safy > safe)
         safe = safy;
      if (safz > safe)
         safe = safz;
   }
   return safe;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Save a primitive as a C++ statement(s) on output stream "out".
 
void TGeoBBox::SavePrimitive(std::ostream &out, Option_t * /*option*/ /*= ""*/)
{
   if (TObject::TestBit(kGeoSavePrimitive))
      return;
   out << "   // Shape: " << GetName() << " type: " << ClassName() << std::endl;
   out << "   dx = " << fDX << ";" << std::endl;
   out << "   dy = " << fDY << ";" << std::endl;
   out << "   dz = " << fDZ << ";" << std::endl;
   if (!TGeoShape::IsSameWithinTolerance(fOrigin[0], 0) || !TGeoShape::IsSameWithinTolerance(fOrigin[1], 0) ||
       !TGeoShape::IsSameWithinTolerance(fOrigin[2], 0)) {
      out << "   origin[0] = " << fOrigin[0] << ";" << std::endl;
      out << "   origin[1] = " << fOrigin[1] << ";" << std::endl;
      out << "   origin[2] = " << fOrigin[2] << ";" << std::endl;
      out << "   TGeoShape *" << GetPointerName() << " = new TGeoBBox(\"" << GetName() << "\", dx,dy,dz,origin);"
          << std::endl;
   } else {
      out << "   TGeoShape *" << GetPointerName() << " = new TGeoBBox(\"" << GetName() << "\", dx,dy,dz);" << std::endl;
   }
   TObject::SetBit(TGeoShape::kGeoSavePrimitive);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set parameters of the box.
 
void TGeoBBox::SetBoxDimensions(Double_t dx, Double_t dy, Double_t dz, Double_t *origin)
{
   fDX = dx;
   fDY = dy;
   fDZ = dz;
   if (origin) {
      fOrigin[0] = origin[0];
      fOrigin[1] = origin[1];
      fOrigin[2] = origin[2];
   }
   if (TMath::Abs(fDX) < TGeoShape::Tolerance() && TMath::Abs(fDY) < TGeoShape::Tolerance() &&
       TMath::Abs(fDZ) < TGeoShape::Tolerance())
      return;
   if ((fDX < 0) || (fDY < 0) || (fDZ < 0))
      SetShapeBit(kGeoRunTimeShape);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Set dimensions based on the array of parameters
/// param[0] - half-length in x
/// param[1] - half-length in y
/// param[2] - half-length in z
 
void TGeoBBox::SetDimensions(Double_t *param)
{
   if (!param) {
      Error("SetDimensions", "null parameters");
      return;
   }
   fDX = param[0];
   fDY = param[1];
   fDZ = param[2];
   if (TMath::Abs(fDX) < TGeoShape::Tolerance() && TMath::Abs(fDY) < TGeoShape::Tolerance() &&
       TMath::Abs(fDZ) < TGeoShape::Tolerance())
      return;
   if ((fDX < 0) || (fDY < 0) || (fDZ < 0))
      SetShapeBit(kGeoRunTimeShape);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Fill box vertices to an array.
 
void TGeoBBox::SetBoxPoints(Double_t *points) const
{
   TGeoBBox::SetPoints(points);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Fill box points.
 
void TGeoBBox::SetPoints(Double_t *points) const
{
   if (!points)
      return;
   Double_t xmin, xmax, ymin, ymax, zmin, zmax;
   xmin = -fDX + fOrigin[0];
   xmax = fDX + fOrigin[0];
   ymin = -fDY + fOrigin[1];
   ymax = fDY + fOrigin[1];
   zmin = -fDZ + fOrigin[2];
   zmax = fDZ + fOrigin[2];
   points[0] = xmin;
   points[1] = ymin;
   points[2] = zmin;
   points[3] = xmin;
   points[4] = ymax;
   points[5] = zmin;
   points[6] = xmax;
   points[7] = ymax;
   points[8] = zmin;
   points[9] = xmax;
   points[10] = ymin;
   points[11] = zmin;
   points[12] = xmin;
   points[13] = ymin;
   points[14] = zmax;
   points[15] = xmin;
   points[16] = ymax;
   points[17] = zmax;
   points[18] = xmax;
   points[19] = ymax;
   points[20] = zmax;
   points[21] = xmax;
   points[22] = ymin;
   points[23] = zmax;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Fill box points.
 
void TGeoBBox::SetPoints(Float_t *points) const
{
   if (!points)
      return;
   Double_t xmin, xmax, ymin, ymax, zmin, zmax;
   xmin = -fDX + fOrigin[0];
   xmax = fDX + fOrigin[0];
   ymin = -fDY + fOrigin[1];
   ymax = fDY + fOrigin[1];
   zmin = -fDZ + fOrigin[2];
   zmax = fDZ + fOrigin[2];
   points[0] = xmin;
   points[1] = ymin;
   points[2] = zmin;
   points[3] = xmin;
   points[4] = ymax;
   points[5] = zmin;
   points[6] = xmax;
   points[7] = ymax;
   points[8] = zmin;
   points[9] = xmax;
   points[10] = ymin;
   points[11] = zmin;
   points[12] = xmin;
   points[13] = ymin;
   points[14] = zmax;
   points[15] = xmin;
   points[16] = ymax;
   points[17] = zmax;
   points[18] = xmax;
   points[19] = ymax;
   points[20] = zmax;
   points[21] = xmax;
   points[22] = ymin;
   points[23] = zmax;
}
 
////////////////////////////////////////////////////////////////////////////////
////// fill size of this 3-D object
////    TVirtualGeoPainter *painter = gGeoManager->GetGeomPainter();
////    if (painter) painter->AddSize3D(8, 12, 6);
 
void TGeoBBox::Sizeof3D() const {}
 
////////////////////////////////////////////////////////////////////////////////
/// Fills a static 3D buffer and returns a reference.
 
const TBuffer3D &TGeoBBox::GetBuffer3D(Int_t reqSections, Bool_t localFrame) const
{
   static TBuffer3D buffer(TBuffer3DTypes::kGeneric);
 
   FillBuffer3D(buffer, reqSections, localFrame);
 
   // TODO: A box itself has has nothing more as already described
   // by bounding box. How will viewer interpret?
   if (reqSections & TBuffer3D::kRawSizes) {
      if (buffer.SetRawSizes(8, 3 * 8, 12, 3 * 12, 6, 6 * 6)) {
         buffer.SetSectionsValid(TBuffer3D::kRawSizes);
      }
   }
   if ((reqSections & TBuffer3D::kRaw) && buffer.SectionsValid(TBuffer3D::kRawSizes)) {
      SetPoints(buffer.fPnts);
      if (!buffer.fLocalFrame) {
         TransformPoints(buffer.fPnts, buffer.NbPnts());
      }
 
      SetSegsAndPols(buffer);
      buffer.SetSectionsValid(TBuffer3D::kRaw);
   }
 
   return buffer;
}
 
////////////////////////////////////////////////////////////////////////////////
/// Fills the supplied buffer, with sections in desired frame
/// See TBuffer3D.h for explanation of sections, frame etc.
 
void TGeoBBox::FillBuffer3D(TBuffer3D &buffer, Int_t reqSections, Bool_t localFrame) const
{
   TGeoShape::FillBuffer3D(buffer, reqSections, localFrame);
 
   if (reqSections & TBuffer3D::kBoundingBox) {
      Double_t halfLengths[3] = {fDX, fDY, fDZ};
      buffer.SetAABoundingBox(fOrigin, halfLengths);
 
      if (!buffer.fLocalFrame) {
         TransformPoints(buffer.fBBVertex[0], 8);
      }
      buffer.SetSectionsValid(TBuffer3D::kBoundingBox);
   }
}
 
////////////////////////////////////////////////////////////////////////////////
/// Check the inside status for each of the points in the array.
/// Input: Array of point coordinates + vector size
/// Output: Array of Booleans for the inside of each point
 
void TGeoBBox::Contains_v(const Double_t *points, Bool_t *inside, Int_t vecsize) const
{
   for (Int_t i = 0; i < vecsize; i++)
      inside[i] = Contains(&points[3 * i]);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Compute the normal for an array o points so that norm.dot.dir is positive
/// Input: Arrays of point coordinates and directions + vector size
/// Output: Array of normal directions
 
void TGeoBBox::ComputeNormal_v(const Double_t *points, const Double_t *dirs, Double_t *norms, Int_t vecsize)
{
   for (Int_t i = 0; i < vecsize; i++)
      ComputeNormal(&points[3 * i], &dirs[3 * i], &norms[3 * i]);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Compute distance from array of input points having directions specified by dirs. Store output in dists
 
void TGeoBBox::DistFromInside_v(const Double_t *points, const Double_t *dirs, Double_t *dists, Int_t vecsize,
                                Double_t *step) const
{
   for (Int_t i = 0; i < vecsize; i++)
      dists[i] = DistFromInside(&points[3 * i], &dirs[3 * i], 3, step[i]);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Compute distance from array of input points having directions specified by dirs. Store output in dists
 
void TGeoBBox::DistFromOutside_v(const Double_t *points, const Double_t *dirs, Double_t *dists, Int_t vecsize,
                                 Double_t *step) const
{
   for (Int_t i = 0; i < vecsize; i++)
      dists[i] = DistFromOutside(&points[3 * i], &dirs[3 * i], 3, step[i]);
}
 
////////////////////////////////////////////////////////////////////////////////
/// Compute safe distance from each of the points in the input array.
/// Input: Array of point coordinates, array of statuses for these points, size of the arrays
/// Output: Safety values
 
void TGeoBBox::Safety_v(const Double_t *points, const Bool_t *inside, Double_t *safe, Int_t vecsize) const
{
   for (Int_t i = 0; i < vecsize; i++)
      safe[i] = Safety(&points[3 * i], inside[i]);
}