PlotMan.cxx

Go to the documentation of this file.

#include <algorithm>

#include "TApplication.h"
#include "TCanvas.h"
#include "TError.h"
#include "TGButton.h"
#include "TGClient.h"
#include "TGFrame.h"
#include "TGLabel.h"
#include "TGProgressBar.h"
#include "TGButton.h"
#include "TGTextEntry.h"
#include "TGNumberEntry.h"
#include "TSystem.h"
#include "TFile.h"
#include "TROOT.h"

#include "AtNuEvent/AtmosEvent.h"
#include "HistMan/HistMan.h"
#include "MessageService/MsgService.h"

#include "AtNuUtils/UtilFile.h"

#include "AtNuUtils/CamAna.h"
#include "AtNuUtils/PlotMan.h"

TChain *fChain = new TChain("ntp");

typedef vector<string> VS;

CVSID("$Id: PlotMan.cxx,v 1.4 2009/02/28 21:46:10 gmieg Exp $");

PlotMan::PlotMan(bool interactive)
{
  fSpinning = false;
  fStopSpinning = false;
  fDoFinish = true;
  fChain = new TChain("ntp");
  fRootFilesSuf = ".root";
  fChainBuilt = false;
  fChainCurrent = false;

  fEvent = -1;
  fEntries = 0;
  fReadNEntries = false;
  fUpdateInterval = 0;
  fUpdateFraction = 0;
  fUpdateSleep = 0;

  fProgress = 0;
  cgSleep = 0;
  cgMain = 0;

  if(interactive && gApplication) this->ControlWindow(0,1,1);
}

PlotMan::~PlotMan()
{
}

void PlotMan::AddCamAna(CamAna *camana, bool dohist, bool docanv)
{
  MSG("PlotMan", Msg::kSynopsis) << "Adding CamAna: " << camana->GetName()
                                 << endl;
  fCamAnas.push_back(camana);
  if(dohist) camana->MakeHistos();
  if(docanv) camana->MakeCanvases();

  fEventsRun.push_back(0);
  fEventsPassed.push_back(0);
  fFilterOn.push_back(false);
  fFilterRev.push_back(false);

  if (cgMain) {
    MSG("PlotMan",Msg::kSynopsis) << " CamAna filters" << endl;
    TGCompositeFrame *cgH1 = new TGHorizontalFrame(cgMain);

    TGLabel *cgLabel = new TGLabel(cgH1,
        Form("%d)%s",fCamAnas.size()-1,camana->GetName()));
    cgH1->AddFrame(cgLabel, new TGLayoutHints(kLHintsLeft));

    TGCheckButton *cgCheck = new TGCheckButton(cgH1, "Filt", 2);
    cgCheck->Connect("Pressed()", "PlotMan", this,
      Form("FilterOn(=true, %d)",fCamAnas.size()-1));
    cgCheck->Connect("Released()", "PlotMan", this,
      Form("FilterOn(=false, %d)",fCamAnas.size()-1));
    cgH1->AddFrame(cgCheck, new TGLayoutHints(kLHintsRight));

    MSG("PlotMan",Msg::kSynopsis) << " CamAna filters" << endl;
    cgCheck = new TGCheckButton(cgH1, "Rev", 2);
    cgCheck->Connect("Pressed()", "PlotMan", this,
      Form("FilterRev(=true, %d)",fCamAnas.size()-1));
    cgCheck->Connect("Released()", "PlotMan", this,
      Form("FilterRev(=false, %d)",fCamAnas.size()-1));
    cgH1->AddFrame(cgCheck, new TGLayoutHints(kLHintsRight));

    cgMain->AddFrame(cgH1, new TGLayoutHints(kLHintsExpandX));

    cgMain->Resize();
    cgMain->MapSubwindows();
    cgMain->Layout();
    cgMain->MapWindow();
  }
}

CamAna *PlotMan::GetCamAna(string caname) {
  for (unsigned int i=0;i<fCamAnas.size();i++) {
    if(caname == fCamAnas[i]->GetName()) return fCamAnas[i];
  }
  return 0;
}

CamAna *PlotMan::GetCamAna(unsigned int canum) {
  if(canum<fCamAnas.size()) return fCamAnas[canum];
  return 0;
}

