evd Namespace Reference

LArSoft includes. More...

Namespaces
	details

Classes
class	AnalysisBaseDrawer
	Aid in the rendering of AnalysisBase objects. More...
class	AnalysisDrawingOptions
class	CalorPad
	A drawing pad showing calorimetric particle ID information. More...
class	CalorView
	View showing calorimetric particle ID information. More...
class	ColorDrawingOptions
class	Display3DPad
	A drawing pad showing a 3D rendering of the detector. More...
class	Display3DView
	View of event shoing the XZ and YZ readout planes. More...
class	DrawingPad
	Base class for event display drawing pads. More...
class	EVD
	a class for transporting photons in a roughly realistic way More...
class	EvdLayoutOptions
class	GraphCluster
class	GraphClusterAlg
class	HeaderDrawer
class	HeaderPad
class	HitSelector
class	InfoTransfer
class	MCBriefPad
class	Ortho3DPad
	A drawing pad showing an orthographic rendering of 3D objects. More...
class	Ortho3DView
	View of event shoing orthographic view of 3D objects. More...
class	RawDataDrawer
	Aid in the rendering of RawData objects. More...
class	RawDrawingOptions
	Display parameters for the raw data. More...
class	RecoBaseDrawer
	Aid in the rendering of RecoBase objects. More...
class	RecoDrawingOptions
class	SimulationDrawer
class	SimulationDrawingOptions
class	Style
class	TQPad
class	TWireProjPad
	A drawing pad for time vs wire. More...
class	ZoomOptionsMultiTPC
class	TWQMultiTPCProjectionView
struct	ZoomOptions
class	TWQProjectionView
class	InputSeeker
	This is obviously a hack, but it's modeled on what EventDisplayBase does. More...
class	JSONFormatter
class	PNGArena
class	PNGView
class	ThreadsafeGalleryEvent
class	WebEVD
class	ILazy
class	LazyDigits
class	LazyWires
struct	Result
class	WebEVDServer

Enumerations
enum	OrthoProj_t { kNoProj, kXY, kXZ, kYZ }
enum	EResult {   kNEXT, kPREV, kQUIT, kERROR,   kSEEK }

Functions
void	webevd_png_write_fn (png_struct_def *png_ptr, png_byte *buffer, long unsigned int nbytes)
void	webevd_png_flush_fn (png_struct_def *png_ptr)
void	AnalyzeArena (const PNGArena &bytes)
static constexpr int	MipMapOffset (int dim, int maxdim)
std::string	LatexName (int pdgcode)
	Convert PDG code to a latex string (root-style) More...
std::string	sup (const std::string &a, const std::string &b)
std::string	sub (const std::string &a, const std::string &b)
std::string	bar (const std::string &x)
std::string	nucl (const std::string &A, const std::string &elem)
std::string	HTMLName (int pdgcode)
	HTML entities style. More...
std::string	ShortInteractionSuffix (int iType)
std::string	MCTruthShortText (const simb::MCTruth &truth)
short	swap_byte_order (short x)
void	write_ok200 (int sock, const std::string content="text/html", bool gzip=false)
void	write_notfound404 (int sock)
void	write_unimp501 (int sock)
std::string	read_all (int sock)
EResult	err (const char *call)
Result	HandleCommand (std::string cmd, int sock)
std::string	FindWebDir ()
void	_HandleGetPNG (std::string doc, int sock, ILazy *digs, ILazy *wires)
void	gzip_buffer (unsigned char *src, int length, std::vector< unsigned char > &dest, int level)
void	write_compressed_buffer (unsigned char *src, int length, int sock, int level, const std::string &name)
void	write_compressed_file (const std::string &loc, int fd_out, int level)
bool	endswith (const std::string &s, const std::string &suffix)
JSONFormatter &	operator<< (JSONFormatter &json, const art::InputTag &t)
JSONFormatter &	operator<< (JSONFormatter &json, const geo::OpDetID &id)
JSONFormatter &	operator<< (JSONFormatter &json, const geo::PlaneID &plane)
JSONFormatter &	operator<< (JSONFormatter &json, const recob::Hit &hit)
JSONFormatter &	operator<< (JSONFormatter &json, const recob::Vertex &vtx)
JSONFormatter &	operator<< (JSONFormatter &json, const simb::MCTruth &mct)
JSONFormatter &	operator<< (JSONFormatter &json, const geo::Point_t &pt)
JSONFormatter &	operator<< (JSONFormatter &json, const sim::SimEnergyDeposit &edep)
JSONFormatter &	operator<< (JSONFormatter &json, const recob::SpacePoint &sp)
JSONFormatter &	operator<< (JSONFormatter &json, const recob::Track &track)
JSONFormatter &	operator<< (JSONFormatter &json, const simb::MCParticle &part)
JSONFormatter &	operator<< (JSONFormatter &json, const recob::OpFlash &flash)
JSONFormatter &	operator<< (JSONFormatter &json, const geo::CryostatGeo &cryo)
JSONFormatter &	operator<< (JSONFormatter &json, const geo::OpDetGeo &opdet)
JSONFormatter &	operator<< (JSONFormatter &os, const PNGView &v)
template<class TProd , class TEvt >
void	SerializeProduct (const TEvt &evt, JSONFormatter &json)
template<class TProd , class TEvt >
void	SerializeProductByLabel (const TEvt &evt, const std::string &in_label, JSONFormatter &json)
template<class T >
void	SerializeEventID (const T &evt, JSONFormatter &json)
void	SerializeEventID (const ThreadsafeGalleryEvent &evt, JSONFormatter &json)
void	SerializePlanes (const geo::GeometryCore *geom, const detinfo::DetectorPropertiesData &detprop, JSONFormatter &json)
void	SerializeGeometry (const geo::GeometryCore *geom, const detinfo::DetectorPropertiesData &detprop, JSONFormatter &json)
template<class T >
void	SerializeHits (const T &evt, const geo::GeometryCore *geom, JSONFormatter &json)
template<class T >
std::map< int, std::vector< T > >	ToSnippets (const std::vector< T > &adcs, T pedestal=0)
template<class T >
void	SerializeDigitTraces (const T &evt, const geo::GeometryCore *geom, JSONFormatter &json)
template<class T >
void	SerializeWireTraces (const T &evt, const geo::GeometryCore *geom, JSONFormatter &json)
template<class T >
void	_HandleGetJSON (std::string doc, int sock, const T *evt, const geo::GeometryCore *geom, const detinfo::DetectorPropertiesData *detprop, ILazy *digs, ILazy *wires)
template<class T >
void	_HandleGet (std::string doc, int sock, const T *evt, ILazy *digs, ILazy *wires, const geo::GeometryCore *geom, const detinfo::DetectorPropertiesData *detprop)

