Inheritance diagram for evd_tool::StandardDrawer:

Public Member Functions
	StandardDrawer (const fhicl::ParameterSet &pset)

virtual void	DetOutline3D (evdb::View3D *view) override

Public Member Functions inherited from evd_tool::IExperimentDrawer
virtual	~IExperimentDrawer () noexcept=default

Protected Member Functions
void	DrawBoxBoundedGeoOutline (evdb::View3D *view, geo::BoxBoundedGeo const &bb, Color_t color, Width_t width, Style_t style) const
	Draw the outline of an object bounded by a box. More...

void	DrawTPCoutline (evdb::View3D *view, geo::TPCGeo const &TPC, Color_t color, Width_t width, Style_t style) const
	Draw the outline of the TPC volume. More...

void	DrawActiveTPCoutline (evdb::View3D *view, geo::TPCGeo const &TPC, Color_t color, Width_t width, Style_t style) const
	Draw the outline of the TPC active volume. More...

void	DrawRectangularBox (evdb::View3D view, double const coordsLo, double const *coordsHi, int color=kGray, int width=1, int style=1) const

void	DrawGrids (evdb::View3D view, double const coordsLo, double const *coordsHi, int color=kGray, int width=1, int style=1) const

void	DrawAxes (evdb::View3D view, double const coordsLo, double const *coordsHi, int color=kGray, int width=1, int style=1) const

Private Member Functions
void	configure (const fhicl::ParameterSet &pset)

Private Attributes
bool	fDrawGrid
	true to draw backing grid More...

bool	fDrawAxes
	true to draw coordinate axes More...

bool	fDrawActive
	true to outline TPC sensitive volumes More...

Detailed Description

Definition at line 26 of file StandardDrawer_tool.cc.

Constructor & Destructor Documentation

evd_tool::StandardDrawer::StandardDrawer ( const fhicl::ParameterSet & pset )

explicit

Definition at line 59 of file StandardDrawer_tool.cc.

 {
     configure(pset);
 }

Member Function Documentation

void evd_tool::StandardDrawer::configure ( const fhicl::ParameterSet & pset )

private

Definition at line 64 of file StandardDrawer_tool.cc.

 {
     // Start by recovering the parameters
     fDrawGrid        = pset.get< bool >("DrawGrid",        true);
     fDrawAxes        = pset.get< bool >("DrawAxes",        true);
     fDrawActive      = pset.get< bool >("DrawActive",      true);
 
     return;
 }

void evd_tool::StandardDrawer::DetOutline3D ( evdb::View3D * view )

overridevirtual

Implements evd_tool::IExperimentDrawer.

Definition at line 75 of file StandardDrawer_tool.cc.

 {
     auto const& geom = *(lar::providerFrom<geo::Geometry>());
 
     // we compute the total volume of the detector, to be used for the axes;
     // we do include the origin by choice
     geo::BoxBoundedGeo detector({ 0.0, 0.0, 0.0 }, { 0.0, 0.0, 0.0 });
 
     // Draw a box for each cryostat, and, within it, for each TPC;
     // the outlined volumes are the ones from the geometry boxes
     for (geo::CryostatGeo const& cryo: geom.IterateCryostats()) {
 
         // include this cryostat in the detector volume
         detector.ExtendToInclude(cryo);
 
         // draw the cryostat box
         DrawBoxBoundedGeoOutline(view, cryo.Boundaries(), kRed + 2, 1, kSolid);
 
         // draw all TPC boxes
         for (geo::TPCGeo const& TPC: cryo.TPCs()) {
 
             DrawTPCoutline(view, TPC, kRed, 2, kSolid);
 
             // BUG the double brace syntax is required to work around clang bug 21629
             // optionally draw the grid
             if (fDrawGrid) {
                 std::array<double, 3U> const
                   tpcLow {{ TPC.MinX(), TPC.MinY(), TPC.MinZ() }},
                   tpcHigh {{ TPC.MaxX(), TPC.MaxY(), TPC.MaxZ() }}
                   ;
                 DrawGrids(view, tpcLow.data(), tpcHigh.data(), kGray+2, 1, kSolid);
             }
 
             // optionally draw the active volume
             if (fDrawActive) DrawActiveTPCoutline(view, TPC, kCyan + 2, 1, kDotted);
 
         } // for TPCs in cryostat
 
     } // for cryostats
 
     // draw axes if requested
     if (fDrawAxes) {
         // BUG the double brace syntax is required to work around clang bug 21629
         std::array<double, 3U> const
           detLow = {{ detector.MinX(), detector.MinY(), detector.MinZ() }},
           detHigh = {{ detector.MaxX(), detector.MaxY(), detector.MaxZ() }}
           ;
         DrawAxes(view, detLow.data(), detHigh.data(), kBlue, 1, kSolid);
     } // if draw axes
 
 }

