MCTrueView.cxx

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////
/// \file    MCTrueView.cxx
/// \brief   A window that gives full list of MC particles, allowing user to
///          turn hits on and off in other views.
/// \author  jpaley@anl.gov
/// \version $Id: MCTrueView.cxx,v 1.5 2012-08-14 19:32:16 ricken Exp $
///////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <map>
#include <string>

#include "TCanvas.h"
#include "TDatabasePDG.h"
#include "TGButton.h"
#include "TGClient.h"
#include "TGFrame.h"
#include "TGLabel.h"
#include "TGLayout.h"
#include "TGWindow.h"
#include "TGScrollBar.h"
#include "TGTextBuffer.h"
#include "TGTextView.h"
#include "TParticle.h"
#include "TParticlePDG.h"
#include "TQObject.h"
#include "RQ_OBJECT.h"

#include "EventDisplay/MCBriefPad.h"
#include "EventDisplay/MCTrueView.h"
#include "EventDisplay/SimulationDrawer.h"
#include "EventDisplay/Style.h"
#include "EventDisplay/RawDataDrawer.h"
#include "EventDisplay/RecoBaseDrawer.h"
#include "Simulation/FLSHit.h"
#include "Simulation/FLSHitList.h"
#include "Simulation/Particle.h"
#include "Simulation/ParticleNavigator.h"
#include "nusimdata/SimulationBase/MCTruth.h"
#include "Utilities/NTree.h"
#include "MCCheater/BackTracker.h"

#include "art/Framework/Services/Registry/ServiceHandle.h"

namespace evd
{

  static std::vector<sim::Particle> gsPartList;
  static std::map<int,int> gsCharge;
  static std::map<int,int> gsNFLSHit;
  static std::map<int,bool> gsHiLite;
  static std::map<int,float> gsPartMom;
  static std::map<int,float> gsPartEDep;
  static std::map<int,float> gsPartTime;

  MCTrueView::MCTrueView(TGMainFrame* mf) : 
    evdb::ObjListCanvas(mf),
    fFirstParticle(0),
    //fCurrEvent(-1),
    fBigFrame(new TGHorizontalFrame(mf, 40, 20)),
    fL1(kLHintsLeft|kLHintsTop|kLHintsExpandX, 2, 2, 2, 2),
    fL2(kLHintsLeft, 4, 4, 4, 4),
    fL3(kLHintsRight, 4, 4, 4, 4),
    fL4(kLHintsLeft|kLHintsExpandY, 4, 4, 4, 4),
    fL5(kLHintsLeft|kLHintsExpandY|kLHintsExpandX, 0, 0, 2, 2),
    fScrollBar(new TGVScrollBar(fBigFrame, 80, 5)),
    fShowFrame(new TGHorizontalFrame(mf, 20, 20)),
    fShowPositive(new TGCheckButton(fShowFrame, "Positives")),
    fShowNegative(new TGCheckButton(fShowFrame, "Negatives")),
    fShowNeutral(new TGCheckButton(fShowFrame, "Neutrals")),
    fSim(0), fRaw(0), fReco(0)
  {
    fSim = new SimulationDrawer();
    fRaw = new RawDataDrawer();
    fReco = new RecoBaseDrawer();

    const char* gsPanelTitle[kNPanel] = {
      "Particle", 
      "Mother",
      "Track Id",
      "Momentum (GeV/c)",
      "Vertex (cm)", 
      "# of hits",
      "Time of 1st Hit",
      "Energy Deposited"
    };
  
    const char* gsFuncName[kNPanel] = {
      "SortParticle()",
      "SortMother()",
      "SortTrackId()",
      "SortMomentum()",
      "SortVtxZ()",
      "SortNHit()",
      "SortTime()",
      "SortEDep()"
    };


    fShowNegative->Connect("Clicked()", "evd::MCTrueView", 
                           this, "UpdateAndDraw()");
    fShowNeutral->Connect("Clicked()", "evd::MCTrueView", 
                          this, "UpdateAndDraw()");
    fShowPositive->Connect("Clicked()", "evd::MCTrueView", 
                           this, "UpdateAndDraw()");

    fShowPositive->SetState(kButtonDown);
    fShowNegative->SetState(kButtonDown);
    fShowNeutral->SetState(kButtonDown);

    fScrollBar->Connect("ProcessedEvent(Event_t*)", "evd::MCTrueView", this,
                        "HandleMouseWheel(Event_t*)");

    for (int i = 0; i < kNPanel; ++i) {
      fPartFrame[i] = new TGVerticalFrame(fBigFrame, 20, 20);
      fColumnLabel[i] = new TGTextButton(fPartFrame[i], gsPanelTitle[i]);
      fPartFrame[i]->AddFrame(fColumnLabel[i], &fL1);
      fColumnLabel[i]->Connect("Clicked()", "evd::MCTrueView", 
                               this, gsFuncName[i]);
    }

    // Build the show by particle type frame
    fShowFrame->AddFrame(fShowNegative, &fL2);
    fShowFrame->AddFrame(fShowNeutral, &fL2);
    fShowFrame->AddFrame(fShowPositive, &fL2);

    // Layout the main frame
    mf->AddFrame(fShowFrame, &fL1);
    mf->AddFrame(fBigFrame, &fL4);

    fBigFrame->AddFrame(fScrollBar, &fL4);
    fScrollBar->SetPosition(0);
    for (int i = 0; i < kNPanel; ++i)
      fBigFrame->AddFrame(fPartFrame[i], &fL4);

    // Add dummy check button frames
    for (int i=0; i<kNPart; ++i) {
      fDrawCheck[i] = new TGCheckButton(fPartFrame[0], "");
      fDrawCheck[i]->Resize(120,8);
      fDrawCheck[i]->Connect("Clicked()","evd::MCTrueView",this, "HiLite()");
      fPartFrame[0]->AddFrame(fDrawCheck[i], &fL5);

      for (int j=1; j<kNPanel; ++j) {
        fPartLabel[j][i] = new TGLabel(fPartFrame[j], "");
        fPartLabel[j][i]->Resize(30,8);
        fPartFrame[j]->AddFrame(fPartLabel[j][i], &fL5);
      }
    }

    Draw();
  }

