evd::SimulationDrawer Class Reference

#include "/cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-12-03/EventDisplay/SimulationDrawer.h"

Public Member Functions
	SimulationDrawer ()
	~SimulationDrawer ()
void	MCTruthShortText (const art::Event &evt, evdb::View2D *view)
void	MCTruthLongText (const art::Event &evt, evdb::View2D *view)
void	MCTruthVertices2D (const art::Event &evt, evdb::View2D *xzview, evdb::View2D *yzview)
void	MCTruthVertices3D (const art::Event &evt, evdb::View3D *view)
void	MCTruthVectors2D (const art::Event &evt, evdb::View2D *xzview, evdb::View2D *yzview)
void	MCTruthVectors3D (const art::Event &evt, evdb::View3D *view)
void	MCTruthTrajectories2D (const art::Event &evt, evdb::View2D *xzview, evdb::View2D *yzview)
void	MCTruthTrajectories3D (const art::Event &evt, evdb::View3D *view)
void	FLSHit2D (const art::Event &evt, evdb::View2D *xzview, evdb::View2D *yzview)
void	FLSHit3D (const art::Event &evt, evdb::View3D *xzview)
void	HiLite (int trkId, bool hlt=true)
void	GetLimits (const art::Event *evt, double &xmin, double &xmax, double &ymin, double &ymax, double &zmin, double &zmax, const std::set< geo::OfflineChan > &hmap={})
void	GetTimeLimits (const art::Event *evt, double &tmin, double &tmax)

Private Member Functions
int	GetMCTruth (const art::Event &evt, std::vector< simb::MCTruth > &mctruth)
int	GetFLSHits (const art::Event &evt, const char *which, std::vector< sim::FLSHitList > &flshits)
int	GetVertexPoints (const art::Event &evt, std::vector< double > &x, std::vector< double > &y, std::vector< double > &z)
std::string	ShortInteractionSuffix (int iType) const
void	PrintParticleAndOffspring (std::stringstream &ss, const sim::Particle *part, std::string prefix, int depth) const
	Helper function for MCTruthLongText. More...
void	MCTruthTrajectoriesAnyD (const art::Event &evt, evdb::View2D *xzview, evdb::View2D *yzview, evdb::View3D *view3D)
	Helper function for MCTruthTrajectories[2|3]D. More...

Private Attributes
std::map< int, bool >	fHighlite

Detailed Description

Definition at line 28 of file SimulationDrawer.h.

Constructor & Destructor Documentation

evd::SimulationDrawer::SimulationDrawer

(

)

Definition at line 56 of file SimulationDrawer.cxx.

  {
  }

evd::SimulationDrawer::~SimulationDrawer

(

)

Definition at line 62 of file SimulationDrawer.cxx.

  {
  }

Member Function Documentation

void evd::SimulationDrawer::FLSHit2D	(	const art::Event &	evt,
		evdb::View2D *	xzview,
		evdb::View2D *	yzview
	)

Definition at line 557 of file SimulationDrawer.cxx.

References evdb::View2D::AddMarker(), evdb::View2D::AddPolyLine(), evdb::View2D::AddPolyMarker(), plot_validation_datamc::c, evd::Style::ColorFromPDG(), evd::SimulationDrawingOptions::fDraw, evd::SimulationDrawingOptions::fFLSHitListModules, evd::SimulationDrawingOptions::fFLSHitStyle, evd::SimulationDrawingOptions::fFLSHitThresh, fHighlite, evd::Style::FromPDG(), sim::FLSHit::GetCellID(), sim::FLSHit::GetEdep(), GetFLSHits(), sim::FLSHit::GetNPoints(), sim::FLSHit::GetPDG(), sim::FLSHit::GetPlaneID(), sim::FLSHit::GetTrackID(), sim::FLSHit::GetX(), sim::FLSHit::GetXAverage(), sim::FLSHit::GetY(), sim::FLSHit::GetYAverage(), sim::FLSHit::GetZ(), sim::FLSHit::GetZAverage(), MECModelEnuComparisons::i, calib::j, evd::SimulationDrawingOptions::kDRAW_HITS, evd::SimulationDrawingOptions::kFLSHIT_AS_LINE, submit_hadd::l, geo::GeometryBase::Plane(), and POTSpillRate::view.