void evd_tool::StandardDrawer::DrawActiveTPCoutline	(	evdb::View3D *	view,
		geo::TPCGeo const &	TPC,
		Color_t	color,
		Width_t	width,
		Style_t	style
	)		const

protected

Draw the outline of the TPC active volume.

Definition at line 139 of file StandardDrawer_tool.cc.

 {
     auto const& activeCenter = TPC.GetActiveVolumeCenter();
     DrawBoxBoundedGeoOutline(view,
       {
         {
           activeCenter.X() - TPC.ActiveHalfWidth(),
           activeCenter.Y() - TPC.ActiveHalfHeight(),
           activeCenter.Z() - TPC.ActiveHalfLength()
         },
         {
           activeCenter.X() + TPC.ActiveHalfWidth(),
           activeCenter.Y() + TPC.ActiveHalfHeight(),
           activeCenter.Z() + TPC.ActiveHalfLength()
         }
       },
       color, width, style
       );
 }

void evd_tool::StandardDrawer::DrawAxes	(	evdb::View3D *	view,
		double const *	coordsLo,
		double const *	coordsHi,
		int	color = `kGray`,
		int	width = `1`,
		int	style = `1`
	)		const

protected

Definition at line 237 of file StandardDrawer_tool.cc.

 {
     /*
      * Axes are drawn encompassing the whole detector volume,
      * the axis length being a fraction of the detector dimensions
      */
     double const vertexMargin = 0.06;
     double const axisLength = 0.40; // 20% of the shortest
 
     double const dx = (coordsHi[0] - coordsLo[0]);
     double const dy = (coordsHi[1] - coordsLo[1]);
     double const dz = (coordsHi[2] - coordsLo[2]);
 
     // axes origin
     double const x0 = coordsLo[0] - dx * vertexMargin;
     double const y0 = coordsLo[1] - dy * vertexMargin;
     double const z0 = coordsLo[2] - dz * vertexMargin;
     // axis length
     double const sz
       = axisLength * std::min({ std::abs(dx), std::abs(dy), std::abs(dz) });
 
     TPolyLine3D& xaxis = view->AddPolyLine3D(2, color, style, width);
     TPolyLine3D& yaxis = view->AddPolyLine3D(2, color, style, width);
     TPolyLine3D& zaxis = view->AddPolyLine3D(2, color, style, width);
     xaxis.SetPoint(0, x0,    y0, z0);
     xaxis.SetPoint(1, sz+x0, y0, z0);
 
     yaxis.SetPoint(0, x0, y0,     z0);
     yaxis.SetPoint(1, x0, y0+sz,  z0);
 
     zaxis.SetPoint(0, x0, y0, z0);
     zaxis.SetPoint(1, x0, y0, z0+sz);
 
     TPolyLine3D& xpoint = view->AddPolyLine3D(3, color, style, width);
     TPolyLine3D& ypoint = view->AddPolyLine3D(3, color, style, width);
     TPolyLine3D& zpoint = view->AddPolyLine3D(3, color, style, width);
 
     xpoint.SetPoint(0, 0.95*sz+x0, y0, z0-0.05*sz);
     xpoint.SetPoint(1, 1.00*sz+x0, y0, z0);
     xpoint.SetPoint(2, 0.95*sz+x0, y0, z0+0.05*sz);
 
     ypoint.SetPoint(0, x0, 0.95*sz+y0, z0-0.05*sz);
     ypoint.SetPoint(1, x0, 1.00*sz+y0, z0);
     ypoint.SetPoint(2, x0, 0.95*sz+y0, z0+0.05*sz);
 
     zpoint.SetPoint(0, x0-0.05*sz, y0, 0.95*sz+z0);
     zpoint.SetPoint(1, x0+0.00*sz, y0, 1.00*sz+z0);
     zpoint.SetPoint(2, x0+0.05*sz, y0, 0.95*sz+z0);
 
     TPolyLine3D& zleg = view->AddPolyLine3D(4, color, style, width);
     zleg.SetPoint(0,  x0-0.05*sz, y0+0.05*sz, z0+1.05*sz);
     zleg.SetPoint(1,  x0+0.05*sz, y0+0.05*sz, z0+1.05*sz);
     zleg.SetPoint(2,  x0-0.05*sz, y0-0.05*sz, z0+1.05*sz);
     zleg.SetPoint(3,  x0+0.05*sz, y0-0.05*sz, z0+1.05*sz);
 
     TPolyLine3D& yleg = view->AddPolyLine3D(5, color, style, width);
     yleg.SetPoint(0,  x0-0.05*sz, y0+1.15*sz, z0);
     yleg.SetPoint(1,  x0+0.00*sz, y0+1.10*sz, z0);
     yleg.SetPoint(2,  x0+0.00*sz, y0+1.05*sz, z0);
     yleg.SetPoint(3,  x0+0.00*sz, y0+1.10*sz, z0);
     yleg.SetPoint(4,  x0+0.05*sz, y0+1.15*sz, z0);
 
     TPolyLine3D& xleg = view->AddPolyLine3D(7, color, style, width);
     xleg.SetPoint(0,  x0+1.05*sz, y0+0.05*sz, z0-0.05*sz);
     xleg.SetPoint(1,  x0+1.05*sz, y0+0.00*sz, z0-0.00*sz);
     xleg.SetPoint(2,  x0+1.05*sz, y0+0.05*sz, z0+0.05*sz);
     xleg.SetPoint(3,  x0+1.05*sz, y0+0.00*sz, z0-0.00*sz);
     xleg.SetPoint(4,  x0+1.05*sz, y0-0.05*sz, z0-0.05*sz);
     xleg.SetPoint(5,  x0+1.05*sz, y0+0.00*sz, z0-0.00*sz);
     xleg.SetPoint(6,  x0+1.05*sz, y0-0.05*sz, z0+0.05*sz);
 
     return;
 }