Variables
HitSelector *	gTheHitSelector
static const int	kNCOLS = 14
static const int	kColor [kNCOLS]
static const int	kColor2 [kNCOLS]
static const int	kRAW = 0
static const int	kCALIB = 1
static const int	kQ = 0
static const int	kTQ = 1
static unsigned int	kPlane
static unsigned int	kWire
static double	kDistance
static int	curr_zooming_plane
static const char *	zoom_opt = 0
static int	shift_lock
static unsigned int	kPlane
static unsigned int	kWire
static double	kDistance
static int	curr_zooming_plane
static const char *	zoom_opt = 0
static int	shift_lock

Detailed Description

LArSoft includes.

Class to perform operations needed to select hits and pass them to InfoTransfer.

Event display classes.

The Event Display.

Author

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

Enumeration Type Documentation

enum evd::EResult

Enumerator
kNEXT
kPREV
kQUIT
kERROR
kSEEK

Definition at line 17 of file WebEVDServer.h.

{kNEXT, kPREV, kQUIT, kERROR, kSEEK};

enum evd::OrthoProj_t

Enumerator
kNoProj
kXY
kXZ
kYZ

Definition at line 12 of file OrthoProj.h.

{kNoProj, kXY, kXZ, kYZ};

Function Documentation

template<class T >

void evd::_HandleGet	(	std::string	doc,
		int	sock,
		const T *	evt,
		ILazy *	digs,
		ILazy *	wires,
		const geo::GeometryCore *	geom,
		const detinfo::DetectorPropertiesData *	detprop
	)

Definition at line 793 of file WebEVDServer.cxx.

{
  if(doc == "/") doc = "/index.html";

  if(endswith(doc, ".png")){
    _HandleGetPNG(doc, sock, digs, wires);
    return;
  }

  if(endswith(doc, ".json")){
    _HandleGetJSON(doc, sock, evt, geom, detprop, digs, wires);
    return;
  }

  // TODO - more sophisticated MIME type handling
  std::string mime = "text/html";
  if(endswith(doc, ".js" )) mime = "application/javascript";
  if(endswith(doc, ".css")) mime = "text/css";
  if(endswith(doc, ".ico")) mime = "image/vnd.microsoft.icon";

  // Otherwise it must be a physical file

  // Don't accidentally serve any file we shouldn't
  const std::set<std::string> whitelist = {"/evd.css", "/evd.js", "/traces.js", "/favicon.ico", "/index.html", "/traces.html"};

  if(whitelist.count(doc)){
    write_ok200(sock, mime, true);
    write_compressed_file(FindWebDir()+doc, sock, Z_DEFAULT_COMPRESSION);
  }
  else{
    write_notfound404(sock);
  }

  close(sock);
}

template<class T >

void evd::_HandleGetJSON	(	std::string	doc,
		int	sock,
		const T *	evt,
		const geo::GeometryCore *	geom,
		const detinfo::DetectorPropertiesData *	detprop,
		ILazy *	digs,
		ILazy *	wires
	)

Definition at line 759 of file WebEVDServer.cxx.

{
  const std::string mime = "application/json";

  std::stringstream ss;
  JSONFormatter json(ss);

  /***/if(doc == "/evtid.json")       SerializeEventID(*evt, json);
  else if(doc == "/tracks.json")      SerializeProduct<recob::Track>(*evt, json);
  else if(doc == "/spacepoints.json") SerializeProduct<recob::SpacePoint>(*evt, json);
  else if(doc == "/vtxs.json")        SerializeProduct<recob::Vertex>(*evt, json);
  else if(doc == "/trajs.json")       SerializeProductByLabel<simb::MCParticle>(*evt, "largeant", json);
  else if(doc == "/mctruth.json")     SerializeProduct<simb::MCTruth>(*evt, json);
  else if(doc == "/simedep.json")     SerializeProduct<sim::SimEnergyDeposit>(*evt, json);
  else if(doc == "/opflashes.json")   SerializeProduct<recob::OpFlash>(*evt, json);
  else if(doc == "/hits.json")        SerializeHits(*evt, geom, json);
  else if(doc == "/geom.json")        SerializeGeometry(geom, *detprop, json);
  else if(doc == "/digs.json")        digs->Serialize(json);
  else if(doc == "/wires.json")       wires->Serialize(json);
  else if(doc == "/dig_traces.json")  SerializeDigitTraces(*evt, geom, json);
  else if(doc == "/wire_traces.json") SerializeWireTraces(*evt, geom, json);
  else{
    write_notfound404(sock);
    close(sock);
    return;
  }

  std::string response = ss.str();
  write_ok200(sock, mime, true);
  write_compressed_buffer((unsigned char*)response.data(), response.size(), sock, Z_DEFAULT_COMPRESSION, doc);
  close(sock);
}

void evd::_HandleGetPNG	(	std::string	doc,
		int	sock,
		ILazy *	digs,
		ILazy *	wires
	)

Definition at line 221 of file WebEVDServer.cxx.

{
  const std::string mime = "image/png";

  // Parse the filename
  char* ctx;

  const char* pName = strtok_r(&doc.front(), "_", &ctx);
  const char* pIdx = strtok_r(0, "_", &ctx);
  const char* pDim = strtok_r(0, ".", &ctx);

  if(!pName || !pIdx || !pDim){
    write_notfound404(sock);
    close(sock);
    return;
  }

  const std::string name(pName);
  const int idx = atoi(pIdx);
  const int dim = atoi(pDim);

  PNGArena* arena = 0;
  if(name == "/dig") arena = &digs->GetArena();
  if(name == "/wire") arena = &wires->GetArena();

  if(!arena || idx >= int(arena->data.size()) || dim > PNGArena::kArenaSize){
    write_notfound404(sock);
    close(sock);
    return;
  }

  write_ok200(sock, mime, false);
  FILE* f = fdopen(sock, "wb");
  arena->WritePNGBytes(f, idx, dim);
  fclose(f);
}

void evd::AnalyzeArena

(

const PNGArena &

bytes

)