Referenced by evd::TZProjPad::Draw().

  {
    art::ServiceHandle<evd::SimulationDrawingOptions> drawopt;
    if ( (drawopt->fDraw & 
          evd::SimulationDrawingOptions::kDRAW_HITS)==0) {
      return;
    }

    art::ServiceHandle<geo::Geometry> geo;

    // Otherwise, unpack and show the FLS hits
    for (unsigned int imod=0; imod<drawopt->fFLSHitListModules.size(); ++imod) {
      const char* which = drawopt->fFLSHitListModules[imod].c_str();
    
    std::vector<sim::FLSHitList> flshits;
    this->GetFLSHits(evt, which, flshits);

    // Indexed by color
    std::map<int, TPolyMarker*> pms_x, pms_y;
    evd::Style style;

    for (unsigned int i=0; i<flshits.size(); ++i) {
      for (unsigned int j=0; j<flshits[i].fHits.size(); ++j) {
        const sim::FLSHit& hit = flshits[i].fHits[j];
        if (hit.GetEdep()<0.001*drawopt->fFLSHitThresh) continue;

        switch (drawopt->fFLSHitStyle) {
        case evd::SimulationDrawingOptions::kFLSHIT_AS_LINE:
          for(int view = 0; view < 2; ++view){
            evdb::View2D* v2d = (view == 0) ? xzview : yzview;
            if(!v2d) continue;

            // Dummy styling, overridden in next line
            TPolyLine& l = v2d->AddPolyLine(hit.GetNPoints(), kBlack, 0, kSolid);
            style.FromPDG(&l, hit.GetPDG());
            for(int i = 0; i < hit.GetNPoints(); ++i){
              double xyzloc[3] = {hit.GetX(i), hit.GetY(i), hit.GetZ(i)};
              double xyzwor[3];
              geo->Plane(hit.GetPlaneID())->Cell(hit.GetCellID())->LocalToWorld(xyzloc, xyzwor);
              l.SetPoint(i, xyzwor[2], xyzwor[view]);
            }
          }
          break;
        default:
          double xyzloc[3] = {hit.GetXAverage(), hit.GetYAverage(), hit.GetZAverage()};
          double xyzwor[3];
          geo->Plane(hit.GetPlaneID())->Cell(hit.GetCellID())->LocalToWorld(xyzloc, xyzwor);

          const int c = style.ColorFromPDG(hit.GetPDG());
          const double sz = 0.5;
          
          if(xzview){
            TPolyMarker* pm = pms_x[c];
            if(!pm){
              pm = &xzview->AddPolyMarker(0, c, kFullDotMedium, sz);
              pms_x[c] = pm;
            }
            pm->SetNextPoint(xyzwor[2], xyzwor[0]);
          }
          if(yzview){
            TPolyMarker* pm = pms_y[c];
            if(!pm){
              pm = &yzview->AddPolyMarker(0, c, kFullDotMedium, sz);
              pms_y[c] = pm;
            }
            pm->SetNextPoint(xyzwor[2], xyzwor[1]);
          }
          
          if(fHighlite[hit.GetTrackID()]){
            if(xzview) xzview->AddMarker(xyzwor[2],xyzwor[0],c,kOpenCircle,sz);
            if(yzview) yzview->AddMarker(xyzwor[2],xyzwor[1],c,kOpenCircle,sz);
          }

        } // FLSHit style
      } // loop on j hits in list
    } // loop on i hit lists
  } // loop o imod folders
}

void evd::SimulationDrawer::FLSHit3D	(	const art::Event &	evt,
		evdb::View3D *	xzview
	)

Definition at line 640 of file SimulationDrawer.cxx.

References evdb::View3D::AddPolyMarker3D(), plot_validation_datamc::c, evd::Style::ColorFromPDG(), evd::SimulationDrawingOptions::fDraw, evd::SimulationDrawingOptions::fFLSHitListModules, evd::SimulationDrawingOptions::fFLSHitThresh, fHighlite, sim::FLSHit::GetCellID(), sim::FLSHit::GetEdep(), sim::FLSHit::GetEntryX(), sim::FLSHit::GetEntryY(), sim::FLSHit::GetEntryZ(), sim::FLSHit::GetExitX(), sim::FLSHit::GetExitY(), sim::FLSHit::GetExitZ(), GetFLSHits(), sim::FLSHit::GetPDG(), sim::FLSHit::GetPlaneID(), sim::FLSHit::GetTrackID(), MECModelEnuComparisons::i, calib::j, evd::SimulationDrawingOptions::kDRAW_HITS, and geo::GeometryBase::Plane().

Referenced by evd::Display3DPad::Draw().

  {
    art::ServiceHandle<evd::SimulationDrawingOptions> drawopt;
    if ( (drawopt->fDraw &
          evd::SimulationDrawingOptions::kDRAW_HITS)==0) {
      return;
    }

    art::ServiceHandle<geo::Geometry> geo;

    evd::Style style;

    // Otherwise, unpack and show the FLS hits
    for (unsigned int imod=0; imod<drawopt->fFLSHitListModules.size(); ++imod) {
      const char* which = drawopt->fFLSHitListModules[imod].c_str();
    
      std::vector<sim::FLSHitList> flshits;
      this->GetFLSHits(evt, which, flshits);
      for (unsigned int i=0; i<flshits.size(); ++i) {
        for (unsigned int j=0; j<flshits[i].fHits.size(); ++j) {
          const sim::FLSHit& hit = flshits[i].fHits[j];

          if (hit.GetEdep()<0.001*drawopt->fFLSHitThresh) continue;

          double xyzloc[3]; // Local cell xyz coordinates
          double xyzwor[3]; // World coordinates
          xyzloc[0] = 0.5*(hit.GetEntryX() + hit.GetExitX());
          xyzloc[1] = 0.5*(hit.GetEntryY() + hit.GetExitY());
          xyzloc[2] = 0.5*(hit.GetEntryZ() + hit.GetExitZ());
        
          geo->Plane(hit.GetPlaneID())->Cell(hit.GetCellID())->LocalToWorld(xyzloc,xyzwor);
        
          int   st = 7;
          int   c  = style.ColorFromPDG(hit.GetPDG());
          float sz = 0.5;

          TPolyMarker3D& p = view->AddPolyMarker3D(1, c, st, sz);
          p.SetPoint(0, xyzwor[0], xyzwor[1], xyzwor[2]);

          if (fHighlite[hit.GetTrackID()]) {
            TPolyMarker3D& p = view->AddPolyMarker3D(1, c, 24, 2*sz);
            p.SetPoint(0, xyzwor[0], xyzwor[1], xyzwor[2]);       
          }

        } // loop on j hits in list
      } // loop on i hit lists
    } // loop o imod folders
  }

int evd::SimulationDrawer::GetFLSHits ( const art::Event &  evt, const char *  which, std::vector< sim::FLSHitList > &  flshits  )

private

Definition at line 713 of file SimulationDrawer.cxx.

References e, MakeMiniprodValidationCuts::f, art::DataViewImpl::getByLabel(), and APDHVSetting::temp.