  //......................................................................

  MCTrueView::~MCTrueView() 
  {

  }
    
  //......................................................................
  void MCTrueView::LoadEvent()
  {
    fPartList.clear();
    gsPartList.clear();
    gsNFLSHit.clear();
    gsHiLite.clear();
    gsPartMom.clear();
    gsPartEDep.clear();
    gsPartTime.clear();

    fFirstParticle = 0;

    //   const art::Event evt;
    //   std::vector< std::vector< const simb::MCTruth*> > fMCTruth;
    //   fSim->GetMCTruth(evt,fMCTruth);

    std::vector< std::vector< const sim::FLSHitList*> > fHitList;
    //   fSim->GetFLSHits(evt,fHitList);    

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

    // loop thru the simulated particles
    for (sim::ParticleNavigator::const_iterator i = pnav.begin(); i != pnav.end(); ++i) {
      const sim::Particle* p = (*i).second;
      int ipdg = p->PdgCode();

      int q = 0;
      float mom = 0.;
      TParticlePDG* pdg = TDatabasePDG::Instance()->GetParticle(ipdg);
      if (pdg) {
        q = (int)pdg->Charge();
        mom = sqrt(p->E()*p->E()-pdg->Mass()*pdg->Mass());
      }
      
      gsCharge[p->TrackId()] = q;
      gsPartList.push_back(*p);
      fPartList.push_back(p->TrackId());
      gsNFLSHit[p->TrackId()] = 0;
      gsPartMom[p->TrackId()] = mom;
      gsPartEDep[p->TrackId()] = 0.;
      gsPartTime[p->TrackId()] = 9.e9;
      
    }
    
    // now count number of FLS hits per track
    for (unsigned int iv=0; iv<fHitList.size(); ++iv) {
      for (unsigned int i=0; i<fHitList[iv].size(); ++i) {
        for (unsigned int j=0; j<fHitList[iv][i]->fHits.size(); ++j) {
          const sim::FLSHit& hit = fHitList[iv][i]->fHits[j];
          for (unsigned int ii=0; ii<gsPartList.size(); ++ii) {
            if (hit.GetTrackID() == gsPartList[ii].TrackId()) {
              int id = gsPartList[ii].TrackId();
              gsNFLSHit[id]++;
              gsPartEDep[id] += hit.GetEdep();
              if (hit.GetEntryT() < gsPartTime[id]) gsPartTime[id] = hit.GetEntryT();
              break;
            }
          }
        }
      }
    }
    //   fCurrEvent = evt.id().event();

    //sim::ParticleTree pt = util::EDMUtils::GetParticleTree(evt);

    //pt.Print();
  
  }
  
  //......................................................................