Definition at line 169 of file PNGArena.cxx.

  {
    for(int blockSize = 1; blockSize <= PNGArena::kArenaSize; blockSize *= 2){
      long nfilled = 0;
      for(unsigned int d = 0; d < bytes.data.size(); ++d){
        for(int iy = 0; iy < PNGArena::kArenaSize/blockSize; ++iy){
          for(int ix = 0; ix < PNGArena::kArenaSize/blockSize; ++ix){
            bool filled = false;
            for(int y = 0; y < blockSize && !filled; ++y){
              for(int x = 0; x < blockSize; ++x){
                if(bytes(d, ix*blockSize+x, iy*blockSize+y, 3) > 0){
                  filled = true;
                  break;
                }
              }
            } // end for y
            if(filled) ++nfilled;
          }
        }
      }

      std::cout << "With block size = " << blockSize << " " << double(nfilled)/((PNGArena::kArenaSize*PNGArena::kArenaSize)/(blockSize*blockSize)*bytes.data.size()) << " of the blocks are filled" << std::endl;
    }
  }

std::string evd::bar

(

const std::string &

x

)

Definition at line 106 of file TruthText.cxx.

  {
    // NB we escape the quote marks in the CSS because we know this is going to
    // be served as CSS and we don't sanitize it there.
    return "<span style=\\\"text-decoration:overline\\\">"+x+"</span>";
  }

bool evd::endswith	(	const std::string &	s,
		const std::string &	suffix
	)

Definition at line 323 of file WebEVDServer.cxx.

{
  return s.rfind(suffix)+suffix.size() == s.size();
}

EResult evd::err

(

const char *

call

)

Definition at line 140 of file WebEVDServer.cxx.

{
  std::cout << call << "() error " << errno << " = " << strerror(errno) << std::endl;
  return kERROR;
  //  return errno;
}

std::string evd::FindWebDir

(

)

Definition at line 194 of file WebEVDServer.cxx.

{
  std::string webdir;

  // For development purposes we prefer to serve the files from the source
  // directory, which allows them to be live-edited with just a refresh of the
  // browser window to see them.
  if(getenv("MRB_SOURCE")) cet::search_path("MRB_SOURCE").find_file("webevd/webevd/WebEVD/web/", webdir);
  // Otherwise, serve the files from where they get installed
  if(webdir.empty() && getenv("PRODUCTS") && getenv("WEBEVD_VERSION")) cet::search_path("PRODUCTS").find_file("webevd/"+std::string(getenv("WEBEVD_VERSION"))+"/webevd/", webdir);

  if(webdir.empty()){
    std::cout << "Unable to find webevd files under $MRB_SOURCE or $PRODUCTS" << std::endl;
    abort();
  }

  return webdir;
}

void evd::gzip_buffer	(	unsigned char *	src,
		int	length,
		std::vector< unsigned char > &	dest,
		int	level
	)

Definition at line 259 of file WebEVDServer.cxx.

{
  // C++20 will allow to use designated initializers here
  z_stream strm;
  strm.zalloc = Z_NULL;
  strm.zfree = Z_NULL;
  strm.opaque = Z_NULL;

  strm.next_in = src;
  strm.avail_in = length;

  // The 16 here is the secret sauce to get gzip header and trailer for some
  // reason...
  deflateInit2(&strm, level, Z_DEFLATED, 15 | 16, 9, Z_DEFAULT_STRATEGY);

  // If we allocate a big enough buffer we can deflate in one pass
  dest.resize(deflateBound(&strm, length));

  strm.next_out = dest.data();
  strm.avail_out = dest.size();

  deflate(&strm, Z_FINISH);

  dest.resize(dest.size() - strm.avail_out);

  deflateEnd(&strm);
}

Result evd::HandleCommand	(	std::string	cmd,
		int	sock
	)

Definition at line 147 of file WebEVDServer.cxx.

{
  EResult code = kERROR;
  int run = -1, subrun = -1, evt = -1;
  bool traces = false;

  if(cmd == "/QUIT") code = kQUIT;
  if(cmd == "/NEXT") code = kNEXT;
  if(cmd == "/PREV") code = kPREV;
  if(cmd == "/NEXT_TRACES"){ code = kNEXT; traces = true;}
  if(cmd == "/PREV_TRACES"){ code = kPREV; traces = true;}

  if(cmd.find("/seek/") == 0 ||
     cmd.find("/seek_traces/") == 0){
    if(cmd.find("/seek_traces/") == 0) traces = true;

    code = kSEEK;
    char* ctx;
    strtok_r(cmd.data(), "/", &ctx); // consumes the "seek" text
    run    = atoi(strtok_r(0, "/", &ctx));
    subrun = atoi(strtok_r(0, "/", &ctx));
    evt    = atoi(strtok_r(0, "/", &ctx));
    // if this goes wrong we get zeros, which seems a reasonable fallback
  }

  write_ok200(sock, "text/html", false);

  const int delay = (code == kQUIT) ? 2000 : 0;
  const std::string txt = (code == kQUIT) ? "Goodbye!" : "Please wait...";
  const std::string next = traces ? "/traces.html" : "/";

  // The script tag to set the style is a pretty egregious layering violation,
  // but doing more seems overkill for a simple interstitial page.
  const std::string msg = TString::Format("<!DOCTYPE html><html><head><meta charset=\"utf-8\"><script>setTimeout(function(){window.location.replace('%s');}, %d);</script></head><body><script>if(window.sessionStorage.theme != 'lighttheme'){document.body.style.backgroundColor='black';document.body.style.color='white';}</script><h1>%s</h1></body></html>", next.c_str(), delay, txt.c_str()).Data();

  write(sock, msg.c_str(), msg.size());
  close(sock);

  if(code == kSEEK){
    return Result(kSEEK, run, subrun, evt);
  }
  else{
    return code;
  }
}

std::string evd::HTMLName

(

int

pdgcode

)

HTML entities style.