void PlotMan::AllFiltersOn(bool filt) {
  for(unsigned int i=0;i<fFilterOn.size();i++) fFilterOn[i] = filt;
}

void PlotMan::FilterOn(bool filt, string caname) {
  for (unsigned int i=0;i<fCamAnas.size();i++) {
    if (caname == fCamAnas[i]->GetName()) {
      fFilterOn[i] = filt;
      MSG("PlotMan",Msg::kSynopsis) << "Turning the filter for " << caname;
      if(filt) MSG("PlotMan",Msg::kSynopsis) << " on" << endl;
      else MSG("PlotMan",Msg::kSynopsis) << " off" << endl;
    }
  }
}

void PlotMan::FilterOn(bool filt, unsigned int canum) {
  if (canum<fFilterOn.size()) {
    fFilterOn[canum] = filt;
    MSG("PlotMan",Msg::kSynopsis) << "Turning the filter for " << fCamAnas[canum]->GetName();
    if(filt) MSG("PlotMan",Msg::kSynopsis) << " on" << endl;
    else MSG("PlotMan",Msg::kSynopsis) << " off" << endl;
  }
}

void PlotMan::AllFiltersRev(bool filt) {
  for(unsigned int i=0;i<fFilterRev.size();i++) fFilterRev[i] = filt;
}

void PlotMan::FilterRev(bool filt, string caname) {
  for (unsigned int i=0;i<fCamAnas.size();i++) {
    if(caname == fCamAnas[i]->GetName()) {
      fFilterRev[i] = filt;
      MSG("PlotMan",Msg::kSynopsis) << "Reverse the filter for " << caname;
      if(filt) MSG("PlotMan",Msg::kSynopsis) << " on" << endl;
      else MSG("PlotMan",Msg::kSynopsis) << " off" << endl;
    }
  }
}

void PlotMan::FilterRev(bool filt, unsigned int canum) {
  if(canum<fFilterRev.size()) {
    fFilterRev[canum] = filt;
    MSG("PlotMan",Msg::kSynopsis) << "Turning the filter for "
                                  << fCamAnas[canum]->GetName();
    if(filt) MSG("PlotMan",Msg::kSynopsis) << " on" << endl;
    else MSG("PlotMan",Msg::kSynopsis) << " off" << endl;
  }
}

void PlotMan::AddFile(string fname) {
  if (! UtilFile::CheckFile(fname) ) {
    MSG("PlotMan",Msg::kWarning)<< "No such file " << fname << endl;
    return;
  }
  fRootFiles.push_back(fname);
  fChainCurrent = false;
  MSG("PlotMan",Msg::kSynopsis) << "Added file: " << fname << endl;
}

void PlotMan::AddFileChecked(std::string fname) {
  int nentries = 0;
  TFile *tf = TFile::Open(fname.c_str());
  if (!tf) {
    MSG("PlotMan",Msg::kError) << "zero TFile" << endl;
    return;
  }
  if (tf->IsZombie()) {
    MSG("PlotMan",Msg::kError) << "zombie TFile" << endl;
    return;
  }
  TObject *obj = tf->Get("ntp");
  if (!obj) {
    MSG("PlotMan",Msg::kError) << "zero TObject ntp" << endl;
    return;
  }

  //TChain in file
  if (obj->InheritsFrom("TChain")) {
    nentries = (dynamic_cast<TChain*>(obj))->GetEntries();
    fChain->Add(dynamic_cast<TChain*>(obj));
  }
  //TTree in file
  else if (obj->InheritsFrom("TTree")) {
    nentries = (dynamic_cast<TTree*>(obj))->GetEntries();
    //Include the 0 to read header from file and get nentries
    fChain->Add(fname.c_str(),0);
  }
  else {
    MSG("PlotMan",Msg::kError) << "TObject not a TChain or TTree" << endl;
    return;
  }
  MSG("PlotMan",Msg::kSynopsis) << "Added file " << fname << " with "
         << nentries << " entries" << endl;
  tf->Close();
  fEntries += nentries;
  if(fProgress) fProgress->SetRange(0,fEntries);
}

void PlotMan::AddList(string lname)
{
  fRootFiles = UtilFile::FileFileList(lname, fRootFilesSuf,
                                      true, true, fRootFiles);
  fChainCurrent = false;
  MSG("PlotMan",Msg::kSynopsis) << "Added file list: " << lname << " nfiles = "
                                << fRootFiles.size() << endl;
}