  void MCTrueView::Update()
  {
    fPartList.clear();
  
    for (unsigned int i=0; i<gsPartList.size(); ++i) {
      sim::Particle p = gsPartList[i];
    
      // check charge information
      int q = gsCharge[p.TrackId()];
      if ( (fShowNegative->GetState() == kButtonUp && q<0) ||
           (fShowPositive->GetState() == kButtonUp && q>0) ||
           (fShowNeutral->GetState()  == kButtonUp && q==0) ) {
        continue;
      }

      fPartList.push_back(p.TrackId());
    }
    
    fScrollBar->SetRange(gsPartList.size(),kNPart);
    fScrollBar->SetPosition(0);

  }

  //......................................................................

  void MCTrueView::UpdateAndDraw() 
  {
    Update();
    Draw();
  }

  //......................................................................

  void MCTrueView::Draw(const char* /*opt*/) 
  {
    //   const art::Event evt;
    //   if (evt.id().event() != fCurrEvent) {
    //     LoadEvent(); 
    //     Update();
    //   }

    evd::Style style;

    int npart = gsPartList.size();

    char buff[256];

    int imin = fFirstParticle;
    int imax = kNPart;

    if (imin < 0) imin = 0;
    if (imin+kNPart > npart)
      imax = npart;
  
    for (int i=0; i<imax; ++i) {
      sim::Particle& p = gsPartList[imin+i];

      // look to see if this particle is in list of good tracks
      if (find(fPartList.begin(),fPartList.end(),p.TrackId()) == 
          fPartList.end()) continue;

      fCheckMap[i] = &p;

      sprintf(buff,"%d: %s",imin+i, Style::LatexName(p.PdgCode()));
      fDrawCheck[i]->SetText(buff);
      if (gsHiLite[p.TrackId()])
        fDrawCheck[i]->SetState(kButtonDown);
      else
        fDrawCheck[i]->SetState(kButtonUp);

      sprintf(buff,"%d",p.Mother());
      fPartLabel[kMother][i]->SetText(buff);
    
      sprintf(buff,"%d",p.TrackId());
      fPartLabel[kTrackId][i]->SetText(buff);
    
      sprintf(buff,"%6.4f",p.P());
      fPartLabel[kMomentum][i]->SetText(buff);
    
      sprintf(buff,"%6.4f",p.Vz());
      fPartLabel[kVtxZ][i]->SetText(buff);

      sprintf(buff,"%d",gsNFLSHit[p.TrackId()]);
      fPartLabel[kNHit][i]->SetText(buff);

      sprintf(buff,"%6.4g",gsPartTime[p.TrackId()]);
      fPartLabel[kTime][i]->SetText(buff);

      sprintf(buff,"%6.4f",gsPartEDep[p.TrackId()]);
      fPartLabel[kEDep][i]->SetText(buff);

      unsigned int icolor = style.ColorFromPDG(p.PdgCode());

      fDrawCheck[i]->ChangeBackground(icolor);
      fDrawCheck[i]->SetTextColor(0xFFFFFF);
      for (int j=1; j<kNPanel; ++j) {
        fPartLabel[j][i]->ChangeBackground(icolor);
        fPartLabel[j][i]->SetTextColor(0xFFFFFF);
      }
    }

    for (int i=imax; i<kNPart; ++i) {
      fDrawCheck[i]->SetText("");
      fDrawCheck[i]->ChangeBackground(0xFFFFFF);
      for (int j=1; j<kNPanel; ++j) {
        fPartLabel[j][i]->SetText("");
        fPartLabel[j][i]->ChangeBackground(0xFFFFFF);
      }
    }

  }

  //......................................................................

  void MCTrueView::SortParticle()
  {
    static bool fwd = true;
    if (fwd) {
      sort(gsPartList.begin(), gsPartList.end(), CompParticle);
      fwd = false;
    }
    else {
      sort(gsPartList.rbegin(), gsPartList.rend(), CompParticle);
      fwd = true;
    }
  
    Draw();

  }

  //......................................................................

  bool MCTrueView::CompParticle(const sim::Particle& a, const sim::Particle& b)
  {
    return (a.PdgCode() < b.PdgCode());
  }

  //......................................................................

  void MCTrueView::SortMother()
  {
    static bool fwd = true;
    if (fwd) {
      sort(gsPartList.begin(), gsPartList.end(), CompMother);
      fwd = false;
    }
    else {
      sort(gsPartList.rbegin(), gsPartList.rend(), CompMother);
      fwd = true;
    }
  
    Draw();

  }

  //......................................................................

  bool MCTrueView::CompMother(const sim::Particle& a, const sim::Particle& b)
  {
    return (a.Mother() < b.Mother());
  }

