diff --git a/test/Event.cxx b/test/Event.cxx
index 2e5449e72df10e359936c59f9427e1d84d72e382..a9d938cfa8a2485ec3f9b0245f3c7dc4d567d217 100644
--- a/test/Event.cxx
+++ b/test/Event.cxx
@@ -70,12 +70,16 @@
// of histograms can be filled. The creation and handling of the
// histograms is taken care of by the HistogramManager class.
//
+// Note: This version of the class Event (see EventMT.h and EventMT.cxx
+// for an alternative) uses static variable to improve performance (by
+// reducing memory allocation) and thus you can only one instance per
+// process (a 2nd instance would shared the array of Tracks).
+//
////////////////////////////////////////////////////////////////////////
#include "TRandom.h"
#include "TDirectory.h"
#include "TProcessID.h"
-#include "TThread.h"
#include "Event.h"
@@ -95,14 +99,8 @@ Event::Event() : fIsValid(kFALSE)
// When the constructor is invoked for the first time, the class static
// variable fgTracks is 0 and the TClonesArray fgTracks is created.
- if (TThread::IsInitialized() && TThread::Self()) {
- // If thread have been enabled and we are not in the main thread
- // let's not share the TClonesArray!
- fTracks = new TClonesArray("Track", 1000);
- } else {
- if (!fgTracks) fgTracks = new TClonesArray("Track", 1000);
- fTracks = fgTracks;
- }
+ if (!fgTracks) fgTracks = new TClonesArray("Track", 1000);
+ fTracks = fgTracks;
fHighPt = new TRefArray;
fMuons = new TRefArray;
fNtrack = 0;
@@ -228,14 +226,8 @@ void Event::SetHeader(Int_t i, Int_t run, Int_t date, Float_t random)
{
fNtrack = 0;
fEvtHdr.Set(i, run, date);
- if (TThread::IsInitialized() && TThread::Self()) {
- // If thread have been enabled and we are not in the main thread
- // let's not share the histogram!
- fH = new TH1F("hstat","Event Histogram",100,0,1);
- } else {
- if (!fgHist) fgHist = new TH1F("hstat","Event Histogram",100,0,1);
- fH = fgHist;
- }
+ if (!fgHist) fgHist = new TH1F("hstat","Event Histogram",100,0,1);
+ fH = fgHist;
fH->Fill(random);
}
diff --git a/test/EventMT.cxx b/test/EventMT.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..1f52601a4aa810a87ba48c115add1057dc29964b
--- /dev/null
+++ b/test/EventMT.cxx
@@ -0,0 +1,407 @@
+// @(#)root/test:$Id$
+// Author: Rene Brun 19/08/96
+
+////////////////////////////////////////////////////////////////////////
+//
+// Event and Track classes
+// =======================
+//
+// The Event class is a naive/simple example of an event structure.
+// public:
+// char fType[20];
+// char *fEventName; //run+event number in character format
+// Int_t fNtrack;
+// Int_t fNseg;
+// Int_t fNvertex;
+// UInt_t fFlag;
+// Double32_t fTemperature;
+// Int_t fMeasures[10];
+// Double32_t fMatrix[4][4];
+// Double32_t *fClosestDistance; //[fNvertex] indexed array!
+// EventHeader fEvtHdr;
+// TClonesArray *fTracks;
+// TRefArray *fHighPt; //array of High Pt tracks only
+// TRefArray *fMuons; //array of Muon tracks only
+// TRef fLastTrack; //pointer to last track
+// TRef fHistoWeb; //EXEC:GetHistoWeb reference to an histogram in a TWebFile
+// TH1F *fH;
+// TBits fTriggerBits; //Bits triggered by this event.
+//
+// The EventHeader class has 3 data members (integers):
+// public:
+// Int_t fEvtNum;
+// Int_t fRun;
+// Int_t fDate;
+//
+//
+// The Event data member fTracks is a pointer to a TClonesArray.
+// It is an array of a variable number of tracks per event.
+// Each element of the array is an object of class Track with the members:
+// private:
+// Float_t fPx; //X component of the momentum
+// Float_t fPy; //Y component of the momentum
+// Float_t fPz; //Z component of the momentum
+// Float_t fRandom; //A random track quantity
+// Float_t fMass2; //The mass square of this particle
+// Float_t fBx; //X intercept at the vertex
+// Float_t fBy; //Y intercept at the vertex
+// Float_t fMeanCharge; //Mean charge deposition of all hits of this track
+// Float_t fXfirst; //X coordinate of the first point
+// Float_t fXlast; //X coordinate of the last point
+// Float_t fYfirst; //Y coordinate of the first point
+// Float_t fYlast; //Y coordinate of the last point
+// Float_t fZfirst; //Z coordinate of the first point
+// Float_t fZlast; //Z coordinate of the last point
+// Double32_t fCharge; //Charge of this track
+// Double32_t fVertex[3]; //Track vertex position
+// Int_t fNpoint; //Number of points for this track
+// Short_t fValid; //Validity criterion
+// Int_t fNsp; //Number of points for this track with a special value
+// Double32_t *fPointValue; //[fNsp] a special quantity for some point.
+// TBits fTriggerBits; //Bits triggered by this track.
+//
+// An example of a batch program to use the Event/Track classes is given
+// in this directory: MainEvent.
+// 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
+//
+// During the processing of the event (optionally) also a large number
+// of histograms can be filled. The creation and handling of the
+// histograms is taken care of by the HistogramManager class.
+//
+// This version of the Event class is a simplified version suitable to
+// use in multiple thread as each Event objects are independent for
+// each other.
+//
+////////////////////////////////////////////////////////////////////////
+
+#include "TRandom.h"
+#include "TDirectory.h"
+#include "TProcessID.h"
+
+#include "Event.h"
+
+
+ClassImp(EventHeader)
+ClassImp(Event)
+ClassImp(Track)
+ClassImp(HistogramManager)
+
+//______________________________________________________________________________
+Event::Event() : fIsValid(kFALSE)
+{
+ // Create an Event object.
+
+ fTracks = new TClonesArray("Track", 1000);
+ fHighPt = new TRefArray;
+ fMuons = new TRefArray;
+ fNtrack = 0;
+ fH = 0;
+ Int_t i0,i1;
+ for (i0 = 0; i0 < 4; i0++) {
+ for (i1 = 0; i1 < 4; i1++) {
+ fMatrix[i0][i1] = 0.0;
+ }
+ }
+ for (i0 = 0; i0 <10; i0++) fMeasures[i0] = 0;
+ for (i0 = 0; i0 <20; i0++) fType[i0] = 0;
+ fClosestDistance = 0;
+ fEventName = 0;
+ fWebHistogram.SetAction(this);
+}
+
+//______________________________________________________________________________
+Event::~Event()
+{
+ Clear();
+ delete fH; fH = 0;
+ delete fHighPt; fHighPt = 0;
+ delete fMuons; fMuons = 0;
+ delete [] fClosestDistance;
+ if (fEventName) delete [] fEventName;
+}
+
+//______________________________________________________________________________
+void Event::Build(Int_t ev, Int_t arg5, Float_t ptmin) {
+ fIsValid = kTRUE;
+ char etype[20];
+ Float_t sigmat, sigmas;
+ gRandom->Rannor(sigmat,sigmas);
+ Int_t ntrack = Int_t(arg5 +arg5*sigmat/120.);
+ Float_t random = gRandom->Rndm(1);
+
+ //Save current Object count
+ Int_t ObjectNumber = TProcessID::GetObjectCount();
+ Clear();
+ fHighPt->Delete();
+ fMuons->Delete();
+
+ Int_t nch = 15;
+ if (ev >= 100) nch += 3;
+ if (ev >= 10000) nch += 3;
+ if (fEventName) delete [] fEventName;
+ fEventName = new char[nch];
+ sprintf(fEventName,"Event%d_Run%d",ev,200);
+ sprintf(etype,"type%d",ev%5);
+ SetType(etype);
+ SetHeader(ev, 200, 960312, random);
+ SetNseg(Int_t(10*ntrack+20*sigmas));
+ SetNvertex(Int_t(1+20*gRandom->Rndm()));
+ SetFlag(UInt_t(random+0.5));
+ SetTemperature(random+20.);
+
+ for(UChar_t m = 0; m < 10; m++) {
+ SetMeasure(m, Int_t(gRandom->Gaus(m,m+1)));
+ }
+ for(UChar_t i0 = 0; i0 < 4; i0++) {
+ for(UChar_t i1 = 0; i1 < 4; i1++) {
+ SetMatrix(i0,i1,gRandom->Gaus(i0*i1,1));
+ }
+ }
+
+ fTriggerBits.SetBitNumber((UInt_t)(64*gRandom->Rndm(1)));
+ fTriggerBits.SetBitNumber((UInt_t)(64*gRandom->Rndm(1)));
+ fTriggerBits.SetBitNumber((UInt_t)(64*gRandom->Rndm(1)));
+
+ // Create and Fill the Track objects
+ for (Int_t t = 0; t < ntrack; t++) AddTrack(random,ptmin);
+
+ //Restore Object count
+ //To save space in the table keeping track of all referenced objects
+ //we assume that our events do not address each other. We reset the
+ //object count to what it was at the beginning of the event.
+ TProcessID::SetObjectCount(ObjectNumber);
+}
+
+//______________________________________________________________________________
+Track *Event::AddTrack(Float_t random, Float_t ptmin)
+{
+ // Add a new track to the list of tracks for this event.
+ // To avoid calling the very time consuming operator new for each track,
+ // the standard but not well know C++ operator "new with placement"
+ // is called. If tracks[i] is 0, a new Track object will be created
+ // otherwise the previous Track[i] will be overwritten.
+
+ TClonesArray &tracks = *fTracks;
+ Track *track = new(tracks[fNtrack++]) Track(random);
+ //Save reference to last Track in the collection of Tracks
+ fLastTrack = track;
+ //Save reference in fHighPt if track is a high Pt track
+ if (track->GetPt() > ptmin) fHighPt->Add(track);
+ //Save reference in fMuons if track is a muon candidate
+ if (track->GetMass2() < 0.11) fMuons->Add(track);
+ return track;
+}
+
+//______________________________________________________________________________
+void Event::Clear(Option_t * /*option*/)
+{
+ fTracks->Clear("C"); //will also call Track::Clear
+ fHighPt->Delete();
+ fMuons->Delete();
+ fTriggerBits.Clear();
+}
+
+///______________________________________________________________________________
+void Event::SetHeader(Int_t i, Int_t run, Int_t date, Float_t random)
+{
+ fNtrack = 0;
+ fEvtHdr.Set(i, run, date);
+ fH = new TH1F("hstat","Event Histogram",100,0,1);
+ fH->Fill(random);
+}
+
+//______________________________________________________________________________
+void Event::SetMeasure(UChar_t which, Int_t what) {
+ if (which<10) fMeasures[which] = what;
+}
+
+//______________________________________________________________________________
+void Event::SetRandomVertex() {
+ // This delete is to test the relocation of variable length array
+ if (fClosestDistance) delete [] fClosestDistance;
+ if (!fNvertex) {
+ fClosestDistance = 0;
+ return;
+ }
+ fClosestDistance = new Double32_t[fNvertex];
+ for (Int_t k = 0; k < fNvertex; k++ ) {
+ fClosestDistance[k] = gRandom->Gaus(1,1);
+ }
+}
+
+//______________________________________________________________________________
+Track::Track(const Track &orig) : TObject(orig)
+{
+ // Copy a track object
+
+ fPx = orig.fPx;
+ fPy = orig.fPy;
+ fPz = orig.fPx;
+ fRandom = orig.fRandom;
+ fMass2 = orig.fMass2;
+ fBx = orig.fBx;
+ fBy = orig.fBy;
+ fMeanCharge = orig.fMeanCharge;
+ fXfirst = orig.fXfirst;
+ fXlast = orig.fXlast;
+ fYfirst = orig.fYfirst;
+ fYlast = orig.fYlast;
+ fZfirst = orig.fZfirst;
+ fZlast = orig.fZlast;
+ fCharge = orig.fCharge;
+
+ fVertex[0] = orig.fVertex[0];
+ fVertex[1] = orig.fVertex[1];
+ fVertex[2] = orig.fVertex[2];
+ fNpoint = orig.fNpoint;
+ fNsp = orig.fNsp;
+ if (fNsp) {
+ fPointValue = new Double32_t[fNsp];
+ for(int i=0; i<fNsp; i++) {
+ fPointValue[i] = orig.fPointValue[i];
+ }
+ } else {
+ fPointValue = 0;
+ }
+ fValid = orig.fValid;
+
+ fTriggerBits = orig.fTriggerBits;
+
+}
+
+//______________________________________________________________________________
+Track::Track(Float_t random) : TObject(),fTriggerBits(64)
+{
+ // Create a track object.
+ // Note that in this example, data members do not have any physical meaning.
+
+ Float_t a,b,px,py;
+ gRandom->Rannor(px,py);
+ fPx = px;
+ fPy = py;
+ fPz = TMath::Sqrt(px*px+py*py);
+ fRandom = 1000*random;
+ if (fRandom < 10) fMass2 = 0.106;
+ else if (fRandom < 100) fMass2 = 0.8;
+ else if (fRandom < 500) fMass2 = 4.5;
+ else if (fRandom < 900) fMass2 = 8.9;
+ else fMass2 = 9.8;
+ gRandom->Rannor(a,b);
+ fBx = 0.1*a;
+ fBy = 0.1*b;
+ fMeanCharge = 0.01*gRandom->Rndm(1);
+ gRandom->Rannor(a,b);
+ fXfirst = a*10;
+ fXlast = b*10;
+ gRandom->Rannor(a,b);
+ fYfirst = a*12;
+ fYlast = b*16;
+ gRandom->Rannor(a,b);
+ fZfirst = 50 + 5*a;
+ fZlast = 200 + 10*b;
+ fCharge = Double32_t(Int_t(3*gRandom->Rndm(1)) - 1);
+
+ fTriggerBits.SetBitNumber((UInt_t)(64*gRandom->Rndm(1)));
+ fTriggerBits.SetBitNumber((UInt_t)(64*gRandom->Rndm(1)));
+ fTriggerBits.SetBitNumber((UInt_t)(64*gRandom->Rndm(1)));
+
+ fVertex[0] = gRandom->Gaus(0,0.1);
+ fVertex[1] = gRandom->Gaus(0,0.2);
+ fVertex[2] = gRandom->Gaus(0,10);
+ fNpoint = Int_t(60+10*gRandom->Rndm(1));
+ fNsp = Int_t(3*gRandom->Rndm(1));
+ if (fNsp) {
+ fPointValue = new Double32_t[fNsp];
+ for(int i=0; i<fNsp; i++) {
+ fPointValue[i] = i+1;
+ }
+ } else {
+ fPointValue = 0;
+ }
+ fValid = Int_t(0.6+gRandom->Rndm(1));
+}
+
+//______________________________________________________________________________
+void Track::Clear(Option_t * /*option*/)
+{
+ fTriggerBits.Clear();
+ delete [] fPointValue;
+ fPointValue=0;
+}
+
+//______________________________________________________________________________
+HistogramManager::HistogramManager(TDirectory *dir)
+{
+ // Create histogram manager object. Histograms will be created
+ // in the "dir" directory.
+
+ // Save current directory and cd to "dir".
+ TDirectory *saved = gDirectory;
+ dir->cd();
+
+ fNtrack = new TH1F("hNtrack", "Ntrack",100,575,625);
+ fNseg = new TH1F("hNseg", "Nseg",100,5800,6200);
+ fTemperature = new TH1F("hTemperature","Temperature",100,19.5,20.5);
+ fPx = new TH1F("hPx", "Px",100,-4,4);
+ fPy = new TH1F("hPy", "Py",100,-4,4);
+ fPz = new TH1F("hPz", "Pz",100,0,5);
+ fRandom = new TH1F("hRandom", "Random",100,0,1000);
+ fMass2 = new TH1F("hMass2", "Mass2",100,0,12);
+ fBx = new TH1F("hBx", "Bx",100,-0.5,0.5);
+ fBy = new TH1F("hBy", "By",100,-0.5,0.5);
+ fMeanCharge = new TH1F("hMeanCharge","MeanCharge",100,0,0.01);
+ fXfirst = new TH1F("hXfirst", "Xfirst",100,-40,40);
+ fXlast = new TH1F("hXlast", "Xlast",100,-40,40);
+ fYfirst = new TH1F("hYfirst", "Yfirst",100,-40,40);
+ fYlast = new TH1F("hYlast", "Ylast",100,-40,40);
+ fZfirst = new TH1F("hZfirst", "Zfirst",100,0,80);
+ fZlast = new TH1F("hZlast", "Zlast",100,0,250);
+ fCharge = new TH1F("hCharge", "Charge",100,-1.5,1.5);
+ fNpoint = new TH1F("hNpoint", "Npoint",100,50,80);
+ fValid = new TH1F("hValid", "Valid",100,0,1.2);
+
+ // cd back to original directory
+ saved->cd();
+}
+
+//______________________________________________________________________________
+HistogramManager::~HistogramManager()
+{
+ // Clean up all histograms.
+
+ // Nothing to do. Histograms will be deleted when the directory
+ // in which tey are stored is closed.
+}
+
+//______________________________________________________________________________
+void HistogramManager::Hfill(Event *event)
+{
+ // Fill histograms.
+
+ fNtrack->Fill(event->GetNtrack());
+ fNseg->Fill(event->GetNseg());
+ fTemperature->Fill(event->GetTemperature());
+
+ for (Int_t itrack = 0; itrack < event->GetNtrack(); itrack++) {
+ Track *track = (Track*)event->GetTracks()->UncheckedAt(itrack);
+ fPx->Fill(track->GetPx());
+ fPy->Fill(track->GetPy());
+ fPz->Fill(track->GetPz());
+ fRandom->Fill(track->GetRandom());
+ fMass2->Fill(track->GetMass2());
+ fBx->Fill(track->GetBx());
+ fBy->Fill(track->GetBy());
+ fMeanCharge->Fill(track->GetMeanCharge());
+ fXfirst->Fill(track->GetXfirst());
+ fXlast->Fill(track->GetXlast());
+ fYfirst->Fill(track->GetYfirst());
+ fYlast->Fill(track->GetYlast());
+ fZfirst->Fill(track->GetZfirst());
+ fZlast->Fill(track->GetZlast());
+ fCharge->Fill(track->GetCharge());
+ fNpoint->Fill(track->GetNpoint());
+ fValid->Fill(track->GetValid());
+ }
+}
diff --git a/test/EventMT.h b/test/EventMT.h
new file mode 100644
index 0000000000000000000000000000000000000000..435669401b6cbaea29fdb0646e9b24fb94e1bf36
--- /dev/null
+++ b/test/EventMT.h
@@ -0,0 +1,200 @@
+#ifndef ROOT_Event
+#define ROOT_Event
+
+//////////////////////////////////////////////////////////////////////////
+// //
+// Event //
+// //
+// Description of the event and track parameters //
+// This version of the Event class is a simplified version suitable to //
+// use in multiple thread as each Event objects are independent for //
+// each other. //
+// //
+//////////////////////////////////////////////////////////////////////////
+
+#include "TObject.h"
+#include "TClonesArray.h"
+#include "TRefArray.h"
+#include "TRef.h"
+#include "TH1.h"
+#include "TBits.h"
+#include "TMath.h"
+
+
+class TDirectory;
+
+class Track : public TObject {
+
+private:
+ Float_t fPx; //X component of the momentum
+ Float_t fPy; //Y component of the momentum
+ Float_t fPz; //Z component of the momentum
+ Float_t fRandom; //A random track quantity
+ Float16_t fMass2; //[0,0,8] The mass square of this particle
+ Float16_t fBx; //[0,0,10] X intercept at the vertex
+ Float16_t fBy; //[0,0,10] Y intercept at the vertex
+ Float_t fMeanCharge; //Mean charge deposition of all hits of this track
+ Float16_t fXfirst; //X coordinate of the first point
+ Float16_t fXlast; //X coordinate of the last point
+ Float16_t fYfirst; //Y coordinate of the first point
+ Float16_t fYlast; //Y coordinate of the last point
+ Float16_t fZfirst; //Z coordinate of the first point
+ Float16_t fZlast; //Z coordinate of the last point
+ Double32_t fCharge; //[-1,1,2] Charge of this track
+ Double32_t fVertex[3]; //[-30,30,16] Track vertex position
+ Int_t fNpoint; //Number of points for this track
+ Short_t fValid; //Validity criterion
+ Int_t fNsp; //Number of points for this track with a special value
+ Double32_t* fPointValue; //[fNsp][0,3] a special quantity for some point.
+ TBits fTriggerBits; //Bits triggered by this track.
+
+public:
+ Track() { fPointValue = 0; }
+ Track(const Track& orig);
+ Track(Float_t random);
+ virtual ~Track() {Clear();}
+ void Clear(Option_t *option="");
+ Float_t GetPx() const { return fPx; }
+ Float_t GetPy() const { return fPy; }
+ Float_t GetPz() const { return fPz; }
+ Float_t GetPt() const { return TMath::Sqrt(fPx*fPx + fPy*fPy); }
+ Float_t GetRandom() const { return fRandom; }
+ Float_t GetBx() const { return fBx; }
+ Float_t GetBy() const { return fBy; }
+ Float_t GetMass2() const { return fMass2; }
+ Float_t GetMeanCharge() const { return fMeanCharge; }
+ Float_t GetXfirst() const { return fXfirst; }
+ Float_t GetXlast() const { return fXlast; }
+ Float_t GetYfirst() const { return fYfirst; }
+ Float_t GetYlast() const { return fYlast; }
+ Float_t GetZfirst() const { return fZfirst; }
+ Float_t GetZlast() const { return fZlast; }
+ Double32_t GetCharge() const { return fCharge; }
+ Double32_t GetVertex(Int_t i=0) {return (i<3)?fVertex[i]:0;}
+ Int_t GetNpoint() const { return fNpoint; }
+ TBits& GetTriggerBits() { return fTriggerBits; }
+ Short_t GetValid() const { return fValid; }
+ virtual void SetValid(Int_t valid=1) { fValid = valid; }
+ Int_t GetN() const { return fNsp; }
+ Double32_t GetPointValue(Int_t i=0) const { return (i<fNsp)?fPointValue[i]:0; }
+
+ ClassDef(Track,2) //A track segment
+};
+
+class EventHeader {
+
+private:
+ Int_t fEvtNum;
+ Int_t fRun;
+ Int_t fDate;
+
+public:
+ EventHeader() : fEvtNum(0), fRun(0), fDate(0) { }
+ virtual ~EventHeader() { }
+ void Set(Int_t i, Int_t r, Int_t d) { fEvtNum = i; fRun = r; fDate = d; }
+ Int_t GetEvtNum() const { return fEvtNum; }
+ Int_t GetRun() const { return fRun; }
+ Int_t GetDate() const { return fDate; }
+
+ ClassDef(EventHeader,1) //Event Header
+};
+
+
+class Event : public TObject {
+
+private:
+ char fType[20]; //event type
+ char *fEventName; //run+event number in character format
+ Int_t fNtrack; //Number of tracks
+ Int_t fNseg; //Number of track segments
+ Int_t fNvertex;
+ UInt_t fFlag;
+ Double32_t fTemperature;
+ Int_t fMeasures[10];
+ Double32_t fMatrix[4][4];
+ Double32_t *fClosestDistance; //[fNvertex][0,0,6]
+ EventHeader fEvtHdr;
+ TClonesArray *fTracks; //->array with all tracks
+ TRefArray *fHighPt; //array of High Pt tracks only
+ TRefArray *fMuons; //array of Muon tracks only
+ TRef fLastTrack; //reference pointer to last track
+ TRef fWebHistogram; //EXEC:GetWebHistogram reference to an histogram in a TWebFile
+ TH1F *fH; //->
+ TBits fTriggerBits; //Bits triggered by this event.
+ Bool_t fIsValid; //
+
+public:
+ Event();
+ virtual ~Event();
+ void Build(Int_t ev, Int_t arg5=600, Float_t ptmin=1);
+ void Clear(Option_t *option ="");
+ Bool_t IsValid() const { return fIsValid; }
+ void ResetHistogramPointer() {fH=0;}
+ void SetNseg(Int_t n) { fNseg = n; }
+ void SetNtrack(Int_t n) { fNtrack = n; }
+ void SetNvertex(Int_t n) { fNvertex = n; SetRandomVertex(); }
+ void SetFlag(UInt_t f) { fFlag = f; }
+ void SetTemperature(Double32_t t) { fTemperature = t; }
+ void SetType(char *type) {strcpy(fType,type);}
+ void SetHeader(Int_t i, Int_t run, Int_t date, Float_t random);
+ Track *AddTrack(Float_t random, Float_t ptmin=1);
+ void SetMeasure(UChar_t which, Int_t what);
+ void SetMatrix(UChar_t x, UChar_t y, Double32_t what) { if (x<3&&y<3) fMatrix[x][y]=what;}
+ void SetRandomVertex();
+
+ Float_t GetClosestDistance(Int_t i) {return fClosestDistance[i];}
+ char *GetType() {return fType;}
+ Int_t GetNtrack() const { return fNtrack; }
+ Int_t GetNseg() const { return fNseg; }
+ Int_t GetNvertex() const { return fNvertex; }
+ UInt_t GetFlag() const { return fFlag; }
+ Double32_t GetTemperature() const { return fTemperature; }
+ EventHeader *GetHeader() { return &fEvtHdr; }
+ TClonesArray *GetTracks() const {return fTracks;}
+ TRefArray *GetHighPt() const {return fHighPt;}
+ TRefArray *GetMuons() const {return fMuons;}
+ Track *GetLastTrack() const {return (Track*)fLastTrack.GetObject();}
+ TH1F *GetHistogram() const {return fH;}
+ TH1 *GetWebHistogram() const {return (TH1*)fWebHistogram.GetObject();}
+ Int_t GetMeasure(UChar_t which) { return (which<10)?fMeasures[which]:0; }
+ Double32_t GetMatrix(UChar_t x, UChar_t y) { return (x<4&&y<4)?fMatrix[x][y]:0; }
+ TBits& GetTriggerBits() { return fTriggerBits; }
+
+ ClassDef(Event,1) //Event structure
+};
+
+
+class HistogramManager {
+
+private:
+ TH1F *fNtrack;
+ TH1F *fNseg;
+ TH1F *fTemperature;
+ TH1F *fPx;
+ TH1F *fPy;
+ TH1F *fPz;
+ TH1F *fRandom;
+ TH1F *fMass2;
+ TH1F *fBx;
+ TH1F *fBy;
+ TH1F *fMeanCharge;
+ TH1F *fXfirst;
+ TH1F *fXlast;
+ TH1F *fYfirst;
+ TH1F *fYlast;
+ TH1F *fZfirst;
+ TH1F *fZlast;
+ TH1F *fCharge;
+ TH1F *fNpoint;
+ TH1F *fValid;
+
+public:
+ HistogramManager(TDirectory *dir);
+ virtual ~HistogramManager();
+
+ void Hfill(Event *event);
+
+ ClassDef(HistogramManager,1) //Manages all histograms
+};
+
+#endif
diff --git a/test/Makefile b/test/Makefile
index b81160a664fcb6c35effd42cb155bb946a24c967..a71b73089920b2eb5d6bcd81d00dac788879196b 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -21,6 +21,15 @@ else
EVENTLIB = $(shell pwd)/$(EVENTSO)
endif
+EVENTMTO = EventMT.$(ObjSuf) EventMTDict.$(ObjSuf)
+EVENTMTS = EventMT.$(SrcSuf) EventMTDict.$(SrcSuf)
+EVENTMTSO = libEventMT.$(DllSuf)
+ifeq ($(PLATFORM),win32)
+EVENTLIB = libEventMT.lib
+else
+EVENTLIB = $(shell pwd)/$(EVENTSMTO)
+endif
+
MAINEVENTO = MainEvent.$(ObjSuf)
MAINEVENTS = MainEvent.$(SrcSuf)
@@ -225,7 +234,7 @@ STRESSHISTS = stressHistogram.$(SrcSuf)
STRESSHIST = stressHistogram$(ExeSuf)
-OBJS = $(EVENTO) $(MAINEVENTO) $(HWORLDO) $(HSIMPLEO) $(MINEXAMO) \
+OBJS = $(EVENTO) $(MAINEVENTO) $(EVENTMTO) $(HWORLDO) $(HSIMPLEO) $(MINEXAMO) \
$(TSTRINGO) $(TCOLLEXO) $(VVECTORO) $(VMATRIXO) $(VLAZYO) \
$(HELLOO) $(ACLOCKO) $(STRESSO) $(TBENCHO) $(BENCHO) \
$(STRESSSHAPESO) $(TCOLLBMO) $(STRESSGEOMETRYO) $(STRESSLO) \
@@ -289,6 +298,40 @@ endif
endif
@echo "$@ done"
+$(EVENTMTSO): $(EVENTMTO)
+ifeq ($(ARCH),aix)
+ /usr/ibmcxx/bin/makeC++SharedLib $(OutPutOpt) $@ $(LIBS) -p 0 $^
+else
+ifeq ($(ARCH),aix5)
+ /usr/vacpp/bin/makeC++SharedLib $(OutPutOpt) $@ $(LIBS) -p 0 $^
+else
+ifeq ($(PLATFORM),macosx)
+# We need to make both the .dylib and the .so
+ $(LD) $(SOFLAGS)$@ $(LDFLAGS) $^ $(OutPutOpt) $@
+ifneq ($(subst $(MACOSX_MINOR),,1234),1234)
+ifeq ($(MACOSX_MINOR),4)
+ ln -sf $@ $(subst .$(DllSuf),.so,$@)
+else
+ $(LD) -bundle -undefined $(UNDEFOPT) $(LDFLAGS) $^ \
+ $(OutPutOpt) $(subst .$(DllSuf),.so,$@)
+endif
+endif
+else
+ifeq ($(PLATFORM),win32)
+ bindexplib $* $^ > $*.def
+ lib -nologo -MACHINE:IX86 $^ -def:$*.def \
+ $(OutPutOpt)$(EVENTMTLIB)
+ $(LD) $(SOFLAGS) $(LDFLAGS) $^ $*.exp $(LIBS) \
+ $(OutPutOpt)$@
+ $(MT_DLL)
+else
+ $(LD) $(SOFLAGS) $(LDFLAGS) $^ $(OutPutOpt) $@ $(EXPLLINKLIBS)
+endif
+endif
+endif
+endif
+ @echo "$@ done"
+
$(EVENT): $(EVENTSO) $(MAINEVENTO)
$(LD) $(LDFLAGS) $(MAINEVENTO) $(EVENTO) $(LIBS) $(OutPutOpt)$@
$(MT_EXE)
@@ -670,12 +713,17 @@ distclean: clean
stressIterators.$(ObjSuf): stressIterators.h
Event.$(ObjSuf): Event.h
+EventMT.$(ObjSuf): EventMT.h
MainEvent.$(ObjSuf): Event.h
EventDict.$(SrcSuf): Event.h EventLinkDef.h
@echo "Generating dictionary $@..."
$(ROOTCINT) -f $@ -c $^
+EventMTDict.$(SrcSuf): EventMT.h EventLinkDef.h
+ @echo "Generating dictionary $@..."
+ $(ROOTCINT) -f $@ -c $^
+
Hello.$(ObjSuf): Hello.h
HelloDict.$(SrcSuf): Hello.h
@echo "Generating dictionary $@..."