Referenced by FLSHit2D(), FLSHit3D(), GetLimits(), and GetTimeLimits().

  {

    flshits.clear();
    art::Handle< std::vector<sim::FLSHitList> > fcol;

    try{
      evt.getByLabel(which, fcol);
      std::vector<sim::FLSHitList> temp(fcol->size());
      for(size_t f = 0; f < fcol->size(); ++f){
        flshits.push_back(fcol->at(f));
      }
    }
    catch(cet::exception& e){
      writeErrMsg("GetFLSHits", e);
    }

    return flshits.size();
  }

void evd::SimulationDrawer::GetLimits	(	const art::Event *	evt,
		double &	xmin,
		double &	xmax,
		double &	ymin,
		double &	ymax,
		double &	zmin,
		double &	zmax,
		const std::set< geo::OfflineChan > &	hmap = {}
	)

Definition at line 840 of file SimulationDrawer.cxx.

References ana::assert(), geo::GeometryBase::CellInfo(), evd::SimulationDrawingOptions::fFLSHitListModules, geom(), sim::FLSHit::GetCellID(), GetFLSHits(), sim::FLSHit::GetPlaneID(), hits(), MECModelEnuComparisons::i, calib::j, geo::kX, geo::kY, and POTSpillRate::view.

Referenced by evd::TZProjPad::AutoZoomTruth().

  {
    assert(evt);

    art::ServiceHandle<evd::SimulationDrawingOptions> drawopt;

    art::ServiceHandle<geo::Geometry> geom;

    xmin = +1e10; ymin = +1e10; zmin = +1e10;
    xmax = -1e10; ymax = -1e10; zmax = -1e10;

    for(unsigned int imod = 0; imod < drawopt->fFLSHitListModules.size(); ++imod){
      std::vector<sim::FLSHitList> lists;
      GetFLSHits(*evt, drawopt->fFLSHitListModules[imod].c_str(), lists);

      for(unsigned int i = 0; i < lists.size(); ++i){
        const std::vector<sim::FLSHit>& hits = lists[i].fHits;

        for(unsigned int j = 0; j < hits.size(); ++j){
          const sim::FLSHit& hit = hits[j];

          if(!hmap.empty() &&
             hmap.find(geo::OfflineChan(hit.GetPlaneID(),
                                        hit.GetCellID())) == hmap.end()) continue;

          geo::View_t view;
          double xyz[3];
          geom->CellInfo(hit.GetPlaneID(), hit.GetCellID(), &view, xyz);

          if(view == geo::kX && xyz[0] < xmin) xmin = xyz[0];
          if(view == geo::kX && xyz[0] > xmax) xmax = xyz[0];
          if(view == geo::kY && xyz[1] < ymin) ymin = xyz[1];
          if(view == geo::kY && xyz[1] > ymax) ymax = xyz[1];
          if(xyz[2] < zmin) zmin = xyz[2];
          if(xyz[2] > zmax) zmax = xyz[2];
        }
      }
    } // end for imod
  }

int evd::SimulationDrawer::GetMCTruth ( const art::Event &  evt, std::vector< simb::MCTruth > &  mctruth  )

private

Definition at line 693 of file SimulationDrawer.cxx.

References evd::SimulationDrawingOptions::fMCTruthModules, evd::SliceNavigator::GetProducts(), APDHVSetting::mod, MECModelEnuComparisons::opt, string, and confusionMatrixTree::t.

Referenced by GetVertexPoints(), MCTruthShortText(), MCTruthTrajectoriesAnyD(), MCTruthVectors2D(), and MCTruthVectors3D().

  {
    mctruth.clear();

    art::ServiceHandle<evd::SimulationDrawingOptions> opt;

    for(const std::string& mod: opt->fMCTruthModules){
      art::ServiceHandle<evd::SliceNavigator> nav;
      std::vector<const simb::MCTruth*> truths;
      nav->GetProducts(evt, mod, "", truths);

      for(const simb::MCTruth* t: truths) mctruth.push_back(*t);
    }

    return mctruth.size();
  }

void evd::SimulationDrawer::GetTimeLimits	(	const art::Event *	evt,
		double &	tmin,
		double &	tmax
	)

Definition at line 886 of file SimulationDrawer.cxx.

References ana::assert(), evd::SimulationDrawingOptions::fFLSHitListModules, sim::FLSHit::GetEntryT(), sim::FLSHit::GetExitT(), GetFLSHits(), hits(), MECModelEnuComparisons::i, and calib::j.

Referenced by evd::TQPad::Draw().

  {
    tmin = FLT_MAX;
    tmax = -FLT_MAX;

    assert(evt);

    art::ServiceHandle<evd::SimulationDrawingOptions> drawopt;

    for(unsigned int imod = 0; imod < drawopt->fFLSHitListModules.size(); ++imod){
      std::vector<sim::FLSHitList> lists;
      GetFLSHits(*evt, drawopt->fFLSHitListModules[imod].c_str(), lists);

      for(unsigned int i = 0; i < lists.size(); ++i){
        const std::vector<sim::FLSHit>& hits = lists[i].fHits;

        for(unsigned int j = 0; j < hits.size(); ++j){
          const sim::FLSHit& hit = hits[j];

          if(hit.GetEntryT() < tmin) tmin = hit.GetEntryT();
          if(hit.GetExitT()  > tmax) tmax = hit.GetExitT();
        }
      }
    }
  }

int evd::SimulationDrawer::GetVertexPoints ( const art::Event &  evt, std::vector< double > &  x, std::vector< double > &  y, std::vector< double > &  z  )

private

Definition at line 737 of file SimulationDrawer.cxx.