void PlotMan::AddDirectory(string dname)
{
  fRootFiles =
    UtilFile::DirFileList(dname,fRootFilesSuf,true,true,fRootFiles);
  fChainCurrent = false;
  MSG("PlotMan",Msg::kSynopsis) << "Added file directory: " << dname << endl;
}

//Build the fChain from the fRootFiles vector
void PlotMan::BuildChain(bool checked) {
  MSG("PlotMan",Msg::kSynopsis) << "Building chain for " << fRootFiles.size()
         << " files";
  if(checked) MSG("PlotMan",Msg::kSynopsis) << " with checking";
  MSG("PlotMan",Msg::kSynopsis) << endl;

  sort(fRootFiles.begin(),fRootFiles.end());
  VS::iterator nend = unique(fRootFiles.begin(),fRootFiles.end());
  if (nend != fRootFiles.end()) {
    MSG("PlotMan",Msg::kWarning) << "Redundant items in the list of root files:"
                                 << endl;

    //This doesn't exactly work, whatever
    for(VS::iterator i=nend;i!=fRootFiles.end();i++)
      MSG("PlotMan",Msg::kWarning)<< "  " << i->c_str() << endl;
  }
  for (VS::iterator i=fRootFiles.begin();i!=nend;i++) {
    if(checked) AddFileChecked(*i);
    else fChain->Add(i->c_str());
    MSG("PlotMan",Msg::kVerbose) << "Added file " << *i << endl;
  }
  if(fReadNEntries) SetEntries(fChain->GetEntries());
  fChainBuilt = true;
  MSG("PlotMan",Msg::kSynopsis) << "Built chain with " << fEntries << " entries"
                                << endl;
}

//Build the fChain from the fRootFiles vector
void PlotMan::ChainReport() {
  MSG("PlotMan",Msg::kSynopsis) << "Chain has NTrees =  " << fChain->GetNtrees() 
                                << endl;
}

void PlotMan::SetBranchStatus(const char* branch, int status) {
  fChain->SetBranchStatus(branch, status);
}

