flight/doc/ffilter.cxx

//#############################################################################################################################################################
//
// filter.c # by Emiliano Mocchiutti (2005/11/25)
//
// Changelog:
// 
// (2006/02/24) Cannot load tracker level0 and level2 data simultaneously, fixed.
//
//#############################################################################################################################################################
//
// Template for the event selection using the EventViewer. The function must be called "filter" while the filename where the function is defined can be anyone.
//
//#############################################################################################################################################################
//
// The idea of the event selection is the following: 
// 1) you must know which kind of data the EventViewer program is using (for example tracker level0, level1 or level2 data?)
// 2) depending on the available data you can define your selection.
// 3) information about data used can be found in the structure "level" which contains the following variables:
//    typedef struct Levels {
//        Int_t calo;            // if equal to 0 calorimeter level 0 , if equal to 1 calorimeter level 1 data.
//        Int_t calol2;          // for the moment this is always 0
//        Int_t tof;             // tof/trigger level 1 or level 0 data
//        Int_t track;           // tracker level 1 or level 0 data
//        Int_t track2;          // if set to one there are tracker level2 data
//        Int_t s4;              // S4 level 1 or level0 data
//        Int_t ac;              // AC level 1 or level0 data  
//        Int_t nd;              // always 0 for the moment
//    } level;
//    evno is the event number to be processed.
//    All data coming from yoda are stored in the tree called "otr", tree "ttr" contains only level2 tracker data.
// 4) to learn how to change things look at examples below.
// 5) to stop the eventviewer this function must return 1 as value, when returning 0 means go on searching.
// 6) is it possible to combine information from different detectors.
//

