75 memset(fPriority, 0, 3*
sizeof(
Int_t));
84 Fatal(
"TGeoVoxelFinder",
"Null pointer for volume");
164 for(
Int_t i=0; i<3; i++) {
190 for(
Int_t i=0; i<3; i++) {
278 for (
id=0;
id<nd;
id++) {
283 for (
Int_t point=0; point<8; point++) {
286 xyz[0] = xyz[1] = pt[0];
287 xyz[2] = xyz[3] = pt[1];
288 xyz[4] = xyz[5] = pt[2];
291 for (
Int_t j=0; j<3; j++) {
292 if (pt[j] < xyz[2*j]) xyz[2*j]=pt[j];
293 if (pt[j] > xyz[2*j+1]) xyz[2*j+1]=pt[j];
296 fBoxes[6*id] = 0.5*(xyz[1]-xyz[0]);
297 fBoxes[6*
id+1] = 0.5*(xyz[3]-xyz[2]);
298 fBoxes[6*
id+2] = 0.5*(xyz[5]-xyz[4]);
299 fBoxes[6*
id+3] = 0.5*(xyz[0]+xyz[1]);
300 fBoxes[6*
id+4] = 0.5*(xyz[2]+xyz[3]);
301 fBoxes[6*
id+5] = 0.5*(xyz[4]+xyz[5]);
312 if (!mat) memcpy(master,local,3*
sizeof(
Double_t));
326 Double_t dxyz, minsafe2=minsafe*minsafe;
330 for (i=0; i<3; i++) {
332 if (dxyz>-1
E-6) rsq+=dxyz*dxyz;
353 for (
id=0;
id<
fIbx-1;
id++) {
357 else printf(
"Woops : slice X\n");
359 printf(
"X efficiency : %g\n", effslice);
363 for (
id=0;
id<
fIby-1;
id++) {
367 else printf(
"Woops : slice X\n");
369 printf(
"Y efficiency : %g\n", effslice);
373 for (
id=0;
id<
fIbz-1;
id++) {
377 else printf(
"Woops : slice X\n");
379 printf(
"Z efficiency : %g\n", effslice);
382 printf(
"Total efficiency : %g\n", eff);
392 Double_t xmin1, xmax1, ymin1, ymax1, zmin1, zmax1;
400 xmax = fBoxes[6*inode+3] + fBoxes[6*inode];
401 ymin = fBoxes[6*inode+4] - fBoxes[6*inode+1];
402 ymax = fBoxes[6*inode+4] + fBoxes[6*inode+1];
403 zmin = fBoxes[6*inode+5] - fBoxes[6*inode+2];
404 zmax = fBoxes[6*inode+5] + fBoxes[6*inode+2];
406 for (
Int_t ib=0; ib<nd; ib++) {
407 if (ib == inode)
continue;
408 xmin1 = fBoxes[6*ib+3] - fBoxes[6*ib];
409 xmax1 = fBoxes[6*ib+3] + fBoxes[6*ib];
410 ymin1 = fBoxes[6*ib+4] - fBoxes[6*ib+1];
411 ymax1 = fBoxes[6*ib+4] + fBoxes[6*ib+1];
412 zmin1 = fBoxes[6*ib+5] - fBoxes[6*ib+2];
413 zmax1 = fBoxes[6*ib+5] + fBoxes[6*ib+2];
417 if (ddx1*ddx2 <= 0.)
continue;
420 if (ddx1*ddx2 <= 0.)
continue;
423 if (ddx1*ddx2 <= 0.)
continue;
431 ovlps =
new Int_t[novlp];
432 memcpy(ovlps, otmp, novlp*
sizeof(
Int_t));
492 list = &
fExtraX[fOEx[islice]+2];
511 list = &
fExtraY[fOEy[islice]+2];
530 list = &
fExtraZ[fOEz[islice]+2];
547 for (icand=0; icand<ncheck; icand++) {
548 bitnumber = (
UInt_t)list[icand];
567 for (icand=0; icand<ncheck; icand++) {
568 bitnumber = (
UInt_t)list[icand];
571 byte = (~td.
fVoxBits1[loc]) & array1[loc] & (1<<bit);
587 for (icand=0; icand<ncheck; icand++) {
588 bitnumber = (
UInt_t)list[icand];
591 byte = (~td.
fVoxBits1[loc]) & array1[loc] & array2[loc] & (1<<bit);
631 if (dind[0]<0 || dind[0]>
fIbx-1)
return 0;
644 dforced[0] = dmin[0];
647 if (isXlimit)
return 0;
653 dforced[0] = dmin[0];
656 if (isXlimit)
return 0;
671 if (dind[1]<0 || dind[1]>
fIby-1)
return 0;
685 dforced[1] = dmin[1];
688 if (isYlimit)
return 0;
694 dforced[1] = dmin[1];
697 if (isYlimit)
return 0;
712 if (dind[2]<0 || dind[2]>
fIbz-1)
return 0;
726 dforced[2] = dmin[2];
729 if (isZlimit)
return 0;
735 dforced[2] = dmin[2];
738 if (isZlimit)
return 0;
761 if (dforced[1]>dslice) {
767 if (dforced[2]>dslice) {
776 if (dforced[2]>dslice) {
789 if (dforced[2]>dslice) {
803 dslice = dmin[islice];
804 if (dslice>=maxstep) {
814 Int_t ndd[2] = {0,0};
819 if (isXlimit)
return 0;
826 if ((dslice>dmin[1]) && td.
fVoxInc[1]) {
841 if ((dslice>dmin[2]) && td.
fVoxInc[2]) {
928 return GetValidExtra(ndd[0], slice1, ndd[1], slice2, new_list, ncheck, td);
931 if (isYlimit)
return 0;
938 if ((dslice>dmin[0]) && td.
fVoxInc[0]) {
953 if ((dslice>dmin[2]) && td.
fVoxInc[2]) {
1040 return GetValidExtra(ndd[0], slice1, ndd[1], slice2, new_list, ncheck, td);
1043 if (isZlimit)
return 0;
1050 if ((dslice>dmin[1]) && td.
fVoxInc[1]) {
1065 if ((dslice>dmin[0]) && td.
fVoxInc[0]) {
1152 return GetValidExtra(ndd[0], slice1, ndd[1], slice2, new_list, ncheck, td);
1178 for (
Int_t i=0; i<3; i++) {
1181 td.
fVoxInc[i] = (dir[i]>0)?1:-1;
1238 memset(&nd[0], 0, 3*
sizeof(
Int_t));
1260 if (slicex && slicey) {
1305 if (point[0]<
fXb[0] || point[0]>
fXb[1])
return 0;
1308 if (point[1]<
fYb[0] || point[1]>
fYb[1])
return 0;
1312 if (point[2]<
fZb[0] || point[2]>
fZb[1])
return 0;
1322 Int_t nd[3] = {0,0,0};
1326 if ((im==-1) || (im==
fIbx-1))
return 0;
1329 if (!nd[0])
return 0;
1337 if ((im==-1) || (im==
fIby-1))
return 0;
1340 if (!nd[1])
return 0;
1353 if ((im==-1) || (im==
fIbz-1))
return 0;
1356 if (!nd[2])
return 0;
1358 if (slice1 && slice2) {
1399 Int_t nd[3] = {0,0,0};
1403 if (!nd[0])
return 0;
1410 if (!nd[1])
return 0;
1422 if (!nd[2])
return 0;
1424 if (slice1 && slice2) {
1485 Int_t nbytes = 1+((nd-1)>>3);
1490 for (current_byte=0; current_byte<nbytes; current_byte++) {
1491 byte = array1[current_byte];
1492 if (!byte)
continue;
1493 for (current_bit=0; current_bit<8; current_bit++) {
1494 if (byte & (1<<current_bit)) {
1495 result[nf++] = (current_byte<<3)+current_bit;
1502 if (ibreak)
return kTRUE;
1515 Int_t nbytes = 1+((nd-1)>>3);
1530 for (current_byte=0; current_byte<nbytes; current_byte++) {
1531 byte = array1[current_byte];
1532 icand = current_byte<<3;
1533 if (!byte)
continue;
1534 for (current_bit=0; current_bit<8; current_bit++) {
1535 if (byte & (1<<current_bit)) {
1543 if (ibreak)
return kTRUE;
1557 Int_t nbytes = 1+((nd-1)>>3);
1562 for (current_byte=0; current_byte<nbytes; current_byte++) {
1564 byte = (~td.
fVoxBits1[current_byte]) & array1[current_byte];
1565 if (!byte)
continue;
1566 for (current_bit=0; current_bit<8; current_bit++) {
1567 if (byte & (1<<current_bit)) {
1576 if (ibreak)
return kTRUE;
1590 Int_t nbytes = 1+((nd-1)>>3);
1594 for (current_byte=0; current_byte<nbytes; current_byte++) {
1595 byte = (~td.
fVoxBits1[current_byte]) & (array1[current_byte] & array2[current_byte]);
1596 if (!byte)
continue;
1597 for (current_bit=0; current_bit<8; current_bit++) {
1598 if (byte & (1<<current_bit)) {
1617 Int_t nbytes = 1+((nd-1)>>3);
1621 for (current_byte=0; current_byte<nbytes; current_byte++) {
1622 byte = (~td.
fVoxBits1[current_byte]) & (array1[current_byte] & array2[current_byte] & array3[current_byte]);
1623 if (!byte)
continue;
1624 for (current_bit=0; current_bit<8; current_bit++) {
1625 if (byte & (1<<current_bit)) {
1641 Int_t nbytes = 1+((nd-1)>>3);
1646 for (current_byte=0; current_byte<nbytes; current_byte++) {
1647 byte = array1[current_byte] & array2[current_byte];
1648 if (!byte)
continue;
1649 for (current_bit=0; current_bit<8; current_bit++) {
1650 if (byte & (1<<current_bit)) {
1651 result[nf++] = (current_byte<<3)+current_bit;
1652 if ((nf==n1) || (nf==n2)) {
1658 if (ibreak)
return kTRUE;
1671 Int_t nbytes = 1+((nd-1)>>3);
1677 for (current_byte=0; current_byte<nbytes; current_byte++) {
1678 byte = array1[current_byte] & array2[current_byte];
1679 icand = current_byte<<3;
1681 if (!byte)
continue;
1682 for (current_bit=0; current_bit<8; current_bit++) {
1683 if (byte & (1<<current_bit)) {
1698 Int_t nbytes = 1+((nd-1)>>3);
1703 for (current_byte=0; current_byte<nbytes; current_byte++) {
1704 byte = array1[current_byte] & array2[current_byte] & array3[current_byte];
1705 if (!byte)
continue;
1706 for (current_bit=0; current_bit<8; current_bit++) {
1707 if (byte & (1<<current_bit)) {
1708 result[nf++] = (current_byte<<3)+current_bit;
1709 if ((nf==n1) || (nf==n2) || (nf==n3)) {
1715 if (ibreak)
return kTRUE;
1728 Int_t nbytes = 1+((nd-1)>>3);
1734 for (current_byte=0; current_byte<nbytes; current_byte++) {
1735 byte = array1[current_byte] & array2[current_byte] & array3[current_byte];
1736 icand = current_byte<<3;
1738 if (!byte)
continue;
1739 for (current_bit=0; current_bit<8; current_bit++) {
1740 if (byte & (1<<current_bit)) {
1754 Int_t nmaxslices = 2*nd+1;
1764 if ((xmin>=xmax) || (ymin>=ymax) || (zmin>=zmax)) {
1771 for (
id=0;
id<nd;
id++) {
1774 boundaries[2*
id+1] = fBoxes[6*
id+3]+fBoxes[6*id];
1776 boundaries[2*
id+2*nd] = fBoxes[6*
id+4]-fBoxes[6*
id+1];
1777 boundaries[2*
id+2*nd+1] = fBoxes[6*
id+4]+fBoxes[6*
id+1];
1779 boundaries[2*
id+4*nd] = fBoxes[6*
id+5]-fBoxes[6*
id+2];
1780 boundaries[2*
id+4*nd+1] = fBoxes[6*
id+5]+fBoxes[6*
id+2];
1792 Int_t nleft, nright;
1795 Double_t xxmin, xxmax, xbmin, xbmax, ddx1, ddx2;
1804 for (
id=0;
id<2*nd;
id++) {
1805 if (!ib) {temp[ib++] = boundaries[index[id]];
continue;}
1806 if (
TMath::Abs(temp[ib-1]-boundaries[index[
id]])>1
E-10)
1807 temp[ib++] = boundaries[index[id]];
1812 delete [] boundaries;
1817 delete [] extra_left;
1818 delete [] extra_right;
1824 if (((temp[0]-xmin)<1
E-10) && ((temp[1]-xmax)>-1
E-10)) {
1852 memset(ind, 0, (nmaxslices*nperslice)*
sizeof(
UChar_t));
1863 for (
id=0;
id<
fNox;
id++) {
1865 fOEx[id] = indextra;
1867 extra[indextra] = extra[indextra+1] = 0;
1869 bits = &ind[current];
1872 for (
Int_t ic=0; ic<nd; ic++) {
1874 xbmax = fBoxes[6*ic+3]+fBoxes[6*ic];
1876 if (ddx1>-1
E-10)
continue;
1878 if (ddx2<1
E-10)
continue;
1885 bits[loc] |= 1<<bit;
1890 if ((
id==0) || (ddx1>-1
E-10)) {
1891 extra_left[nleft++] = ic;
1894 if ((
id==(
fNoz-1)) || (ddx2<1
E-10)) {
1895 extra_right[nright++] = ic;
1899 if (
fNsliceX[
id]>0) current += nperslice;
1901 extra[indextra] = nleft;
1902 extra[indextra+1] = nright;
1903 if (nleft) memcpy(&extra[indextra+2], extra_left, nleft*
sizeof(
Int_t));
1904 if (nright) memcpy(&extra[indextra+2+nleft], extra_right, nright*
sizeof(
Int_t));
1905 indextra += 2+nleft+nright;
1913 if (indextra>nmaxslices*4) printf(
"Woops!!!\n");
1922 for (
id=0;
id<2*nd;
id++) {
1923 if (!ib) {temp[ib++] = boundaries[2*nd+index[id]];
continue;}
1924 if (
TMath::Abs(temp[ib-1]-boundaries[2*nd+index[
id]])>1
E-10)
1925 temp[ib++]=boundaries[2*nd+index[id]];
1930 delete [] boundaries;
1935 delete [] extra_left;
1936 delete [] extra_right;
1942 if (((temp[0]-ymin)<1
E-10) && ((temp[1]-ymax)>-1
E-10)) {
1972 memset(ind, 0, (nmaxslices*nperslice)*
sizeof(
UChar_t));
1983 for (
id=0;
id<
fNoy;
id++) {
1985 fOEy[id] = indextra;
1987 extra[indextra] = extra[indextra+1] = 0;
1989 bits = &ind[current];
1992 for (
Int_t ic=0; ic<nd; ic++) {
1994 xbmax = fBoxes[6*ic+4]+fBoxes[6*ic+1];
1996 if (ddx1>-1
E-10)
continue;
1998 if (ddx2<1
E-10)
continue;
2005 bits[loc] |= 1<<bit;
2010 if ((
id==0) || (ddx1>-1
E-10)) {
2011 extra_left[nleft++] = ic;
2014 if ((
id==(
fNoz-1)) || (ddx2<1
E-10)) {
2015 extra_right[nright++] = ic;
2019 if (
fNsliceY[
id]>0) current += nperslice;
2021 extra[indextra] = nleft;
2022 extra[indextra+1] = nright;
2023 if (nleft) memcpy(&extra[indextra+2], extra_left, nleft*
sizeof(
Int_t));
2024 if (nright) memcpy(&extra[indextra+2+nleft], extra_right, nright*
sizeof(
Int_t));
2025 indextra += 2+nleft+nright;
2033 if (indextra>nmaxslices*4) printf(
"Woops!!!\n");
2042 for (
id=0;
id<2*nd;
id++) {
2043 if (!ib) {temp[ib++] = boundaries[4*nd+index[id]];
continue;}
2044 if ((
TMath::Abs(temp[ib-1]-boundaries[4*nd+index[
id]]))>1
E-10)
2045 temp[ib++]=boundaries[4*nd+index[id]];
2050 delete [] boundaries;
2055 delete [] extra_left;
2056 delete [] extra_right;
2062 if (((temp[0]-zmin)<1
E-10) && ((temp[1]-zmax)>-1
E-10)) {
2092 memset(ind, 0, (nmaxslices*nperslice)*
sizeof(
UChar_t));
2103 for (
id=0;
id<
fNoz;
id++) {
2105 fOEz[id] = indextra;
2107 extra[indextra] = extra[indextra+1] = 0;
2109 bits = &ind[current];
2112 for (
Int_t ic=0; ic<nd; ic++) {
2114 xbmax = fBoxes[6*ic+5]+fBoxes[6*ic+2];
2116 if (ddx1>-1
E-10)
continue;
2118 if (ddx2<1
E-10)
continue;
2125 bits[loc] |= 1<<bit;
2130 if ((
id==0) || (ddx1>-1
E-10)) {
2131 extra_left[nleft++] = ic;
2134 if ((
id==(fNoz-1)) || (ddx2<1
E-10)) {
2135 extra_right[nright++] = ic;
2139 if (
fNsliceZ[
id]>0) current += nperslice;
2141 extra[indextra] = nleft;
2142 extra[indextra+1] = nright;
2143 if (nleft) memcpy(&extra[indextra+2], extra_left, nleft*
sizeof(
Int_t));
2144 if (nright) memcpy(&extra[indextra+2+nleft], extra_right, nright*
sizeof(
Int_t));
2145 indextra += 2+nleft+nright;
2153 if (indextra>nmaxslices*4) printf(
"Woops!!!\n");
2157 delete [] boundaries;
2162 delete [] extra_left;
2163 delete [] extra_right;
2167 if (nd>1)
Error(
"SortAll",
"Volume %s: Cannot make slices on any axis",
fVolume->
GetName());
2192 for (
id=0;
id<
fIbx;
id++) {
2193 printf(
"%15.10f\n",
fXb[
id]);
2194 if (
id == (fIbx-1))
break;
2195 printf(
"slice %i : %i\n",
id,
fNsliceX[
id]);
2198 for (i=0; i<nbytes; i++) {
2200 for (bit=0; bit<8; bit++) {
2201 if (byte & (1<<bit)) printf(
" %i ", 8*i+bit);
2207 printf(
" extra_about_left = %i\n", nextra);
2209 printf(
" extra_about_right = %i\n", nextra);
2212 printf(
"%15.10f\n",
fXb[0]);
2213 for (
id=0;
id<nd;
id++) printf(
" %i ",
id);
2215 printf(
"%15.10f\n",
fXb[1]);
2219 for (
id=0;
id<
fIby;
id++) {
2220 printf(
"%15.10f\n",
fYb[
id]);
2221 if (
id == (fIby-1))
break;
2222 printf(
"slice %i : %i\n",
id,
fNsliceY[
id]);
2225 for (i=0; i<nbytes; i++) {
2227 for (bit=0; bit<8; bit++) {
2228 if (byte & (1<<bit)) printf(
" %i ", 8*i+bit);
2233 printf(
" extra_about_left = %i\n", nextra);
2235 printf(
" extra_about_right = %i\n", nextra);
2238 printf(
"%15.10f\n",
fYb[0]);
2239 for (
id=0;
id<nd;
id++) printf(
" %i ",
id);
2241 printf(
"%15.10f\n",
fYb[1]);
2246 for (
id=0;
id<
fIbz;
id++) {
2247 printf(
"%15.10f\n",
fZb[
id]);
2248 if (
id == (fIbz-1))
break;
2249 printf(
"slice %i : %i\n",
id,
fNsliceZ[
id]);
2252 for (i=0; i<nbytes; i++) {
2254 for (bit=0; bit<8; bit++) {
2255 if (byte & (1<<bit)) printf(
" %i ", 8*i+bit);
2261 printf(
" extra_about_left = %i\n", nextra);
2263 printf(
" extra_about_right = %i\n", nextra);
2266 printf(
"%15.10f\n",
fZb[0]);
2267 for (
id=0;
id<nd;
id++) printf(
" %i ",
id);
2269 printf(
"%15.10f\n",
fZb[1]);
2286 if ((im==-1) || (im==
fIbx-1)) {
2287 printf(
"Voxel X limits: OUT\n");
2289 printf(
"Voxel X limits: %g %g\n",
fXb[im],
fXb[im+1]);
2294 if ((im==-1) || (im==
fIby-1)) {
2295 printf(
"Voxel Y limits: OUT\n");
2297 printf(
"Voxel Y limits: %g %g\n",
fYb[im],
fYb[im+1]);
2302 if ((im==-1) || (im==
fIbz-1)) {
2303 printf(
"Voxel Z limits: OUT\n");
2305 printf(
"Voxel Z limits: %g %g\n",
fZb[im],
fZb[im+1]);
2318 for (
Int_t i=0; i<nd; i++) {
2329 void TGeoVoxelFinder::Streamer(
TBuffer &R__b)
Statefull info for the current geometry level.
virtual const char * GetName() const
Returns name of object.
virtual Int_t WriteClassBuffer(const TClass *cl, void *pointer)=0
Bool_t Union(Int_t n1, UChar_t *array1, TGeoStateInfo &td)
make union of older bits with new array printf("Union - one slice\n");
virtual void Voxelize(Option_t *option="")
Voxelize attached volume according to option If the volume is an assembly, make sure the bbox is comp...
virtual Double_t GetDX() const
void SetCylVoxels(Bool_t flag=kTRUE)
Geometrical transformation package.
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
TGeoNode * GetNode(const char *name) const
get the pointer to a daughter node
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) ...
TGeoVolume, TGeoVolumeMulti, TGeoVolumeAssembly are the volume classes.
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
Buffer base class used for serializing objects.
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) ...
Short_t Min(Short_t a, Short_t b)
TGeoVoxelFinder & operator=(const TGeoVoxelFinder &)
assignment operator
void box(Int_t pat, Double_t x1, Double_t y1, Double_t x2, Double_t y2)
virtual void SortCrossedVoxels(const Double_t *point, const Double_t *dir, TGeoStateInfo &td)
get the list in the next voxel crossed by a ray
static Bool_t IsSameWithinTolerance(Double_t a, Double_t b)
Check if two numbers differ with less than a tolerance.
Bool_t NeedRebuild() const
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")...
static Double_t Tolerance()
Int_t GetNdaughters() const
void SetInvalid(Bool_t flag=kTRUE)
void PrintVoxelLimits(const Double_t *point) const
print the voxel containing point
void Sort(Index n, const Element *a, Index *index, Bool_t down=kTRUE)
virtual TGeoMatrix * GetMatrix() const =0
TObject & operator=(const TObject &rhs)
TObject assignment operator.
virtual void Print(Option_t *option="") const
Print the voxels.
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 SetBoxPoints(Double_t *points) const
Fill box vertices to an array.
void SortAll(Option_t *option="")
order bounding boxes along x, y, z
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 SetNeedRebuild(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
TGeoVoxelFinder()
Default constructor.
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
virtual const Double_t * GetOrigin() const
Bool_t GetIndices(const Double_t *point, TGeoStateInfo &td)
Get indices for current slices on x, y, z.
virtual Double_t GetDY() const
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.
virtual void ReadFastArray(Bool_t *b, Int_t n)=0
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
virtual Double_t Efficiency()
Compute voxelization efficiency.
virtual Int_t ReadClassBuffer(const TClass *cl, void *pointer, const TClass *onfile_class=0)=0
Int_t * GetValidExtra(Int_t *list, Int_t &ncheck, TGeoStateInfo &td)
Get extra candidates that are not contained in current check list.
R__EXTERN TGeoManager * gGeoManager
virtual Int_t * GetNextCandidates(const Double_t *point, Int_t &ncheck, TGeoStateInfo &td)
Returns list of new candidates in next voxel.
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 ...
static RooMathCoreReg dummy
Finder class handling voxels.
virtual void ComputeBBox()=0
Mother of all ROOT objects.
void BuildVoxelLimits()
build the array of bounding boxes of the nodes inside
Bool_t IntersectAndStore(Int_t n1, UChar_t *array1, TGeoStateInfo &td)
return the list of nodes corresponding to one array of bits
A node represent a volume positioned inside another.They store links to both volumes and to the TGeoM...
virtual ~TGeoVoxelFinder()
Destructor.
Int_t GetNcandidates(TGeoStateInfo &td) const
virtual void Fatal(const char *method, const char *msgfmt,...) const
Issue fatal error message.
void FindOverlaps() const
loop all nodes marked as overlaps and find overlapping brothers
TGeoShape * GetShape() const
Long64_t LocMin(Long64_t n, const T *a)
TGeoVolume * GetVolume() const
Long64_t BinarySearch(Long64_t n, const T *array, T value)
void SetOverlaps(Int_t *ovlp, Int_t novlp)
set the list of overlaps for this node (ovlp must be created with operator new)
virtual Version_t ReadVersion(UInt_t *start=0, UInt_t *bcnt=0, const TClass *cl=0)=0
virtual Double_t GetDZ() const
virtual Bool_t IsAssembly() const
Returns true if the volume is an assembly or a scaled assembly.