tschum/FWlite_Analysis/PlotTool.cc

#include "PlotTool.h"
//------------------------------------------------------------------
//Constructur: Set some global Variables to define canvas output
PlotTool::PlotTool() {

        this->SetClass("TChain", 100);

        samePad_trees = true;
        samePad_vars = false;
        samePad_cuts = false;
        sameCanv_trees = false;
        sameCanv_vars = false;
        sameCanv_cuts = false;

        showLegend = false;
        logY = true;
        verbose = true;

        globalCuts="";

        varBlockNames = "";   //Set to "ALL" or add Names, i.e. varBlockNames += "CaloTower"
        recreateTree = false; //force recreation of friend tree

        normHists = false; //scale all histos intergrals to 1

}

//------------------------------------------------------------------
//Fill object PlotTool with Chains constructed from files from given source 

int PlotTool::init(string fileName, string dirPath, string treeName,
                   string fileLabel) {
  this->New(this->GetEntries() );
  int currChain = this->GetEntries() - 1;

  if (currChain < 0)
    return currChain;

  TStopwatch timer;
  timer.Start();


  fileNames.clear();

  //check if alternative label is different from default(searchString)
  if (fileLabel=="") {
    fileLabel=fileName;
  }
  ((TChain*) this->At(currChain))->SetName(fileLabel.c_str());

  TList *files = new TList();
  TSystemFile* sysFile = 0;
  if(fileName.find(".") != string::npos) {
    ifstream f(fileName.c_str());
    if( ! f.is_open() ) return -1;
    string line;

    while (!f.eof()) {
      getline(f,line);
      sysFile = new TSystemFile(line.c_str(),dirPath.c_str());
      files->Add(sysFile);
    }


  } else {
    TSystemDirectory dir("sourceDir", dirPath.c_str());
    files = dir.GetListOfFiles();
  }
  if (files->GetEntries()>0) {
    TIter next(files);
    TSystemFile *file;
    TString fname;
    string filePath;

    if(verbose && fileName.find(".") == string::npos )  cout<<"Open"<<dirPath.c_str()<<" Search for .root files that contain: "
                                                            <<fileName.c_str()<<endl;
    if(verbose && fileName.find(".") != string::npos )  cout<<"Open"<<dirPath.c_str()<<" Search lines with .root in: "
                                                            <<fileName.c_str()<<endl;


    while ((file=(TSystemFile*)next())) {
      fname = file->GetName();
      if (!fname.EndsWith(".root"))
        continue;
      if (!fname.Contains(fileName.c_str()) && fileName.find(".") == string::npos )
        continue;

      filePath = dirPath;
      filePath += fname.Data();
      //fwlite::ChainEvent to lop over events, jets, etc
      fileNames.push_back(filePath.c_str());

      if (((TChain*) this->At(currChain))->AddFile(filePath.c_str(), -1,
                                                   treeName.c_str()) ) {
        if(verbose)     cout<<"Chained "<<((TChain*) this->At(currChain))->GetNtrees()<<" file(s) with "<<((TChain*) this->At(currChain))->GetEntries()<<" events."<<endl;
      } else {
        return -1;
      }

    }
  } else
    return -1;

  for (int i=0; i<((TChain*) this->At(currChain))->GetListOfBranches()->GetEntries(); ++i) {

    string s(((TChain*) this->At(currChain))->GetListOfBranches()->At(i)->GetName());

    string branch_alias = s;
    string branch_name = s;
    if (s.find(".", s.size()-1) != string::npos)
      branch_name += "obj";

    size_t a = s.find("_");
    if (a != string::npos) {
      size_t b = s.find("_", a+1);
      if (b != string::npos) {
        size_t c = s.find("_", b+1);
        if (c != string::npos) {
          string _prod     =s.substr(0,a);
          string _label    =s.substr(a+1, b-a-1);
          string _instance =s.substr(b+1, c-b-1);
          branch_alias = _label;
          if(_instance.length() > 0 )  {
            branch_alias += "_";
            branch_alias += _instance;
            ((TChain*) this->At(currChain))->SetAlias(_instance.c_str(),
                                                      branch_name.c_str());
          }
          string branch_alias_full = _prod + "_" + branch_alias;
          ((TChain*) this->At(currChain))->SetAlias(branch_alias_full.c_str(),
                                                    branch_name.c_str());
        }
      }
    }

    ((TChain*) this->At(currChain))->SetAlias(branch_alias.c_str(),
                                              branch_name.c_str());

  }


  string friendTreeName("friendTree");

  string friendFileName("/scratch/hh/current/cms/user/");
  friendFileName += gSystem->GetUserInfo()->fUser;
  friendFileName += "/temp/";
  friendFileName += fileLabel;
  friendFileName += ".root";
  string fileOpt = "update";
  if( recreateTree )    fileOpt = "recreate";

  FWliteVariables fwVars(friendTreeName, friendFileName, fileOpt);

  if(varBlockNames.length() > 1 ) {
    fwVars.loop(fileNames, varBlockNames);
    if(verbose)   cout<<"add friend tree with additional variables: "<<varBlockNames<<endl;
    ((TChain*) this->At(currChain))->AddFriend(friendTreeName.c_str(),
                                               friendFileName.c_str());
  } else {
    if(verbose)   cout<<"No additional variables added."<<endl;
  }

  
  timer.Stop();
  if(verbose) timer.Print();
       
  return this->GetEntries();

}
//------------------------------------------------------------------
//Draw given Chain with given variable and given cuts
TH1* PlotTool::plot(int chainIndex, string histName, string cutName,
                int nEntries, string bins, string drwOpt) {

        TH1* thisHist = 0;

        if (chainIndex >= this->GetEntries() )
                return thisHist;

        TStopwatch timer;
        if(verbose) {
          cout<<"Plot: "<<histName<<" "<<cutName<<" from chain "<<this->At(chainIndex)->GetName()<<endl;
          timer.Start();
        }

        int currN = nEntries;
        if (nEntries < 0)
                currN = ((TChain*) this->At(chainIndex))->GetEntries(); //nEntries<0 : all entries are plotted!

        //++++ Create and name Canvases according to global variables +++++++++++++
        ostringstream currHistName;
        if (samePad_trees)
                currHistName<<((TChain*) this->At(chainIndex))->GetName()<<":";
        if (samePad_vars)
                currHistName<<histName;
        if (samePad_cuts)
                currHistName<<"{"<<cutName<<"}";

        ostringstream currPadName;
        if (!samePad_trees)
                currPadName<<((TChain*) this->At(chainIndex))->GetName()<<":";
        if (!samePad_vars)
                currPadName<<histName;
        if (!samePad_cuts)
                currPadName<<"{"<<cutName<<"}";

        ostringstream currCanvName;
        if (!sameCanv_trees && !samePad_trees)
                currCanvName<<((TChain*) this->At(chainIndex))->GetName()<<":";
        if (!sameCanv_vars && !samePad_vars)
                currCanvName<<histName;
        if (!sameCanv_cuts && !samePad_cuts)
                currCanvName<<"{"<<cutName<<"}";

        if ( (sameCanv_trees || samePad_trees) && (sameCanv_vars || samePad_vars)
                        && (sameCanv_cuts || samePad_cuts))
                currCanvName<<"All";

        string currOpt = drwOpt;
        bool useSubPads = (sameCanv_trees && !samePad_trees) || (sameCanv_vars
                        && !samePad_vars) || (sameCanv_cuts && !samePad_cuts);

        if (useSubPads) {
                if ( !canvases_[currCanvName.str()] || !gROOT->GetListOfCanvases()->FindObject(currCanvName.str().c_str()) ) {
                        canvases_[currCanvName.str()] = new TCanvas(currCanvName.str().c_str(), currCanvName.str().c_str());
                } else if (canvases_[currCanvName.str()]->GetNumber() >= 0) {
                        canvases_[currCanvName.str()]->SetNumber(canvases_[currCanvName.str()]->GetNumber()+1);
                }
        }

        if ( !pads_[currPadName.str()] || !gROOT->GetListOfCanvases()->FindObject(currPadName.str().c_str()) ) {
                pads_[currPadName.str()] = new TCanvas(currPadName.str().c_str(), currPadName.str().c_str());
                //              if (logY)
                //                      pads_[currPadName.str()]->SetLogy(1);
        } else {
                pads_[currPadName.str()]->cd();
                currOpt += "SAMES";
                if (useSubPads)
                        canvases_[currCanvName.str()]->SetNumber(canvases_[currCanvName.str()]->GetNumber()-1);
        }
        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


        //Draw histogram:
        string cutNameWithGlobal = cutName;
        if(cutName!="" && globalCuts!="")    cutNameWithGlobal += "&&";
        if(globalCuts!="")                   cutNameWithGlobal += globalCuts;

        histName += ">>htemp";
        if(bins != "") histName += bins;


        int draw_err = ((TChain*) this->At(chainIndex))->Draw(histName.c_str(), cutNameWithGlobal.c_str(),
                        currOpt.c_str(), currN);
        if (draw_err < 0)
                return thisHist;

        //++++ Fix for histos with no entries +++++++++++++
        if (draw_err == 0) {
                if (currOpt.find("SAMES") == string::npos) {
                        pads_[currPadName.str()]->Close();
                        pads_.erase(currPadName.str() );
                        if (useSubPads)
                                canvases_[currCanvName.str()]->SetNumber(canvases_[currCanvName.str()]->GetNumber()-1);
                }
                if(verbose) cout<< "Warning: "<<currHistName.str().c_str()<<" in "<<currPadName.str()
                                <<" has no entries and is not drawn!"<<endl;
                return thisHist;
        }
        //++++++++++++++++++++++++++++++++++++++++++++++++++

        thisHist = (TH1*) pads_[currPadName.str()]->GetPrimitive("htemp");

        thisHist->SetName(currHistName.str().c_str());

        // Update for 2D histograms
        if( thisHist->InheritsFrom("TH2") ) {
                        pads_[currPadName.str()]->Draw();
                        setCanvas( pads_[currPadName.str()] );
        }


        if(verbose && draw_err > 0) {
          timer.Stop();
          cout<<"Done: Selected "<<draw_err<<" objects in "<< currN <<" processed events."<<endl;
          timer.Print();
        }
        return thisHist;

}
//------------------------------------------------------------------
//Standard loop to draw all chains and multiple variables and cuts
int PlotTool::loop(vector<string> _histName, vector<string> _cutName,
                int nEntries, string bins, string drwOpt, bool correspond) {

        int numProcessed = 0;

        TH1* currHist = 0;


        if (correspond == false) {

                for (int i=0; i<this->GetEntries(); ++i) {
                        for (vector<string>::iterator it1 =_histName.begin(); it1
                                        != _histName.end(); ++it1) {
                                for (vector<string>::iterator it2 =_cutName.begin(); it2
                                                != _cutName.end(); ++it2) {

                                  currHist = plot(i, *it1, *it2, nEntries, bins, drwOpt);
                                  if(currHist) numProcessed += int(currHist->GetEntries());
                                

                                }
                        }
                }
        } else {

                if (_histName.size() != _cutName.size() )
                        return -1;

                for (int i=0; i<this->GetEntries(); ++i) {
                        for (vector<string>::iterator it1 =_histName.begin(), it2 =
                                        _cutName.begin(); it1 != _cutName.end()&&it2
                                        != _cutName.end(); ++it1, ++it2) {

                          currHist = plot(i, *it1, *it2, nEntries, bins, drwOpt);
                          if(currHist) numProcessed += int(currHist->GetEntries());

                        }
                }
        }

        updatePads();
        fillCanvases();

        return numProcessed;
}

