~vpec/maus/tof_calib_read
» Revision
697.144.3
: src/map/MapCppTrackerTrackFit/MapCppTrackerTrackFit.cc
« back to all changes in this revision
Viewing changes to src/map/MapCppTrackerTrackFit/MapCppTrackerTrackFit.cc
- browse files at revision 697.144.3
- compare with another revision
- compare with revision 656.9.11
- download diff
- download tarball
- view history from revision 697.144.3
- Committer: Adam Dobbs
- Date: 2016-07-19 13:29:58 UTC
- mto: (697.142.9 merge-candidate)
- mto: This revision was merged to the branch mainline in revision 723.
- Revision ID: phuccj@gmail.com-20160719132958-hl1gdoalbajb5u4o
Adding forgotten files
- files added:
- src/map/MapCppTrackerTrackFit
added
removed
src/map/MapCppTrackerTrackFit/MapCppTrackerTrackFit.cc
1
/* This file is part of MAUS: http://micewww.pp.rl.ac.uk:8080/projects/maus
2
*
3
* MAUS is free software: you can redistribute it and/or modify
4
* it under the terms of the GNU General Public License as published by
5
* the Free Software Foundation, either version 3 of the License, or
6
* (at your option) any later version.
7
*
8
* MAUS is distributed in the hope that it will be useful,
9
* but WITHOUT ANY WARRANTY; without even the implied warranty of
10
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
* GNU General Public License for more details.
12
*
13
* You should have received a copy of the GNU General Public License
14
* along with MAUS. If not, see <http://www.gnu.org/licenses/>.
15
*
16
*/
17
18
#include "src/map/MapCppTrackerTrackFit/MapCppTrackerTrackFit.hh"
19
20
#include <sstream>
21
22
#include "src/common_cpp/API/PyWrapMapBase.hh"
23
#include "src/common_cpp/Recon/Kalman/MAUSTrackWrapper.hh"
24
25
namespace MAUS {
26
27
PyMODINIT_FUNC init_MapCppTrackerTrackFit(void) {
28
PyWrapMapBase<MapCppTrackerTrackFit>::PyWrapMapBaseModInit
29
("MapCppTrackerTrackFit", "", "", "", "");
30
}
31
32
33
MapCppTrackerTrackFit::MapCppTrackerTrackFit() : MapBase<Data>("MapCppTrackerTrackFit"),
34
_kalman_on(true),
35
_helical_track_fitter(NULL),
36
_straight_track_fitter(NULL) {
37
}
38
39
40
MapCppTrackerTrackFit::~MapCppTrackerTrackFit() {
41
}
42
43
44
void MapCppTrackerTrackFit::_birth(const std::string& argJsonConfigDocument) {
45
// Pull out the global settings
46
if (!Globals::HasInstance()) {
47
GlobalsManager::InitialiseGlobals(argJsonConfigDocument);
48
}
49
Json::Value* json = Globals::GetConfigurationCards();
50
_kalman_on = (*json)["SciFiKalmanOn"].asBool();
51
_use_mcs = (*json)["SciFiKalman_use_MCS"].asBool();
52
_use_eloss = (*json)["SciFiKalman_use_Eloss"].asBool();
53
_use_patrec_seed = (*json)["SciFiSeedPatRec"].asBool();
54
_correct_pz = (*json)["SciFiKalmanCorrectPz"].asBool();
55
// Values used to set the track rating:
56
_excellent_num_trackpoints = (*json)["SciFiExcellentNumTrackpoints"].asInt();
57
_good_num_trackpoints = (*json)["SciFiGoodNumTrackpoints"].asInt();
58
_poor_num_trackpoints = (*json)["SciFiPoorNumTrackpoints"].asInt();
59
_excellent_p_value = (*json)["SciFiExcellentPValue"].asDouble();
60
_good_p_value = (*json)["SciFiGoodPValue"].asDouble();
61
_poor_p_value = (*json)["SciFiPoorPValue"].asDouble();
62
_excellent_num_spacepoints = (*json)["SciFiExcellentNumSpacepoints"].asInt();
63
_good_num_spacepoints = (*json)["SciFiGoodNumSpacepoints"].asInt();
64
_poor_num_spacepoints = (*json)["SciFiPoorNumSpacepoints"].asInt();
65
66
// Build the geometery helper instance
67
MiceModule* module = Globals::GetReconstructionMiceModules();
68
std::vector<const MiceModule*> modules =
69
module->findModulesByPropertyString("SensitiveDetector", "SciFi");
70
_geometry_helper = SciFiGeometryHelper(modules);
71
_geometry_helper.Build();
72
SciFiTrackerMap& geo_map = _geometry_helper.GeometryMap();
73
74
if (_use_patrec_seed) {
75
_seed_value = -1.0;
76
} else {
77
_seed_value = (*json)["SciFiSeedCovariance"].asDouble();
78
}
79
80
// Set up final track fit (Kalman filter)
81
HelicalPropagator* helical_prop = new HelicalPropagator(&_geometry_helper);
82
helical_prop->SetCorrectPz(_correct_pz);
83
helical_prop->SetIncludeMCS(_use_mcs);
84
helical_prop->SetSubtractELoss(_use_eloss);
85
_helical_track_fitter = new Kalman::TrackFit(helical_prop);
86
87
StraightPropagator* straight_prop = new StraightPropagator(&_geometry_helper);
88
straight_prop->SetIncludeMCS(_use_mcs);
89
_straight_track_fitter = new Kalman::TrackFit(straight_prop);
90
91
// Each measurement plane has a unique alignment and rotation => they all need their own
92
// measurement object.
93
for (SciFiTrackerMap::iterator track_it = geo_map.begin();
94
track_it != geo_map.end(); ++track_it) {
95
int tracker_const = (track_it->first == 0 ? -1 : 1);
96
for (SciFiPlaneMap::iterator plane_it = track_it->second.Planes.begin();
97
plane_it != track_it->second.Planes.end(); ++plane_it) {
98
99
int id = plane_it->first * tracker_const;
100
_helical_track_fitter->AddMeasurement(id,
101
new MAUS::SciFiHelicalMeasurements(plane_it->second));
102
_straight_track_fitter->AddMeasurement(id,
103
new MAUS::SciFiStraightMeasurements(plane_it->second));
104
}
105
}
106
}
107
108
109
void MapCppTrackerTrackFit::_death() {
110
if (_helical_track_fitter) {
111
delete _helical_track_fitter;
112
_helical_track_fitter = NULL;
113
}
114
if (_straight_track_fitter) {
115
delete _straight_track_fitter;
116
_straight_track_fitter = NULL;
117
}
118
}
119
120
121
void MapCppTrackerTrackFit::_process(Data* data) const {
122
Spill& spill = *(data->GetSpill());
123
124
/* return if not physics spill */
125
if (spill.GetDaqEventType() != "physics_event")
126
return;
127
128
if (spill.GetReconEvents()) {
129
for (unsigned int k = 0; k < spill.GetReconEvents()->size(); k++) {
130
SciFiEvent *event = spill.GetReconEvents()->at(k)->GetSciFiEvent();
131
if (!event) {
132
continue;
133
}
134
_set_field_values(event);
135
136
// Kalman Track Fit.
137
if (_kalman_on) {
138
event->clear_scifitracks();
139
track_fit(*event);
140
}
141
}
142
} else {
143
std::cout << "No recon events found\n";
144
}
145
}
146
147
void MapCppTrackerTrackFit::_set_field_values(SciFiEvent* event) const {
148
event->set_mean_field_up(_geometry_helper.GetFieldValue(0));
149
event->set_mean_field_down(_geometry_helper.GetFieldValue(1));
150
151
event->set_variance_field_up(_geometry_helper.GetFieldVariance(0));
152
event->set_variance_field_down(_geometry_helper.GetFieldVariance(1));
153
154
event->set_range_field_up(_geometry_helper.GetFieldRange(0));
155
event->set_range_field_down(_geometry_helper.GetFieldRange(1));
156
}
157
158
159
void MapCppTrackerTrackFit::track_fit(SciFiEvent &evt) const {
160
size_t number_helical_tracks = evt.helicalprtracks().size();
161
size_t number_straight_tracks = evt.straightprtracks().size();
162
for (size_t track_i = 0; track_i < number_helical_tracks; track_i++) {
163
SciFiHelicalPRTrack* helical = evt.helicalprtracks().at(track_i);
164
165
Kalman::Track data_track = BuildTrack(helical, &_geometry_helper, 5);
166
Kalman::State seed = ComputeSeed(helical, &_geometry_helper, _use_eloss, _seed_value);
167
168
_helical_track_fitter->SetTrack(data_track);
169
_helical_track_fitter->SetSeed(seed);
170
171
_helical_track_fitter->Filter(false);
172
_helical_track_fitter->Smooth(false);
173
174
SciFiTrack* track = ConvertToSciFiTrack(_helical_track_fitter, &_geometry_helper, helical);
175
calculate_track_rating(track);
176
177
evt.add_scifitrack(track);
178
}
179
for (size_t track_i = 0; track_i < number_straight_tracks; track_i++) {
180
SciFiStraightPRTrack* straight = evt.straightprtracks().at(track_i);
181
Kalman::Track data_track = BuildTrack(straight, &_geometry_helper, 4);
182
183
Kalman::State seed = ComputeSeed(straight, &_geometry_helper, _seed_value);
184
185
_straight_track_fitter->SetTrack(data_track);
186
_straight_track_fitter->SetSeed(seed);
187
188
_straight_track_fitter->Filter(false);
189
_straight_track_fitter->Smooth(false);
190
191
SciFiTrack* track = ConvertToSciFiTrack(_straight_track_fitter, &_geometry_helper, straight);
192
calculate_track_rating(track);
193
194
evt.add_scifitrack(track);
195
}
196
}
197
198
void MapCppTrackerTrackFit::calculate_track_rating(SciFiTrack* track) const {
199
SciFiBasePRTrack* pr_track = track->pr_track_pointer();
200
int number_spacepoints = pr_track->get_num_points();
201
int number_trackpoints = track->GetNumberDataPoints();
202
203
bool excel_numtp = (number_trackpoints >= _excellent_num_trackpoints);
204
bool good_numtp = (number_trackpoints >= _good_num_trackpoints);
205
bool poor_numtp = (number_trackpoints >= _poor_num_trackpoints);
206
bool excel_numsp = (number_spacepoints >= _excellent_num_spacepoints);
207
bool good_numsp = (number_spacepoints >= _good_num_spacepoints);
208
bool poor_numsp = (number_spacepoints >= _poor_num_spacepoints);
209
bool excel_pval = (track->P_value() >= _excellent_p_value);
210
bool good_pval = (track->P_value() >= _good_p_value);
211
bool poor_pval = (track->P_value() >= _poor_p_value);
212
213
int rating = 0;
214
215
if (excel_numtp && excel_numsp && excel_pval) {
216
rating = 1;
217
} else if (good_numtp && good_numsp && good_pval) {
218
rating = 2;
219
} else if (poor_numtp && poor_numsp && poor_pval) {
220
rating = 3;
221
} else {
222
rating = 5;
223
}
224
225
track->SetRating(rating);
226
}
227
228
} // ~namespace MAUS
Loggerhead is a web-based interface for Breezy
Version: 2.0.1