void PlotMan::SpinChain(int nevents) {
  Emit("SpinChain()");
  if (fSpinning)  {
    MSG("PlotMan",Msg::kSynopsis) << "Already Spinning Chain" << endl;
    return;
  }

  if(!fChainBuilt) BuildChain();

  fSpinning = true;
  MSG("PlotMan",Msg::kSynopsis) << "Spinning Chain";
  if(fUpdateInterval>0)
    MSG("PlotMan",Msg::kSynopsis) << " (update interval=" << fUpdateInterval << ")";
  if(fUpdateFraction>0)
    MSG("PlotMan",Msg::kSynopsis) << " (update fraction=" << fUpdateFraction << ")";
  MSG("PlotMan",Msg::kSynopsis) << endl;
  const AtmosEvent* event = 0;
  fChain->SetBranchAddress("evt",&event);

  int ThisTreeNumber = -1;
  int irun = 0;
  int i = fEvent+1;//Start at fEvent+1 to not double count events
  MSG("PlotMan",Msg::kSynopsis) << "\r on entry " << i;
  if(fEntries>0) MSG("PlotMan",Msg::kSynopsis) << " of " << fEntries;
  MSG("PlotMan",Msg::kSynopsis) << flush;
  for (; fChain->GetEntry(i)>0; i++) {
    bool ThisRetStatus = this->FillCamEvent(event);
    if(fProgress) fProgress->Increment(1);

    if(fUpdateInterval>0) if (i%fUpdateInterval == 0) {
      MSG("PlotMan",Msg::kSynopsis) << "\r on entry " << i;
      if(fEntries>0) MSG("PlotMan",Msg::kSynopsis) << " of " << fEntries;
      MSG("PlotMan",Msg::kSynopsis) << flush;
      if (ThisRetStatus) {
        this->UpdateCanvases();
        if(fUpdateSleep>0) gSystem->Sleep(fUpdateSleep);
      }

      if(cgSnarl) cgSnarl->SetNumber(event->Snarl);
      if(cgRun) cgRun->SetNumber(event->Run);
      if(cgSubRun) cgSubRun->SetNumber(event->SubRun);
    }

    if (fUpdateFraction>0 && fEntries>0) {
      double upinter = (double)fEntries / (double)fUpdateFraction;
      int iinter = (int)(i/upinter);
      if (((double)i - iinter*upinter) < 1.) {
        MSG("PlotMan",Msg::kSynopsis) << "\r on entry " << i;
        if(fEntries>0) MSG("PlotMan",Msg::kSynopsis) << " of " << fEntries;
        MSG("PlotMan",Msg::kSynopsis) << flush;
        if (ThisRetStatus) {
          this->UpdateCanvases();
          if(fUpdateSleep>0) gSystem->Sleep(fUpdateSleep);
        }
      }

      if(cgSnarl) cgSnarl->SetNumber(event->Snarl);
      if(cgRun) cgRun->SetNumber(event->Run);
      if(cgSubRun) cgSubRun->SetNumber(event->SubRun);
    }

    if (fChain->GetTreeNumber() != ThisTreeNumber) {
      MSG("PlotMan",Msg::kSynopsis) << "\r on tree " << fChain->GetTreeNumber() + 1
             << " of " << fChain->GetNtrees() << flush;
      ThisTreeNumber = fChain->GetTreeNumber();
    }

    gSystem->ProcessEvents();

    irun++;
    if(nevents>0 && irun>=nevents) break;

    if(fStopSpinning) break;
  }
  MSG("PlotMan",Msg::kSynopsis) << endl;
  MSG("PlotMan",Msg::kSynopsis) << "Ran " << irun << " events in this spin" << endl;
  fEvent = i;

  for (unsigned int i=0;i<fCamAnas.size();i++) {
    MSG("PlotMan",Msg::kSynopsis) << "Ana " << fCamAnas[i]->GetName() << "\t\t"
           << "Passed " << fEventsPassed[i]
           << " of " << fEventsRun[i] << " Events" << endl;
  }

  fSpinning = false;
  fStopSpinning = false;
  if(fDoFinish) this->FinishSpin();
  MSG("PlotMan",Msg::kSynopsis) << "Done Spinning Chain" << endl;
}

void PlotMan::StepEvent(int nevents)
{
  if (fSpinning)  {
    MSG("PlotMan",Msg::kWarning)<< "Can't step while spinning Chain" << endl;
    return;
  }
  if(!fChainBuilt) BuildChain();

  fSpinning = true;
  MSG("PlotMan",Msg::kSynopsis) << "Stepping chain by " << nevents << " events" << endl;
  const AtmosEvent* event = 0;
  fChain->SetBranchAddress("evt",&event);

  int i = fEvent+nevents;

  if(i<0) i = 0;
  if(i>=fEntries) i = fEntries-1;

  if (fChain->GetEntry(i)) {
    this->FillCamEvent(event);
    this->UpdateCanvases();
    if(fProgress) fProgress->Increment(nevents);
    if(cgSnarl) cgSnarl->SetNumber(event->Snarl);
    if(cgRun) cgRun->SetNumber(event->Run);
    if(cgSubRun) cgSubRun->SetNumber(event->SubRun);
  }
  else {
    MSG("PlotMan",Msg::kWarning)<< "Chain could not get entry " << i << endl;
  }

  fEvent = i;
  fSpinning = false;
  fStopSpinning = false;
  MSG("PlotMan",Msg::kInfo) << "Done stepping Chain" << endl;
}