//Helper methods to allow for using simple strings as input
int PlotTool::loop(string histName, string cutName, int nEntries, string bins, string drwOpt) {

        vector<string> _histName;
        _histName.push_back(histName);
        vector<string> _cutName;
        _cutName.push_back(cutName);

        return loop(_histName, _cutName, nEntries, bins, drwOpt);

}

int PlotTool::loop(vector<string> _histName, string cutName, int nEntries, string bins,
                string drwOpt) {

        vector<string> _cutName;
        _cutName.push_back(cutName);

        return loop(_histName, _cutName, nEntries, bins, drwOpt);

}

int PlotTool::loop(string histName, vector<string> _cutName, int nEntries, string bins,
                string drwOpt) {

        vector<string> _histName;
        _histName.push_back(histName);

        return loop(_histName, _cutName, nEntries, bins, drwOpt);
}
//------------------------------------------------------------------
//redraw the canvas to make changes in style visible
int PlotTool::updatePads() {

        for (map< string, TCanvas* >::iterator it=pads_.begin() ; it != pads_.end(); ++it) {
                if ( ! gROOT->GetListOfCanvases()->FindObject((*it).first.c_str() ) ) {
                  pads_.erase(it);
                  continue;
                }
                if( (*it).second->GetListOfPrimitives()->GetEntries() == 0 ) {
                  (*it).second->Close();
                  pads_.erase(it);
                  continue;
                }
                (*it).second->Draw();
                setCanvas((*it).second);

        }

        return pads_.size();

}