Definition at line 121 of file TruthText.cxx.

  {
    // NB we escape the quote marks in the CSS because we know this is going to
    // be served as CSS and we don't sanitize it there.
    switch(pdgcode){
    case  22:   return "γ";
    case -11:   return sup("e", "+");
    case  11:   return sup("e", "-");
    case  13:   return "μ";
    case -15:   return bar("τ");
    case  15:   return "τ";
    case -13:   return bar("μ");
    case  12:   return sub("ν", "e");
    case  14:   return sub("ν", "μ");
    case  16:   return sub("ν", "τ");
    case -12:   return sub(bar("ν"), "e");
    case -14:   return sub(bar("ν"), "μ");
    case -16:   return sub(bar("ν"), "τ");
    case  111:  return sup("π", "0");
    case  211:  return sup("π", "+");
    case -211:  return sup("π", "-");
    case  221:  return "η";
    case  331:  return "η'";
    case  130:  return sub(sup("K", "0"), "L");
    case  310:  return sub(sup("K", "0"), "L");
    case  311:  return sup("K", "0");
    case -311:  return sup(bar("K"), "0");
    case  321:  return sup("K", "+");
    case -321:  return sup("K", "-");
    case  2112: return "n";
    case  2212: return "p";
    case -2112: return bar("n");
    case -2212: return bar("p");
    case  2224: return sup("Δ", "++");
    case  3122: return sup("Λ", "0");
    case  3222: return sup("Σ", "+");
    case -3222: return sup("Σ", "-");

    case 1000010020: return nucl("2", "H");
    case 1000010030: return nucl("3", "H");
    case 1000020030: return nucl("3", "He");
    case 1000020040: return nucl("4", "He");
    case 1000040070: return nucl("7", "Be");
    case 1000040080: return nucl("8", "Be");
    case 1000040100: return nucl("10", "Be");
    case 1000050090: return nucl("9", "B");
    case 1000050100: return nucl("10", "B");
    case 1000050110: return nucl("11", "B");
    case 1000060100: return nucl("10", "C");
    case 1000060110: return nucl("11", "C");
    case 1000060120: return nucl("12", "C");
    case 1000060130: return nucl("13", "C");
    case 1000060140: return nucl("14", "C");
    case 1000070150: return nucl("15", "N");
    case 1000100220: return nucl("22", "Ne");
    case 1000140300: return nucl("30", "Si");
    case 1000150330: return nucl("33", "P");
    case 1000160340: return nucl("34", "S");
    case 1000160350: return nucl("35", "S");
    case 1000160360: return nucl("36", "S");
    case 1000170350: return nucl("35", "Cl");
    case 1000170360: return nucl("36", "Cl");
    case 1000170370: return nucl("37", "Cl");
    case 1000180380: return nucl("38", "Ar");
    case 1000180400: return nucl("40", "Ar");
    case 1000210480: return nucl("48", "Sc");
    case 1000260560: return nucl("56", "Fe");
    case 1000220480: return nucl("48", "Ti");
    case 1000080160: return nucl("16", "O");
    case 1000070140: return nucl("14", "N");
    case 1000110230: return nucl("23", "Na");
    case 1000130270: return nucl("27", "Al");
    case 1000140280: return nucl("28", "Si");
    case 1000200400: return nucl("40", "Ca");
    case 1000561370: return nucl("137", "Ba");
    default: return sub("X", std::to_string(pdgcode));
    }
    return 0;
  }

std::string evd::LatexName

(

int

pdgcode

)

Convert PDG code to a latex string (root-style)

Definition at line 12 of file TruthText.cxx.

  {
    switch(pdgcode){
    case  22:   return "#gamma";
    case -11:   return "e^{+}";
    case  11:   return "e^{-}";
    case  13:   return "#mu";
    case -15:   return "#bar{#tau}";
    case  15:   return "#tau";
    case -13:   return "#bar{#mu}";
    case  12:   return "#nu_{e}";
    case  14:   return "#nu_{#mu}";
    case  16:   return "#nu_{#tau}";
    case -12:   return "#bar{#nu}_{e}";
    case -14:   return "#bar{#nu}_{#mu}";
    case -16:   return "#bar{#nu}_{#tau}";
    case  111:  return "#pi^{0}";
    case  211:  return "#pi^{+}";
    case -211:  return "#pi^{-}";;
    case  221:  return "#eta";
    case  331:  return "#eta'";
    case  130:  return "K^{0}_{L}";
    case  310:  return "K^{0}_{S}";
    case  311:  return "K^{0}";
    case -311:  return "#bar{K}^{0}";
    case  321:  return "K^{+}";
    case -321:  return "K^{-}";
    case  2112: return "n";
    case  2212: return "p";
    case -2112: return "#bar{n}";
    case -2212: return "#bar{p}";
    case  2224: return "#Delta^{++}";
    case  3122: return "#Lambda^{0}";
    case  3222: return "#Sigma^{+}";
    case -3222: return "#Sigma^{-}";

    case 1000010020: return "^{2}H";
    case 1000010030: return "^{3}H";
    case 1000020030: return "^{3}He";
    case 1000020040: return "^{4}He";
    case 1000040070: return "^{7}Be";
    case 1000040080: return "^{8}Be";
    case 1000040100: return "^{10}Be";
    case 1000050090: return "^{9}B";
    case 1000050100: return "^{10}B";
    case 1000050110: return "^{11}B";
    case 1000060100: return "^{10}C";
    case 1000060110: return "^{11}C";
    case 1000060120: return "^{12}C";
    case 1000060130: return "^{13}C";
    case 1000060140: return "^{14}C";
    case 1000070150: return "^{15}N";
    case 1000100220: return "^{22}Ne";
    case 1000140300: return "^{30}Si";
    case 1000150330: return "^{33}P";
    case 1000160340: return "^{34}S";
    case 1000160350: return "^{35}S";
    case 1000160360: return "^{36}S";
    case 1000170350: return "^{35}Cl";
    case 1000170360: return "^{36}Cl";
    case 1000170370: return "^{37}Cl";
    case 1000180380: return "^{38}Ar";
    case 1000180400: return "^{40}Ar";
    case 1000210480: return "^{48}Sc";
    case 1000260560: return "^{56}Fe";
    case 1000220480: return "^{48}Ti";
    case 1000080160: return "^{16}O";
    case 1000070140: return "^{14}N";
    case 1000110230: return "^{23}Na";
    case 1000130270: return "^{27}Al";
    case 1000140280: return "^{28}Si";
    case 1000200400: return "^{40}Ca";
    case 1000561370: return "^{137}Ba";
    default:
      static char buf[256];
      sprintf(buf,"X_{%d}", pdgcode);
      return buf;
    }
    return 0;
  }

std::string evd::MCTruthShortText

(

const simb::MCTruth &

truth

)

Definition at line 250 of file TruthText.cxx.

  {
    std::string origin;
    std::string incoming;
    std::string outgoing;
    // Label cosmic rays -- others are pretty obvious
    if(truth.Origin() == simb::kCosmicRay) origin = "c-ray: ";

    for(int j = 0; j < truth.NParticles(); ++j){
      const simb::MCParticle& p = truth.GetParticle(j);

      const unsigned int bufsize = 4096;
      char buf[bufsize];

      if(p.P() > 0.05){
        snprintf(buf, bufsize, "%s&nbsp;[%.1f GeV/c]",
                 HTMLName(p.PdgCode()).c_str(), p.P());
      }
      else{
        snprintf(buf, bufsize, "%s",
                 HTMLName(p.PdgCode()).c_str());
      }
      if(p.StatusCode() == 0){
        if(!incoming.empty()) incoming += " + ";
        incoming += buf;
      }
      if(p.StatusCode() == 1){
        if(!outgoing.empty()) outgoing += " + ";
        outgoing += buf;
      }
    } // loop on j particles

    if(origin.empty() && incoming.empty()) return outgoing;

    const std::string suffix = ShortInteractionSuffix(truth.GetNeutrino().InteractionType());
    return origin+incoming+" &rarr; "+outgoing+suffix;
  }

