---

MainEvent.cpp

Go to the documentation of this file.

// @(#)root/test:$Name:  $:$Id: MainEvent.cpp,v 1.2 2005/04/18 14:52:56 berthon Exp $
// Author: Rene Brun   19/01/97

//
//             A simple example with a ROOT tree
//             =================================
//
//  This program creates :
//    - a ROOT file
//    - a tree
//  Additional arguments can be passed to the program to control the flow
//  of execution. (see comments describing the arguments in the code).
//      Event  nevent comp split fill
//  All arguments are optional. Default is:
//      Event  400      1    1     1
//
//  In this example, the tree consists of one single "super branch"
//  The statement ***tree->Branch("event", event, 64000,split);*** below
//  will parse the structure described in Event.h and will make
//  a new branch for each data member of the class if split is set to 1.
//    - 9 branches corresponding to the basic types fType, fNtrack,fNseg,
//           fNvertex,fFlag,fTemperature,fMeasures,fMatrix,fClosesDistance.
//    - 3 branches corresponding to the members of the subobject EventHeader.
//    - one branch for each data member of the class Track of TClonesArray.
//    - one branch for the TRefArray of high Pt tracks
//    - one branch for the TRefArray of muon tracks
//    - one branch for the reference pointer to the last track
//    - one branch for the object fH (histogram of class TH1F).
//
//  if split = 0 only one single branch is created and the complete event
//  is serialized in one single buffer.
//  if split = -2 the event is split using the old TBranchObject mechanism
//  if split = -1 the event is streamed using the old TBranchObject mechanism
//  if split > 0  the event is split using the new TBranchElement mechanism.
//
//  if comp = 0 no compression at all.
//  if comp = 1 event is compressed.
//  if comp = 2 same as 1. In addition branches with floats in the TClonesArray
//                         are also compressed.
//  The 4th argument fill can be set to 0 if one wants to time
//     the percentage of time spent in creating the event structure and
//     not write the event in the file.
//  In this example, one loops over nevent events.
//  The branch "event" is created at the first event.
//  The branch address is set for all other events.
//  For each event, the event header is filled and ntrack tracks
//  are generated and added to the TClonesArray list.
//  For each event the event histogram is saved as well as the list
//  of all tracks.
//
//  The two TRefArray contain only references to the original tracks owned by
//  the TClonesArray fTracks.
//
//  The number of events can be given as the first argument to the program.
//  By default 400 events are generated.
//  The compression option can be activated/deactivated via the second argument.
//
//   ---Running/Linking instructions----
//  This program consists of the following files and procedures.
//    - Event.h event class description
//    - Event.C event class implementation
//    - MainEvent.C the main program to demo this class might be used (this file)
//    - EventCint.C  the CINT dictionary for the event and Track classes
//        this file is automatically generated by rootcint (see Makefile),
//        when the class definition in Event.h is modified.
//
//   ---Analyzing the Event.root file with the interactive root
//        example of a simple session
//   Root > TFile f("Event.root")
//   Root > T.Draw("fNtrack")   //histogram the number of tracks per event
//   Root > T.Draw("fPx")       //histogram fPx for all tracks in all events
//   Root > T.Draw("fXfirst:fYfirst","fNtrack>600")
//                              //scatter-plot for x versus y of first point of each track
//   Root > T.Draw("fH.GetRMS()")  //histogram of the RMS of the event histogram
//
//   Look also in the same directory at the following macros:
//     - eventa.C  an example how to read the tree
//     - eventb.C  how to read events conditionally
//

#include <stdlib.h>

#include "Riostream.h"
#include "TROOT.h"
#include "TFile.h"
#include "TNetFile.h"
#include "TRandom.h"
#include "TTree.h"
#include "TBranch.h"
#include "TClonesArray.h"
#include "TStopwatch.h"

#include "XANADOO/domain/interface/XANAEsdEvent.h"


//______________________________________________________________________________

class MainEventClass {

 public:
 
   MainEventClass();
   ~MainEventClass() {}
   
   void process();
   void end(); 
   
   Int_t nb, nevent;
   TTree *tree;
   TFile *hfile; 
   XANAEsdEvent *event;
   TBranch *branch;
   
};

int main(int argc, char **argv)
{
   MainEventClass main;
   main.process();
   main.end();
   return 0;
}


MainEventClass::MainEventClass() :
 tree(0), hfile(0), event(0), branch(0)
{
   nevent = 400;     // by default create 400 events
   Int_t comp   = 1;       // by default file is compressed
   Int_t split  = 1;       // by default, split Event in sub branches
   Int_t write  = 1;       // by default the tree is filled
   Int_t hfill  = 0;       // by default histograms are not filled
   Int_t read   = 0;
   Int_t arg4   = 1;
   Int_t arg5   = 600;     //default number of tracks per event
   Int_t netf   = 0;
   
//   Event *event = 0;

   // Fill event, header and tracks with some random numbers
   nb = 0;
   Int_t bufsize;
   Double_t told = 0;
   Double_t tnew = 0;

      // Create a new ROOT binary machine independent file.
      // Note that this file may contain any kind of ROOT objects, histograms,
      // pictures, graphics objects, detector geometries, tracks, events, etc..
      // This file is now becoming the current directory.
      hfile = new TFile("Event.root","RECREATE");
      hfile->SetCompressionLevel(comp);

     // Create histogram to show write_time in function of time
     Float_t curtime = -0.5;

     // Create a ROOT Tree and one superbranch
      tree = new TTree("T","An example of a ROOT tree");
      tree->SetAutoSave(1000000000);  // autosave when 1 Gbyte written
      bufsize = 256000;
      if (split)  bufsize /= 4;
// try XANA event class
//      event = new Event();
      event = new XANAEsdEvent;
//      TTree::SetBranchStyle(branchStyle);
// try XANA event class
//      TBranch *branch = tree->Branch("event", "Event", &event, bufsize,split);
      branch = tree->Branch("event","XANAEsdEvent",&event,bufsize,split);
      branch->SetAutoDelete(kFALSE);
      Float_t ptmin = 1;

}

void MainEventClass::process() 
{
      for (Int_t ev = 0; ev < nevent; ev++) {

//         event->Build(ev, arg5, ptmin);
         branch->ResetAddress();
         branch->SetAddress(&event);
         event->setGeneral(1,1);

//         nb += tree->Fill();  //fill the tree
        tree->Fill();  //fill the tree

//         if (hm) hm->Hfill(event);      //fill histograms
      }
}

void MainEventClass::end() 
{
   printf("\n%d events and %d bytes processed.\n",nevent,nb);
   hfile->Write();
   tree->Print();
   delete hfile;
}

---