int PlotTool::fillCanvases() {

        for (map< string, TCanvas* >::iterator it=canvases_.begin() ; it
                        != canvases_.end(); ++it) {
                string canvName = (*it).first;
                if (gROOT->GetListOfCanvases()->FindObject(canvName.c_str()) ) {

                        int numP = (*it).second->GetNumber()+1;

                        if (numP <= 0)
                                continue;

                        int x = int( sqrt(numP) );
                        int y = x;
                        if (x*y < numP)
                                x += 1;
                        if (x*y < numP)
                                x += 1;
                        if (x*y < numP) {
                                x -= 1;
                                y += 1;
                        }


                        (*it).second->Divide(x, y);
                        int padIndex = 1;
                        for (map< string, TCanvas* >::iterator it2=pads_.begin() ; it2
                                        != pads_.end(); ++it2) {
                                string padName = (*it2).first;
                                if (gROOT->GetListOfCanvases()->FindObject(padName.c_str() ) ) {
                string n1 = canvName.substr(0,canvName.find(":"));
                string n2("");
                if(canvName.find("{") != string::npos ) n2 = canvName.substr(canvName.find("{"),canvName.find("}"));

                if ( (padName.find(canvName.c_str()) != string::npos ) || (padName.find(n1) != string::npos && padName.find(n2) != string::npos) || !strcmp( canvName.c_str(), "All") ) {
                                                (*it).second->cd(padIndex);
                                                (*it2).second->DrawClonePad();
                                                (*it2).second->Close();
                                                pads_.erase(it2);
                                                ++padIndex;
                                        }
                                } else
                                        pads_.erase(it2);
                        }
                        (*it).second->SetNumber(-1);

                } else
                        canvases_.erase(it);
        }

        return canvases_.size();

}
//------------------------------------------------------------------
void PlotTool::setCanvas(TCanvas* thisCanvas) {


        TH1* thisHist = 0;
        TPaveStats* thisStatsBox = 0;
        TPaletteAxis* palette =0;
        TLegend* thisLeg = 0;
        int counter =0;
        double maxEntry=0;

        ((TFrame*) thisCanvas->GetFrame())->Delete();
        thisCanvas->GetFrame()->SetLineWidth(gStyle->GetLineWidth() );

        thisCanvas->SetLeftMargin(0.2);
        thisCanvas->SetRightMargin(0.06);
        thisCanvas->SetBottomMargin(0.2);
        thisCanvas->SetTopMargin(0.1);

        if (logY)
                thisCanvas->SetLogy(1);
        else
                thisCanvas->SetLogy(0);

        if (showLegend)
                thisLeg = new TLegend();

        for (int i = 0; i != thisCanvas->GetListOfPrimitives()->GetSize(); ++i) {


                if ( !thisCanvas->GetListOfPrimitives()->At(i)->InheritsFrom("TH1"))
                        continue;


                thisHist = ((TH1*) thisCanvas->GetListOfPrimitives()->At(i));

                TString testString( thisHist->GetName() );
                if( testString.BeginsWith("frame_") ) continue;

                setColor(thisHist, counter);
                setMathLabels(thisHist);

                if(normHists) thisHist->Scale(1/thisHist->GetSumOfWeights());

                if (thisHist->GetMaximum() > maxEntry)
                        maxEntry = thisHist->GetMaximum();

                thisStatsBox = (TPaveStats*) thisHist->GetListOfFunctions()->FindObject("stats");
                if (thisStatsBox)
                        setStats(thisCanvas, thisStatsBox, thisHist, counter);

                palette = (TPaletteAxis*) thisHist->GetListOfFunctions()->FindObject("palette");
                if (palette)
                        setPalette(thisCanvas, palette);

                if (thisLeg)
                        thisLeg->AddEntry(thisHist,thisHist->GetName())->SetTextSize(0.04);

                ++counter;

        }

        if (maxEntry != 0)
                setHistMax(thisCanvas, maxEntry);

        thisCanvas->cd();
        thisCanvas->Update();

        if (thisLeg)
                setLegend(thisCanvas, thisLeg, counter);

}
//------------------------------------------------------------------
//private helper classes to set the canvas and hist style
void PlotTool::setStats(TCanvas* thisCanvas, TPaveStats* thisStatsBox,
                TH1* thisHist, int counter) {

        if (thisCanvas->GetRightMargin() < .2)
                thisCanvas->SetRightMargin(.2);

        thisStatsBox->SetLineColor(thisHist->GetLineColor());
        thisStatsBox->SetX2NDC(1.);
        thisStatsBox->SetY2NDC(1-thisCanvas->GetTopMargin()-0.16*counter);
        thisStatsBox->SetX1NDC(1-thisCanvas->GetRightMargin()+0.01);
        thisStatsBox->SetY1NDC(thisStatsBox->GetY2NDC()-.15);

}