void evd_tool::StandardDrawer::DrawBoxBoundedGeoOutline	(	evdb::View3D *	view,
		geo::BoxBoundedGeo const &	bb,
		Color_t	color,
		Width_t	width,
		Style_t	style
	)		const

protected

Draw the outline of an object bounded by a box.

Definition at line 128 of file StandardDrawer_tool.cc.

 {
     // BUG the double brace syntax is required to work around clang bug 21629
     std::array<double, 3U> const
       low {{ bb.MinX(), bb.MinY(), bb.MinZ() }},
       high {{ bb.MaxX(), bb.MaxY(), bb.MaxZ() }};
       ;
     DrawRectangularBox(view, low.data(), high.data(), color, width, style);
 } // StandardDrawer::DrawBoxBoundedGeoOutline()

void evd_tool::StandardDrawer::DrawGrids	(	evdb::View3D *	view,
		double const *	coordsLo,
		double const *	coordsHi,
		int	color = `kGray`,
		int	width = `1`,
		int	style = `1`
	)		const

protected

Definition at line 192 of file StandardDrawer_tool.cc.

 {
     // uniform step size, each 25 cm except that at least 5 per plane
     double const gridStep = std::min(25.0,
       std::min({
         std::abs(coordsHi[0] - coordsLo[0]),
         std::abs(coordsHi[1] - coordsLo[1]),
         std::abs(coordsHi[2] - coordsLo[2])
       }) / 5
       );
 
     // Grid running along x and y at constant z
     for (double z = coordsLo[2]; z <= coordsHi[2]; z += gridStep) {
 
         // across x, on bottom plane, fixed z
         TPolyLine3D& gridt = view->AddPolyLine3D(2, color, style, width);
         gridt.SetPoint(0, coordsLo[0], coordsLo[1], z);
         gridt.SetPoint(1, coordsHi[0], coordsLo[1], z);
 
         // on right plane, across y, fixed z
         TPolyLine3D& grids = view->AddPolyLine3D(2, color, style, width);
         grids.SetPoint(0, coordsHi[0], coordsLo[1], z);
         grids.SetPoint(1, coordsHi[0], coordsHi[1], z);
 
     }
 
     // Grid running along z at constant x
     for (double x = coordsLo[0]; x <= coordsHi[0]; x += gridStep) {
         // fixed x, on bottom plane, across z
         TPolyLine3D& gridt = view->AddPolyLine3D(2, color, style, width);
         gridt.SetPoint(0, x, coordsLo[1], coordsLo[2]);
         gridt.SetPoint(1, x, coordsLo[1], coordsHi[2]);
     }
 
     // Grid running along z at constant y
     for (double y = coordsLo[1]; y <= coordsHi[1]; y += gridStep) {
         // on right plane, fixed y, across z
         TPolyLine3D& grids = view->AddPolyLine3D(2, color, style, width);
         grids.SetPoint(0, coordsHi[0], y, coordsLo[2]);
         grids.SetPoint(1, coordsHi[0], y, coordsHi[2]);
     }
 
     return;
 }