References GetMCTruth(), MECModelEnuComparisons::i, calib::j, simb::MCParticle::StatusCode(), simb::MCParticle::Vx(), simb::MCParticle::Vy(), and simb::MCParticle::Vz().

Referenced by MCTruthVertices2D(), and MCTruthVertices3D().

  {
    x.clear();
    y.clear();
    z.clear();
    //
    // The list of vertexs are attached to individual particles. To
    // get a unique list of vertexs, loop over the particles and keep
    // only the unique vertex points.
    //
    std::vector<simb::MCTruth> mctruth;
    this->GetMCTruth(evt, mctruth);
    for (unsigned int i=0; i<mctruth.size(); ++i) {
      double x0, y0, z0;
      bool   in_list;
      for (int j=0; j<mctruth[i].NParticles(); ++j) {
        const simb::MCParticle& p = mctruth[i].GetParticle(j);
        //
        // Skip all but incoming and out-going particles
        //
        if (!(p.StatusCode()==0 || p.StatusCode()==1)) continue;
        x0 = p.Vx();
        y0 = p.Vy();
        z0 = p.Vz();
        //
        // Check if this vertex is already in the list. 
        //
        in_list = false;
        for (unsigned int k=0; k<x.size(); ++k) {
          in_list = ((x0 == x[k]) && (y0 == y[k]) && (z0 == z[k]));
          if (in_list) break;
        }
        if (in_list==false) {
          x.push_back(x0);
          y.push_back(y0);
          z.push_back(z0);
        }
      }
    }
    return x.size();
  }

void evd::SimulationDrawer::HiLite	(	int	trkId,
		bool	hlt = true
	)

Definition at line 833 of file SimulationDrawer.cxx.

References fHighlite.

Referenced by evd::MCTrueView::HiLite().

  {
    fHighlite[trkId] = dohilite;
  }

void evd::SimulationDrawer::MCTruthLongText	(	const art::Event &	evt,
		evdb::View2D *	view
	)

Definition at line 307 of file SimulationDrawer.cxx.

References allTimeWatchdog::endl, evd::SimulationDrawingOptions::fText, evd::SimulationDrawingOptions::fTextIncludeDirections, evd::SimulationDrawingOptions::fTextIncludeVertex, evd::SimulationDrawingOptions::kTEXT_LONG, getGoodRuns4SAM::n, sim::ParticleNavigator::NumberOfPrimaries(), cheat::BackTracker::ParticleNavigator(), sim::ParticleNavigator::Primary(), PrintParticleAndOffspring(), and ss.

Referenced by evd::MCBriefPad::Draw().

  {
    art::ServiceHandle<evd::SimulationDrawingOptions> drawopt;
    // Skip drawing if option is turned off
    if ((drawopt->fText & 
        evd::SimulationDrawingOptions::kTEXT_LONG)==0) {
      return;
    }

    art::ServiceHandle<cheat::BackTracker> bt;
    const sim::ParticleNavigator& pnav = bt->ParticleNavigator();

    const bool showVtxs  = drawopt->fTextIncludeVertex;
    const bool showDirs  = drawopt->fTextIncludeDirections;

    std::stringstream ss;
    ss<< "Long MCTruth text ( from sim::Particle )"<< std::endl;
    ss<<" Particle       ( KineticEnergy )    [ Process ] ";
    if (showVtxs) ss<<" at  (Vx, Vy, Vz, T)";
    if (showDirs) ss<<" with direction  (Px, Py, Pz)";
    ss<<" TrackId"<<std::endl;

    // loop over all the primary particles
    for(int n = 0; n < pnav.NumberOfPrimaries(); ++n){
      ss << "\u2500\u2500";
      PrintParticleAndOffspring(ss, pnav.Primary(n), "  ", 1);
    }
    mf::LogVerbatim("SimulationDrawer") << ss.str();
  }

void evd::SimulationDrawer::MCTruthShortText	(	const art::Event &	evt,
		evdb::View2D *	view
	)

Definition at line 68 of file SimulationDrawer.cxx.

References evdb::View2D::AddLatex(), evd::Style::ColorFromPDG(), colors, evd::SimulationDrawingOptions::fDraw, evdb::Colors::Foreground(), evd::SimulationDrawingOptions::fText, GetMCTruth(), MECModelEnuComparisons::i, calib::j, simb::kCosmicRay, evd::SimulationDrawingOptions::kTEXT_SHORT, latex(), evd::Style::LatexName(), simb::MCParticle::P(), simb::MCParticle::PdgCode(), ShortInteractionSuffix(), simb::MCParticle::StatusCode(), and string.