void PlotMan::StepPassEvent(int nevents)
{
  if (fSpinning)  {
    MSG("PlotMan",Msg::kInfo) << "Can't step while spinning Chain" << endl;
    return;
  }
  if(!fChainBuilt) BuildChain();

  fSpinning = true;
  MSG("PlotMan",Msg::kInfo) << "Stepping chain by " << nevents << " events"
                            << endl;
  const AtmosEvent* event = 0;
  fChain->SetBranchAddress("evt",&event);

  int i = fEvent+1;
  if(nevents<0) i = fEvent-1;

  if(i<0) i = 0;
  if(i>=fEntries) i = fEntries-1;

  if(fChain->GetEntry(i) == 0) return;
  int npassed = 0;

  while (nevents > 0 && npassed < nevents) {
    while (!this->FillCamEvent(event)) {
      i++;
      if(fChain->GetEntry(i) == 0) fStopSpinning = true;
      if(fProgress) fProgress->Increment(1);
      gSystem->ProcessEvents();
      if(fStopSpinning) break;
    }
    if(fStopSpinning) break;
    npassed++;
  }

  while (nevents < 0 && npassed < -nevents) {
    while (!this->FillCamEvent(event)) {
      i--;
      if(fChain->GetEntry(i) == 0) fStopSpinning = true;
      if(fProgress) fProgress->Increment(1);
      gSystem->ProcessEvents();
      if(fStopSpinning) break;
    }
    if(fStopSpinning) break;
    npassed++;
  }

  if(cgSnarl && event) cgSnarl->SetNumber(event->Snarl);
  if(cgRun && event) cgRun->SetNumber(event->Run);
  if(cgSubRun && event) cgSubRun->SetNumber(event->SubRun);
  this->UpdateCanvases();

  fEvent = i;
  fSpinning = false;
  fStopSpinning = false;
  MSG("PlotMan",Msg::kInfo) << "Done stepping Chain" << endl;
}

void PlotMan::JumpToEvent(int ievent) {
  if (fSpinning)  {
    MSG("PlotMan",Msg::kInfo) << "Can't step while spinning Chain" << endl;
    return;
  }
  if(!fChainBuilt) BuildChain();

  fSpinning = true;
  MSG("PlotMan",Msg::kInfo) << "Jumping to event " << ievent << endl;
  const AtmosEvent* event = 0;
  fChain->SetBranchAddress("evt", &event);

  int i = ievent;

  if(i<0) i = 0;
  if(i>=fEntries) i = fEntries - 1;

  if (fChain->GetEntry(i) != 0) {
    this->FillCamEvent(event);
    this->UpdateCanvases();
    if(fProgress) fProgress->SetPosition(i);
    if(cgSnarl) cgSnarl->SetNumber(event->Snarl);
    if(cgRun) cgRun->SetNumber(event->Run);
    if(cgSubRun) cgSubRun->SetNumber(event->SubRun);
  }

  fEvent = i;
  fSpinning = false;
  fStopSpinning = false;
  MSG("PlotMan",Msg::kInfo) << "Done stepping Chain" << endl;
}

void PlotMan::ManSnarlJump() {
  if(!cgSnarl) return;
  JumpToSnarl((int)cgSnarl->GetNumber());
}

void PlotMan::ManRunJump() {
  if(!cgRun || !cgSubRun) return;
  JumpToRun((int)cgRun->GetNumber()*100 + (int)cgSubRun->GetNumber());
}

void PlotMan::SetUpdateSleep(int sleep) {
  if(sleep < 0) return;
  fUpdateSleep = sleep;
  MSG("PlotMan",Msg::kSynopsis) << "Setting Update Sleep to " << fUpdateSleep
                                << "ms" << endl;
  if(cgSleep) cgSleep->SetNumber(sleep);
}

void PlotMan::ManUpdateSleep() {
  if(!cgSleep) return;
  fUpdateSleep = (int)cgSleep->GetNumber();
  MSG("PlotMan",Msg::kSynopsis) << "Setting Update Sleep to " << fUpdateSleep
                                << "ms" << endl;
}

void PlotMan::JumpToSnarl(int snarl) {
  if (fSpinning)  {
    MSG("PlotMan",Msg::kInfo) << "Can't jump while spinning Chain" << endl;
    return;
  }
  if(!fChainBuilt) BuildChain();

  int ToSnarl = snarl;

  MSG("PlotMan",Msg::kInfo) << "Jumping to snarl " << ToSnarl << endl;
  fSpinning = true;
  const AtmosEvent* event = 0;
  fChain->SetBranchAddress("evt", &event);

  int i = fEvent+1;

  if(i<0) i = 0;
  //if(i>=fEntries) i = fEntries-1;

  MSG("PlotMan",Msg::kSynopsis) << " Starting at i = " << i << endl;
  MSG("PlotMan",Msg::kSynopsis) << " Chain has nentries = "
                                << fChain->GetEntries() << endl;
  for (; fChain->GetEntry(i)>0; i++) {
    if(event->Snarl >= ToSnarl) break;
    gSystem->ProcessEvents();
    if(fStopSpinning) break;
  }
  MSG("PlotMan",Msg::kSynopsis) << " Ending at i = " << i << endl;

  FillCamEvent(event);
  UpdateCanvases();
  if(fProgress) fProgress->SetPosition(i);
  if(cgSnarl) cgSnarl->SetNumber(event->Snarl);

  fEvent = i;
  fSpinning = false;
  fStopSpinning = false;
  MSG("PlotMan",Msg::kInfo) << "Done jumping through chain" << endl;
}