void evd_tool::StandardDrawer::DrawRectangularBox	(	evdb::View3D *	view,
		double const *	coordsLo,
		double const *	coordsHi,
		int	color = `kGray`,
		int	width = `1`,
		int	style = `1`
	)		const

protected

Definition at line 159 of file StandardDrawer_tool.cc.

 {
     TPolyLine3D& top = view->AddPolyLine3D(5, color, width, style);
     top.SetPoint(0, coordsLo[0], coordsHi[1], coordsLo[2]);
     top.SetPoint(1, coordsHi[0], coordsHi[1], coordsLo[2]);
     top.SetPoint(2, coordsHi[0], coordsHi[1], coordsHi[2]);
     top.SetPoint(3, coordsLo[0], coordsHi[1], coordsHi[2]);
     top.SetPoint(4, coordsLo[0], coordsHi[1], coordsLo[2]);
 
     TPolyLine3D& side = view->AddPolyLine3D(5, color, width, style);
     side.SetPoint(0, coordsHi[0], coordsHi[1], coordsLo[2]);
     side.SetPoint(1, coordsHi[0], coordsLo[1], coordsLo[2]);
     side.SetPoint(2, coordsHi[0], coordsLo[1], coordsHi[2]);
     side.SetPoint(3, coordsHi[0], coordsHi[1], coordsHi[2]);
     side.SetPoint(4, coordsHi[0], coordsHi[1], coordsLo[2]);
 
     TPolyLine3D& side2 = view->AddPolyLine3D(5, color, width, style);
     side2.SetPoint(0, coordsLo[0], coordsHi[1], coordsLo[2]);
     side2.SetPoint(1, coordsLo[0], coordsLo[1], coordsLo[2]);
     side2.SetPoint(2, coordsLo[0], coordsLo[1], coordsHi[2]);
     side2.SetPoint(3, coordsLo[0], coordsHi[1], coordsHi[2]);
     side2.SetPoint(4, coordsLo[0], coordsHi[1], coordsLo[2]);
 
     TPolyLine3D& bottom = view->AddPolyLine3D(5, color, width, style);
     bottom.SetPoint(0, coordsLo[0], coordsLo[1], coordsLo[2]);
     bottom.SetPoint(1, coordsHi[0], coordsLo[1], coordsLo[2]);
     bottom.SetPoint(2, coordsHi[0], coordsLo[1], coordsHi[2]);
     bottom.SetPoint(3, coordsLo[0], coordsLo[1], coordsHi[2]);
     bottom.SetPoint(4, coordsLo[0], coordsLo[1], coordsLo[2]);
 
     return;
 }