Referenced by evd::MCBriefPad::Draw().

  {
    art::ServiceHandle<evd::SimulationDrawingOptions> drawopt;
    if ( (drawopt->fText & 
          evd::SimulationDrawingOptions::kTEXT_SHORT) == 0) {
      return;
    }

    art::ServiceHandle<evdb::Colors> colors;

    std::vector<simb::MCTruth> mctruth;
    this->GetMCTruth(evt, mctruth);

    // Letting text get too large is a performance problem, and eventually
    // segfaults (don't know why).  Cap at a reasonable size.  There's nothing
    // special about this precise size.
    const unsigned int mctextmax = 2000;
    bool cappedtext = false;

    evd::Style style;
    std::string mctext;
    for (unsigned int i = 0; i < mctruth.size(); ++i) {
      if(i > 0) mctext += ", ";

      bool firstin  = true;
      bool firstout = true;
      std::string origin;
      std::string incoming;
      std::string outgoing;
      // Label cosmic rays -- others are pretty obvious
      if (mctruth[i].Origin()==simb::kCosmicRay) { origin = "c-ray: "; }
      for (int j=0; j<mctruth[i].NParticles(); ++j) {

        const simb::MCParticle& p = mctruth[i].GetParticle(j);
        // Print text in color if there are other MCTruth objects drawn
        int pcolor = ( drawopt->fDraw == 0 ) ? colors->Foreground(0) : style.ColorFromPDG(p.PdgCode() );

        const unsigned int bufsize = 1024;
        char buff[bufsize];
        if (p.P()>0.05) {
          snprintf(buff, bufsize, "#color[%d]{%s #scale[0.75]{[%.1f#scale[0.5]{GeV/c}]}}",
                  pcolor,
                  Style::LatexName(p.PdgCode()), 
                  p.P());
        }
        else {
          snprintf(buff, bufsize, "#color[%d]{%s}",
                  pcolor,
                  Style::LatexName(p.PdgCode()));
        }
        if (p.StatusCode()==0) {
          if(mctext.size() + incoming.size() + 3 + strlen(buff) > mctextmax){
            cappedtext = true;
            break;
          }
          if (!firstin) incoming += " + ";
          incoming += buff;
          firstin = false;
        }
        if (p.StatusCode()==1) {
          if(mctext.size() + outgoing.size() + 3 + strlen(buff) > mctextmax){
            cappedtext = true;
            break;
          }
          if (!firstout) outgoing += " + ";
          outgoing += buff;
          firstout = false;
        }
      } // loop on j particles
      if (origin=="" && incoming=="") {
        if(mctext.size() + outgoing.size() > mctextmax){
          cappedtext = true;
          break;
        }
        mctext += outgoing;
      }
      else {
        const int intType = mctruth[i].GetNeutrino().InteractionType();
        const std::string suffix = ShortInteractionSuffix(intType);
        const std::string newtext = origin+incoming+" #rightarrow "+outgoing+suffix;
        if(mctext.size() + newtext.size() > mctextmax){
          cappedtext = true;
          break;
        }
        mctext += newtext;
      }
      if(cappedtext) break; // if capped inside particle loop
    } // loop on i mctruth objects

    if(cappedtext){
      if(mctext.empty()) mctext = "Too many particles"; // shouldn't happen
      else mctext += "... and more!";
    }

    TLatex& latex = view->AddLatex(0.01, 0.055, mctext.c_str());
    latex.SetTextColor(colors->Foreground(0));
    latex.SetTextSize(0.15);
  }

void evd::SimulationDrawer::MCTruthTrajectories2D	(	const art::Event &	evt,
		evdb::View2D *	xzview,
		evdb::View2D *	yzview
	)

Definition at line 542 of file SimulationDrawer.cxx.

References MCTruthTrajectoriesAnyD().

Referenced by evd::TZProjPad::Draw().

  {
    MCTruthTrajectoriesAnyD(evt, xzview, yzview, 0);
  }

void evd::SimulationDrawer::MCTruthTrajectories3D	(	const art::Event &	evt,
		evdb::View3D *	view
	)

Definition at line 549 of file SimulationDrawer.cxx.

References MCTruthTrajectoriesAnyD().

Referenced by evd::Display3DPad::Draw().

  {
    MCTruthTrajectoriesAnyD(evt, 0, 0, view);
  }

void evd::SimulationDrawer::MCTruthTrajectoriesAnyD ( const art::Event &  evt, evdb::View2D *  xzview, evdb::View2D *  yzview, evdb::View3D *  view3D  )

private

Helper function for MCTruthTrajectories[2|3]D.

Definition at line 481 of file SimulationDrawer.cxx.

References abs(), evdb::View2D::AddPolyLine(), evdb::View3D::AddPolyLine3D(), sim::ParticleNavigator::begin(), plot_validation_datamc::c, evd::Style::ColorFromPDG(), sim::ParticleNavigator::end(), evd::SimulationDrawingOptions::fDraw, GetMCTruth(), calib::j, evd::SimulationDrawingOptions::kDRAW_GAMMAS, evd::SimulationDrawingOptions::kDRAW_NEUTRALS, evd::SimulationDrawingOptions::kDRAW_TRAJECT, evd::Style::LineStyleFromPDG(), evd::Style::LineWidthFromPDG(), getGoodRuns4SAM::n, simb::MCParticle::NumberTrajectoryPoints(), part, cheat::BackTracker::ParticleNavigator(), make_root_from_grid_output::pdg, simb::MCParticle::PdgCode(), simb::MCParticle::Position(), and w.