void PlotMan::JumpToRun(int run) {
  if (fSpinning)  {
    MSG("PlotMan",Msg::kInfo) << "Can't jump while spinning Chain" << endl;
    return;
  }
  if(!fChainBuilt) BuildChain();

  int ToRun = run;

  MSG("PlotMan",Msg::kInfo) << "Jumping to run " << ToRun << endl;
  fSpinning = true;
  const AtmosEvent* event = 0;
  fChain->SetBranchAddress("evt", &event);

  int i = fEvent+1;

  if(i<0) i = 0;
  //if(i>=fEntries) i = fEntries-1;

  MSG("PlotMan",Msg::kSynopsis) << " Starting at i = " << i << endl;
  MSG("PlotMan",Msg::kSynopsis) << " Chain has nentries = "
                                << fChain->GetEntries() << endl;
  for (; fChain->GetEntry(i)>0; i++) {
    if(((event->Run*100)+event->SubRun) >= ToRun) break;
    gSystem->ProcessEvents();
    if(fStopSpinning) break;
  }
  MSG("PlotMan",Msg::kSynopsis) << " Ending at i = " << i << endl;

  FillCamEvent(event);
  UpdateCanvases();
  if(fProgress) fProgress->SetPosition(i);
  if(cgRun) cgRun->SetNumber(event->Run);
  if(cgSubRun) cgSubRun->SetNumber(event->SubRun);

  fEvent = i;
  fSpinning = false;
  fStopSpinning = false;
  MSG("PlotMan",Msg::kInfo) << "Done jumping through chain" << endl;
}

bool PlotMan::FillCamEvent(const AtmosEvent* event) {
  if (!event) {
    MSG("PlotMan",Msg::kWarning) << "FillCamEvent has empty AtmosEvent" << endl;
    return false;
  }

  bool RetStatus = true;
  bool FillStatus = true;
  for (unsigned int i=0;i<fCamAnas.size();i++) {
    RetStatus = false;
    fEventsRun[i]++;
    FillStatus = fCamAnas[i]->FillEvent(event);
    if(!(FillStatus^fFilterRev[i]) && fFilterOn[i]) break;
    fEventsPassed[i]++;
    RetStatus = true;
  }
  return RetStatus;
}

void PlotMan::FinishSpin()
{
  for(unsigned int i=0;i<fCamAnas.size();i++) fCamAnas[i]->Finish();
}

void PlotMan::UpdateCanvases(TFolder *tfol)
{
  if(gROOT->IsBatch()) return;
  //For empty parameter, start at the top
  TFolder *tf = tfol;
  if (!tf) {
    HistMan hm("");
    tf = &(hm.BaseFolder());
  }

  TCollection *flist = tf->GetListOfFolders();
  TIter itr(flist->MakeIterator());
  TObject *fobj = 0;
  while ( (fobj=itr()) ) {
    if (fobj->InheritsFrom("TFolder")) {
      this->UpdateCanvases(dynamic_cast<TFolder*>(fobj));
      continue;
    }
    if (fobj->InheritsFrom("TCanvas")) {
      TCanvas *tc = dynamic_cast<TCanvas*>(fobj);
      tc->Modified();
      TList *tl = tc->GetListOfPrimitives();
      for (int j=0;j<tl->GetSize();j++) {
        if(! tl->At(j)->InheritsFrom("TPad")) continue;
        TPad *tp = dynamic_cast<TPad*>(tl->At(j));
        tp->Modified();
      }
      tc->Update();
    }
  }

  /*
  for (unsigned int i=0;i<fCanvases.size();i++) {
    fCanvases[i]->Modified();
    TList *tl = fCanvases[i]->GetListOfPrimitives();
    for (int j=0;j<tl->GetSize();j++) {
      if(! tl->At(j)->InheritsFrom("TPad")) continue;
      TPad *thispad = dynamic_cast<TPad*>(tl->At(j));
      thispad->Modified();
    }
    fCanvases[i]->Update();
  }
  */
  return;
}

