← Back to branch summary

~ajdobbs/maus/rootfitter

« back to all changes in this revision

Viewing changes to src/common_cpp/DataStructure/Global/PrimaryChain.cc

  • Committer: Adam Dobbs
  • Date: 2017-02-28 17:58:27 UTC
  • mfrom: (1149.2.21 maus-primarychain)
  • Revision ID: phuccj@gmail.com-20170228175827-vhunrks5hzqsayb5
Merge: global recon updates

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/common_cpp/DataStructure/Global/PrimaryChain.cc
17
17
 
18
18
#include "DataStructure/Global/PrimaryChain.hh"
19
19
 
20
 
#include <vector>
21
 
#include <algorithm>
22
 
#include <utility>
23
 
 
24
 
#include "Utils/Exception.hh"
 
20
#include "Utils/Squeak.hh"
25
21
 
26
22
namespace MAUS {
27
23
namespace DataStructure {
29
25
 
30
26
// Default constructor
31
27
PrimaryChain::PrimaryChain()
32
 
    : _mapper_name(""),
33
 
      _goodness_of_fit(0.) {
34
 
  _tracks = new std::vector<MAUS::DataStructure::Global::TRefTrackPair*>();
35
 
  _parent_primary_chains = new TRefArray();
 
28
    : _mapper_name(""), _type(MAUS::DataStructure::Global::kNoChainType),
 
29
      _multiplicity(MAUS::DataStructure::Global::kUnique), _us_daughter(NULL), _ds_daughter(NULL) {
 
30
  _tracks = new TRefArray();
36
31
}
37
32
 
38
 
// Copy contructor
 
33
// Copy constructor
39
34
PrimaryChain::PrimaryChain(const PrimaryChain &primary_chain)
40
 
    : _mapper_name(""),
41
 
      _goodness_of_fit(primary_chain._goodness_of_fit),
42
 
      _comments(primary_chain._comments) {
43
 
  _tracks = new std::vector<MAUS::DataStructure::Global::TRefTrackPair*>();
44
 
  std::vector<MAUS::DataStructure::Global::TRefTrackPair*>::iterator iter;
45
 
  for (iter = primary_chain._tracks->begin();
46
 
      iter < primary_chain._tracks->end(); iter++) {
47
 
    _tracks->push_back(new MAUS::DataStructure::Global::TRefTrackPair(**iter));
48
 
  }
49
 
  _parent_primary_chains =
50
 
      new TRefArray(*primary_chain.get_parent_primary_chains());
 
35
    : _mapper_name(primary_chain._mapper_name), _type(primary_chain._type),
 
36
      _multiplicity(primary_chain._multiplicity),
 
37
      _us_daughter(primary_chain._us_daughter), _ds_daughter(primary_chain._ds_daughter) {
 
38
  _tracks = new TRefArray(*primary_chain._tracks);
51
39
}
52
40
 
53
 
// Constructor setting #_mapper_name
 
41
// Constructor setting mapper name
54
42
PrimaryChain::PrimaryChain(std::string mapper_name)
55
 
    : _mapper_name(mapper_name),
56
 
      _goodness_of_fit(0.) {
57
 
  _tracks = new std::vector<MAUS::DataStructure::Global::TRefTrackPair*>();
58
 
  _parent_primary_chains = new TRefArray();
 
43
    : _mapper_name(mapper_name), _type(MAUS::DataStructure::Global::kNoChainType),
 
44
      _multiplicity(MAUS::DataStructure::Global::kUnique), _us_daughter(NULL), _ds_daughter(NULL) {
 
45
  _tracks = new TRefArray();
 
46
}
 
47
 
 
48
// Constructor setting mapper name and chain type
 
49
PrimaryChain::PrimaryChain(std::string mapper_name,
 
50
    MAUS::DataStructure::Global::ChainType chain_type)
 
51
    : _mapper_name(mapper_name), _type(chain_type),
 
52
      _multiplicity(MAUS::DataStructure::Global::kUnique), _us_daughter(NULL), _ds_daughter(NULL) {
 
53
  _tracks = new TRefArray();
59
54
}
60
55
 
61
56
// Destructor
62
57
PrimaryChain::~PrimaryChain() {
63
 
  std::vector<MAUS::DataStructure::Global::TRefTrackPair*>::iterator iter;
64
 
  for (iter = _tracks->begin(); iter < _tracks->end(); iter++)
65
 
    delete *iter;
66
 
  delete _parent_primary_chains;
 
58
  delete _tracks;
67
59
}
68
60
 
69
 
// Assignment operator
 
61
// Assignment Operator
70
62
PrimaryChain& PrimaryChain::operator=(const PrimaryChain &primary_chain) {
71
63
  if (this == &primary_chain) {
72
64
    return *this;
73
65
  }
74
 
  _mapper_name        = primary_chain._mapper_name;
75
 
  std::vector<MAUS::DataStructure::Global::TRefTrackPair*>::iterator iter;
76
 
  for (iter = primary_chain._tracks->begin();
77
 
      iter < primary_chain._tracks->end(); iter++) {
78
 
    _tracks->push_back(new MAUS::DataStructure::Global::TRefTrackPair(**iter));
79
 
  }
80
 
  _goodness_of_fit    = primary_chain._goodness_of_fit;
81
 
  _parent_primary_chains =
82
 
      new TRefArray(*primary_chain._parent_primary_chains);
83
 
  _comments = primary_chain._comments;
 
66
  _mapper_name = primary_chain._mapper_name;
 
67
  _type = primary_chain._type;
 
68
  _multiplicity = primary_chain._multiplicity;
 
69
  _tracks = new TRefArray(*primary_chain._tracks);
 
70
  _us_daughter = primary_chain._us_daughter;
 
71
  _ds_daughter = primary_chain._ds_daughter;
84
72
  return *this;
85
73
}
86
74
 
87
 
// Create a new PrimaryChain, identical to the original, but separate.  All
88
 
// constituent tracks are also cloned.
89
 
PrimaryChain* PrimaryChain::Clone() const {
90
 
  MAUS::DataStructure::Global::PrimaryChain* primaryChainNew =
91
 
      new MAUS::DataStructure::Global::PrimaryChain(_mapper_name);
92
 
 
93
 
  MAUS::DataStructure::Global::Track *track;
94
 
  MAUS::DataStructure::Global::Track *parent;
95
 
  // MAUS::DataStructure::Global::Track const *track;
96
 
  // MAUS::DataStructure::Global::Track const *parent;
97
 
 
98
 
  // First, we loop through all of the tracks, cloning each, and
99
 
  // placing the clones in a temporary map...
100
 
  std::map<const MAUS::DataStructure::Global::Track*,
101
 
           MAUS::DataStructure::Global::Track*> tempMap;
102
 
  for (size_t i = 0; i < _tracks->size(); i++) {
103
 
    track = _tracks->at(i)->GetTrack();
104
 
    tempMap[track] = track->Clone();
105
 
  }
106
 
 
107
 
  // Second, we loop through again.  Clones are added to the new
108
 
  // PrimaryChain, either as Primaries or with the appropriate
109
 
  // Clone...
110
 
  for (size_t i = 0; i < _tracks->size(); i++) {
111
 
    track = _tracks->at(i)->GetTrack();
112
 
    if (!_tracks->at(i)->second.IsValid()) {
113
 
      primaryChainNew->AddPrimaryTrack(tempMap[track]);
114
 
    } else {
115
 
      parent = _tracks->at(i)->GetParent();
116
 
      primaryChainNew->AddTrack(tempMap[track],
117
 
                                tempMap[parent]);
118
 
    }
119
 
  }
120
 
 
121
 
  primaryChainNew->set_goodness_of_fit(_goodness_of_fit);
122
 
 
123
 
  primaryChainNew->set_parent_primary_chains(
124
 
      new TRefArray(*_parent_primary_chains));
125
 
 
126
 
  primaryChainNew->set_comments(_comments);
127
 
 
128
 
  return primaryChainNew;
129
 
}
130
 
 
131
 
bool PrimaryChain::AddTrack(MAUS::DataStructure::Global::Track* track,
132
 
                            MAUS::DataStructure::Global::Track* parent) {
133
 
  // Check track is valid
134
 
  if (!track) {
135
 
    throw(Exceptions::Exception(Exceptions::recoverable,
136
 
                 "Attempting to add a NULL Track",
137
 
                 "DataStructure::Global::PrimaryChain::AddTrack()"));
138
 
  }
139
 
 
140
 
  // Check parent is valid.  If not, then add the track as a primary
141
 
  if (!parent)
142
 
    return AddPrimaryTrack(track);
143
 
 
144
 
  // Check parent is already in the _track vector.
145
 
  bool found = false;
146
 
  for (size_t i = 0; i < _tracks->size(); i++) {
147
 
    if (_tracks->at(i)->GetTrack() == parent) {
148
 
      found = true;
149
 
      break;
150
 
    }
151
 
  }
152
 
 
153
 
  if (!found) {
154
 
    throw(Exceptions::Exception(Exceptions::recoverable,
155
 
                 "Proposed Parent not in Primary Chain",
156
 
                 "DataStructure::Global::PrimaryChain::AddTrack()"));
157
 
  }
158
 
 
159
 
  // Add the track with parent
160
 
  MAUS::DataStructure::Global::TRefTrackPair* newPair =
161
 
      new MAUS::DataStructure::Global::TRefTrackPair(track, parent);
162
 
  _tracks->push_back(newPair);
163
 
  return true;
164
 
}
165
 
 
166
 
bool PrimaryChain::AddPrimaryTrack(MAUS::DataStructure::Global::Track* track) {
167
 
  // Check track is valid
168
 
  if (!track) {
169
 
    throw(Exceptions::Exception(Exceptions::recoverable,
170
 
                 "Attempting to add a NULL Track",
171
 
                 "DataStructure::Global::PrimaryChain::AddPrimaryTrack()"));
172
 
  }
173
 
 
174
 
  // Add the track with a NULL parent
175
 
  MAUS::DataStructure::Global::TRefTrackPair* newPair =
176
 
      new MAUS::DataStructure::Global::TRefTrackPair(track, NULL);
177
 
  _tracks->push_back(newPair);
178
 
  return true;
179
 
}
180
 
 
181
 
bool PrimaryChain::HasTrack(MAUS::DataStructure::Global::Track* track) {
182
 
  // Find track in vector
183
 
  std::vector<MAUS::DataStructure::Global::TRefTrackPair*>::iterator iter;
184
 
  for (iter = _tracks->begin(); iter < _tracks->end(); iter++) {
185
 
    if ((*iter)->GetTrack() == track) {
186
 
      return true;
187
 
    }
188
 
  }
189
 
  return false;
190
 
}
191
 
 
192
 
bool PrimaryChain::HasTrackAsParent(
193
 
    MAUS::DataStructure::Global::Track* parent) {
194
 
  // Find track as parent vector
195
 
  std::vector<MAUS::DataStructure::Global::TRefTrackPair*>::iterator iter;
196
 
  for (iter = _tracks->begin(); iter < _tracks->end(); iter++) {
197
 
    if ((*iter)->GetParent() == parent) {
198
 
      return true;
199
 
    }
200
 
  }
201
 
  return false;
202
 
}
203
 
 
204
 
bool PrimaryChain::IsPrimaryTrack(MAUS::DataStructure::Global::Track* track) {
205
 
  // Find track in vector
206
 
  std::vector<MAUS::DataStructure::Global::TRefTrackPair*>::iterator iter;
207
 
  for (iter = _tracks->begin(); iter < _tracks->end(); iter++) {
208
 
    if ((*iter)->GetTrack() == track) {
209
 
      return !((*iter)->second.IsValid());
210
 
    }
211
 
  }
212
 
  return false;
213
 
}
214
 
 
215
 
std::vector<MAUS::DataStructure::Global::Track*> PrimaryChain::GetTracks() {
216
 
  std::vector<MAUS::DataStructure::Global::Track*> result;
217
 
 
218
 
  // Get a pointer for each of the tracks stored.
219
 
  std::vector<MAUS::DataStructure::Global::TRefTrackPair*>::iterator iter;
220
 
  for (iter = _tracks->begin(); iter < _tracks->end(); iter++) {
221
 
    result.push_back((*iter)->GetTrack());
222
 
  }
223
 
 
224
 
  return result;
225
 
}
226
 
 
227
 
std::vector<MAUS::DataStructure::Global::Track*>
228
 
PrimaryChain::GetPrimaryTracks() {
229
 
  std::vector<MAUS::DataStructure::Global::Track*> result;
230
 
 
231
 
  // Get a pointer for each of the tracks that is primary
232
 
  std::vector<MAUS::DataStructure::Global::TRefTrackPair*>::iterator iter;
233
 
  for (iter = _tracks->begin(); iter < _tracks->end(); iter++) {
234
 
    if ((*iter)->second.IsValid() == false)
235
 
      result.push_back((*iter)->GetTrack());
236
 
  }
237
 
 
238
 
  return result;
239
 
}
240
 
 
241
 
MAUS::DataStructure::Global::Track* PrimaryChain::GetTrackParent(
242
 
    MAUS::DataStructure::Global::Track* track) {
243
 
  // Find track, and return parent
244
 
  std::vector<MAUS::DataStructure::Global::TRefTrackPair*>::iterator iter;
245
 
  for (iter = _tracks->begin(); iter < _tracks->end(); iter++) {
246
 
    if ((*iter)->GetTrack() == track) {
247
 
      return (*iter)->GetParent();
248
 
    }
249
 
  }
250
 
  return NULL;
251
 
}
252
 
 
253
 
std::vector<MAUS::DataStructure::Global::Track*>
254
 
PrimaryChain::GetTrackDaughters(MAUS::DataStructure::Global::Track* track) {
255
 
  std::vector<MAUS::DataStructure::Global::Track*> result;
256
 
 
257
 
  // Find all tracks with this track as a parent
258
 
  std::vector<MAUS::DataStructure::Global::TRefTrackPair*>::iterator iter;
259
 
  for (iter = _tracks->begin(); iter < _tracks->end(); iter++) {
260
 
    if ((*iter)->GetParent() == track) {
261
 
      result.push_back((*iter)->GetTrack());
262
 
    }
263
 
  }
264
 
 
265
 
  return result;
266
 
}
267
 
 
268
 
void PrimaryChain::ClearTracks() {
269
 
  std::vector<MAUS::DataStructure::Global::TRefTrackPair*>::iterator iter;
270
 
  for (iter = _tracks->begin(); iter < _tracks->end(); iter++)
271
 
    delete *iter;
272
 
  _tracks->clear();
273
 
}
274
 
 
275
 
void PrimaryChain::AddParentChain(
276
 
    MAUS::DataStructure::Global::PrimaryChain* chain) {
277
 
  // Check primary chain is valid
278
 
  if (!chain) {
279
 
    throw(Exceptions::Exception(Exceptions::recoverable,
280
 
                 "Attempting to add a NULL PrimaryChain",
281
 
                 "DataStructure::Global::PrimaryChain::AddParentChain()"));
282
 
  }
283
 
 
284
 
  _parent_primary_chains->Add(chain);
285
 
}
286
 
 
287
 
std::vector<MAUS::DataStructure::Global::PrimaryChain*>
288
 
PrimaryChain::GetParentChains() {
289
 
  std::vector<MAUS::DataStructure::Global::PrimaryChain*> result;
290
 
  // Not a fast function, ROOT recommends avoiding unnecessary repeats
291
 
  int n = _parent_primary_chains->GetEntries();
292
 
  for (int i = 0; i < n; ++i) {
293
 
    // Cast the TObject* into a PrimaryChain*, and add to result
294
 
    result.push_back((MAUS::DataStructure::Global::PrimaryChain*)
295
 
                     _parent_primary_chains->At(i));
296
 
  }
297
 
  return result;
298
 
}
299
 
 
300
 
void PrimaryChain::set_track_parent_pairs(
301
 
    std::vector<MAUS::DataStructure::Global::TRefTrackPair*>* tracks) {
302
 
  if (_tracks != NULL) {
303
 
    // These TRefTrackPair's are unique to this PrimaryChain, and
304
 
    // owned by it.  Delete them before we replace the vector.
305
 
    for (size_t i = 0; i < _tracks->size(); ++i)
306
 
      delete _tracks->at(i);
307
 
    delete _tracks;
308
 
  }
309
 
  _tracks = tracks;
310
 
}
311
 
 
312
 
std::vector<MAUS::DataStructure::Global::TRefTrackPair*>*
313
 
PrimaryChain::get_track_parent_pairs() const {
314
 
  return _tracks;
315
 
}
316
 
 
317
 
void PrimaryChain::set_goodness_of_fit(double goodness_of_fit) {
318
 
  _goodness_of_fit = goodness_of_fit;
319
 
}
320
 
 
321
 
double PrimaryChain::get_goodness_of_fit() const {
322
 
  return _goodness_of_fit;
323
 
}
324
 
 
325
 
 
326
 
void PrimaryChain::set_parent_primary_chains(TRefArray* parent_primary_chains) {
327
 
  if (_parent_primary_chains != NULL) {
328
 
    delete _parent_primary_chains;
329
 
  }
330
 
  _parent_primary_chains = parent_primary_chains;
331
 
}
332
 
 
333
 
TRefArray* PrimaryChain::get_parent_primary_chains() const {
334
 
  return _parent_primary_chains;
335
 
}
336
 
 
337
 
void PrimaryChain::AddComment(std::string key, std::string comment) {
338
 
  _comments[key] = comment;
339
 
}
340
 
 
341
 
void PrimaryChain::ClearComments() {
342
 
  _comments.clear();
343
 
}
344
 
 
345
 
void PrimaryChain::RemoveComment(std::string key) {
346
 
  _comments.erase(key);
347
 
}
348
 
 
349
 
void PrimaryChain::set_comments(
350
 
    std::map<std::string, std::string> comments) {
351
 
  _comments = comments;
352
 
}
353
 
 
354
 
std::map<std::string, std::string> PrimaryChain::get_comments() const {
355
 
  return _comments;
356
 
}
 
75
MAUS::DataStructure::Global::PrimaryChain* PrimaryChain::GetUSDaughter() const {
 
76
  MAUS::DataStructure::Global::PrimaryChain* us_daughter =
 
77
    (MAUS::DataStructure::Global::PrimaryChain*) _us_daughter.GetObject();
 
78
  return us_daughter;
 
79
}
 
80
 
 
81
void PrimaryChain::SetUSDaughter(MAUS::DataStructure::Global::PrimaryChain* us_daughter) {
 
82
  if (_type == MAUS::DataStructure::Global::kThrough) {
 
83
    _us_daughter = us_daughter;
 
84
  } else {
 
85
    Squeak::mout(Squeak::error)
 
86
        << "Attempting to add an upstream daughter chain to a non-through primary chain";
 
87
  }
 
88
}
 
89
 
 
90
MAUS::DataStructure::Global::PrimaryChain* PrimaryChain::GetDSDaughter() const {
 
91
  MAUS::DataStructure::Global::PrimaryChain* ds_daughter =
 
92
    (MAUS::DataStructure::Global::PrimaryChain*) _ds_daughter.GetObject();
 
93
  return ds_daughter;
 
94
}
 
95
 
 
96
void PrimaryChain::SetDSDaughter(MAUS::DataStructure::Global::PrimaryChain* ds_daughter) {
 
97
  if (_type == MAUS::DataStructure::Global::kThrough) {
 
98
    _ds_daughter = ds_daughter;
 
99
  } else {
 
100
    Squeak::mout(Squeak::error)
 
101
        << "Attempting to add a downstream daughter chain to a non-through primary chain";
 
102
  }
 
103
}
 
104
 
 
105
MAUS::DataStructure::Global::Track*
 
106
    PrimaryChain::GetMatchedTrack(MAUS::DataStructure::Global::PID pid) const {
 
107
  MAUS::DataStructure::Global::Track* track = NULL;
 
108
  int n = _tracks->GetEntries();
 
109
  for (int i = 0; i < n; i++) {
 
110
    track = (MAUS::DataStructure::Global::Track*) _tracks->At(i);
 
111
    if (track and track->get_mapper_name() == "MapCppGlobalTrackMatching"
 
112
        and track->get_pid() == pid) {
 
113
      return track;
 
114
    }
 
115
  }
 
116
  return 0;
 
117
}
 
118
 
 
119
std::vector<MAUS::DataStructure::Global::Track*> PrimaryChain::GetMatchedTracks() const {
 
120
  std::vector<MAUS::DataStructure::Global::Track*> tracks;
 
121
  MAUS::DataStructure::Global::Track* track = NULL;
 
122
  int n = _tracks->GetEntries();
 
123
  for (int i = 0; i < n; i++) {
 
124
    track = (MAUS::DataStructure::Global::Track*) _tracks->At(i);
 
125
    if (track and track->get_mapper_name() == "MapCppGlobalTrackMatching") {
 
126
      tracks.push_back(track);
 
127
    }
 
128
  }
 
129
  return tracks;
 
130
}
 
131
 
 
132
void PrimaryChain::AddMatchedTrack(MAUS::DataStructure::Global::Track* track) {
 
133
  track->set_mapper_name("MapCppGlobalTrackMatching");
 
134
  _tracks->Add(track);
 
135
  int n = _tracks->GetEntries();
 
136
  for (int i = 0; i < n; i++) {
 
137
    track = (MAUS::DataStructure::Global::Track*) _tracks->At(i);
 
138
    if (track and track->get_mapper_name() == "MapCppGlobalPID") {
 
139
      Squeak::mout(Squeak::error) << "Attempting to add a PID'd track to a primary chain "
 
140
                                  << "that already contains one." << std::endl;
 
141
      return;
 
142
    }
 
143
  }
 
144
}
 
145
 
 
146
MAUS::DataStructure::Global::Track* PrimaryChain::GetPIDTrack() const {
 
147
  MAUS::DataStructure::Global::Track* track = 0;
 
148
  int n = _tracks->GetEntries();
 
149
  for (int i = 0; i < n; i++) {
 
150
    track = (MAUS::DataStructure::Global::Track*) _tracks->At(i);
 
151
    if (track and track->get_mapper_name() == "MapCppGlobalPID") {
 
152
      return track;
 
153
    }
 
154
  }
 
155
  return 0;
 
156
}
 
157
 
 
158
void PrimaryChain::SetPIDTrack(MAUS::DataStructure::Global::Track* track) {
 
159
  MAUS::DataStructure::Global::Track* chain_track = 0;
 
160
  // Need to check whether a PID track exists
 
161
  int n = _tracks->GetEntries();
 
162
  for (int i = 0; i < n; i++) {
 
163
    chain_track = (MAUS::DataStructure::Global::Track*) _tracks->At(i);
 
164
    if (chain_track and chain_track->get_mapper_name() == "MapCppGlobalPID") {
 
165
      Squeak::mout(Squeak::error) << "Attempting to add a PID'd track to a primary chain "
 
166
                                  << "that already contains one." << std::endl;
 
167
      return;
 
168
    }
 
169
  }
 
170
  // Only add if no PID track already exists
 
171
  track->set_mapper_name("MapCppGlobalPID");
 
172
  _tracks->Add(track);
 
173
}
 
174
 
 
175
MAUS::DataStructure::Global::Track* PrimaryChain::GetFittedTrack() const {
 
176
  MAUS::DataStructure::Global::Track* track = 0;
 
177
  int n = _tracks->GetEntries();
 
178
  for (int i = 0; i < n; i++) {
 
179
    track = (MAUS::DataStructure::Global::Track*) _tracks->At(i);
 
180
    if (track and track->get_mapper_name() == "MapCppGlobalTrackFitting") {
 
181
      return track;
 
182
    }
 
183
  }
 
184
  return 0;
 
185
}
 
186
 
 
187
void PrimaryChain::SetFittedTrack(MAUS::DataStructure::Global::Track* track) {
 
188
  MAUS::DataStructure::Global::Track* chain_track = 0;
 
189
  // Need to check whether a fitted track exists
 
190
  int n = _tracks->GetEntries();
 
191
  for (int i = 0; i < n; i++) {
 
192
    chain_track = (MAUS::DataStructure::Global::Track*) _tracks->At(i);
 
193
    if (chain_track and chain_track->get_mapper_name() == "MapCppGlobalTrackFitting") {
 
194
      Squeak::mout(Squeak::error) << "Attempting to add a Fitted track to a primary chain "
 
195
                                  << "that already contains one." << std::endl;
 
196
      return;
 
197
    }
 
198
  }
 
199
  // Only add if no Fitted track already exists
 
200
  track->set_mapper_name("MapCppGlobalTrackFitting");
 
201
  _tracks->Add(track);
 
202
}
 
203
 
 
204
 
357
205
} // ~namespace Global
358
206
} // ~namespace DataStructure
359
207
} // ~namespace MAUS