static constexpr int evd::MipMapOffset ( int  dim, int  maxdim  )

static

Definition at line 16 of file PNGArena.h.

  {
    if(dim >= maxdim) return 0;
    return MipMapOffset(dim*2, maxdim) + (dim*2)*(dim*2)*4;
  }

std::string evd::nucl	(	const std::string &	A,
		const std::string &	elem
	)

Definition at line 114 of file TruthText.cxx.

  {
    return "<sup>"+A+"</sup>"+elem;
  }

JSONFormatter& evd::operator<<	(	JSONFormatter &	json,
		const art::InputTag &	t
	)

Definition at line 329 of file WebEVDServer.cxx.

{
  json << "\"" << t.label();
  if(!t.instance().empty()) json << ":" << t.instance();
  if(!t.process().empty()) json << ":" << t.process();
  json << "\"";
  return json;
}

JSONFormatter& evd::operator<<	(	JSONFormatter &	json,
		const geo::OpDetID &	id
	)

Definition at line 339 of file WebEVDServer.cxx.

{
  json << "\"" << std::string(id) << "\"";
  return json;
}

JSONFormatter& evd::operator<<	(	JSONFormatter &	json,
		const geo::PlaneID &	plane
	)

Definition at line 347 of file WebEVDServer.cxx.

{
  return json << "\"" << std::string(plane) << "\"";
}

JSONFormatter& evd::operator<<	(	JSONFormatter &	json,
		const recob::Hit &	hit
	)

Definition at line 353 of file WebEVDServer.cxx.

{
  return json << "{\"wire\": " << geo::WireID(hit.WireID()).Wire
              << ", \"tick\": " << hit.PeakTime()
              << ", \"rms\": " << hit.RMS()
              << ", \"peakamp\": " << hit.PeakAmplitude() << "}";
}

JSONFormatter& evd::operator<<	(	JSONFormatter &	json,
		const recob::Vertex &	vtx
	)

Definition at line 362 of file WebEVDServer.cxx.

{
  return json << TVector3(vtx.position().x(),
                          vtx.position().y(),
                          vtx.position().z());
}

JSONFormatter& evd::operator<<	(	JSONFormatter &	json,
		const simb::MCTruth &	mct
	)

Definition at line 370 of file WebEVDServer.cxx.

{
  // Don't show MCTruth for cosmic rays, which can be extremely
  // lengthy. Ideally we should exclude them from the list entirely, but this
  // requires less change to the structure of the code.
  if(mct.Origin() == simb::kCosmicRay) return json << "\"\"";

  return json << "\"" << MCTruthShortText(mct) << "\"";
}

JSONFormatter& evd::operator<<	(	JSONFormatter &	json,
		const geo::Point_t &	pt
	)

Definition at line 381 of file WebEVDServer.cxx.

{
  return json << TVector3(pt.X(), pt.Y(), pt.Z());
}

JSONFormatter& evd::operator<<	(	JSONFormatter &	json,
		const sim::SimEnergyDeposit &	edep
	)

Definition at line 387 of file WebEVDServer.cxx.

{
  return json << "{\"pdg\": " << edep.PdgCode() << ", "
              << "\"start\": " << edep.Start() << ", "
              << "\"end\": " << edep.End() << ", "
              << "\"edep\": " << edep.Energy()
              << "}";
}

JSONFormatter& evd::operator<<	(	JSONFormatter &	json,
		const recob::SpacePoint &	sp
	)

Definition at line 397 of file WebEVDServer.cxx.

{
  return json << TVector3(sp.XYZ());
}

JSONFormatter& evd::operator<<	(	JSONFormatter &	json,
		const recob::Track &	track
	)

Definition at line 403 of file WebEVDServer.cxx.

{
  std::vector<TVector3> pts;

  const recob::TrackTrajectory& traj = track.Trajectory();
  for(unsigned int j = traj.FirstValidPoint(); j <= traj.LastValidPoint(); ++j){
    if(!traj.HasValidPoint(j)) continue;
    const geo::Point_t pt = traj.LocationAtPoint(j);
    pts.emplace_back(pt.X(), pt.Y(), pt.Z());
  }

  return json << "{ \"positions\": " << pts << " }";
}

JSONFormatter& evd::operator<<	(	JSONFormatter &	json,
		const simb::MCParticle &	part
	)

Definition at line 418 of file WebEVDServer.cxx.

{
  const int apdg = abs(part.PdgCode());
  if(apdg == 12 || apdg == 14 || apdg == 16) return json << "{ \"pdg\": " << apdg << ", \"positions\": [] }"; // decay neutrinos
  std::vector<TVector3> pts;
  for(unsigned int j = 0; j < part.NumberTrajectoryPoints(); ++j){
    pts.emplace_back(part.Vx(j), part.Vy(j), part.Vz(j));
  }

  return json << "{ \"pdg\": " << apdg << ", \"positions\": " << pts << " }";
}

JSONFormatter& evd::operator<<	(	JSONFormatter &	json,
		const recob::OpFlash &	flash
	)

Definition at line 431 of file WebEVDServer.cxx.

{
  json << std::map<std::string, double>{
    {"tcenter", flash.Time()},
    {"twidth", flash.TimeWidth()},
    {"ycenter", flash.YCenter()},
    {"ywidth", flash.YWidth()},
    {"zcenter", flash.ZCenter()},
    {"zwidth", flash.ZWidth()},
    {"totpe", flash.TotalPE()}
  };

  return json;
}

JSONFormatter& evd::operator<<	(	JSONFormatter &	json,
		const geo::CryostatGeo &	cryo
	)

Definition at line 447 of file WebEVDServer.cxx.

{
  const TVector3 r0(cryo.MinX(), cryo.MinY(), cryo.MinZ());
  const TVector3 r1(cryo.MaxX(), cryo.MaxY(), cryo.MaxZ());
  return json << "{ \"min\": "  << r0 << ", \"max\": " << r1 << " }";
}

JSONFormatter& evd::operator<<	(	JSONFormatter &	json,
		const geo::OpDetGeo &	opdet
	)

Definition at line 455 of file WebEVDServer.cxx.

