plotG.cc File Reference

#include "CanvasInTab.hh"
#include <fstream>
#include <string>
#include <sstream>
#include <vector>
#include <set>
#include <map>
#include <iostream>
#include <iomanip>
#include <locale>
#include <cstring>
#include <TApplication.h>
#include <TGApplication.h>
#include <TTree.h>
#include <TNtuple.h>
#include <TBranch.h>
#include <TProfile.h>
#include <TGraph.h>
#include <TAxis.h>
#include <TGraphErrors.h>
#include <TROOT.h>
#include <TCanvas.h>
#include <TFile.h>
#include <TGFileBrowser.h>
#include <TGFileDialog.h>
#include <TChain.h>
#include <TColor.h>

Include dependency graph for plotG.cc:

Go to the source code of this file.

Classes
struct	SpeciesInfoAOS
struct	SpeciesInfoSOA

Macros
#define	USE_CANVASINTAB
#define	_PROCESS_ONE_FILE_   ProcessSingleFile

Functions
const TGFileInfo *	OpenRootFile ()
void	ProcessSingleFile (TFile *file)
int	ProcessSingleFile (const char *filePath)
int	main (int argc, char **argv)

Macro Definition Documentation

#define _PROCESS_ONE_FILE_   ProcessSingleFile

Definition at line 338 of file plotG.cc.

#define USE_CANVASINTAB

Definition at line 26 of file plotG.cc.

Function Documentation

int main	(	int	argc,
		char **	argv
	)

Definition at line 341 of file plotG.cc.

{
  //--------------------------------
  int initialArgc = argc;
  vector<char*> initialArgv(argc);
  for(int i = 0 ; i < argc ; ++i)
  {
    initialArgv[i] = argv[i];
  }
  //--------------------------------

  TApplication* rootApp = new TApplication("PlotG",&argc, argv);

  const char* filePath = 0;

  if(initialArgc == 1) // no file provided in argument
  {
    const TGFileInfo* fileInfo = OpenRootFile();
    filePath = fileInfo->fFilename;
    if(fileInfo->fFileNamesList && fileInfo->fFileNamesList->GetSize()>1)
    {
      // several files selected
      // user has to tick "Multiple selection"
      perror("Multiple selection of files not supported, implement your own!");
     //
     // For instance, start from:
     //   TChain* tree = new TChain("species");
     //   tree->AddFileInfoList(fileInfo->fFileNamesList);
     // Or call ProcessSingleFile for each file,
     // you'll need to do some adaptation
    }
    else
    {
      if(_PROCESS_ONE_FILE_(filePath)) return 1;
    }
  }
  else // a file is provided in argument
  {
    filePath = initialArgv[1];
    if(_PROCESS_ONE_FILE_(filePath)) return 1;
  }

  rootApp->Run();
  delete rootApp;
  return 0;
}

Here is the call graph for this function:

const TGFileInfo* OpenRootFile

(

)

Definition at line 64 of file plotG.cc.

{
    const char *gOpenAsTypes[] = {
    "ROOT files",   "*.root",
    "All files",    "*"
  };

  static TGFileInfo fi;
  fi.fFileTypes = gOpenAsTypes;
  //  fi.SetMultipleSelection(kTRUE);
  // User must check the box "multiple selection" in the dialog box
  //  fi.fIniDir = StrDup(".");
  new TGFileDialog(gClient->GetRoot(),
                   gClient->GetRoot(), kFDOpen, &fi);

  return &fi;
}

Here is the caller graph for this function:

void ProcessSingleFile

(

TFile *

file

)

Definition at line 158 of file plotG.cc.