/*
void PlotMan::PrintCanvases(string fn) {
  if (fCanvases.size() == 0) return;
  fCanvases[0]->Print((fn+"[").c_str());
  for (unsigned int i=0;i<fCanvases.size();i++) {
    fCanvases[i]->Print(fn.c_str());
  }
  fCanvases[0]->Print((fn+"]").c_str());
  return;
}
*/

void PlotMan::WriteOut(string fn)
{
  HistMan hm("");
  hm.WriteOut(fn.c_str());
}

void PlotMan::SetEntries(int entries)
{
  fEntries = entries;
  if(fProgress) fProgress->SetRange(0,fEntries);
}

void PlotMan::Reset()
{
  if (fSpinning)  {
    MSG("PlotMan",Msg::kInfo) << "Can't reset while spinning Chain" << endl;
    return;
  }

  fChain->Reset();
  fEntries = 0;

  MSG("PlotMan",Msg::kInfo) << "Resetting PlotMan" << endl;
  fEvent=0;
  if(fProgress) fProgress->Reset();
  for(unsigned int i=0;i<fCamAnas.size();i++) fCamAnas[i]->Reset();
}

void PlotMan::SetLoud(int loud, string lstream)
{
  if(loud<=0) gErrorIgnoreLevel = kFatal;
  MsgStream *s = MsgService::Instance()->GetStream(lstream.c_str());

  if(loud>= 4) s->SetLogLevel(Msg::kVerbose);
  if(loud== 3) s->SetLogLevel(Msg::kDebug);
  if(loud== 2) s->SetLogLevel(Msg::kSynopsis);
  if(loud== 1) s->SetLogLevel(Msg::kInfo);
  if(loud== 0) s->SetLogLevel(Msg::kWarning);
  if(loud==-1) s->SetLogLevel(Msg::kError);
  if(loud<=-2) s->SetLogLevel(Msg::kFatal);
}

int PlotMan::GetLoud(string lstream)
{
  MsgStream *s = MsgService::Instance()->GetStream(lstream.c_str());

  Msg::LogLevel_t loglevel = s->GetLogLevel();
  if(loglevel==Msg::kVerbose) return 4;;
  if(loglevel==Msg::kDebug) return 3;
  if(loglevel==Msg::kSynopsis) return 2;
  if(loglevel==Msg::kInfo) return 1;
  if(loglevel==Msg::kWarning) return 0;
  if(loglevel==Msg::kError) return -1;
  if(loglevel==Msg::kFatal) return -2;
  return 0;
}