{
  return json << "{ \"name\": " << opdet.ID() << ", "
              << "\"center\": " << TVector3(opdet.GetCenter().X(),
                                            opdet.GetCenter().Y(),
                                            opdet.GetCenter().Z()) << ", "
              << "\"length\": " << opdet.Length() << ", "
              << "\"width\": " << opdet.Width() << ", "
              << "\"height\": " << opdet.Height() << " }";
}

JSONFormatter& evd::operator<<	(	JSONFormatter &	os,
		const PNGView &	v
	)

Definition at line 467 of file WebEVDServer.cxx.

{
  bool first = true;
  os << "{\"blocks\": [\n";
  for(unsigned int ix = 0; ix < v.blocks.size(); ++ix){
    for(unsigned int iy = 0; iy < v.blocks[ix].size(); ++iy){
      const png_byte* b = v.blocks[ix][iy];
      if(!b) continue;

      if(!first) os << ",\n";
      first = false;

      int dataidx = 0;
      for(unsigned int d = 0; d < v.arena.data.size(); ++d){
        if(b >= &v.arena.data[d]->front() &&
           b <  &v.arena.data[d]->front() + 4*PNGArena::kArenaSize*PNGArena::kArenaSize){
          dataidx = d;
          break;
        }
      }

      const int texdx = ((b-&v.arena.data[dataidx]->front())/4)%PNGArena::kArenaSize;
      const int texdy = ((b-&v.arena.data[dataidx]->front())/4)/PNGArena::kArenaSize;

      os << "{"
         << "\"x\": " << ix*PNGArena::kBlockSize << ", "
         << "\"y\": " << iy*PNGArena::kBlockSize << ", "
         << "\"dx\": " << PNGArena::kBlockSize << ", "
         << "\"dy\": " << PNGArena::kBlockSize << ", "
         << "\"fname\": \"" << v.arena.name << "_" << dataidx << "\", "
         << "\"texdim\": " << PNGArena::kArenaSize << ", "
         << "\"u\": " << texdx << ", "
         << "\"v\": " << texdy << ", "
         << "\"du\": " << PNGArena::kBlockSize << ", "
         << "\"dv\": " << PNGArena::kBlockSize
         << "}";
    }
  }
  os << "\n]}";
  return os;
}

std::string evd::read_all

(

int

sock

)

Definition at line 125 of file WebEVDServer.cxx.

{
  std::string ret;

  std::vector<char> buf(1024*1024);
  while(true){
    const int nread = read(sock, &buf.front(), buf.size());
    if(nread == 0) return ret;
    ret.insert(ret.end(), buf.begin(), buf.begin()+nread);
    // Only handle GETs, so no need to wait for payload (for which we'd need to
    // check Content-Length too).
    if(ret.find("\r\n\r\n") != std::string::npos) return ret;
  }
}

template<class T >

void evd::SerializeDigitTraces	(	const T &	evt,
		const geo::GeometryCore *	geom,
		JSONFormatter &	json
	)

Definition at line 705 of file WebEVDServer.cxx.

{
  // [tag][plane][wire index][t0]
  std::map<art::InputTag, std::map<geo::PlaneID, std::map<int, std::map<int, std::vector<short>>>>> traces;

  for(art::InputTag tag: evt.template getInputTags<std::vector<raw::RawDigit>>()){
    typename T::template HandleT<std::vector<raw::RawDigit>> digs; // deduce handle type
    // This can fail in the case of dropped products
    if(!evt.getByLabel(tag, digs)) continue;

    for(const raw::RawDigit& dig: *digs){
      for(geo::WireID wire: geom->ChannelToWire(dig.Channel())){
        const geo::PlaneID plane(wire);

        raw::RawDigit::ADCvector_t adcs(dig.Samples());
        raw::Uncompress(dig.ADCs(), adcs, dig.Compression());

        traces[tag][plane][wire.Wire] = ToSnippets(adcs, short(dig.GetPedestal()));
      } // end for wire
    } // end for dig
  } // end for tag

  json << traces;
}

template<class T >

void evd::SerializeEventID	(	const T &	evt,
		JSONFormatter &	json
	)

Definition at line 553 of file WebEVDServer.cxx.

{
  typedef std::map<std::string, int> EIdMap;
  json << EIdMap({{"run", evt.run()}, {"subrun", evt.subRun()}, {"evt", evt.event()}});
}

void evd::SerializeEventID	(	const ThreadsafeGalleryEvent &	evt,
		JSONFormatter &	json
	)

Definition at line 560 of file WebEVDServer.cxx.

{
  SerializeEventID(evt.eventAuxiliary(), json);
}

void evd::SerializeGeometry	(	const geo::GeometryCore *	geom,
		const detinfo::DetectorPropertiesData &	detprop,
		JSONFormatter &	json
	)

Definition at line 617 of file WebEVDServer.cxx.

{
  json << "{\n";
  SerializePlanes(geom, detprop, json);
  json << ",\n\n";

  json << "  \"cryos\": [\n";
  for(unsigned int i = 0; i < geom->Ncryostats(); ++i){
    json << "    " << geom->Cryostat(i);
    if(i != geom->Ncryostats()-1) json << ",\n"; else json << "\n";
  }
  json << "  ],\n\n";

  json << "  \"opdets\": [\n";
  for(unsigned int i = 0; i < geom->NOpDets(); ++i){
    json << "    " << geom->OpDetGeoFromOpDet(i);
    if(i != geom->NOpDets()-1) json << ",\n"; else json << "\n";
  }
  json << "  ]\n";
  json << "}\n";
}

template<class T >

void evd::SerializeHits	(	const T &	evt,
		const geo::GeometryCore *	geom,
		JSONFormatter &	json
	)

Definition at line 643 of file WebEVDServer.cxx.

{
  std::map<art::InputTag, std::map<geo::PlaneID, std::vector<recob::Hit>>> plane_hits;

  for(art::InputTag tag: evt.template getInputTags<std::vector<recob::Hit>>()){
    typename T::template HandleT<std::vector<recob::Hit>> hits; // deduce handle type
    // This can fail in the case of dropped products
    if(!evt.getByLabel(tag, hits)) continue;

    for(const recob::Hit& hit: *hits){
      // Would possibly be right for disambiguated hits?
      //    const geo::WireID wire(hit.WireID());

      for(geo::WireID wire: geom->ChannelToWire(hit.Channel())){
        const geo::PlaneID plane(wire);

        // Correct for disambiguated hits
        //      plane_hits[plane].push_back(hit);

        // Otherwise we have to update the wire number
        plane_hits[tag][plane].emplace_back(hit.Channel(), hit.StartTick(), hit.EndTick(), hit.PeakTime(), hit.SigmaPeakTime(), hit.RMS(), hit.PeakAmplitude(), hit.SigmaPeakAmplitude(), hit.SummedADC(), hit.Integral(), hit.SigmaIntegral(), hit.Multiplicity(), hit.LocalIndex(), hit.GoodnessOfFit(), hit.DegreesOfFreedom(), hit.View(), hit.SignalType(), wire);
      }
    }
  } // end for tag

  json << plane_hits;
}