Referenced by MCTruthTrajectories2D(), and MCTruthTrajectories3D().

  {
    art::ServiceHandle<evd::SimulationDrawingOptions> drawopt;
    if ( (drawopt->fDraw &
          evd::SimulationDrawingOptions::kDRAW_TRAJECT)==0) {
      return;
    }
    
    // TODO: Seems this call is required for GetParticleList to work properly?
    std::vector<simb::MCTruth> mctruth;
    this->GetMCTruth(evt, mctruth);

    art::ServiceHandle<cheat::BackTracker> bt;
    const sim::ParticleNavigator& pnav = bt->ParticleNavigator();

    evd::Style style;
    for(sim::ParticleNavigator::const_iterator j=pnav.begin(); 
        j != pnav.end();
        ++j) {
      const sim::Particle part = *((*j).second);
      
      const int pdg = part.PdgCode();
      
      // Decay neutrinos are just messy
      if (abs(pdg) == 12 || abs(pdg) == 14 || abs(pdg) == 16) continue;
      
      const int N = part.NumberTrajectoryPoints();
      const int c = style.ColorFromPDG(pdg);
      const int w = style.LineWidthFromPDG(pdg);
      const int s = style.LineStyleFromPDG(pdg);
      
      // This drawing mode disables neutral particles
      bool draw_neutrals = (drawopt->fDraw &
                            evd::SimulationDrawingOptions::kDRAW_NEUTRALS);
      //      if (!draw_neutrals && s!=kSolid) continue;
      bool draw_gammas   = (drawopt->fDraw &
                            evd::SimulationDrawingOptions::kDRAW_GAMMAS);
      if (!draw_neutrals && s==kDotted) continue;
      if (!draw_gammas && s==kDashed) continue;
      
      TPolyLine* xz = xzview ? &xzview->AddPolyLine(N, c, w, s) : 0;
      TPolyLine* yz = yzview ? &yzview->AddPolyLine(N, c, w, s) : 0;
      TPolyLine3D* xyz = view3D ? &view3D->AddPolyLine3D(N, c, w, s) : 0;
      
      for(int n = 0; n < N; ++n){
        const TLorentzVector& vec = part.Position(n);
        if(xz) xz->SetPoint(n, vec.Z(), vec.X());
        if(yz) yz->SetPoint(n, vec.Z(), vec.Y());
        if(xyz) xyz->SetPoint(n, vec.X(), vec.Y(), vec.Z());
      }
      
      if(xz) xz->SetBit(kCannotPick);
      if(yz) yz->SetBit(kCannotPick);
      if(xyz) xyz->SetBit(kCannotPick);
    } // end for j

  }

void evd::SimulationDrawer::MCTruthVectors2D	(	const art::Event &	evt,
		evdb::View2D *	xzview,
		evdb::View2D *	yzview
	)

Definition at line 391 of file SimulationDrawer.cxx.

References evdb::View2D::AddLine(), evd::SimulationDrawingOptions::fDraw, evd::Style::FromPDG(), GetMCTruth(), MECModelEnuComparisons::i, calib::j, evd::SimulationDrawingOptions::kDRAW_VECTORS, submit_hadd::l, simb::MCParticle::P(), simb::MCParticle::PdgCode(), simb::MCParticle::Px(), simb::MCParticle::Py(), simb::MCParticle::Pz(), r(), simb::MCParticle::StatusCode(), simb::MCParticle::Vx(), simb::MCParticle::Vy(), simb::MCParticle::Vz(), x1, and y1.

Referenced by evd::TZProjPad::Draw().

  {
    art::ServiceHandle<evd::SimulationDrawingOptions> drawopt;
    if ( (drawopt->fDraw & 
          evd::SimulationDrawingOptions::kDRAW_VECTORS)==0) {
      return;
    }

    // Unpack and draw the MC vectors
    std::vector<simb::MCTruth> mctruth;
    this->GetMCTruth(evt, mctruth);

    evd::Style style;
    for (unsigned int i=0; i<mctruth.size(); ++i) {
      for (int j=0; j<mctruth[i].NParticles(); ++j) {
        const simb::MCParticle& p = mctruth[i].GetParticle(j);
      
        // Skip all but incoming and out-going particles
        if (!(p.StatusCode()==0 || p.StatusCode()==1)) continue;
      
        double r  = p.P()*100.0;          // Scale length so 1 m = 1 GeV/c
        if (r<0.1) continue;              // Skip very short particles
        if (p.StatusCode()==0) r = -r;    // Flip for incoming particles
      
        double x0 = p.Vx();
        double y0 = p.Vy();
        double z0 = p.Vz();
        double x1 = x0 + r * p.Px()/p.P();
        double y1 = y0 + r * p.Py()/p.P();
        double z1 = z0 + r * p.Pz()/p.P();
        if (xzview!=0) {
          TLine& l = xzview->AddLine(z0, x0, z1, x1);
          style.FromPDG(&l,p.PdgCode());
        }
        if (yzview!=0) {
          TLine& l = yzview->AddLine(z0, y0, z1, y1);
          style.FromPDG(&l,p.PdgCode());
        }
      } // loop on j particles
    } // loop on i mctruth objects
  }

void evd::SimulationDrawer::MCTruthVectors3D	(	const art::Event &	evt,
		evdb::View3D *	view
	)

Definition at line 437 of file SimulationDrawer.cxx.

References evdb::View3D::AddPolyLine3D(), plot_validation_datamc::c, evd::Style::ColorFromPDG(), evd::SimulationDrawingOptions::fDraw, GetMCTruth(), MECModelEnuComparisons::i, calib::j, evd::SimulationDrawingOptions::kDRAW_VECTORS, submit_hadd::l, evd::Style::LineStyleFromPDG(), evd::Style::LineWidthFromPDG(), simb::MCParticle::P(), simb::MCParticle::PdgCode(), simb::MCParticle::Px(), simb::MCParticle::Py(), simb::MCParticle::Pz(), r(), simb::MCParticle::StatusCode(), simb::MCParticle::Vx(), simb::MCParticle::Vy(), simb::MCParticle::Vz(), w, x1, and y1.