void PlotTool::setMathLabels(TH1* thisHist) {

        string t = thisHist ->GetTitle();
        string x = thisHist->GetXaxis()->GetTitle();
        string y = thisHist->GetYaxis()->GetTitle();

//      if (x.find("__") != string::npos)
//        x = x.substr(0,x.find("__"));
//      if (y.find("__") != string::npos)
//        y = y.substr(0,y.find("__"));

        if (x.find(".phi()") != string::npos)
                x.replace(x.find(".phi()"), 6, " #phi");
        if (y.find(".phi()") != string::npos)
                y.replace(y.find(".phi()"), 6, " #phi");

        if (x.find(".eta()") != string::npos)
                x.replace(x.find(".eta()"), 6, " #eta");
        if (y.find(".eta()") != string::npos)
                y.replace(y.find(".eta()"), 6, " #eta");

        if (x.find(".theta()") != string::npos)
                x.replace(x.find(".theta()"), 6, " #theta");
        if (y.find(".theta()") != string::npos)
                y.replace(y.find(".theta()"), 6, " #theta");

        if (x.find(".chi2()") != string::npos)
                x.replace(x.find(".chi2()"), 7, " #chi^{2}");
        if (y.find(".chi2()") != string::npos)
                y.replace(y.find(".chi2()"), 7, " #chi^{2}");

        if (x.find(".pt()") != string::npos)
                x.replace(x.find(".pt()"), 5, " p_{T} [GeV]");
        if (y.find(".pt()") != string::npos)
                y.replace(y.find(".pt()"), 5, " p_{T} [GeV]");

        if (x.find(".et()") != string::npos)
                x.replace(x.find(".et()"), 5, " E_{T} [GeV]");
        if (y.find(".et()") != string::npos)
                y.replace(y.find(".et()"), 5, " E_{T} [GeV]");

        //splitlines for many cuts
        string test1= "{" + globalCuts + "}";
        string test2= "&&" + globalCuts;

        if(t.find(test1) != string::npos) t.replace(t.find(test1),test1.length(),"");
        if(t.find(test2) != string::npos) t.replace(t.find(test2),test2.length(),"");

        if (t.find("{") != string::npos && t.find("#splitline") == string::npos) {
          t.replace(t.find_last_of("{"), 1, "}{");
          string t_old = t;
          t = "#splitline{";
          t +=  t_old;
        }

        thisHist ->SetTitle(t.c_str());
        thisHist->GetXaxis()->SetTitle(x.c_str());
        thisHist->GetYaxis()->SetTitle(y.c_str());

}