int filter(Int_t evno, TTree *otr, TTree *ttr, Levels & level){
    //
    // example n. 1
    // select events where the energy deposit in S4 is greater than 0.7 MIP
    //
    Bool_t S4 = true;
    //
    // check the data level
    //
    if ( level.s4 == 0 ) {
        S4 = false;
        //
        // determine in which branch we can find S4 data in the tree otr.
        //
        pamela::S4::S4Event  *s4 = 0;
        otr->SetBranchAddress("S4.Event", &s4);
        otr->GetEntry(evno);
        //
        // if we have level0 data we must calibrate the data to make a selection in MIP.
        //      
        Float_t s4data = ((float)s4->S4_DATA -32.) *  0.29;    
        //
        // if the condition is satisfied S4 is true.
        //
        if ( s4data>0.7 ) S4 = true;
    };

    //
    // example n. 2
    // select events with one or more tracks
    //
    Bool_t TRACKER = true;
    //
    // check we have tracker LEVEL2 data
    //
    if ( level.track2 == 1 ){
        TRACKER = false;
        //
        // access tracker level2 data, store variables in the structure trk.
        //
        struct Tracklev2 trk;
        settrklev2(ttr,trk);
        //
        // get entry, here we are assuming we have syncronized data.
        //
        ttr->GetEntry(evno);
        //
        if ( trk.ntrk > 0 ){
            //
            TRACKER = true;
            //
            //  example of how to calculate rigidity from deflection and select negative particles with rigidity less than 1 GV:
            //
            //      Float_t rig = 0.;
            //
            //      notice that in the structure trk columns and rows of matrixes are inverted respect to the fortran style al[0][4] is deflection for the first track 
            //      al[1][4] would be deflection for the second track, etc.
            //
            //      if ( trk.al[0][4] != 0. ) rig = 1./trk.al[0][4];
            //      if ( abs(rig) < 1. ) TRACKER = true;
        };
    };

    //
    // example n. 3
    // select events with 6 hist in the X-view of the tracker and 6 hit in the Y-view of the tracker
    //
    Bool_t TRACKER2 = true;
    //
    if ( level.track == 0 ){
        TRACKER2 = false;
        Int_t fnclx = 0;
        Int_t fncly = 0;
        pamela::tracker::TrackerEvent *ttrk = 0;    
        otr->SetBranchAddress("Tracker.Event", &ttrk);    
        otr->GetEntry(evno);    
        for (Int_t l = 0; l<12; l++){   
            Int_t planeno = ttrk->DSPnumber[l]-1;       
            if ( planeno < 0 || planeno > 11 ) planeno = 0;
            if ( planeno >= 0 ) {
                if ( (planeno+1)%2 ){
                    for (Int_t m = 0; m<3; m++){
                        if ( ttrk->signcluster[l][m] != 0. ){
                            fncly++;
                        };
                    };         
                } else {
                    for (Int_t m = 0; m<3; m++){
                        if ( ttrk->signcluster[l][m] != 0. ){
                            fnclx++;
                        };
                    };
                };
            };    
        };
        if ( fnclx == 6 &&  fncly == 6 ) TRACKER2 = true;
    };
    
    //
    // example n. 4
    // select events with qtot greater than 100 and nstrip greater than 100 in the calorimeter (interacting particles)
    //
    Bool_t CALO = true;
    //
    // check if we have calorimeter level1 data
    //
    if ( level.calo == 1 ){
        CALO = false;
        CalorimeterLevel1 *calo = new CalorimeterLevel1();
        otr->SetBranchAddress("CaloLevel1.Event", &calo);
        otr->GetEntry(evno);
        if ( calo->qtot > 100 && calo->nstrip > 100) CALO = true;
    };

    //
    // example n. 5
    // select calorimeter selftrigger events
    //
    Bool_t TRIGGER = true;
    if ( level.tof == 0 || level.tof == 1 ){
        //      
        Bool_t TRIGGER = false;
        //
        // define where to find in the tree otr the Trigger.Event branch
        //
        pamela::trigger::TriggerEvent  *trig = 0;
        otr->SetBranchAddress("Trigger.Event", &trig);
        //
        // get the entry number "evno" passed by the main EventViewer program
        //
        otr->GetEntry(evno);  
        //
        // check the first element of the variable patterntrig which tell us if this one is a calorimeter trigger
        //
        if ( trig->patterntrig[0] ) {
            //
            // set the boolean variable TRIGGER to true. Instead of setting this variable it is possible to return(1) here.
            //
            TRIGGER = true;
        };
        //
        // example if one want to select S4/pulser triggers
        //
        //if ( trig->patterntrig[1] & (1<<0) ) TRIGGER = true;
    };

    //
    // example n. 6
    // select events with AC hits
    //
    Bool_t AC = true;
    //
    // in the case of level0 data
    //
    if ( level.ac == 0){
        AC = false;
        pamela::anticounter::AnticounterEvent  *ace = 0;
        otr->SetBranchAddress("Anticounter.Event", &ace);
        otr->GetEntry(evno);
        Int_t hitmapA = 0;
        Int_t hitmapB = 0;
        //
        // hitmap variable contain the information
        //
        hitmapA = ace->hitmap[0];
        hitmapB = ace->hitmap[1];
        if ( hitmapA || hitmapB ) AC = true;
    };
    //
    // in the case of level1 data
    //
    if ( level.ac == 1){
        AC = false;
        AnticounterLevel1 *ace = new AnticounterLevel1();
        otr->SetBranchAddress("AcLevel1.Event", &ace);
        otr->GetEntry(evno);
        Int_t hitmapA = 0;
        Int_t hitmapB = 0;
        hitmapA = ace->hitmap[0];
        hitmapB = ace->hitmap[1];
        if ( hitmapA || hitmapB ) AC = true;
    };

    //
    // example n. 7
    // select events in which we have at least one AC hit outside the trigger time window (we need level1 data)
    //
    Bool_t AC2 = true;
    if ( level.ac == 1){
        AC2 = false;
        AnticounterLevel1 *ace = new AnticounterLevel1();
        otr->SetBranchAddress("AcLevel1.Event", &ace);
        otr->GetEntry(evno);
        Int_t hitstatusA = 0;
        Int_t hitstatusB = 0;
        Int_t hitmapA = 0;
        Int_t hitmapB = 0;
        hitmapA = ace->hitmap[0];
        hitmapB = ace->hitmap[1];
        hitstatusA = ace->hitstatus[0];
        hitstatusB = ace->hitstatus[1];
        Int_t deltaA = hitstatusA - hitmapA;
        Int_t deltaB = hitstatusB - hitmapB;
        if ( deltaA || deltaB ) AC2 = true;
    };


    //
    // example n. 8
    // select events with one or more detected neutrons:
    //
    Bool_t ND = true;
    if ( level.nd == 0){
        ND = false;
        Int_t tmpSize;    
        Int_t nTrig = 0;
        pamela::neutron::NeutronEvent  *ne = 0;
        pamela::neutron::NeutronRecord *nr = 0;
        otr->SetBranchAddress("Neutron.Event", &ne);
        otr->GetEntry(evno);
        tmpSize = ne->Records->GetEntries();
        for (Int_t j = 0; j < tmpSize; j++){
            nr = (pamela::neutron::NeutronRecord*)ne->Records->At(j);   
            nTrig        += (int)nr->trigPhysics;
        };    
        if ( nTrig > 0 ) ND = true;
    };

    //
    // Here we can use the boolean variables and decide if the event passed the selecion or not.
    // 
    // if the event pass the selection return one, zero otherwise.
    //

    //
    // Some examples:
    //

    // A - select only calorimeter selftrigger events 
    //
    // if ( TRIGGER ) return(1);

    // B - select calorimeter self-trigger events with at least one fitted track:
    //
    // if ( TRIGGER && TRACKER ) return(1);

    // C - select events with at least one track (default behaviour so it is uncommented)
    //
    if ( TRACKER ) return(1);    

    // D - select interacting events in the calorimeter
    //
    //    if  ( CALO ) return(1);


    // E - select events with hit in the anticounters
    //
    //    if ( AC ) return(1);

    // F - select events with energy release in S4 greater than 0.7 MIPs, at least one track, no hit in the anticounters and at least one neutron detected:
    //
    // if ( S4 && TRACKER && !AC && ND ) return(1);

    //
    // if nothing match, return 0.
    //
    return(0);
};
1	//#############################################################################################################################################################
2	//
3	// filter.c # by Emiliano Mocchiutti (2005/11/25)
4	//
5	// Changelog:
6	//
7	// (2006/02/24) Cannot load tracker level0 and level2 data simultaneously, fixed.
8	//
9	//#############################################################################################################################################################
10	//
11	// Template for the event selection using the EventViewer. The function must be called "filter" while the filename where the function is defined can be anyone.
12	//
13	//#############################################################################################################################################################
14	//
15	// The idea of the event selection is the following:
16	// 1) you must know which kind of data the EventViewer program is using (for example tracker level0, level1 or level2 data?)
17	// 2) depending on the available data you can define your selection.
18	// 3) information about data used can be found in the structure "level" which contains the following variables:
19	// typedef struct Levels {
20	// Int_t calo; // if equal to 0 calorimeter level 0 , if equal to 1 calorimeter level 1 data.
21	// Int_t calol2; // for the moment this is always 0
22	// Int_t tof; // tof/trigger level 1 or level 0 data
23	// Int_t track; // tracker level 1 or level 0 data
24	// Int_t track2; // if set to one there are tracker level2 data
25	// Int_t s4; // S4 level 1 or level0 data
26	// Int_t ac; // AC level 1 or level0 data
27	// Int_t nd; // always 0 for the moment
28	// } level;
29	// evno is the event number to be processed.
30	// All data coming from yoda are stored in the tree called "otr", tree "ttr" contains only level2 tracker data.
31	// 4) to learn how to change things look at examples below.
32	// 5) to stop the eventviewer this function must return 1 as value, when returning 0 means go on searching.
33	// 6) is it possible to combine information from different detectors.
34	//
35
36	int filter(Int_t evno, TTree otr, TTree ttr, Levels & level){
37	//
38	// example n. 1
39	// select events where the energy deposit in S4 is greater than 0.7 MIP
40	//
41	Bool_t S4 = true;
42	//
43	// check the data level
44	//
45	if ( level.s4 == 0 ) {
46	S4 = false;
47	//
48	// determine in which branch we can find S4 data in the tree otr.
49	//
50	pamela::S4::S4Event *s4 = 0;
51	otr->SetBranchAddress("S4.Event", &s4);
52	otr->GetEntry(evno);
53	//
54	// if we have level0 data we must calibrate the data to make a selection in MIP.
55	//
56	Float_t s4data = ((float)s4->S4_DATA -32.) * 0.29;
57	//
58	// if the condition is satisfied S4 is true.
59	//
60	if ( s4data>0.7 ) S4 = true;
61	};
62
63	//
64	// example n. 2
65	// select events with one or more tracks
66	//
67	Bool_t TRACKER = true;
68	//
69	// check we have tracker LEVEL2 data
70	//
71	if ( level.track2 == 1 ){
72	TRACKER = false;
73	//
74	// access tracker level2 data, store variables in the structure trk.
75	//
76	struct Tracklev2 trk;
77	settrklev2(ttr,trk);
78	//
79	// get entry, here we are assuming we have syncronized data.
80	//
81	ttr->GetEntry(evno);
82	//
83	if ( trk.ntrk > 0 ){
84	//
85	TRACKER = true;
86	//
87	// example of how to calculate rigidity from deflection and select negative particles with rigidity less than 1 GV:
88	//
89	// Float_t rig = 0.;
90	//
91	// notice that in the structure trk columns and rows of matrixes are inverted respect to the fortran style al[0][4] is deflection for the first track
92	// al[1][4] would be deflection for the second track, etc.
93	//
94	// if ( trk.al[0][4] != 0. ) rig = 1./trk.al[0][4];
95	// if ( abs(rig) < 1. ) TRACKER = true;
96	};
97	};
98
99	//
100	// example n. 3
101	// select events with 6 hist in the X-view of the tracker and 6 hit in the Y-view of the tracker
102	//
103	Bool_t TRACKER2 = true;
104	//
105	if ( level.track == 0 ){
106	TRACKER2 = false;
107	Int_t fnclx = 0;
108	Int_t fncly = 0;
109	pamela::tracker::TrackerEvent *ttrk = 0;
110	otr->SetBranchAddress("Tracker.Event", &ttrk);
111	otr->GetEntry(evno);
112	for (Int_t l = 0; l<12; l++){
113	Int_t planeno = ttrk->DSPnumber[l]-1;
114	if ( planeno < 0 \|\| planeno > 11 ) planeno = 0;
115	if ( planeno >= 0 ) {
116	if ( (planeno+1)%2 ){
117	for (Int_t m = 0; m<3; m++){
118	if ( ttrk->signcluster[l][m] != 0. ){
119	fncly++;
120	};
121	};
122	} else {
123	for (Int_t m = 0; m<3; m++){
124	if ( ttrk->signcluster[l][m] != 0. ){
125	fnclx++;
126	};
127	};
128	};
129	};
130	};
131	if ( fnclx == 6 && fncly == 6 ) TRACKER2 = true;
132	};
133
134	//
135	// example n. 4
136	// select events with qtot greater than 100 and nstrip greater than 100 in the calorimeter (interacting particles)
137	//
138	Bool_t CALO = true;
139	//
140	// check if we have calorimeter level1 data
141	//
142	if ( level.calo == 1 ){
143	CALO = false;
144	CalorimeterLevel1 *calo = new CalorimeterLevel1();
145	otr->SetBranchAddress("CaloLevel1.Event", &calo);
146	otr->GetEntry(evno);
147	if ( calo->qtot > 100 && calo->nstrip > 100) CALO = true;
148	};
149
150	//
151	// example n. 5
152	// select calorimeter selftrigger events
153	//
154	Bool_t TRIGGER = true;
155	if ( level.tof == 0 \|\| level.tof == 1 ){
156	//
157	Bool_t TRIGGER = false;
158	//
159	// define where to find in the tree otr the Trigger.Event branch
160	//
161	pamela::trigger::TriggerEvent *trig = 0;
162	otr->SetBranchAddress("Trigger.Event", &trig);
163	//
164	// get the entry number "evno" passed by the main EventViewer program
165	//
166	otr->GetEntry(evno);
167	//
168	// check the first element of the variable patterntrig which tell us if this one is a calorimeter trigger
169	//
170	if ( trig->patterntrig[0] ) {
171	//
172	// set the boolean variable TRIGGER to true. Instead of setting this variable it is possible to return(1) here.
173	//
174	TRIGGER = true;
175	};
176	//
177	// example if one want to select S4/pulser triggers
178	//
179	//if ( trig->patterntrig[1] & (1<<0) ) TRIGGER = true;
180	};
181
182	//
183	// example n. 6
184	// select events with AC hits
185	//
186	Bool_t AC = true;
187	//
188	// in the case of level0 data
189	//
190	if ( level.ac == 0){
191	AC = false;
192	pamela::anticounter::AnticounterEvent *ace = 0;
193	otr->SetBranchAddress("Anticounter.Event", &ace);
194	otr->GetEntry(evno);
195	Int_t hitmapA = 0;
196	Int_t hitmapB = 0;
197	//
198	// hitmap variable contain the information
199	//
200	hitmapA = ace->hitmap[0];
201	hitmapB = ace->hitmap[1];
202	if ( hitmapA \|\| hitmapB ) AC = true;
203	};
204	//
205	// in the case of level1 data
206	//
207	if ( level.ac == 1){
208	AC = false;
209	AnticounterLevel1 *ace = new AnticounterLevel1();
210	otr->SetBranchAddress("AcLevel1.Event", &ace);
211	otr->GetEntry(evno);
212	Int_t hitmapA = 0;
213	Int_t hitmapB = 0;
214	hitmapA = ace->hitmap[0];
215	hitmapB = ace->hitmap[1];
216	if ( hitmapA \|\| hitmapB ) AC = true;
217	};
218
219	//
220	// example n. 7
221	// select events in which we have at least one AC hit outside the trigger time window (we need level1 data)
222	//
223	Bool_t AC2 = true;
224	if ( level.ac == 1){
225	AC2 = false;
226	AnticounterLevel1 *ace = new AnticounterLevel1();
227	otr->SetBranchAddress("AcLevel1.Event", &ace);
228	otr->GetEntry(evno);
229	Int_t hitstatusA = 0;
230	Int_t hitstatusB = 0;
231	Int_t hitmapA = 0;
232	Int_t hitmapB = 0;
233	hitmapA = ace->hitmap[0];
234	hitmapB = ace->hitmap[1];
235	hitstatusA = ace->hitstatus[0];
236	hitstatusB = ace->hitstatus[1];
237	Int_t deltaA = hitstatusA - hitmapA;
238	Int_t deltaB = hitstatusB - hitmapB;
239	if ( deltaA \|\| deltaB ) AC2 = true;
240	};
241
242
243	//
244	// example n. 8
245	// select events with one or more detected neutrons:
246	//
247	Bool_t ND = true;
248	if ( level.nd == 0){
249	ND = false;
250	Int_t tmpSize;
251	Int_t nTrig = 0;
252	pamela::neutron::NeutronEvent *ne = 0;
253	pamela::neutron::NeutronRecord *nr = 0;
254	otr->SetBranchAddress("Neutron.Event", &ne);
255	otr->GetEntry(evno);
256	tmpSize = ne->Records->GetEntries();
257	for (Int_t j = 0; j < tmpSize; j++){
258	nr = (pamela::neutron::NeutronRecord*)ne->Records->At(j);
259	nTrig += (int)nr->trigPhysics;
260	};
261	if ( nTrig > 0 ) ND = true;
262	};
263
264	//
265	// Here we can use the boolean variables and decide if the event passed the selecion or not.
266	//
267	// if the event pass the selection return one, zero otherwise.
268	//
269
270	//
271	// Some examples:
272	//
273
274	// A - select only calorimeter selftrigger events
275	//
276	// if ( TRIGGER ) return(1);
277
278	// B - select calorimeter self-trigger events with at least one fitted track:
279	//
280	// if ( TRIGGER && TRACKER ) return(1);
281
282	// C - select events with at least one track (default behaviour so it is uncommented)
283	//
284	if ( TRACKER ) return(1);
285
286	// D - select interacting events in the calorimeter
287	//
288	// if ( CALO ) return(1);
289
290
291	// E - select events with hit in the anticounters
292	//
293	// if ( AC ) return(1);
294
295	// F - select events with energy release in S4 greater than 0.7 MIPs, at least one track, no hit in the anticounters and at least one neutron detected:
296	//
297	// if ( S4 && TRACKER && !AC && ND ) return(1);
298
299	//
300	// if nothing match, return 0.
301	//
302	return(0);
303	};