Referenced by evd::Display3DPad::Draw().

  {
    art::ServiceHandle<evd::SimulationDrawingOptions> drawopt;
    if ( (drawopt->fDraw &
          evd::SimulationDrawingOptions::kDRAW_VECTORS)==0) {
      return;
    }
    
    // Unpack and draw the MC vectors
    std::vector<simb::MCTruth> mctruth;
    this->GetMCTruth(evt, mctruth);
    
    evd::Style style;
    for (unsigned int i=0; i<mctruth.size(); ++i) {
      for (int j=0; j<mctruth[i].NParticles(); ++j) {
        const simb::MCParticle& p = mctruth[i].GetParticle(j);
        
        // Skip all but incoming and out-going particles
        if (!(p.StatusCode()==0 || p.StatusCode()==1)) continue;
      
        double r  = p.P()*100.0;          // Scale length so 1 m = 1 GeV/c
        if (r<0.1) continue;              // Skip very short particles
        if (p.StatusCode()==0) r = -r; // Flip for incoming particles
      
        double x0 = p.Vx();
        double y0 = p.Vy();
        double z0 = p.Vz();
        double x1 = x0 + r * p.Px()/p.P();
        double y1 = y0 + r * p.Py()/p.P();
        double z1 = z0 + r * p.Pz()/p.P();
      
        int c = style.ColorFromPDG(p.PdgCode());
        int s = style.LineStyleFromPDG(p.PdgCode());
        int w = style.LineWidthFromPDG(p.PdgCode());
        TPolyLine3D& l = view->AddPolyLine3D(2,c,w,s);
        l.SetPoint(0, x0, y0, z0);
        l.SetPoint(1, x1, y1, z1);
      } // loop on j particles
    } // loop on i mctruth objects
  }

void evd::SimulationDrawer::MCTruthVertices2D	(	const art::Event &	evt,
		evdb::View2D *	xzview,
		evdb::View2D *	yzview
	)

Definition at line 340 of file SimulationDrawer.cxx.

References evdb::View2D::AddMarker(), evd::SimulationDrawingOptions::fDraw, GetVertexPoints(), MECModelEnuComparisons::i, evd::SimulationDrawingOptions::kDRAW_VERTEX, kOrange, submit_syst::x, submit_syst::y, and test::z.

Referenced by evd::TZProjPad::Draw().

  {
    art::ServiceHandle<evd::SimulationDrawingOptions> drawopt;
    if ( (drawopt->fDraw & 
          evd::SimulationDrawingOptions::kDRAW_VERTEX)==0) {
      return;
    }
    std::vector<double> x;
    std::vector<double> y;
    std::vector<double> z;
    this->GetVertexPoints(evt, x, y, z);
    unsigned int i;
    int    gold = kOrange-4;
    int    star = 30;
    double sz   = 2.0;
    for (i=0; i<x.size(); ++i) {
      if(xzview) xzview->AddMarker(z[i], x[i], gold, star, sz);
      if(yzview) yzview->AddMarker(z[i], y[i], gold, star, sz);
    }
 }

void evd::SimulationDrawer::MCTruthVertices3D	(	const art::Event &	evt,
		evdb::View3D *	view
	)

Definition at line 365 of file SimulationDrawer.cxx.

References evdb::View3D::AddPolyMarker3D(), evd::SimulationDrawingOptions::fDraw, GetVertexPoints(), MECModelEnuComparisons::i, evd::SimulationDrawingOptions::kDRAW_VERTEX, kOrange, submit_syst::x, submit_syst::y, and test::z.

Referenced by evd::Display3DPad::Draw().

  {
    art::ServiceHandle<evd::SimulationDrawingOptions> drawopt;
    if ( (drawopt->fDraw & 
          evd::SimulationDrawingOptions::kDRAW_VERTEX)==0) {
      return;
    }
    std::vector<double> x;
    std::vector<double> y;
    std::vector<double> z;
    this->GetVertexPoints(evt, x, y, z);

    int    gold = kOrange-4;
    int    star = 30;
    double sz   = 2.0;
    TPolyMarker3D& pm = view->AddPolyMarker3D(x.size(), gold, star, sz);
    
    unsigned int i;
    for (i=0; i<x.size(); ++i) {
      pm.SetPoint(i, x[i], y[i], z[i]);
    }
  }

void evd::SimulationDrawer::PrintParticleAndOffspring ( std::stringstream &  ss, const sim::Particle *  part, std::string  prefix, int  depth  ) const

private

Helper function for MCTruthLongText.

Definition at line 171 of file SimulationDrawer.cxx.

References genie::units::A, simb::MCParticle::Daughter(), e, simb::MCParticle::E(), sim::ParticleNavigator::end(), allTimeWatchdog::endl, sim::ParticleNavigator::find(), evd::SimulationDrawingOptions::fTextDepthLimit, evd::SimulationDrawingOptions::fTextIncludeDirections, evd::SimulationDrawingOptions::fTextIncludeVertex, MECModelEnuComparisons::i, simb::MCParticle::Mass(), getGoodRuns4SAM::n, simb::MCParticle::NumberDaughters(), simb::MCParticle::P(), cheat::BackTracker::ParticleNavigator(), simb::MCParticle::PdgCode(), simb::MCParticle::Process(), simb::MCParticle::Px(), simb::MCParticle::Py(), simb::MCParticle::Pz(), simb::MCParticle::T(), simb::MCParticle::TrackId(), simb::MCParticle::Vx(), simb::MCParticle::Vy(), and simb::MCParticle::Vz().

