geo.h File Reference

Supply basic geometry functions. More...

Go to the source code of this file.

Classes
struct	rect

Enumerations
enum	noe_view_t { kX, kY, kXorY }

Functions
int	pixx_from_pixy (const int y)
void	setboxes ()
void	setfd ()
int	total_x_pixels (const int pixels_x)
int	total_y_pixels (const int pixels_y)
int	scintpix_from_pixx (const int x)
int	det_to_screen_y (const int plane, const int cell)
int	det_to_screen_x (const int plane)
std::pair< int, int >	cppoint_to_screen (const cppoint &tp)
int	screen_to_plane (const noe_view_t view, const int x)
int	screen_to_plane_unbounded (const noe_view_t view, const int x)
int	screen_to_cell (const noe_view_t view, const int x, const int y)
int	screen_to_cell_unbounded (const noe_view_t view, const int x, const int y)

Detailed Description

Supply basic geometry functions.

Author

messi.nosp@m.er@i.nosp@m.ndian.nosp@m.a.ed.nosp@m.u

Version

Definition in file geo.h.

Enumeration Type Documentation

enum noe_view_t

Enumerator
kX
kY
kXorY

Definition at line 1 of file geo.h.

{ kX, kY, kXorY };

Function Documentation

std::pair<int, int> cppoint_to_screen

(

const cppoint &

tp

)

Definition at line 139 of file geo.cxx.

References cppoint::cell, det_to_screen_x(), det_to_screen_y(), cppoint::fcell, cppoint::fplane, pixx, pixy, and cppoint::plane.

Referenced by draw_track_in_one_view(), draw_vertex_in_one_view(), and rect::xmax().

{
  return std::pair<int, int>(
    det_to_screen_x(tp.plane)          + (0.5 + tp.fplane)*pixx/2,
    det_to_screen_y(tp.plane, tp.cell) + (0.5 - tp.fcell )*pixy
  );
}

int det_to_screen_x

(

const int

plane

)

Definition at line 100 of file geo.cxx.

References first_mucatcher, pixx, and screenxoffset.

Referenced by cppoint_to_screen(), dozooming(), draw_hit(), and rect::xmax().

{
  const bool xview = plane%2 == 1;
  return 1 + // Don't overdraw the border
    pixx*((plane

         // space out the muon catcher planes so they are twice as far
         // apart as normal.  This is very close to right, since the depth
         // of (two scintillator planes + one steel plane + air gaps) is
         // within 10% of the depth of two scintillator planes.
         +(plane > first_mucatcher?plane-first_mucatcher:0))/2)

        // stagger x and y planes
      + xview*pixx/2

      - screenxoffset;
}

int det_to_screen_y	(	const int	plane,
		const int	cell
	)

Definition at line 119 of file geo.cxx.

References getBrightness::cell, first_mucatcher, ncells_perplane, pixy, screenyoffset_xview, and screenyoffset_yview.

Referenced by cppoint_to_screen(), dozooming(), draw_hit(), and rect::xmax().

{
  const bool xview = plane%2 == 1;

  // In each view, every other plane is offset by half a cell width
  const bool celldown = !((plane/2)%2 ^ (plane%2));

  return + pixy*(ncells_perplane-cell) // cells numbered from the bottom

         - (pixy-1)

         // Physical stagger of planes in each view, but not in the muon
         // catcher, which is a better approximation to the current MC
         // geometry and plausible from visual inspection of the real
         // muon catcher.
         + (plane < first_mucatcher)*celldown*pixy/2

         - (xview?screenyoffset_xview:screenyoffset_yview);
}

int pixx_from_pixy

(

const int

y

)

Definition at line 51 of file geo.cxx.

References celldepth, ExtruGlueThick, ExtruWidth, and makeTrainCVSamples::int.

Referenced by dozooming(), and rect::xmax().

{
  const double meancellwidth = (2*ExtruWidth+ExtruGlueThick)/32;

  // Comes out to 3.36, giving pixel ratios 3:1, 2:7, 3:10, 4:13, 5:17, etc.
  const double planepix_per_cellpix = 2*celldepth/meancellwidth;

  return int(y*planepix_per_cellpix + 0.5);
}

int scintpix_from_pixx

(

const int

x

)

Definition at line 61 of file geo.cxx.

References celldepth, ExtruDepth, ExtruWallThick, and makeTrainCVSamples::int.

Referenced by draw_hit(), and rect::xmax().

{
  const double scintdepth = ExtruDepth - 2*ExtruWallThick;
  return int(x * scintdepth/(2*celldepth) + 0.5);
}

int screen_to_cell	(	const noe_view_t	view,
		const int	x,
		const int	y
	)

Definition at line 229 of file geo.cxx.

References plot_validation_datamc::c, first_mucatcher, kY, ncells_perplane, NDAPDHVSetting::plane, screen_to_cell_unbounded(), and screen_to_plane().

Referenced by screen_to_activecell(), and rect::xmax().

{
  const int c = screen_to_cell_unbounded(view, x, y);
  const int plane = screen_to_plane(view, x);
  if(c < 0) return -1;
  if(c >= ncells_perplane) return -1;
  if(plane >= first_mucatcher && view == kY && c >= 2*ncells_perplane/3) return -1;
  return c;
}

int screen_to_cell_unbounded	(	const noe_view_t	view,
		const int	x,
		const int	y
	)

Definition at line 215 of file geo.cxx.

