forked from sPHENIX-Collaboration/coresoftware
/
PHPatternReco.h
326 lines (254 loc) · 8.2 KB
/
PHPatternReco.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
#ifndef TRACKRECO_PHPATTERNRECO_H
#define TRACKRECO_PHPATTERNRECO_H
#include "VertexFitter.h"
#include <trackbase/TrkrDefs.h>
// Helix Hough includes
#include <HelixHough/SimpleHit3D.h>
#include <HelixHough/SimpleTrack3D.h>
#include <HelixHough/HelixKalmanState.h>
#include <fun4all/SubsysReco.h>
#include <Eigen/Core> // for Matrix
#include <map>
#include <string> // for string
#include <vector>
// forward declarations
class BbcVertexMap;
//class CellularAutomaton;
class HelixHoughBin;
class HelixHoughSpace;
class HelixHoughFuncs;
class PHCompositeNode;
class PHTimer;
class TrkrClusterContainer;
class TrkrHitSetContainer;
class SvtxTrackMap;
class SvtxVertexMap;
class TFile;
class TH2D;
class TH3D;
class TNtuple;
///
class PHPatternReco: public SubsysReco {
public:
PHPatternReco(unsigned int nlayers = 7, unsigned int min_nlayers = 7,
const std::string &name = "PHPatternReco");
~PHPatternReco() override ;
int Init(PHCompositeNode *topNode) override;
int InitRun(PHCompositeNode *topNode) override;
int process_event(PHCompositeNode *topNode) override;
int End(PHCompositeNode *topNode) override;
void set_file_name(const std::string &fname){_fname = fname;}
void set_mag_field(float mag_field) {
_mag_field = mag_field;
}
float get_mag_field() const {
return _mag_field;
}
void set_min_pT(float pt) {
_min_pt = pt;
}
void set_max_kappa(float kappa_max);
void set_min_d(float d_min) {_min_d = d_min;}
void set_max_d(float d_max) {_max_d = d_max;}
void set_min_dzdl(float dzdl_min) {_min_dzdl = dzdl_min; }
void set_max_dzdl(float dzdl_max) {_max_dzdl = dzdl_max;}
void set_min_z0(float z0_min) { _min_z0 = z0_min;}
void set_max_z0(float z0_max) { _max_z0 = z0_max;}
float get_max_kappa() const {return _max_kappa;}
float get_min_z0() const {return _min_z0;}
float get_max_z0() const {return _max_z0;}
/// radiation length per layer, sequential layer indexes required here
void set_material(int layer, float value);
/// turn on DCA limitation
void setCutOnDCA(bool cod) {
_cut_on_dca = cod;
}
/// sets an upper limit on X-Y DCA
void set_dcaxy_cut(float dcut) {
_dcaxy_cut = dcut;
}
/// sets an upper limit on Z DCA
void set_dcaz_cut(float dzcut) {
_dcaz_cut = dzcut;
}
/// sets a chi2 cut
void set_chi2_cut(float chi2_cut) {
_ca_chi2 = chi2_cut;
}
void set_ca_z_cut(float z_cut) {
_ca_z_cut = z_cut;
}
/// adjust the fit pt by a recalibration factor (constant B versus real mag
/// field)
void setPtRescaleFactor(float pt_rescale) {
_pt_rescale = pt_rescale;
}
void set_ca_phi_cut(float phi_cut)
{
_ca_phi_cut = phi_cut;
}
void set_mult_onebin(float mult)
{
_mult_onebin = mult;
}
void set_mult_twobins(float mult)
{
_mult_twobins = mult;
}
void set_mult_threebins(float mult)
{
_mult_threebins= mult;
}
void set_min_zvtx_tracks(unsigned int min_zvtx_tracks)
{
_min_zvtx_tracks = min_zvtx_tracks;
}
const std::vector<int>& get_seeding_layer() const {
return _seeding_layer;
}
void set_seeding_layer(const int* seedingLayer, const int n) {
_seeding_layer.assign(seedingLayer, seedingLayer + n);
}
void add_zoom(unsigned int n_kappa, unsigned int n_phi, unsigned int n_d, unsigned int n_dzdl, unsigned int n_z0);
void set_nzooms() {nzooms = zooms_vec.size();}
void reset_zooms() {zooms_vec.clear();}
private:
//--------------
// InitRun Calls
//--------------
int create_nodes(PHCompositeNode *topNode);
int initialize_geometry(PHCompositeNode *topNode);
//--------------------
// Process Event Calls
//--------------------
int get_nodes(PHCompositeNode *topNode);
int translate_input(PHCompositeNode *topNode);
void set_nbins(unsigned int izoom);
void initialize_houghbin();
void vote_z_init(unsigned int zoomlevel);
void find_track_candidates_z_init(unsigned int zoomlevel);
void vote_z(unsigned int zoomlevel);
void find_track_candidates_z(unsigned int zoomlevel);
void vote_xy(unsigned int zoomlevel);
void find_track_candidates_xy(unsigned int zoomlevel);
void prune_z(unsigned int zoomlevel);
void prune_xy(unsigned int zoomlevel);
void reset_hits_used();
int export_output();
//------------------
// Subfunction Calls
//------------------
/// convert from inverse curvature to momentum
float kappa_to_pt(float kappa);
/// convert from momentum to inverse curvature
float pt_to_kappa(float pt);
void bins_to_SimpleTrack3D(std::vector<SimpleTrack3D>& temp_tracks, int imap, unsigned int zoomlevel);
int build_triplets_to_SimpleTrack3D(std::vector<SimpleTrack3D>& new_tracks, bool forward);
int turnoff_hits_used_in_triplets();
int cellular_automaton_zvtx_init(std::vector<SimpleTrack3D>& temp_tracks);
int fit_vertex();
/// convert the covariance from HelixHough coords to x,y,z,px,py,pz
void convertHelixCovarianceToEuclideanCovariance(float B, float phi,
float d, float kappa, float z0, float dzdl,
Eigen::Matrix<float, 5, 5> const& input,
Eigen::Matrix<float, 6, 6>& output);
void shift_coordinate_system(double dx, double dy, double dz);
float shift_phi_range(float phi);
int _event;
PHTimer *_t_output_io;
std::vector<int> _seeding_layer; //layer numbers that are used for seeding
unsigned int _nlayers; ///< number of detector layers
unsigned int _min_nlayers; ///< minimum number of layers to make a track
unsigned int _ca_nlayers;
unsigned int _ca_min_nlayers;
float _ca_chi2;
std::vector<float> _radii; ///< radial distance of each layer (cm)
std::vector<float> _material; ///< material at each layer in rad. lengths
std::map<int, float> _user_material; ///< material in user ladder indexes
float _mag_field; ///< in Tesla
// bool _reject_ghosts;
bool _remove_hits;
bool _use_max_kappa;
bool fill_multi_zvtx;
float _min_pt;
float _max_kappa;
float _min_d;
float _max_d;
float _min_dzdl;
float _max_dzdl;
float _min_z0;
float _max_z0;
bool _cut_on_dca;
float _dcaxy_cut;
float _dcaz_cut;
float _pt_rescale;
float _ca_phi_cut;
float _ca_z_cut;
float _z_cut;
float _mult_onebin;
float _mult_twobins;
float _mult_threebins;
unsigned int _min_zvtx_tracks;
unsigned int bin;
unsigned int ik;
unsigned int ip;
unsigned int id;
unsigned int il;
unsigned int iz;
unsigned int nkappa;
unsigned int nphi;
unsigned int nd;
unsigned int ndzdl;
unsigned int nz0;
unsigned int cluster_id;
/// recorded layer indexes to internal sequential indexes
std::map<int, unsigned int> _layer_ilayer_map;
// object storage
std::vector<SimpleTrack3D> _temp_tracks;
std::vector<SimpleTrack3D> _tracks; ///< working array of tracks
std::vector<HelixKalmanState> _track_states;
std::vector<double> _track_errors; ///< working array of track chisq
std::vector<Eigen::Matrix<float, 5, 5> > _track_covars; ///< working array of track covariances
std::vector<float> _vertex; ///< working array for collision vertex
std::vector<std::vector<float> > _vertex_list;
// node pointers
BbcVertexMap* _bbc_vertexes;
TrkrClusterContainer* _clustermap;
TrkrHitSetContainer *_hitsets;
SvtxTrackMap* _trackmap;
SvtxVertexMap* _vertexmap;
VertexFitter _vertex_finder;
HelixHoughSpace* _hough_space;
HelixHoughFuncs* _hough_funcs;
// CellularAutomaton* ca;
int _mode;
TNtuple* _ntp_zvtx_by_event;
TNtuple* _ntp_zvtx_by_track;
TH2D* _z0_dzdl;
TH2D* _kappa_phi;
TH2D* _d_phi;
TH3D* _kappa_d_phi;
TFile* _ofile;
TFile* _ofile2;
std::string _fname;
int _nlayers_all;
std::map<int, unsigned int> _layer_ilayer_map_all;
std::vector<float> _radii_all;
std::vector<std::vector<unsigned int> > zooms_vec;
std::map<unsigned int, bool> hits_used;
std::map<unsigned int, SimpleHit3D> hits_map;
std::map<unsigned int, HelixHoughBin* > bins_map;
std::map<unsigned int, HelixHoughBin* > bins_map_prev;
std::map<unsigned int, HelixHoughBin* > bins_map_cur;
std::map<unsigned int, HelixHoughBin* > bins_map_sel;
std::map<unsigned int, unsigned int> kappa_phi_map;
std::map<unsigned int, unsigned int> d_phi_map;
std::map<unsigned int, unsigned int> kappa_d_phi_map;
float hit[50][3];
float hitpos3d[3];
unsigned int nzooms;
bool separate_helicity;
int helicity;
int n_vtx_tracks;
};
#endif // __PHPATTERNRECO_H__