void evd::SerializePlanes	(	const geo::GeometryCore *	geom,
		const detinfo::DetectorPropertiesData &	detprop,
		JSONFormatter &	json
	)

Definition at line 566 of file WebEVDServer.cxx.

{
  bool first = true;

  json << "  \"planes\": {\n";
  for(geo::PlaneID plane: geom->IteratePlaneIDs()){
    const geo::PlaneGeo& planegeo = geom->Plane(plane);
    const int view = planegeo.View();
    const unsigned int nwires = planegeo.Nwires();
    const double pitch = planegeo.WirePitch();
    const TVector3 c = planegeo.GetCenter();

    const TVector3 d = planegeo.GetIncreasingWireDirection();
    const TVector3 n = planegeo.GetNormalDirection();
    const TVector3 wiredir = planegeo.GetWireDirection();

    const double depth = planegeo.Depth();
    const double width = planegeo.Width();
    const TVector3 depthdir = planegeo.DepthDir();
    const TVector3 widthdir = planegeo.WidthDir();

    const double tick_origin = detprop.ConvertTicksToX(0, plane);
    const double tick_pitch = detprop.ConvertTicksToX(1, plane) - tick_origin;

    const int maxTick = detprop.NumberTimeSamples();

    if(!first) json << ",\n";
    first = false;

    json << "    " << plane << ": {"
         << "\"view\": " << view << ", "
         << "\"nwires\": " << nwires << ", "
         << "\"pitch\": " << pitch << ", "
         << "\"nticks\": " << maxTick << ", "
         << "\"tick_origin\": " << tick_origin << ", "
         << "\"tick_pitch\": " << tick_pitch << ", "
         << "\"center\": " << c << ", "
         << "\"across\": " << d << ", "
         << "\"wiredir\": " << wiredir << ", "
         << "\"depth\": " << depth << ", "
         << "\"width\": " << width << ", "
         << "\"depthdir\": " << depthdir << ", "
         << "\"widthdir\": " << widthdir << ", "
         << "\"normal\": " << n << "}";
  }
  json << "\n  }";
}

template<class TProd , class TEvt >

void evd::SerializeProduct	(	const TEvt &	evt,
		JSONFormatter &	json
	)

Definition at line 511 of file WebEVDServer.cxx.

{
  json << "{";

  const std::vector<art::InputTag> tags = evt.template getInputTags<std::vector<TProd>>();

  for(const art::InputTag& tag: tags){
    typename TEvt::template HandleT<std::vector<TProd>> prods; // deduce handle type
    // This can fail in the case of dropped products
    if(!evt.getByLabel(tag, prods)) continue;

    json << "  " << tag << ": ";

    json << *prods;

    if(tag != tags.back()){
      json << ",";
    }
    json << "\n";
  }

  json << "}";
}

template<class TProd , class TEvt >

void evd::SerializeProductByLabel	(	const TEvt &	evt,
		const std::string &	in_label,
		JSONFormatter &	json
	)

Definition at line 537 of file WebEVDServer.cxx.

{
  typename TEvt::template HandleT<std::vector<TProd>> prods; // deduce handle type
  evt.getByLabel(in_label, prods);

  if(prods.isValid()){
    json << *prods;
  }
  else{
    json << "[]";
  }
}

template<class T >

void evd::SerializeWireTraces	(	const T &	evt,
		const geo::GeometryCore *	geom,
		JSONFormatter &	json
	)

Definition at line 733 of file WebEVDServer.cxx.

{
  // [tag][plane][wire][t0]
  std::map<art::InputTag, std::map<geo::PlaneID, std::map<int, std::map<int, std::vector<float>>>>> traces;

  for(art::InputTag tag: evt.template getInputTags<std::vector<recob::Wire>>()){
    typename T::template HandleT<std::vector<recob::Wire>> wires; // deduce handle type
    // This can fail in the case of dropped products
    if(!evt.getByLabel(tag, wires)) continue;

    for(const recob::Wire& rbwire: *wires){
      // Place all wire traces on the first wire (== channel) they are found on
      const geo::WireID wire =  geom->ChannelToWire(rbwire.Channel())[0];
      const geo::PlaneID plane(wire);

      traces[tag][plane][wire.Wire] = ToSnippets(rbwire.Signal());
    } // end for rbwire
  } // end for tag

  json << traces;
}

std::string evd::ShortInteractionSuffix

(

int

iType

)

Definition at line 202 of file TruthText.cxx.

  {
    switch(iType){
    case simb::kQE:
    case simb::kCCQE:
      return " (QE)";

    case simb::kRes:
    case simb::kResCCNuProtonPiPlus:
    case simb::kResCCNuNeutronPi0:
    case simb::kResCCNuNeutronPiPlus:
    case simb::kResCCNuBarNeutronPiMinus:
    case simb::kResCCNuBarProtonPi0:
    case simb::kResCCNuBarProtonPiMinus:
      return " (RES)";

    case simb::kDIS:
    case simb::kCCDIS:
      return " (DIS)";

    case simb::kCoh:
    case simb::kCCCOH:
      return " (COH)";

    case simb::kNCQE:
    case simb::kNCDIS:
    case simb::kResNCNuProtonPi0:
    case simb::kResNCNuProtonPiPlus:
    case simb::kResNCNuNeutronPi0:
    case simb::kResNCNuNeutronPiMinus:
    case simb::kResNCNuBarProtonPi0:
    case simb::kResNCNuBarProtonPiPlus:
    case simb::kResNCNuBarNeutronPi0:
    case simb::kResNCNuBarNeutronPiMinus:
      return " (NC)";

    case simb::kElectronScattering:
      return " (ES)";

    case simb::kInverseBetaDecay:
      return " (IBD)";

    default: // simb::kNuElectronElastic and simb::kInverseMuDecay
      return "";
    }
  }

std::string evd::sub	(	const std::string &	a,
		const std::string &	b
	)

Definition at line 100 of file TruthText.cxx.

  {
    return a+"<sub>"+b+"</sub>";
  }

std::string evd::sup	(	const std::string &	a,
		const std::string &	b
	)