void PlotMan::ControlWindow(const TGWindow *p, UInt_t w, UInt_t h)
{
  TGLayoutHints *cgLayout =
    new TGLayoutHints(kLHintsExpandX | kLHintsExpandY);

  TGCompositeFrame *cgH1 = 0;
  TGLabel *cgLabel = 0;

  cgMain = new TGMainFrame(p, w, h);
  cgMain->SetCleanup(kDeepCleanup);
  cgMain->Connect("CloseWindow()","PlotMan",this,"CloseWindow()");

  TGTextButton *cgStart = new TGTextButton(cgMain, "Start", 1);
  cgStart->Connect("Clicked()","PlotMan",this,"SpinChain()");
  cgMain->AddFrame(cgStart, cgLayout);

  TGTextButton *cgStop = new TGTextButton(cgMain, "&Stop", 2);
  cgStop->Connect("Clicked()","PlotMan",this,"StopSpinning()");
  cgMain->AddFrame(cgStop, cgLayout);

  cgH1 = new TGHorizontalFrame(cgMain);

  cgLabel = new TGLabel(cgH1,"Sleep(ms):");
  cgH1->AddFrame(cgLabel, new TGLayoutHints(kLHintsLeft | kLHintsExpandY));

  cgSleep = new TGNumberEntry(cgH1, 0, 5, -1);
  cgSleep->Connect("ValueSet(Long_t)", "PlotMan", this, "ManUpdateSleep()");
  cgH1->AddFrame(cgSleep, cgLayout);

  cgMain->AddFrame(cgH1, cgLayout);

  TGTextButton *cgNextPass = new TGTextButton(cgMain, "&NextPass", 3);
  cgNextPass->Connect("Clicked()","PlotMan",this,"StepPassEvent(=1)");
  cgMain->AddFrame(cgNextPass, cgLayout);

  TGTextButton *cgPrevPass = new TGTextButton(cgMain, "&PrevPass", 3);
  cgPrevPass->Connect("Clicked()","PlotMan",this,"StepPassEvent(=-1)");
  cgMain->AddFrame(cgPrevPass, cgLayout);

  TGTextButton *cgNext = new TGTextButton(cgMain, "&Next", 3);
  cgNext->Connect("Clicked()","PlotMan",this,"Next()");
  cgMain->AddFrame(cgNext, cgLayout);

  TGTextButton *cgPrev = new TGTextButton(cgMain, "&Prev", 4);
  cgPrev->Connect("Clicked()","PlotMan",this,"Prev()");
  cgMain->AddFrame(cgPrev, cgLayout);

  //Run Number Entry
  cgH1 = new TGHorizontalFrame(cgMain);
  cgLabel = new TGLabel(cgH1, "Run:");
  cgH1->AddFrame(cgLabel, new TGLayoutHints(kLHintsLeft | kLHintsExpandY));
  cgRun = new TGNumberEntry(cgH1, 0, 5, -1);
  cgRun->Connect("ValueSet(Long_t)", "PlotMan", this, "ManRunJump()");
  cgH1->AddFrame(cgRun, cgLayout);
  cgMain->AddFrame(cgH1, cgLayout);

  //SubRun Number Entry
  cgH1 = new TGHorizontalFrame(cgMain);
  cgLabel = new TGLabel(cgH1, "SubRun:");
  cgH1->AddFrame(cgLabel, new TGLayoutHints(kLHintsLeft | kLHintsExpandY));
  cgSubRun = new TGNumberEntry(cgH1, 0, 5, -1);
  cgSubRun->Connect("ValueSet(Long_t)", "PlotMan", this, "ManRunJump()");
  cgH1->AddFrame(cgSubRun, cgLayout);
  cgMain->AddFrame(cgH1, cgLayout);

  //Snarl Number Entry
  cgH1 = new TGHorizontalFrame(cgMain);
  cgLabel = new TGLabel(cgH1, "Snarl:");
  cgH1->AddFrame(cgLabel, new TGLayoutHints(kLHintsLeft | kLHintsExpandY));
  cgSnarl = new TGNumberEntry(cgH1, 0, 5, -1);
  cgSnarl->Connect("ValueSet(Long_t)", "PlotMan", this, "ManSnarlJump()");
  cgH1->AddFrame(cgSnarl, cgLayout);
  cgMain->AddFrame(cgH1, cgLayout);

  TGTextButton *tgReDraw = new TGTextButton(cgMain, "&ReDraw", 4);
  tgReDraw->Connect("Clicked()","PlotMan",this,"ReDraw()");
  cgMain->AddFrame(tgReDraw, cgLayout);

  TGTextButton *cgReset = new TGTextButton(cgMain, "&Reset", 5);
  cgReset->Connect("Clicked()","PlotMan",this,"Reset()");
  cgMain->AddFrame(cgReset, cgLayout);

  TGTextButton *cgQuit = new TGTextButton(cgMain, "&Quit", 6);
  cgQuit->Connect("Clicked()","PlotMan",this,"CloseWindow()" );
  cgMain->AddFrame(cgQuit, cgLayout);

  fProgress = new TGHProgressBar(cgMain,100);
  fProgress->SetBarColor("lightgreen");
  fProgress->ShowPosition();
  cgMain->AddFrame(fProgress, cgLayout);

  cgMain->MapSubwindows();
  cgMain->Resize();

  cgMain->Layout();

  cgMain->SetWindowName("Ntp Control Window");
  cgMain->SetIconName("Ntp Control Window");

  cgMain->MapWindow();
}

void PlotMan::CloseWindow() {
  if (fSpinning)  {
    MSG("PlotMan",Msg::kInfo) << "Can't close window while spinning Chain" << endl;
    return;
  }
  if(gApplication) gApplication->Terminate();
}

---