References first_mucatcher, kX, ncells_perplane, pixy, NDAPDHVSetting::plane, screen_to_plane(), screenyoffset_xview, and screenyoffset_yview.

Referenced by dozooming(), screen_to_cell(), and rect::xmax().

{
  // Where y would be if not offset.  Do not pass into functions.
  const int unoffsety = y + (view == kX?screenyoffset_xview:screenyoffset_yview);

  const int plane = screen_to_plane(view, x);

  // See comments in det_to_screen_y() on the muon catcher.
  const bool celldown = (plane < first_mucatcher) && !((plane/2)%2 ^ (plane%2));
  const int effy = unoffsety - celldown*(pixy/2) - 2;

  return ncells_perplane - effy/pixy - 1;
}

int screen_to_plane	(	const noe_view_t	view,
		const int	x
	)

Definition at line 207 of file geo.cxx.

References kX, nplanes, and screen_to_plane_unbounded().

Referenced by screen_to_activecell(), screen_to_cell(), screen_to_cell_unbounded(), update_active_indices(), and rect::xmax().

{
  const int p = screen_to_plane_unbounded(view, x);
  if(p < (view == kX?1:0)) return -1;
  if(p >= nplanes) return -1;
  return p;
}

int screen_to_plane_unbounded	(	const noe_view_t	view,
		const int	x
	)

Definition at line 182 of file geo.cxx.

References first_mucatcher, kX, kY, pixx, and screenxoffset.

Referenced by dozooming(), screen_to_plane(), and rect::xmax().

{
  // Where x would be if not offset
  const int unoffsetx = x + screenxoffset;

  // The number of the first muon catcher plane counting only planes
  // in one view.
  const int halfmucatch = (first_mucatcher)/2 + (view == kY);

  // Account for the plane stagger and border width.
  const int effx = unoffsetx - 2 -
    (unoffsetx-2 >= halfmucatch*pixx)*(pixx/2);

  // Half the plane number, as long as we're not in the muon catcher
  int halfp = view == kX? (effx-pixx/2)/pixx
                        :(    effx   )/pixx;

  // Fix up the case of being in the muon catcher
  if(halfp > halfmucatch) halfp = halfmucatch +
                                  (halfp - halfmucatch)/2;

  // The plane number, except it might be out of range
  return halfp*2 + (view == kX);
}

void setboxes

(

)

Definition at line 149 of file geo.cxx.

References first_mucatcher, kX, kY, ncells_perplane, nplanes, pixx, pixy, screenxoffset, screenyoffset_xview, screenyoffset_yview, total_x_pixels(), total_y_pixels(), rect::xmin, rect::xsize, rect::ymin, and rect::ysize.

Referenced by draw_background(), setfd(), setup(), and rect::xmax().

{
  const int ybox = total_y_pixels(pixy);
  const int xbox = total_x_pixels(pixx);

  const int xboxnomu = pixx*(first_mucatcher/2) + pixy/2 /* cell stagger */;

  // muon catcher is 1/3 empty.  Do not include cell stagger here since we want
  // the extra half cells to be inside the active box.
  const int yboxnomu = (ncells_perplane/3)*pixy;

  screenview[kX].xmin = -screenxoffset + pixx/2 /* plane stagger */;
  screenview[kX].ymin = -screenyoffset_xview;
  screenview[kX].xsize = xbox;
  screenview[kX].ysize = ybox;

  const bool hasmucatch = first_mucatcher < nplanes;

  // In the x view the blank spaces are to the left of the hits, but in
  // the y view, they are to the right, but I don't want the box to include them.
  const int hacky_subtraction_for_y_mucatch = hasmucatch * pixx;

  screenview[kY].xmin = -screenxoffset;
  screenview[kY].ymin = -screenyoffset_yview;
  screenview[kY].xsize = xbox-hacky_subtraction_for_y_mucatch;
  screenview[kY].ysize = ybox;

  screenmu.xmin = -screenxoffset + 1 + xboxnomu;
  screenmu.ymin = -screenyoffset_yview;
  screenmu.xsize = xbox-xboxnomu-hacky_subtraction_for_y_mucatch-1;
  screenmu.ysize = yboxnomu;
}

void setfd

(

)

Definition at line 80 of file geo.cxx.

References FDfirst_mucatcher, FDncells_perplane, FDnplanes_perview, FDpixx, FDpixy, first_mucatcher, isfd, ncells_perplane, nplanes, nplanes_perview, pixx, pixy, and setboxes().

Referenced by draw_event(), and rect::xmax().

{
  isfd = true;

  nplanes_perview = FDnplanes_perview;
  first_mucatcher = FDfirst_mucatcher;
  ncells_perplane = FDncells_perplane;

  nplanes = 2*nplanes_perview;

  pixx = FDpixx;
  pixy = FDpixy;

  setboxes();
}

int total_x_pixels

(

const int

pixels_x

)

Definition at line 67 of file geo.cxx.

References first_mucatcher, nplanes, and nplanes_perview.

Referenced by setboxes(), and rect::xmax().

{
  return pixels_x*(nplanes_perview +
         (first_mucatcher < nplanes?
         nplanes_perview - first_mucatcher/2: 0)) + 1;
}

int total_y_pixels

(

const int

pixels_y

)

Definition at line 74 of file geo.cxx.

References ncells_perplane.

Referenced by setboxes(), and rect::xmax().

{
  return ncells_perplane*pixels_y
         + pixels_y/2 /* cell stagger */ + 1 /* border */;
}