Definition at line 94 of file TruthText.cxx.

  {
    return a+"<sup>"+b+"</sup>";
  }

short evd::swap_byte_order

(

short

x

)

Definition at line 78 of file WebEVDServer.cxx.

{
  char* cx = (char*)&x;
  std::swap(cx[0], cx[1]);
  return x;
}

template<class T >

std::map<int, std::vector<T> > evd::ToSnippets	(	const std::vector< T > &	adcs,
		T	pedestal = 0
	)

Definition at line 672 of file WebEVDServer.cxx.

{
  std::vector<T> snip;
  snip.reserve(adcs.size());

  std::map<int, std::vector<T>> snips;

  int t = 0;
  for(T adc: adcs){
    if(adc == 0){
      if(!snip.empty()){
        snips[t-snip.size()] = snip;
        snip.clear();
      }
    }
    else{
      snip.push_back(adc - pedestal);
    }

    ++t;
  } // end for adc

  // Save last in-progress snippet if necessary
  if(!snip.empty()) snips[t-snip.size()] = snip;

  // this is a bit of a hack to teach the viewer how long the full trace
  // is
  snips[adcs.size()] = {};

  return snips;
}

void evd::webevd_png_flush_fn

(

png_struct_def *

png_ptr

)

Definition at line 102 of file PNGArena.cxx.

  {
    // Nothing to do here, but libpng requires we provide this
  }

void evd::webevd_png_write_fn	(	png_struct_def *	png_ptr,
		png_byte *	buffer,
		long unsigned int	nbytes
	)

Definition at line 88 of file PNGArena.cxx.

  {
    FILE* fout = (FILE*)png_get_io_ptr(png_ptr);
    const size_t ret = fwrite(buffer, 1, nbytes, fout);

    if(ret != nbytes){
      std::cout << "Error writing " << nbytes << " bytes of png -- returned " << ret << std::endl;
      perror(0);
      std::cout << std::endl;
    }
  }

void evd::write_compressed_buffer	(	unsigned char *	src,
		int	length,
		int	sock,
		int	level,
		const std::string &	name
	)

Definition at line 291 of file WebEVDServer.cxx.

{
  std::vector<unsigned char> dest;
  gzip_buffer(src, length, dest, level);

  std::cout << "Writing " << length << " bytes (compressed to " << dest.size() << ") for " << name << "\n" << std::endl;

  write(sock, dest.data(), dest.size());
}

void evd::write_compressed_file	(	const std::string &	loc,
		int	fd_out,
		int	level
	)

Definition at line 306 of file WebEVDServer.cxx.

{
  int fd_in = open(loc.c_str(), O_RDONLY);

  // Map in the whole file
  struct stat st;
  fstat(fd_in, &st);
  unsigned char* src = (unsigned char*)mmap(0, st.st_size, PROT_READ, MAP_PRIVATE, fd_in, 0);

  write_compressed_buffer(src, st.st_size, fd_out, level, loc);

  munmap(src, st.st_size);

  close(fd_in);
}

void evd::write_notfound404

(

int

sock

)

Definition at line 101 of file WebEVDServer.cxx.

{
  const char str[] =
    "HTTP/1.0 404 Not Found\r\n"
    "Server: WebEVD/1.0.0\r\n"
    "Content-Type: text/plain\r\n"
    "\r\n"
    "404. Huh?\r\n";

  write(sock, str, strlen(str));
}

void evd::write_ok200	(	int	sock,
		const std::string	content = "text/html",
		bool	gzip = false
	)

Definition at line 85 of file WebEVDServer.cxx.

{
  std::string str =
    "HTTP/1.0 200 OK\r\n"
    "Server: WebEVD/1.0.0\r\n"
    "Content-Type: "+content+"\r\n";

  if(gzip) str += "Content-Encoding: gzip\r\n";

  str += "\r\n";

  write(sock, &str.front(), str.size());
}

void evd::write_unimp501

(

int

sock

)

Definition at line 113 of file WebEVDServer.cxx.

{
  const char str[] =
    "HTTP/1.0 501 Not Implemented\r\n"
    "Server: WebEVD/1.0.0\r\n"
    "Content-Type: text/plain\r\n"
    "\r\n"
    "I don't know how to do that\r\n";

  write(sock, str, strlen(str));
}

Variable Documentation

int evd::curr_zooming_plane

static

Definition at line 47 of file TWQMultiTPCProjection.cxx.

int evd::curr_zooming_plane

static

Definition at line 53 of file TWQProjectionView.cxx.

HitSelector* evd::gTheHitSelector

Definition at line 25 of file DrawingPad.cxx.

const int evd::kCALIB = 1

static

Definition at line 30 of file TQPad.cxx.

const int evd::kColor[kNCOLS]

static

Initial value:

= { kRed+2, kGreen+2, kBlue+2, kYellow+2, kMagenta-9, kCyan-6,
                                      8, 29, 30, 38, 40, 41, 42, 46 }

Definition at line 11 of file eventdisplay.h.

const int evd::kColor2[kNCOLS]

static

Initial value:

= { kRed, kGreen, kBlue, kYellow, kMagenta, kCyan,
                                      8, 29, 30, 38, 40, 41, 42, 46 }

Definition at line 13 of file eventdisplay.h.

double evd::kDistance

static

Definition at line 46 of file TWQMultiTPCProjection.cxx.

double evd::kDistance

static

Definition at line 52 of file TWQProjectionView.cxx.

const int evd::kNCOLS = 14

static

Definition at line 10 of file eventdisplay.h.

unsigned int evd::kPlane

static

Definition at line 44 of file TWQMultiTPCProjection.cxx.

unsigned int evd::kPlane

static

Definition at line 50 of file TWQProjectionView.cxx.

const int evd::kQ = 0

static

Definition at line 32 of file TQPad.cxx.

const int evd::kRAW = 0

static

Definition at line 29 of file TQPad.cxx.

const int evd::kTQ = 1

static

Definition at line 33 of file TQPad.cxx.

unsigned int evd::kWire

static

Definition at line 45 of file TWQMultiTPCProjection.cxx.

unsigned int evd::kWire

static

Definition at line 51 of file TWQProjectionView.cxx.

int evd::shift_lock

static

Definition at line 50 of file TWQMultiTPCProjection.cxx.

int evd::shift_lock

static

Definition at line 56 of file TWQProjectionView.cxx.

const char* evd::zoom_opt = 0

static

Definition at line 48 of file TWQMultiTPCProjection.cxx.

const char* evd::zoom_opt = 0

static

Definition at line 54 of file TWQProjectionView.cxx.