void PlotTool::setColor(TH1* thisHist, int counter) {

  thisHist->SetLineWidth(gStyle->GetLineWidth());

        if (counter == 0) {

                thisHist->SetLineColor(kRed+1);
                //if( gStyle->GetHistFillStyle() ) thisHist->SetFillColor  (kRed+1);
                //else 
                thisHist->SetFillStyle(0);
                thisHist->SetMarkerColor(kRed+1);
        } else if (counter == 1) {
                thisHist->SetLineColor(kBlue+1);
                //if( gStyle->GetHistFillStyle() ) thisHist->SetFillColor  (kBlue+1);
                //else 
                thisHist->SetFillStyle(0);
                thisHist->SetMarkerColor(kBlue+1);

        } else if (counter == 2) {
                thisHist->SetLineColor(kGreen+2);
                //if( gStyle->GetHistFillStyle() ) thisHist->SetFillColor  (kGreen+2);
                //else
                thisHist->SetFillStyle(0);
                thisHist->SetMarkerColor(kGreen+2);

        } else if (counter == 3) {
                thisHist->SetLineColor(kMagenta+2);
                //if( gStyle->GetHistFillStyle() ) thisHist->SetFillColor  (kMagenta+2);
                //else
                thisHist->SetFillStyle(0);
                thisHist->SetMarkerColor(kMagenta+2);

        } else if (counter == 4) {
                thisHist->SetLineColor(kCyan+2);
                //if( gStyle->GetHistFillStyle() ) thisHist->SetFillColor  (kCyan+2);
                //else
                thisHist->SetFillStyle(0);
                thisHist->SetMarkerColor(kCyan+2);

        } else {
                thisHist->SetLineColor(kBlack);
                //if( gStyle->GetHistFillStyle() ) thisHist->SetFillColor  (kBlack);
                //else
                thisHist->SetFillStyle(0);
                thisHist->SetMarkerColor(kBlack);

        }


}