{
  int speciesID;
  int number;
  int nEvent;
  char speciesName[500];
  double time;  // time
  double sumG;  // sum of G over all events
  double sumG2; // sum of G^2 over all events

  TTree* tree = (TTree*)file->Get("species");
  tree->SetBranchAddress("speciesID", &speciesID);
  tree->SetBranchAddress("number", &number);
  tree->SetBranchAddress("nEvent", &nEvent);
  tree->SetBranchAddress("speciesName", &speciesName);
  tree->SetBranchAddress("time", &time);
  tree->SetBranchAddress("sumG", &sumG);
  tree->SetBranchAddress("sumG2", &sumG2);

  Long64_t nentries = tree->GetEntries();
  // cout << nentries <<" entries" << endl;

  if(nentries == 0)
  {
    cout << "No entries found in the tree species contained in the file "
         << file->GetPath() << endl;
    exit(1);
  }

  //----------------------------------------------------------------------------
  // This first loop is used in case the processed ROOT file is issued from the
  // accumulation of several ROOT files (e.g. hadd)

  std::map<int, std::map<double, SpeciesInfoAOS>> speciesTimeInfo;

  for (int j=0; j < nentries; j++)
  {
    tree->GetEntry(j);

    SpeciesInfoAOS& infoAOS = speciesTimeInfo[speciesID][time];

    infoAOS.fNumber += number;
    infoAOS.fG += sumG;
    infoAOS.fG2 += sumG2;
    infoAOS.fNEvent += nEvent;
    infoAOS.fName = speciesName;
  }

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

  std::map<int, SpeciesInfoSOA> speciesInfo;

  auto it_SOA = speciesTimeInfo.begin();
  auto end_SOA = speciesTimeInfo.end();

  for (; it_SOA!=end_SOA ; ++it_SOA)
  {
    const int _speciesID = it_SOA->first;
    SpeciesInfoSOA& info = speciesInfo[_speciesID];

    auto it2 = it_SOA->second.begin();
    auto end2 = it_SOA->second.end();

    info.fName = it2->second.fName;
    const size_t size2 = it_SOA->second.size();
    info.fG.resize(size2);
    info.fGerr.resize(size2);
    info.fTime.resize(size2);

    for(int i2 = 0 ;it2!=end2;++it2, ++i2)
    {
      SpeciesInfoAOS& infoAOS = it2->second;
      
      double _SumG2 = infoAOS.fG2;
      double _MeanG = infoAOS.fG/infoAOS.fNEvent;
      double _Gerr = sqrt((_SumG2/infoAOS.fNEvent - pow(_MeanG,2))
                          /(infoAOS.fNEvent-1) );

      info.fG[i2] = _MeanG;
      info.fGerr[i2] = _Gerr;
      info.fTime[i2] = it2->first;
      info.fRelatErr += _Gerr/(_MeanG + 1e-30); // add an epsilon to prevent NAN
    }
  }

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

#ifdef USE_CANVASINTAB
  CanvasInTab* myFrame =
  new CanvasInTab(gClient->GetRoot(), 500, 500);
#endif

  std::map<int, SpeciesInfoSOA>::iterator it = speciesInfo.begin();
  std::map<int, SpeciesInfoSOA>::iterator end = speciesInfo.end();

  for (; it != end; ++it)
  {
    speciesID = it->first;
    SpeciesInfoSOA& info = it->second;
//    if(strstr(info.fName.c_str(), "H2O^") != 0) continue;
    
    if(info.fG.empty()) continue;

    TGraphErrors* gSpecies = new TGraphErrors(info.fG.size(),
                                              info.fTime.data(),
                                              info.fG.data(),
                                              0,
                                              info.fGerr.data());

#ifdef USE_CANVASINTAB
    int nCanvas = myFrame->AddCanvas(info.fName.c_str());
    myFrame->GetCanvas(nCanvas);
    TCanvas* cSpecies = myFrame->GetCanvas(nCanvas);
#else
    TCanvas* cSpecies = new TCanvas(info.fName.c_str(),
                                    info.fName.c_str());
#endif

    cSpecies->cd();
    int color = (2+speciesID)%TColor::GetNumberOfColors();
    if(color == 5 || color==10 || color==0) ++color;
    
    // cout << info.fName.c_str() << " " << color << endl;
    
    gSpecies->SetMarkerStyle(20+speciesID);
    gSpecies->SetMarkerColor(color);
    info.fRelatErr /= (double)info.fG.size();

    gSpecies->SetTitle((info.fName
                        + " - speciesID: "
                        + std::to_string(speciesID)+" rel. Err. "
                        + std::to_string(info.fRelatErr)).c_str() );
    gSpecies->GetXaxis()->SetTitle("Time [ns]");
    gSpecies->GetYaxis()->SetTitle("G [molecules/100 eV]");
    gSpecies->Draw("ap");
    cSpecies->SetLogx();
  }
  
#ifdef USE_CANVASINTAB
  int nCanvas = myFrame->GetNCanvas();
  for(int i = 0 ; i < nCanvas ; ++i)
  {
    myFrame->GetCanvas(i)->Update();
  }
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ProcessSingleFile

(

const char *

filePath

)

Definition at line 307 of file plotG.cc.

{
  if(filePath == 0 || strlen(filePath) == 0)
  {
    perror("You must provide a valid file");
    return 1;
  }

  TFile* file = TFile::Open(filePath);

  if(file == 0)
  {
    perror ("Error opening ntuple file");
    exit(1);
  }
  
  if(!file-> IsOpen())
  {
    perror ("Error opening ntuple file");
    exit(1);
  }
  else
  {
    cout << "Opening ntple file " << filePath << endl;
  }
  ProcessSingleFile(file);
  return 0;
}

Here is the call graph for this function: