Logo ROOT  
Reference Guide
ProofStdVect.C File Reference

Detailed Description

Selector for generic processing with stdlib collections.

#define ProofStdVect_cxx
#include "ProofStdVect.h"
#include <TMath.h>
#include <TTree.h>
#include <TRandom3.h>
#include <TROOT.h>
#include <TString.h>
#include <TSystem.h>
#include <TFile.h>
#include <TCanvas.h>
#include <TH1F.h>
// Constructor
fCreate = kFALSE;
fTree = 0;
fFile = 0;
fProofFile = 0;
fRandom = 0;
fHgood = 0;
fHbad = 0;
// Destructor
void ProofStdVect::Begin(TTree * /*tree*/)
// The Begin() function is called at the start of the query.
// When running with PROOF Begin() is only called on the client.
// The tree argument is deprecated (on PROOF 0 is passed).
TString option = GetOption();
// Dataset creation run?
if (fInput && fInput->FindObject("ProofStdVect_Create")) {
fCreate = kTRUE;
} else if (option.Contains("create")) {
fCreate = kTRUE;
void ProofStdVect::SlaveBegin(TTree * /*tree*/)
// The SlaveBegin() function is called after the Begin() function.
// When running with PROOF SlaveBegin() is called on each slave server.
// The tree argument is deprecated (on PROOF 0 is passed).
TString option = GetOption();
// Dataset creation run?
if (fInput && fInput->FindObject("ProofStdVect_Create")) {
fCreate = kTRUE;
} else if (option.Contains("create")) {
fCreate = kTRUE;
// If yes, create the output file ...
if (fCreate) {
// Just create the object
fProofFile = new TProofOutputFile("ProofStdVect.root",
TProofOutputFile::kDataset, opt, "TestStdVect");
// Open the file
fFile = fProofFile->OpenFile("RECREATE");
if (fFile && fFile->IsZombie()) SafeDelete(fFile);
// Cannot continue
if (!fFile) {
Info("SlaveBegin", "could not create '%s': instance is invalid!", fProofFile->GetName());
// Create a TTree
fTree = new TTree("stdvec", "Tree with std vector");
// File resident
// Init the random generator
fRandom = new TRandom3(0);
} else {
// Create two histograms
fHgood = new TH1F("Hgood", "Good hits", 100., -2.5, 2.5);
fHbad = new TH1F("Hbad", "Bad hits", 100., -6., 6.);
Bool_t ProofStdVect::Process(Long64_t entry)
// The Process() function is called for each entry in the tree (or possibly
// keyed object in the case of PROOF) to be processed. The entry argument
// specifies which entry in the currently loaded tree is to be processed.
// It can be passed to either ProofStdVect::GetEntry() or TBranch::GetEntry()
// to read either all or the required parts of the data. When processing
// keyed objects with PROOF, the object is already loaded and is available
// via the fObject pointer.
// This function should contain the "body" of the analysis. It can contain
// simple or elaborate selection criteria, run algorithms on the data
// of the event and typically fill histograms.
// The processing can be stopped by calling Abort().
// Use fStatus to set the return value of TTree::Process().
// The return value is currently not used.
if (fCreate) {
if (!fTree) return kTRUE;
// Number of vectors
Int_t nv = (Int_t) (entry % 10);
if (nv < 1) nv = 1;
// Create vectors
for (Int_t i = 0; i < nv; i++) {
std::vector<bool> vb;
std::vector<float> vfx, vfy;
Int_t np = (Int_t) (entry % 100);
if (np < 1) np = 1;
for (Int_t j = 0; j < np; j++) {
float x = (float)j;
float y = 5.*x;
Double_t sy = (Double_t) (0.1*y);
Double_t ym = fRandom->Gaus((Double_t)y, sy);
Double_t c2 = TMath::Abs((ym - y) / sy);
bool xb = (1. - TMath::Erfc(c2/TMath::Sqrt(2.)) > .95) ? 0 : 1;
// Fill the tree
// Clear the vectors
std::vector<std::vector<bool> >::iterator ivb;
for (ivb = fVb.begin(); ivb != fVb.end(); ivb++) {
std::vector<std::vector<float> >::iterator ivf;
for (ivf = fVfx.begin(); ivf != fVfx.end(); ivf++) {
for (ivf = fVfy.begin(); ivf != fVfy.end(); ivf++) {
} else {
// Read the entry
// Plot normalized values for bad and good hits
for (UInt_t i = 0; i < fVfyr->size(); i++) {
std::vector<bool> &vb = fVbr->at(i);
std::vector<float> &vfx = fVfxr->at(i);
std::vector<float> &vfy = fVfyr->at(i);
for (UInt_t j = 0; j < vfy.size(); j++) {
Double_t ny = (vfy.at(j) - 5*vfx.at(j)) / (0.1 * 5 * vfx.at(j));
if (vb.at(j) < 0.5)
return kTRUE;
void ProofStdVect::SlaveTerminate()
// The SlaveTerminate() function is called after all entries or objects
// have been processed. When running with PROOF SlaveTerminate() is called
// on each slave server.
// Nothing to do in read mode
if (!fCreate) return;
// Write the ntuple to the file
if (fFile) {
if (!fTree) {
Error("SlaveTerminate", "'tree' is undefined!");
Bool_t cleanup = kFALSE;
if (fTree->GetEntries() > 0) {
} else {
cleanup = kTRUE;
// Cleanup, if needed
if (cleanup) {
TUrl uf(*(fFile->GetEndpointUrl()));
void ProofStdVect::Terminate()
// The Terminate() function is the last function to be called during
// a query. It always runs on the client, it can be used to present
// the results graphically or save the results to file.
// Nothing to do in create mode
if (fCreate) return;
// Create a canvas, with 2 pads
TCanvas *c1 = new TCanvas("cvstdvec", "Test StdVec", 800,10,700,780);
TPad *pad1 = (TPad *) c1->GetPad(1);
TPad *pad2 = (TPad *) c1->GetPad(2);
if (fHbad) fHbad->Draw();
if (fHgood) fHgood->Draw();
// The Init() function is called when the selector needs to initialize
// a new tree or chain. Typically here the branch addresses and branch
// pointers of the tree will be set.
// It is normally not necessary to make changes to the generated
// code, but the routine can be extended by the user if needed.
// Init() will be called many times when running on PROOF
// (once per file to be processed).
// Nothing to do in create mode
if (fCreate) return;
// Set object pointer
fVbr = 0;
fVfxr = 0;
fVfyr = 0;
// Set branch addresses and branch pointers
if (!tree) return;
fChain = tree;
fChain->SetBranchAddress("Vb", &fVbr, &b_Vb);
fChain->SetBranchAddress("Vfx", &fVfxr, &b_Vfx);
fChain->SetBranchAddress("Vfy", &fVfyr, &b_Vfy);
Bool_t ProofStdVect::Notify()
// The Notify() function is called when a new file is opened. This
// can be either for a new TTree in a TChain or when when a new TTree
// is started when using PROOF. It is normally not necessary to make changes
// to the generated code, but the routine can be extended by the
// user if needed. The return value is currently not used.
// Nothing to do in create mode
if (fCreate) return kTRUE;
Info("Notify","processing file: %s",fChain->GetCurrentFile()->GetName());
return kTRUE;
Selector for generic processing with stdlib collections.
#define SafeDelete(p)
Definition: RConfig.hxx:547
int Int_t
Definition: RtypesCore.h:45
unsigned int UInt_t
Definition: RtypesCore.h:46
const Bool_t kFALSE
Definition: RtypesCore.h:92
bool Bool_t
Definition: RtypesCore.h:63
double Double_t
Definition: RtypesCore.h:59
long long Long64_t
Definition: RtypesCore.h:73
const Bool_t kTRUE
Definition: RtypesCore.h:91
void Info(const char *location, const char *msgfmt,...)
Use this function for informational messages.
Definition: TError.cxx:220
void Error(const char *location, const char *msgfmt,...)
Use this function in case an error occurred.
Definition: TError.cxx:187
R__EXTERN TSystem * gSystem
Definition: TSystem.h:559
The Canvas class.
Definition: TCanvas.h:23
Small helper to keep current directory context.
Definition: TDirectory.h:52
1-D histogram with a float per channel (see TH1 documentation)}
Definition: TH1.h:575
The most important graphics class in the ROOT system.
Definition: TPad.h:26
TVirtualPad * cd(Int_t subpadnumber=0) override
Set Current pad.
Definition: TPad.cxx:603
Class to steer the merging of files produced on the workers.
Random number generator class based on M.
Definition: TRandom3.h:27
Basic string class.
Definition: TString.h:136
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
virtual int Unlink(const char *name)
Unlink, i.e.
Definition: TSystem.cxx:1379
A TTree represents a columnar dataset.
Definition: TTree.h:79
This class represents a WWW compatible URL.
Definition: TUrl.h:33
void Draw(Option_t *option="") override=0
Default Draw method for all objects.
return c1
Definition: legend1.C:41
Double_t y[n]
Definition: legend1.C:17
Double_t x[n]
Definition: legend1.C:17
return c2
Definition: legend2.C:14
void Begin(Int_t type)
void Init(TClassEdit::TInterpreterLookupHelper *helper)
Definition: TClassEdit.cxx:171
Double_t Erfc(Double_t x)
Compute the complementary error function erfc(x).
Definition: TMath.cxx:194
Double_t Sqrt(Double_t x)
Definition: TMath.h:691
Short_t Abs(Short_t d)
Definition: TMathBase.h:120
Definition: tree.py:1
Gerardo Ganis (gerar.nosp@m.do.g.nosp@m.anis@.nosp@m.cern.nosp@m..ch)

Definition in file ProofStdVect.C.