83 Fatal(
"TGeoVoxelFinder",
"Null pointer for volume");
207 for (
id = 0;
id < nd;
id++) {
211 box->SetBoxPoints(&vert[0]);
212 for (
Int_t point = 0; point < 8; point++) {
215 xyz[0] = xyz[1] =
pt[0];
216 xyz[2] = xyz[3] =
pt[1];
217 xyz[4] = xyz[5] =
pt[2];
220 for (
Int_t j = 0; j < 3; j++) {
221 if (
pt[j] < xyz[2 * j])
223 if (
pt[j] > xyz[2 * j + 1])
224 xyz[2 * j + 1] =
pt[j];
227 fBoxes[6 *
id] = 0.5 * (xyz[1] - xyz[0]);
228 fBoxes[6 *
id + 1] = 0.5 * (xyz[3] - xyz[2]);
229 fBoxes[6 *
id + 2] = 0.5 * (xyz[5] - xyz[4]);
230 fBoxes[6 *
id + 3] = 0.5 * (xyz[0] + xyz[1]);
231 fBoxes[6 *
id + 4] = 0.5 * (xyz[2] + xyz[3]);
232 fBoxes[6 *
id + 5] = 0.5 * (xyz[4] + xyz[5]);
244 memcpy(master, local, 3 *
sizeof(
Double_t));
259 Double_t dxyz, minsafe2 = minsafe * minsafe;
260 Int_t ist = 6 * inode;
263 for (i = 0; i < 3; i++) {
288 for (
id = 0;
id <
fIbx - 1;
id++) {
292 effslice = nd / effslice;
294 printf(
"Woops : slice X\n");
296 printf(
"X efficiency : %g\n", effslice);
300 for (
id = 0;
id <
fIby - 1;
id++) {
304 effslice = nd / effslice;
306 printf(
"Woops : slice X\n");
308 printf(
"Y efficiency : %g\n", effslice);
312 for (
id = 0;
id <
fIbz - 1;
id++) {
316 effslice = nd / effslice;
318 printf(
"Woops : slice X\n");
320 printf(
"Z efficiency : %g\n", effslice);
323 printf(
"Total efficiency : %g\n", eff);
334 Double_t xmin1, xmax1, ymin1, ymax1, zmin1, zmax1;
337 Int_t *ovlps =
nullptr;
348 for (
Int_t ib = 0; ib < nd; ib++) {
360 if (ddx1 * ddx2 <= 0.)
364 if (ddx1 * ddx2 <= 0.)
368 if (ddx1 * ddx2 <= 0.)
377 ovlps =
new Int_t[novlp];
378 memcpy(ovlps, otmp, novlp *
sizeof(
Int_t));
437 Int_t *list =
nullptr;
457 Int_t *list =
nullptr;
477 Int_t *list =
nullptr;
500 for (icand = 0; icand < ncheck; icand++) {
501 bitnumber = (
UInt_t)list[icand];
502 loc = bitnumber >> 3;
504 byte = (~td.fVoxBits1[loc]) & (1 << bit);
521 for (icand = 0; icand < ncheck; icand++) {
522 bitnumber = (
UInt_t)list[icand];
523 loc = bitnumber >> 3;
525 byte = (~td.fVoxBits1[loc]) & array1[loc] & (1 << bit);
543 for (icand = 0; icand < ncheck; icand++) {
544 bitnumber = (
UInt_t)list[icand];
545 loc = bitnumber >> 3;
547 byte = (~td.fVoxBits1[loc]) & array1[loc] & array2[loc] & (1 << bit);
591 if (dind[0] < 0 || dind[0] >
fIbx - 1)
606 dforced[0] = dmin[0];
616 dforced[0] = dmin[0];
635 if (dind[1] < 0 || dind[1] >
fIby - 1)
651 dforced[1] = dmin[1];
661 dforced[1] = dmin[1];
680 if (dind[2] < 0 || dind[2] >
fIbz - 1)
696 dforced[2] = dmin[2];
706 dforced[2] = dmin[2];
733 if (dforced[1] > dslice) {
739 if (dforced[2] > dslice) {
748 if (dforced[2] > dslice) {
761 if (dforced[2] > dslice) {
775 dslice = dmin[islice];
776 if (dslice >= maxstep) {
786 Int_t ndd[2] = {0, 0};
801 if ((dslice > dmin[1]) && td.
fVoxInc[1]) {
802 xptnew = point[1] + dslice / td.
fVoxInvdir[1];
820 if ((dslice > dmin[2]) && td.
fVoxInc[2]) {
821 xptnew = point[2] + dslice / td.
fVoxInvdir[2];
917 return GetValidExtra(ndd[0], slice1, ndd[1], slice2, new_list, ncheck, td);
930 if ((dslice > dmin[0]) && td.
fVoxInc[0]) {
931 xptnew = point[0] + dslice / td.
fVoxInvdir[0];
949 if ((dslice > dmin[2]) && td.
fVoxInc[2]) {
950 xptnew = point[2] + dslice / td.
fVoxInvdir[2];
1046 return GetValidExtra(ndd[0], slice1, ndd[1], slice2, new_list, ncheck, td);
1059 if ((dslice > dmin[1]) && td.
fVoxInc[1]) {
1060 xptnew = point[1] + dslice / td.
fVoxInvdir[1];
1078 if ((dslice > dmin[0]) && td.
fVoxInc[0]) {
1079 xptnew = point[0] + dslice / td.
fVoxInvdir[0];
1175 return GetValidExtra(ndd[0], slice1, ndd[1], slice2, new_list, ncheck, td);
1177 default:
Error(
"GetNextCandidates",
"Invalid islice=%i inside %s", islice,
fVolume->
GetName());
1200 for (
Int_t i = 0; i < 3; i++) {
1204 td.
fVoxInc[i] = (dir[i] > 0) ? 1 : -1;
1261 memset(&nd[0], 0, 3 *
sizeof(
Int_t));
1283 if (slicex && slicey) {
1324 if (point[0] <
fXb[0] || point[0] >
fXb[1])
1328 if (point[1] <
fYb[0] || point[1] >
fYb[1])
1333 if (point[2] <
fZb[0] || point[2] >
fZb[1])
1344 Int_t nd[3] = {0, 0, 0};
1348 if ((im == -1) || (im ==
fIbx - 1))
1361 if ((im == -1) || (im ==
fIby - 1))
1379 if ((im == -1) || (im ==
fIbz - 1))
1386 if (slice1 && slice2) {
1421 Int_t nd[3] = {0, 0, 0};
1449 if (slice1 && slice2) {
1504 Int_t nbytes = 1 + ((nd - 1) >> 3);
1509 for (current_byte = 0; current_byte < nbytes; current_byte++) {
1510 byte = array1[current_byte];
1513 for (current_bit = 0; current_bit < 8; current_bit++) {
1514 if (
byte & (1 << current_bit)) {
1515 result[nf++] = (current_byte << 3) + current_bit;
1536 Int_t nbytes = 1 + ((nd - 1) >> 3);
1551 for (current_byte = 0; current_byte < nbytes; current_byte++) {
1552 byte = array1[current_byte];
1553 icand = current_byte << 3;
1556 for (current_bit = 0; current_bit < 8; current_bit++) {
1557 if (
byte & (1 << current_bit)) {
1580 Int_t nbytes = 1 + ((nd - 1) >> 3);
1585 for (current_byte = 0; current_byte < nbytes; current_byte++) {
1587 byte = (~td.fVoxBits1[current_byte]) & array1[current_byte];
1590 for (current_bit = 0; current_bit < 8; current_bit++) {
1591 if (
byte & (1 << current_bit)) {
1615 Int_t nbytes = 1 + ((nd - 1) >> 3);
1619 for (current_byte = 0; current_byte < nbytes; current_byte++) {
1620 byte = (~td.fVoxBits1[current_byte]) & (array1[current_byte] & array2[current_byte]);
1623 for (current_bit = 0; current_bit < 8; current_bit++) {
1624 if (
byte & (1 << current_bit)) {
1644 Int_t nbytes = 1 + ((nd - 1) >> 3);
1648 for (current_byte = 0; current_byte < nbytes; current_byte++) {
1649 byte = (~td.fVoxBits1[current_byte]) & (array1[current_byte] & array2[current_byte] & array3[current_byte]);
1652 for (current_bit = 0; current_bit < 8; current_bit++) {
1653 if (
byte & (1 << current_bit)) {
1669 Int_t nbytes = 1 + ((nd - 1) >> 3);
1674 for (current_byte = 0; current_byte < nbytes; current_byte++) {
1675 byte = array1[current_byte] & array2[current_byte];
1678 for (current_bit = 0; current_bit < 8; current_bit++) {
1679 if (
byte & (1 << current_bit)) {
1680 result[nf++] = (current_byte << 3) + current_bit;
1681 if ((nf == n1) || (nf == n2)) {
1702 Int_t nbytes = 1 + ((nd - 1) >> 3);
1708 for (current_byte = 0; current_byte < nbytes; current_byte++) {
1709 byte = array1[current_byte] & array2[current_byte];
1710 icand = current_byte << 3;
1714 for (current_bit = 0; current_bit < 8; current_bit++) {
1715 if (
byte & (1 << current_bit)) {
1731 Int_t nbytes = 1 + ((nd - 1) >> 3);
1736 for (current_byte = 0; current_byte < nbytes; current_byte++) {
1737 byte = array1[current_byte] & array2[current_byte] & array3[current_byte];
1740 for (current_bit = 0; current_bit < 8; current_bit++) {
1741 if (
byte & (1 << current_bit)) {
1742 result[nf++] = (current_byte << 3) + current_bit;
1743 if ((nf == n1) || (nf == n2) || (nf == n3)) {
1764 Int_t nbytes = 1 + ((nd - 1) >> 3);
1770 for (current_byte = 0; current_byte < nbytes; current_byte++) {
1771 byte = array1[current_byte] & array2[current_byte] & array3[current_byte];
1772 icand = current_byte << 3;
1776 for (current_bit = 0; current_bit < 8; current_bit++) {
1777 if (
byte & (1 << current_bit)) {
1790 Int_t nperslice = 1 + (nd - 1) / (8 *
sizeof(
UChar_t));
1791 Int_t nmaxslices = 2 * nd + 1;
1799 zmin = (
box->GetOrigin())[2] -
box->GetDZ();
1800 zmax = (
box->GetOrigin())[2] +
box->GetDZ();
1808 for (
id = 0;
id < nd;
id++) {
1813 boundaries[2 *
id + 2 * nd] =
fBoxes[6 *
id + 4] -
fBoxes[6 *
id + 1];
1814 boundaries[2 *
id + 2 * nd + 1] =
fBoxes[6 *
id + 4] +
fBoxes[6 *
id + 1];
1816 boundaries[2 *
id + 4 * nd] =
fBoxes[6 *
id + 5] -
fBoxes[6 *
id + 2];
1817 boundaries[2 *
id + 4 * nd + 1] =
fBoxes[6 *
id + 5] +
fBoxes[6 *
id + 2];
1819 auto prod = nmaxslices * nperslice;
1820 if (nmaxslices != prod / nperslice) {
1835 Int_t nleft, nright;
1838 Double_t xxmin, xxmax, xbmin, xbmax, ddx1, ddx2;
1847 for (
id = 0;
id < 2 * nd;
id++) {
1849 temp[ib++] = boundaries[
index[
id]];
1853 temp[ib++] = boundaries[
index[
id]];
1858 delete[] boundaries;
1863 delete[] extra_left;
1864 delete[] extra_right;
1870 if (((temp[0] -
xmin) < 1E-10) && ((temp[1] -
xmax) > -1E-10)) {
1902 memset(ind, 0, (nmaxslices * nperslice) *
sizeof(
UChar_t));
1916 for (
id = 0;
id <
fNox;
id++) {
1920 extra[indextra] = extra[indextra + 1] = 0;
1922 bits = &ind[current];
1924 xxmax =
fXb[
id + 1];
1925 for (
Int_t ic = 0; ic < nd; ic++) {
1928 ddx1 = xbmin - xxmax;
1931 ddx2 = xbmax - xxmin;
1938 loc = bitnumber / 8;
1939 bit = bitnumber % 8;
1940 bits[loc] |= 1 << bit;
1943 ddx1 = xbmin - xxmin;
1944 ddx2 = xbmax - xxmax;
1945 if ((
id == 0) || (ddx1 > -1E-10)) {
1946 extra_left[nleft++] = ic;
1949 if ((
id == (
fNoz - 1)) || (ddx2 < 1E-10)) {
1950 extra_right[nright++] = ic;
1955 current += nperslice;
1957 extra[indextra] = nleft;
1958 extra[indextra + 1] = nright;
1960 memcpy(&extra[indextra + 2], extra_left, nleft *
sizeof(
Int_t));
1962 memcpy(&extra[indextra + 2 + nleft], extra_right, nright *
sizeof(
Int_t));
1963 indextra += 2 + nleft + nright;
1973 if (indextra > nmaxslices * 4)
1974 printf(
"Woops!!!\n");
1983 for (
id = 0;
id < 2 * nd;
id++) {
1985 temp[ib++] = boundaries[2 * nd +
index[
id]];
1988 if (
TMath::Abs(temp[ib - 1] - boundaries[2 * nd +
index[
id]]) > 1E-10)
1989 temp[ib++] = boundaries[2 * nd +
index[
id]];
1994 delete[] boundaries;
1999 delete[] extra_left;
2000 delete[] extra_right;
2006 if (((temp[0] -
ymin) < 1E-10) && ((temp[1] -
ymax) > -1E-10)) {
2039 memset(ind, 0, (nmaxslices * nperslice) *
sizeof(
UChar_t));
2053 for (
id = 0;
id <
fNoy;
id++) {
2057 extra[indextra] = extra[indextra + 1] = 0;
2059 bits = &ind[current];
2061 xxmax =
fYb[
id + 1];
2062 for (
Int_t ic = 0; ic < nd; ic++) {
2065 ddx1 = xbmin - xxmax;
2068 ddx2 = xbmax - xxmin;
2075 loc = bitnumber / 8;
2076 bit = bitnumber % 8;
2077 bits[loc] |= 1 << bit;
2080 ddx1 = xbmin - xxmin;
2081 ddx2 = xbmax - xxmax;
2082 if ((
id == 0) || (ddx1 > -1E-10)) {
2083 extra_left[nleft++] = ic;
2086 if ((
id == (
fNoz - 1)) || (ddx2 < 1E-10)) {
2087 extra_right[nright++] = ic;
2092 current += nperslice;
2094 extra[indextra] = nleft;
2095 extra[indextra + 1] = nright;
2097 memcpy(&extra[indextra + 2], extra_left, nleft *
sizeof(
Int_t));
2099 memcpy(&extra[indextra + 2 + nleft], extra_right, nright *
sizeof(
Int_t));
2100 indextra += 2 + nleft + nright;
2110 if (indextra > nmaxslices * 4)
2111 printf(
"Woops!!!\n");
2120 for (
id = 0;
id < 2 * nd;
id++) {
2122 temp[ib++] = boundaries[4 * nd +
index[
id]];
2125 if ((
TMath::Abs(temp[ib - 1] - boundaries[4 * nd +
index[
id]])) > 1E-10)
2126 temp[ib++] = boundaries[4 * nd +
index[
id]];
2131 delete[] boundaries;
2136 delete[] extra_left;
2137 delete[] extra_right;
2143 if (((temp[0] - zmin) < 1E-10) && ((temp[1] - zmax) > -1E-10)) {
2176 memset(ind, 0, (nmaxslices * nperslice) *
sizeof(
UChar_t));
2190 for (
id = 0;
id <
fNoz;
id++) {
2194 extra[indextra] = extra[indextra + 1] = 0;
2196 bits = &ind[current];
2198 xxmax =
fZb[
id + 1];
2199 for (
Int_t ic = 0; ic < nd; ic++) {
2202 ddx1 = xbmin - xxmax;
2205 ddx2 = xbmax - xxmin;
2212 loc = bitnumber / 8;
2213 bit = bitnumber % 8;
2214 bits[loc] |= 1 << bit;
2217 ddx1 = xbmin - xxmin;
2218 ddx2 = xbmax - xxmax;
2219 if ((
id == 0) || (ddx1 > -1E-10)) {
2220 extra_left[nleft++] = ic;
2223 if ((
id == (
fNoz - 1)) || (ddx2 < 1E-10)) {
2224 extra_right[nright++] = ic;
2229 current += nperslice;
2231 extra[indextra] = nleft;
2232 extra[indextra + 1] = nright;
2234 memcpy(&extra[indextra + 2], extra_left, nleft *
sizeof(
Int_t));
2236 memcpy(&extra[indextra + 2 + nleft], extra_right, nright *
sizeof(
Int_t));
2237 indextra += 2 + nleft + nright;
2247 if (indextra > nmaxslices * 4)
2248 printf(
"Woops!!!\n");
2252 delete[] boundaries;
2257 delete[] extra_left;
2258 delete[] extra_right;
2288 for (
id = 0;
id <
fIbx;
id++) {
2289 printf(
"%15.10f\n",
fXb[
id]);
2290 if (
id == (
fIbx - 1))
2292 printf(
"slice %i : %i\n",
id,
fNsliceX[
id]);
2295 for (i = 0; i < nbytes; i++) {
2297 for (bit = 0; bit < 8; bit++) {
2298 if (
byte & (1 << bit))
2299 printf(
" %i ", 8 * i + bit);
2305 printf(
" extra_about_left = %i\n", nextra);
2307 printf(
" extra_about_right = %i\n", nextra);
2310 printf(
"%15.10f\n",
fXb[0]);
2311 for (
id = 0;
id < nd;
id++)
2314 printf(
"%15.10f\n",
fXb[1]);
2318 for (
id = 0;
id <
fIby;
id++) {
2319 printf(
"%15.10f\n",
fYb[
id]);
2320 if (
id == (
fIby - 1))
2322 printf(
"slice %i : %i\n",
id,
fNsliceY[
id]);
2325 for (i = 0; i < nbytes; i++) {
2327 for (bit = 0; bit < 8; bit++) {
2328 if (
byte & (1 << bit))
2329 printf(
" %i ", 8 * i + bit);
2334 printf(
" extra_about_left = %i\n", nextra);
2336 printf(
" extra_about_right = %i\n", nextra);
2339 printf(
"%15.10f\n",
fYb[0]);
2340 for (
id = 0;
id < nd;
id++)
2343 printf(
"%15.10f\n",
fYb[1]);
2348 for (
id = 0;
id <
fIbz;
id++) {
2349 printf(
"%15.10f\n",
fZb[
id]);
2350 if (
id == (
fIbz - 1))
2352 printf(
"slice %i : %i\n",
id,
fNsliceZ[
id]);
2355 for (i = 0; i < nbytes; i++) {
2357 for (bit = 0; bit < 8; bit++) {
2358 if (
byte & (1 << bit))
2359 printf(
" %i ", 8 * i + bit);
2365 printf(
" extra_about_left = %i\n", nextra);
2367 printf(
" extra_about_right = %i\n", nextra);
2370 printf(
"%15.10f\n",
fZb[0]);
2371 for (
id = 0;
id < nd;
id++)
2374 printf(
"%15.10f\n",
fZb[1]);
2391 if ((im == -1) || (im ==
fIbx - 1)) {
2392 printf(
"Voxel X limits: OUT\n");
2394 printf(
"Voxel X limits: %g %g\n",
fXb[im],
fXb[im + 1]);
2399 if ((im == -1) || (im ==
fIby - 1)) {
2400 printf(
"Voxel Y limits: OUT\n");
2402 printf(
"Voxel Y limits: %g %g\n",
fYb[im],
fYb[im + 1]);
2407 if ((im == -1) || (im ==
fIbz - 1)) {
2408 printf(
"Voxel Z limits: OUT\n");
2410 printf(
"Voxel Z limits: %g %g\n",
fZb[im],
fZb[im + 1]);
2424 for (
Int_t i = 0; i < nd; i++) {
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t index
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize id
R__EXTERN TGeoManager * gGeoManager
Buffer base class used for serializing objects.
virtual Version_t ReadVersion(UInt_t *start=nullptr, UInt_t *bcnt=nullptr, const TClass *cl=nullptr)=0
virtual void ReadFastArray(Bool_t *b, Int_t n)=0
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=nullptr)=0
virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer)=0
Geometrical transformation package.
virtual void LocalToMaster(const Double_t *local, Double_t *master) const
convert a point by multiplying its column vector (x, y, z, 1) to matrix inverse
A node represent a volume positioned inside another.They store links to both volumes and to the TGeoM...
TGeoVolume * GetVolume() const
void SetOverlaps(Int_t *ovlp, Int_t novlp)
set the list of overlaps for this node (ovlp must be created with operator new)
virtual TGeoMatrix * GetMatrix() const =0
static Bool_t IsSameWithinTolerance(Double_t a, Double_t b)
Check if two numbers differ with less than a tolerance.
virtual void ComputeBBox()=0
static Double_t Tolerance()
TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes.
void SetCylVoxels(Bool_t flag=kTRUE)
Int_t GetNdaughters() const
void FindOverlaps() const
loop all nodes marked as overlaps and find overlapping brothers
TGeoNode * GetNode(const char *name) const
get the pointer to a daughter node
TGeoShape * GetShape() const
virtual Bool_t IsAssembly() const
Returns true if the volume is an assembly or a scaled assembly.
Finder class handling voxels.
void Print(Option_t *option="") const override
Print the voxels.
Bool_t Union(Int_t n1, UChar_t *array1, TGeoStateInfo &td)
make union of older bits with new array printf("Union - one slice\n");
void SetNeedRebuild(Bool_t flag=kTRUE)
void Streamer(TBuffer &) override
Stream an object of class TGeoVoxelFinder.
virtual Int_t * GetCheckList(const Double_t *point, Int_t &nelem, TGeoStateInfo &td)
get the list of daughter indices for which point is inside their bbox
virtual Int_t * GetNextVoxel(const Double_t *point, const Double_t *dir, Int_t &ncheck, TGeoStateInfo &td)
get the list of new candidates for the next voxel crossed by current ray printf("### GetNextVoxel\n")...
~TGeoVoxelFinder() override
Destructor.
virtual void Voxelize(Option_t *option="")
Voxelize attached volume according to option If the volume is an assembly, make sure the bbox is comp...
void DaughterToMother(Int_t id, const Double_t *local, Double_t *master) const
convert a point from the local reference system of node id to reference system of mother volume
Bool_t Intersect(Int_t n1, UChar_t *array1, Int_t &nf, Int_t *result)
return the list of nodes corresponding to one array of bits
virtual Int_t * GetNextCandidates(const Double_t *point, Int_t &ncheck, TGeoStateInfo &td)
Returns list of new candidates in next voxel.
Bool_t GetIndices(const Double_t *point, TGeoStateInfo &td)
Get indices for current slices on x, y, z.
void SortAll(Option_t *option="")
order bounding boxes along x, y, z
Bool_t IsSafeVoxel(const Double_t *point, Int_t inode, Double_t minsafe) const
Computes squared distance from POINT to the voxel(s) containing node INODE.
Int_t * GetExtraY(Int_t islice, Bool_t left, Int_t &nextra) const
Return the list of extra candidates in a given Y slice compared to another (left or right)
void BuildVoxelLimits()
build the array of bounding boxes of the nodes inside
Int_t * GetVoxelCandidates(Int_t i, Int_t j, Int_t k, Int_t &ncheck, TGeoStateInfo &td)
get the list of candidates in voxel (i,j,k) - no check
void SetInvalid(Bool_t flag=kTRUE)
virtual void FindOverlaps(Int_t inode) const
create the list of nodes for which the bboxes overlap with inode's bbox
void PrintVoxelLimits(const Double_t *point) const
print the voxel containing point
Bool_t NeedRebuild() const
Int_t GetNcandidates(TGeoStateInfo &td) const
virtual Double_t Efficiency()
Compute voxelization efficiency.
virtual void SortCrossedVoxels(const Double_t *point, const Double_t *dir, TGeoStateInfo &td)
get the list in the next voxel crossed by a ray
Int_t * GetExtraZ(Int_t islice, Bool_t left, Int_t &nextra) const
Return the list of extra candidates in a given Z slice compared to another (left or right)
Int_t * GetExtraX(Int_t islice, Bool_t left, Int_t &nextra) const
Return the list of extra candidates in a given X slice compared to another (left or right)
Int_t * GetValidExtra(Int_t *list, Int_t &ncheck, TGeoStateInfo &td)
Get extra candidates that are not contained in current check list.
Bool_t IntersectAndStore(Int_t n1, UChar_t *array1, TGeoStateInfo &td)
return the list of nodes corresponding to one array of bits
TGeoVoxelFinder()
Default constructor.
const char * GetName() const override
Returns name of object.
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
void box(Int_t pat, Double_t x1, Double_t y1, Double_t x2, Double_t y2)
Long64_t LocMin(Long64_t n, const T *a)
Returns index of array with the minimum element.
Short_t Min(Short_t a, Short_t b)
Returns the smallest of a and b.
void Sort(Index n, const Element *a, Index *index, Bool_t down=kTRUE)
Sort the n elements of the array a of generic templated type Element.
Long64_t BinarySearch(Long64_t n, const T *array, T value)
Binary search in an array of n values to locate value.
Short_t Abs(Short_t d)
Returns the absolute value of parameter Short_t d.
Statefull info for the current geometry level.