@@ -10,32 +10,17 @@ derives from the TSelector class and implements the member functions
10
10
with specific analysis algorithms. When running the analysis, ROOT
11
11
calls the member functions in a well defined sequence and with well
12
12
defined arguments. By following the model this analysis class can be
13
- used to process data sequentialy on a local workstation and in batch
14
- or in parallel using PROOF.
13
+ used to process data sequentially.
15
14
16
15
ROOT can generate a skeleton class for a given TTree. This skeleton
17
16
class is a good a starting point for the analysis class. It is
18
17
recommended that users follow this method.
19
18
20
- When running with PROOF a number of "slave" processes are used to
21
- analyze the events. The user creates a PROOF session from the client
22
- workstation which allocates a number of slaves. The slaves instantiate
23
- an object of the users analysis class. Each slave processes a fraction
24
- of the events as determined by the relative performance of the servers
25
- on which the slaves are running. The PROOF system takes care of distributing
26
- the work. It calls the TSelector functions in each slave. It also
27
- distributes the input list to the slaves. This is a TList with streamable
28
- objects provided in the client. After processing the events PROOF combines
29
- the partial results of the slaves and returns the consolidated objects
30
- (e.g. histograms) to the client session.
31
-
32
19
The two sequences below show the order in which the TSelector member
33
20
functions are called when either processing a tree or chain on a single
34
- workstation or when using PROOF to process trees or collections of keyed
35
- objects on a distributed system. When running on a sequential query
36
- the user calls TTree::Process() and TChain::Process(), when using PROOF
37
- the user calls TDSet::Process() (a few other entry points are available
38
- as well). Each of the member functions is described in detail after the
21
+ workstation. When running on a sequential query
22
+ the user calls TTree::Process() and TChain::Process().
23
+ Each of the member functions is described in detail after the
39
24
call sequences.
40
25
41
26
@@ -57,29 +42,6 @@ Init()
57
42
SlaveTerminate()
58
43
Terminate()
59
44
60
-
61
- Distributed, parallel query, using PROOF:
62
-
63
- ++ CLIENT Session ++ ++ (n) SLAVES ++
64
- Begin()
65
- SlaveBegin()
66
- Init()
67
- Notify()
68
- Process()
69
- ...
70
- Process()
71
- ...
72
- Init()
73
- Notify()
74
- Process()
75
- ...
76
- Process()
77
- ...
78
- SlaveTerminate()
79
- Terminate()
80
-
81
-
82
-
83
45
==============================================================================
84
46
Main Framework Functions
85
47
==============================================================================
@@ -89,18 +51,12 @@ The Begin() and SlaveBegin() member functions
89
51
90
52
The Begin() function is called at the start of the query. It always runs
91
53
in the client ROOT session. The SlaveBegin() function is either called
92
- in the client or when running with PROOF, on each of the slaves .
54
+ in the client.
93
55
All initialization that is needed for Process() (see below) must therefore
94
56
be put in SlaveBegin(). Code which needs to access the local client
95
57
environment, e.g. graphics or the filesystem must be put in Begin().
96
- When running with PROOF the input list (fInput) is distributed to the
97
- slaves after Begin() returns and before SlaveBegin() is called.
98
- This way objects on the client can be made available to the
99
- TSelector instances in the slaves.
100
58
101
- The tree argument is deprecated. (In the case of PROOF the tree is not
102
- available on the client and 0 will be passed. The Init() function should
103
- be used to implement operations depending on the tree)
59
+ The tree argument is deprecated.
104
60
105
61
Signature:
106
62
@@ -115,8 +71,7 @@ The Init() member function
115
71
The Init() function is called when the selector needs to initialize
116
72
a new tree or chain. Typically here the branch addresses of the tree
117
73
will be set. It is normally not necessary to make changes to the generated
118
- code, but the routine can be extended by the user if needed. Init() will
119
- be called many times when running with PROOF.
74
+ code, but the routine can be extended by the user if needed.
120
75
121
76
Signature:
122
77
@@ -127,8 +82,8 @@ The Notify() member function
127
82
----------------------------
128
83
129
84
The Notify() function is called when a new file is opened. This can be either
130
- for a new TTree in a TChain or when when a new TTree is started when using
131
- PROOF. Typically here the branch pointers will be retrieved. It is normaly
85
+ for a new TTree in a TChain.
86
+ Typically here the branch pointers will be retrieved. It is normally
132
87
not necessary to make changes to the generated code, but the routine
133
88
can be extended by the user if needed.
134
89
@@ -140,13 +95,11 @@ Signature:
140
95
The Process() member function
141
96
-----------------------------
142
97
143
- The Process() function is called for each entry in the tree (or possibly
144
- keyed object in the case of PROOF) to be processed. The entry argument
98
+ The Process() function is called for each entry in the tree
99
+ to be processed. The entry argument
145
100
specifies which entry in the currently loaded tree is to be processed.
146
101
It can be passed to either TTree::GetEntry() or TBranch::GetEntry()
147
- to read either all or the required parts of the data. When processing
148
- keyed objects with PROOF, the object is already loaded and is available
149
- via the fObject pointer.
102
+ to read either all or the required parts of the data.
150
103
151
104
This function should contain the "body" of the analysis. It can contain
152
105
simple or elaborate selection criteria, run algorithms on the data
@@ -161,11 +114,7 @@ The SlaveTerminate() and Terminate() member functions
161
114
-----------------------------------------------------
162
115
163
116
The SlaveTerminate() function is called after all entries or objects
164
- have been processed. When running with PROOF it is executed by
165
- each of the slaves. It can be used to do post processing before the
166
- partial results of the slaves are merged. After SlaveTerminate()
167
- the objects in the fOutput lists in the slaves are combined by the
168
- PROOF system and returned to the client ROOT session.
117
+ have been processed.
169
118
The Terminate() function is the last function to be called during
170
119
a query. It always runs on the client, it can be used to present
171
120
the results graphically or save the results to file.
@@ -198,8 +147,7 @@ Signature:
198
147
The SetInputList() member function
199
148
----------------------------------
200
149
201
- Setter for the input list of objects to be transfered to the
202
- remote PROOF servers. The input list is transfered after the execution
150
+ The input list is transfered after the execution
203
151
of the Begin() function, so objects can still be added in Begin() to
204
152
this list. These objects are then available during the selection process
205
153
(e.g. predefined histograms, etc.). Does not transfer ownership.
@@ -214,10 +162,8 @@ The GetOutputList() member function
214
162
215
163
Getter for the output list of objects to be transfered back to the
216
164
client. The output list on each slave is transfered back to the client
217
- session after the execution of the SlaveTerminate() function. The PROOF
218
- master server merges the objects from the slave output lists in a single
219
- output list (merging partial objects into a single one). Ownership remains
220
- with the selector. Each query will clear this list.
165
+ session after the execution of the SlaveTerminate() function.
166
+ Ownership remains with the selector. Each query will clear this list.
221
167
222
168
Signature:
223
169
0 commit comments