void PlotTool::setPalette(TCanvas* thisCanvas, TPaletteAxis* palette) {

        palette->SetLabelSize(0.045);
        if (thisCanvas->GetRightMargin() < .15)
                thisCanvas->SetRightMargin(.15);
        palette->SetX1NDC(1-thisCanvas->GetRightMargin()+0.01);
        palette->SetY1NDC(thisCanvas->GetBottomMargin());
        palette->SetX2NDC(palette->GetX1NDC()+0.05);
        palette->SetY2NDC(1-thisCanvas->GetTopMargin());

}

void PlotTool::setHistMax(TCanvas* thisCanvas, double maxEntry) {

        TH1* thisHist = 0;

        for (int i = 0; i != thisCanvas->GetListOfPrimitives()->GetSize(); ++i) {

                if ( !thisCanvas->GetListOfPrimitives()->At(i)->InheritsFrom("TH1") )
                        continue;
                thisHist = ((TH1*) thisCanvas->GetListOfPrimitives()->At(i));
                if (thisHist->GetMaximum() < maxEntry) {
                        double minEntry=thisHist->GetBinContent(thisHist->GetMinimumBin());
                        if (logY) {
                                int bin = (thisHist->GetMinimumBin()+1);
                                minEntry=thisHist->GetBinContent(bin);
                        }
                        thisHist->GetYaxis()->SetRangeUser(minEntry, maxEntry*1.2);
                }
                break;

        }

}

void PlotTool::setLegend(TCanvas* thisCanvas, TLegend* thisLeg, int counter) {

        thisLeg->SetFillStyle(0);
        thisLeg->SetX1NDC(1-thisCanvas->GetRightMargin()-0.5);
        thisLeg->SetY1NDC(1-thisCanvas->GetTopMargin()-0.05*counter);
        thisLeg->SetX2NDC(1-thisCanvas->GetRightMargin());
        thisLeg->SetY2NDC(1-thisCanvas->GetTopMargin());
        thisLeg->SetEntrySeparation(0.5);
        thisLeg->Draw("NDC");

}

void PlotTool::createColors() {
        const Int_t NRGBs = 5;
        const Int_t NCont = 255;

        Double_t stops[NRGBs] = { 0.00, 0.34, 0.61, 0.84, 1.00 };
        Double_t red[NRGBs] = { 0.00, 0.00, 0.87, 1.00, 0.51 };
        Double_t green[NRGBs] = { 0.00, 0.81, 1.00, 0.20, 0.00 };
        Double_t blue[NRGBs] = { 0.51, 1.00, 0.12, 0.00, 0.00 };
        TColor::CreateGradientColorTable(NRGBs, stops, red, green, blue, NCont);
        gStyle->SetNumberContours(NCont);

}

//------------------------------------------------------------------

int PlotTool::saveCanvases(string name, string path) {

        TSystemDirectory d("", path.c_str());
        if (!d.GetListOfFiles())
                return -1;

        string namePs = path +"/" + name;
        string nameRt = path +"/" + name;

        if (name.find(".ps") == string::npos)
                namePs += ".ps";

        if (name.find(".root") == string::npos)
                nameRt += ".root";

        int savedCanvs =0;


        TIter next(gROOT->GetListOfCanvases());
        TCanvas* canv;
        while ((canv=(TCanvas*)next())) {
          string modName = (*canv).GetName();
          if(modName.find("{") != string::npos) modName = modName.substr(0,modName.find("{"));
          (*canv).SetTitle( modName.c_str() );

        }


        TPostScript ps(namePs.c_str(),112);
        TFile rt(nameRt.c_str(),"recreate");

        next.Reset();
        while ((canv=(TCanvas*)next())) {
          ps.NewPage();


          (*canv).Write();
          (*canv).Draw();
          (*canv).Update();


          ++savedCanvs;

        }

        ps.Close();
        rt.Close();


        if(verbose && savedCanvs) {
          cout<<"Saved file "<<rt.GetName()<<" with "<<savedCanvs<<" canvases."<<endl;
          cout<<"Saved file "<<ps.GetName()<<" with "<<savedCanvs<<" pages."<<endl;
}
        return savedCanvs;

}
//------------------------------------------------------------------

int PlotTool::clearCanvases()
{

  while(gROOT->GetListOfCanvases()->GetEntries()) ((TCanvas*) gROOT->GetListOfCanvases()->At(0))->Close();
  pads_.clear();
  autoVars.clear();
  return pads_.size() + gROOT->GetListOfCanvases()->GetEntries();

}
//------------------------------------------------------------------
int PlotTool::setVariables(string label)
{

        for (int i=0; i< this->GetEntries(); ++i) {
          cout<<"--------------------------------"<<endl;
          cout<<((TChain*) this->At(i))->GetName()<<endl;
          cout<<"------------"<<endl;

          TList* leaves = (TList*) ((TChain*) this->At(i))->GetListOfLeaves();
          for (int j=0; j< leaves->GetEntries(); ++j) {
            TString leafName ( leaves->At(j)->GetName() );
            if(! leafName.EndsWith(".") ) continue;
            if(! leafName.Contains(label.c_str() ) ) continue;

            TClass cl( ( (TLeafElement*) leaves->At(j) )->GetTypeName() );
            cout<<"++++++"<<endl;
            cout<< leafName.Data() <<endl;
            for(int k=0;k<cl.GetListOfAllPublicMethods()->GetEntries();++k) {
              string typeName ( ((TMethod*) cl.GetListOfAllPublicMethods()->At(k))->GetReturnTypeName() );
              string methName ( cl.GetListOfAllPublicMethods()->At(k)->GetName() );
              if( methName != "product") continue;
                cout<< typeName <<endl;
                string _type;
                TString testString( typeName.c_str() );
                if( testString.BeginsWith("vector<") ) {
                  _type = typeName.substr(typeName.find("<")+1,typeName.find(">")-typeName.find("<")-1);
                  string _varSize = leafName.Data();
                  _varSize += "obj@.size()";
                  autoVars.push_back( _varSize );
                  }
                else _type = typeName.substr(0,typeName.find("*"));
                  TClass _cl( _type.c_str() );
                  for(int l=0;l<_cl.GetListOfAllPublicMethods()->GetEntries();++l) {
                    string _typeName ( ((TMethod*) _cl.GetListOfAllPublicMethods()->At(l))->GetReturnTypeName() );
                    string _methName ( _cl.GetListOfAllPublicMethods()->At(l)->GetName() );
                    //              if(_typeName.find("void") != string::npos ) continue;
                    //              cout<<"   "<<_typeName<<"  "<<_methName<<endl;

                    cout<<" "<<_typeName<<"  "<<_methName<<endl;
                    if(_methName.find("operator")==string::npos&&(_typeName=="float"||_typeName=="double"||_typeName=="int"||_typeName=="unsigned int"||_typeName=="bool"||_typeName=="unsigned short"||_typeName=="unsigned long"||_typeName=="unsigned long long")) {

                      cout<<"-->   "<<_typeName<<"  "<<_methName<<endl;

                      string  _varName = leafName.Data();
                      _varName += "obj.";
                      _varName += _methName;
                      _varName += "()";
                      autoVars.push_back( _varName );
                    }
                  }
                  
              
            }

          }

        }

        return autoVars.size();

}

//------------------------------------------------------------------
Revision:	1.19
Committed:	Fri Feb 12 15:21:17 2010 UTC (15 years, 3 months ago) by tschum
Content type:	text/plain
Branch:	MAIN
Changes since 1.18:	+48 -18 lines
Log Message:	improved jetContent vars, plot utils