  //......................................................................

  void MCTrueView::SortMomentum()
  {
    static bool fwd = true;
    if (fwd) {
      sort(gsPartList.begin(), gsPartList.end(), CompMomentum);
      fwd = false;
    }
    else {
      sort(gsPartList.rbegin(), gsPartList.rend(), CompMomentum);
      fwd = true;
    }  
    Draw();
  }

  //......................................................................

  bool MCTrueView::CompMomentum(const sim::Particle& a, const sim::Particle& b)
  {  
    return (gsPartMom[a.TrackId()] < gsPartMom[b.TrackId()]);
  }

  //......................................................................

  void MCTrueView::SortTrackId()
  {
    static bool fwd = true;
    if (fwd) {
      sort(gsPartList.begin(), gsPartList.end(), CompTrackId);
      fwd = false;
    }
    else {
      sort(gsPartList.rbegin(), gsPartList.rend(), CompTrackId);
      fwd = true;
    }  
    Draw();
  }

  //......................................................................

  bool MCTrueView::CompTrackId(const sim::Particle& a, const sim::Particle& b)
  {  
    return (a.TrackId() < b.TrackId());
  }

  //......................................................................

  void MCTrueView::SortVtxZ()
  {
    static bool fwd = true;
    if (fwd) {
      sort(gsPartList.begin(), gsPartList.end(), CompVtxZ);
      fwd = false;
    }
    else {
      sort(gsPartList.rbegin(), gsPartList.rend(), CompVtxZ);
      fwd = true;
    }
  
    Draw();

  }

  //......................................................................

  bool MCTrueView::CompVtxZ(const sim::Particle& a, const sim::Particle& b)
  {
    return (a.Vz() < b.Vz());
  }

  //......................................................................

  void MCTrueView::SortNHit()
  {
    static bool fwd = true;
    if (fwd) {
      sort(gsPartList.begin(), gsPartList.end(), CompNHit);
      fwd = false;
    }
    else {
      sort(gsPartList.rbegin(), gsPartList.rend(), CompNHit);
      fwd = true;
    }
  
    Draw();

  }

  //......................................................................

  bool MCTrueView::CompNHit(const sim::Particle& a, const sim::Particle& b)
  {
    return (gsNFLSHit[a.TrackId()] < gsNFLSHit[b.TrackId()]);
  }

  //......................................................................

  void MCTrueView::SortTime()
  {
    static bool fwd = true;
    if (fwd) {
      sort(gsPartList.begin(), gsPartList.end(), CompTime);
      fwd = false;
    }
    else {
      sort(gsPartList.rbegin(), gsPartList.rend(), CompTime);
      fwd = true;
    }
  
    Draw();

  }

  //......................................................................

  bool MCTrueView::CompTime(const sim::Particle& a, const sim::Particle& b)
  {
    return (gsPartTime[a.TrackId()] < gsPartTime[b.TrackId()]);
  }

  //......................................................................

  void MCTrueView::SortEDep()
  {
    static bool fwd = true;
    if (fwd) {
      sort(gsPartList.begin(), gsPartList.end(), CompEDep);
      fwd = false;
    }
    else {
      sort(gsPartList.rbegin(), gsPartList.rend(), CompEDep);
      fwd = true;
    }
  
    Draw();

  }

  //......................................................................

  bool MCTrueView::CompEDep(const sim::Particle& a, const sim::Particle& b)
  {
    return (gsPartEDep[a.TrackId()] < gsPartEDep[b.TrackId()]);
  }

  //......................................................................

  void MCTrueView::HandleMouseWheel(Event_t */*event*/)
  {
    if (fFirstParticle != fScrollBar->GetPosition()) {
      fFirstParticle = fScrollBar->GetPosition();
      Draw();
    }
  }

  //......................................................................

  void MCTrueView::HiLite()
  {
    int imin = fFirstParticle;
    int imax = kNPart;
    int npart = gsPartList.size();

    if (imin < 0) imin = 0;
    if (imin+kNPart > npart)
      imax = npart;
  
    for (int i=0; i<imax; ++i) {
      gsHiLite[fCheckMap[i]->TrackId()] = fDrawCheck[i]->IsDown();
      fSim->HiLite(fCheckMap[i]->TrackId(), fDrawCheck[i]->IsDown());
    }
    // now we want to communicate to other windows to update...
    // how best to do this?

    //  evdb::IoModule::Instance()->Reload();

  }

} // end namespace evd
////////////////////////////////////////////////////////////////////////