Referenced by MCTruthLongText().

  {
    art::ServiceHandle<evd::SimulationDrawingOptions> drawopt;
    const int depthLimit = drawopt->fTextDepthLimit;
    const bool showVtxs  = drawopt->fTextIncludeVertex;
    const bool showDirs  = drawopt->fTextIncludeDirections;

    art::ServiceHandle<cheat::BackTracker> bt;
    const sim::ParticleNavigator& pnav = bt->ParticleNavigator();

    // Find out what the particle is called and print it. Fallback is PDG code
    const TDatabasePDG* db = TDatabasePDG::Instance();
    const TParticlePDG* defn = db->GetParticle(part->PdgCode());
    if(defn){
      ss << defn->GetName();
    }
    else if(part->PdgCode() > 1000000000){
      const int strange = (part->PdgCode()/10000000)%10;
      const int element = (part->PdgCode()/10000)%1000;
      const int A       = (part->PdgCode()/10)%1000;
      const int I       =  part->PdgCode()%10;
      switch(element){
      case  1: ss << "H"; break;
      case  2: ss << "He"; break;
      case  3: ss << "Li"; break;
      case  4: ss << "Be"; break;
      case  5: ss << "B"; break;
      case  6: ss << "C"; break;
      case  7: ss << "N"; break;
      case  8: ss << "O"; break;
      case  9: ss << "F"; break;
      case 10: ss << "Ne"; break;
      case 11: ss << "Na"; break;
      case 12: ss << "Mg"; break;
      case 13: ss << "Al"; break;
      case 14: ss << "Si"; break;
      case 15: ss << "P"; break;
      case 16: ss << "S"; break;
      case 17: ss << "Cl"; break;
      case 18: ss << "Ar"; break;
      case 19: ss << "K"; break;
      case 20: ss << "Ca"; break;
      case 21: ss << "Sc"; break;
      case 22: ss << "Ti"; break;
      case 23: ss << "V"; break;
      case 24: ss << "Cr"; break;
      case 25: ss << "Mn"; break;
      case 26: ss << "Fe"; break;
      case 27: ss << "Co"; break;
      case 49: ss << "In"; break;
      case 50: ss << "Sn"; break;
      case 51: ss << "Sb"; break;
      case 52: ss << "Te"; break;
      case 53: ss << "I"; break;
      case 54: ss << "Xe"; break;
      case 55: ss << "Cs"; break;
      case 56: ss << "Ba"; break;
      case 57: ss << "La"; break;
      default: ss << element << "-";
      }

      ss << A;

      // Excited nuclear state.  If it became useful, we could distinguish
      // between several different ones.
      if(I != 0) ss << "*";

      const char* Lambda  = "\u039b";
      for(int i = 0; i < strange; i++) ss << Lambda;
    }
    else{
      // Anti-nuclei will land here, among perhaps some other obscure particles
      ss << part->PdgCode();
    }

    // Print the kinetic energy, and the process that created this particle
    const double ke = part->E()-part->Mass();
    char Estr[1024];
    if(ke > 1)
      sprintf(Estr, "%.3lf GeV", ke);
    else if(ke > 1e-3)
      sprintf(Estr, "%.3lf MeV", 1e3*ke);
    else
      sprintf(Estr, "%.3lf keV", 1e6*ke);

    ss << "\t(" << Estr << ")\t[" << part->Process() << "]";
    if(showVtxs){
      ss << " at (" << part->Vx() << ", " << part->Vy() << ", " << part->Vz() << "; " << part->T() << ") ";
    }
    if(showDirs){
      double ptot=part->P();
      if (showVtxs) ss<<",";
      if (ptot>1e-6) {
         ss << " p-hat (" << part->Px()/ptot << ", " << part->Py()/ptot << ", " << part->Pz()/ptot << ") ";
      } else {
         ss << " p=0 ";
      }
    }
    ss << "\t" << part->TrackId() << std::endl;

    // Reached depth limit, shouldn't print daughters
    if(depth >= depthLimit && depthLimit > 0) return; 
    // Unicode "light" box drawing characters
    const char* kHoriz  = "\u2500";
    const char* kVert   = "\u2502";
    const char* kCorner = "\u2514";
    const char* kTee    = "\u251c";

    // Print our daughters too, indented
    const int N = part->NumberDaughters();
    for(int n = 0; n < N; ++n){
      sim::ParticleNavigator::const_iterator childIt =  pnav.find(part->Daughter(n));
    
      // Should always be there because we created the daughter links ourselves
      // but better safe than sorry...
      if(childIt == pnav.end()) continue;

      if(n == N-1){
        ss << prefix << kCorner << kHoriz << kHoriz;
        PrintParticleAndOffspring(ss, childIt->second,
                                  prefix+"     ", depth+1);
      }
      else{
        ss << prefix << kTee << kHoriz << kHoriz;
        PrintParticleAndOffspring(ss, childIt->second,
                                  prefix+kVert+"  ", depth+1);
      }
    }

  }

std::string evd::SimulationDrawer::ShortInteractionSuffix ( int  iType ) const

private

Definition at line 784 of file SimulationDrawer.cxx.

References simb::kCCCOH, simb::kCCDIS, simb::kCCQE, simb::kCoh, simb::kDIS, simb::kElectronScattering, simb::kInverseBetaDecay, simb::kNCDIS, simb::kNCQE, simb::kQE, simb::kRes, simb::kResCCNuBarNeutronPiMinus, simb::kResCCNuBarProtonPi0, simb::kResCCNuBarProtonPiMinus, simb::kResCCNuNeutronPi0, simb::kResCCNuNeutronPiPlus, simb::kResCCNuProtonPiPlus, simb::kResNCNuBarNeutronPi0, simb::kResNCNuBarNeutronPiMinus, simb::kResNCNuBarProtonPi0, simb::kResNCNuBarProtonPiPlus, simb::kResNCNuNeutronPi0, simb::kResNCNuNeutronPiMinus, simb::kResNCNuProtonPi0, and simb::kResNCNuProtonPiPlus.

Referenced by MCTruthShortText().

  {
    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 "";
    }
  }

Member Data Documentation

std::map<int,bool> evd::SimulationDrawer::fHighlite

private

Definition at line 104 of file SimulationDrawer.h.

Referenced by FLSHit2D(), FLSHit3D(), and HiLite().

---

The documentation for this class was generated from the following files:

• /cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-12-03/EventDisplay/SimulationDrawer.h
• /cvmfs/nova-development.opensciencegrid.org/novasoft/releases/N20-12-03/EventDisplay/SimulationDrawer.cxx