← Back to branch summary

~ajdobbs/maus/rootfitter

« back to all changes in this revision

Viewing changes to tests/cpp_unit/DataStructure/Global/PrimaryChainTest.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:
tests/cpp_unit/DataStructure/Global/PrimaryChainTest.cc
19
19
#include "src/common_cpp/DataStructure/Global/TrackPoint.hh"
20
20
#include "src/common_cpp/DataStructure/Global/Track.hh"
21
21
#include "src/common_cpp/DataStructure/Global/PrimaryChain.hh"
 
22
#include "src/common_cpp/DataStructure/Global/ReconEnums.hh"
22
23
 
23
24
#include "gtest/gtest.h"
24
25
 
29
30
  PrimaryChainTestDS()  {}
30
31
  virtual ~PrimaryChainTestDS() {}
31
32
  virtual void SetUp()    {
32
 
    _primary_chain0 = new MAUS::DataStructure::Global::PrimaryChain();
33
 
 
34
 
    _t0 = new MAUS::DataStructure::Global::Track();
35
 
    _t0->set_mapper_name("t0");
36
 
    _t1 = new MAUS::DataStructure::Global::Track();
37
 
    _t1->set_mapper_name("t1");
38
 
    _t2 = new MAUS::DataStructure::Global::Track();
39
 
    _t2->set_mapper_name("t2");
40
 
 
41
 
    track_parent_pairs =
42
 
        new std::vector<MAUS::DataStructure::Global::TRefTrackPair*>();
43
 
    track_parent_pairs->push_back(
44
 
        new MAUS::DataStructure::Global::TRefTrackPair(_t0, NULL));
45
 
    track_parent_pairs->push_back(
46
 
        new MAUS::DataStructure::Global::TRefTrackPair(_t1, _t0));
47
 
    track_parent_pairs->push_back(
48
 
        new MAUS::DataStructure::Global::TRefTrackPair(_t2, _t0));
49
 
    _primary_chain0->set_track_parent_pairs(track_parent_pairs);
50
 
 
51
 
    _goodness_of_fit = 5.;
52
 
    _primary_chain0->set_goodness_of_fit(_goodness_of_fit);
53
 
 
54
 
    _test_comment_key   = "TestError1";
55
 
    _test_comment_value = "Test errors are FUN!";
56
 
    _test_comments[_test_comment_key] = _test_comment_value;
57
 
    _primary_chain0->set_comments(_test_comments);
58
 
  }
59
 
  virtual void TearDown() {}
 
33
    _us_chain = new DataStructure::Global::PrimaryChain("USChain", DataStructure::Global::kUS);
 
34
    _ds_chain = new DataStructure::Global::PrimaryChain("DSChain", DataStructure::Global::kDS);
 
35
    _through_chain = new DataStructure::Global::PrimaryChain("ThroughChain",
 
36
        DataStructure::Global::kThrough);
 
37
    _us_track = new MAUS::DataStructure::Global::Track();
 
38
    _us_track->set_pid(DataStructure::Global::kEPlus);
 
39
    _ds_track = new MAUS::DataStructure::Global::Track();
 
40
    _ds_track->set_pid(DataStructure::Global::kEMinus);
 
41
    _through_track = new MAUS::DataStructure::Global::Track();
 
42
    _through_track->set_pid(DataStructure::Global::kMuPlus);
 
43
    _through_track->AddTrack(_us_track);
 
44
    _through_track->AddTrack(_ds_track);
 
45
    _pid_track = new MAUS::DataStructure::Global::Track();
 
46
    _pid_track->set_pid(DataStructure::Global::kMuMinus);
 
47
    _fitted_track = new MAUS::DataStructure::Global::Track();
 
48
    _fitted_track->set_pid(DataStructure::Global::kPiPlus);
 
49
    _us_chain->AddMatchedTrack(_us_track);
 
50
    _ds_chain->AddMatchedTrack(_ds_track);
 
51
    _through_chain->AddMatchedTrack(_through_track);
 
52
    _through_chain->SetUSDaughter(_us_chain);
 
53
    _through_chain->SetDSDaughter(_ds_chain);
 
54
    _through_chain->SetPIDTrack(_pid_track);
 
55
    _through_chain->SetFittedTrack(_fitted_track);
 
56
  }
 
57
  virtual void TearDown() {
 
58
    delete _us_chain;
 
59
    delete _ds_chain;
 
60
    delete _through_chain;
 
61
    delete _us_track;
 
62
    delete _ds_track;
 
63
    delete _through_track;
 
64
    delete _pid_track;
 
65
    delete _fitted_track;
 
66
  }
60
67
 protected:
61
 
  MAUS::DataStructure::Global::PrimaryChain* _primary_chain0;
62
 
  MAUS::DataStructure::Global::Track* _t0;
63
 
  MAUS::DataStructure::Global::Track* _t1;
64
 
  MAUS::DataStructure::Global::Track* _t2;
65
 
  double _goodness_of_fit;
66
 
  std::vector<MAUS::DataStructure::Global::TRefTrackPair*> *track_parent_pairs;
67
 
  std::string _test_comment_key;
68
 
  std::string _test_comment_value;
69
 
  std::map<std::string, std::string> _test_comments;
 
68
  DataStructure::Global::PrimaryChain* _us_chain;
 
69
  DataStructure::Global::PrimaryChain* _ds_chain;
 
70
  DataStructure::Global::PrimaryChain* _through_chain;
 
71
  DataStructure::Global::Track* _us_track;
 
72
  DataStructure::Global::Track* _ds_track;
 
73
  DataStructure::Global::Track* _through_track;
 
74
  DataStructure::Global::Track* _pid_track;
 
75
  DataStructure::Global::Track* _fitted_track;
70
76
};
71
77
 
72
78
TEST_F(PrimaryChainTestDS, test_default_constructor) {
73
 
  MAUS::DataStructure::Global::PrimaryChain primary_chain;
74
 
 
75
 
  EXPECT_TRUE(primary_chain.get_track_parent_pairs()->empty());
76
 
  EXPECT_EQ(0., primary_chain.get_goodness_of_fit());
77
 
  EXPECT_EQ(0U, primary_chain.get_comments().size());
78
 
}
79
 
 
80
 
TEST_F(PrimaryChainTestDS, test_named_constructor) {
81
 
  MAUS::DataStructure::Global::PrimaryChain primary_chain("MapName");
82
 
 
83
 
  EXPECT_TRUE(primary_chain.get_track_parent_pairs()->empty());
84
 
  EXPECT_EQ(0., primary_chain.get_goodness_of_fit());
85
 
  EXPECT_EQ("MapName", primary_chain.get_mapper_name());
86
 
  EXPECT_EQ(0U, primary_chain.get_comments().size());
87
 
}
88
 
 
89
 
TEST_F(PrimaryChainTestDS, test_getters_setters) {
90
 
  ASSERT_EQ(3U, _primary_chain0->get_track_parent_pairs()->size());
91
 
  EXPECT_EQ(_t0, _primary_chain0->get_track_parent_pairs()->at(0)->GetTrack());
92
 
  EXPECT_EQ(_t1, _primary_chain0->get_track_parent_pairs()->at(1)->GetTrack());
93
 
  EXPECT_EQ(_t2, _primary_chain0->get_track_parent_pairs()->at(2)->GetTrack());
94
 
  EXPECT_EQ("t0", _primary_chain0->get_track_parent_pairs()
95
 
            ->at(0)->GetTrack()->get_mapper_name());
96
 
  EXPECT_EQ("t1", _primary_chain0->get_track_parent_pairs()
97
 
            ->at(1)->GetTrack()->get_mapper_name());
98
 
  EXPECT_EQ("t2", _primary_chain0->get_track_parent_pairs()
99
 
            ->at(2)->GetTrack()->get_mapper_name());
100
 
  EXPECT_TRUE(NULL == _primary_chain0->get_track_parent_pairs()
101
 
              ->at(0)->GetParent());
102
 
  EXPECT_EQ(_t0, _primary_chain0->get_track_parent_pairs()
103
 
            ->at(1)->GetParent());
104
 
  EXPECT_EQ(_t0, _primary_chain0->get_track_parent_pairs()
105
 
            ->at(2)->GetParent());
106
 
  EXPECT_EQ(_goodness_of_fit, _primary_chain0->get_goodness_of_fit());
107
 
  ASSERT_EQ(1U, _primary_chain0->get_comments().size());
108
 
  EXPECT_EQ(_test_comment_value,
109
 
            _primary_chain0->get_comments().at(_test_comment_key));
 
79
  DataStructure::Global::PrimaryChain primary_chain;
 
80
  EXPECT_EQ(primary_chain.get_chain_type(), DataStructure::Global::kNoChainType);
 
81
  EXPECT_EQ(primary_chain.get_multiplicity(), DataStructure::Global::kUnique);
 
82
}
 
83
 
 
84
TEST_F(PrimaryChainTestDS, test_constructor_mappername) {
 
85
  DataStructure::Global::PrimaryChain primary_chain("MapperName");
 
86
  EXPECT_EQ(primary_chain.get_chain_type(), DataStructure::Global::kNoChainType);
 
87
  EXPECT_EQ(primary_chain.get_multiplicity(), DataStructure::Global::kUnique);
 
88
  EXPECT_EQ(primary_chain.get_mapper_name(), "MapperName");
 
89
}
 
90
 
 
91
TEST_F(PrimaryChainTestDS, test_constructor_mappername_type) {
 
92
  DataStructure::Global::PrimaryChain primary_chain("MapperName", DataStructure::Global::kUS);
 
93
  EXPECT_EQ(primary_chain.get_chain_type(), DataStructure::Global::kUS);
 
94
  EXPECT_EQ(primary_chain.get_multiplicity(), DataStructure::Global::kUnique);
 
95
  EXPECT_EQ(primary_chain.get_mapper_name(), "MapperName");
110
96
}
111
97
 
112
98
TEST_F(PrimaryChainTestDS, test_copy_constructor) {
113
 
  MAUS::DataStructure::Global::PrimaryChain primary_chain2(*_primary_chain0);
114
 
 
115
 
  ASSERT_NE(&primary_chain2, _primary_chain0);
116
 
  ASSERT_EQ(3U, primary_chain2.get_track_parent_pairs()->size());
117
 
  EXPECT_EQ(_t0, primary_chain2.get_track_parent_pairs()->at(0)->GetTrack());
118
 
  EXPECT_EQ(_t1, primary_chain2.get_track_parent_pairs()->at(1)->GetTrack());
119
 
  EXPECT_EQ(_t2, primary_chain2.get_track_parent_pairs()->at(2)->GetTrack());
120
 
  EXPECT_EQ("t0", primary_chain2.get_track_parent_pairs()
121
 
            ->at(0)->GetTrack()->get_mapper_name());
122
 
  EXPECT_EQ("t1", primary_chain2.get_track_parent_pairs()
123
 
            ->at(1)->GetTrack()->get_mapper_name());
124
 
  EXPECT_EQ("t2", primary_chain2.get_track_parent_pairs()
125
 
            ->at(2)->GetTrack()->get_mapper_name());
126
 
  EXPECT_TRUE(NULL == primary_chain2.get_track_parent_pairs()
127
 
              ->at(0)->GetParent());
128
 
  EXPECT_EQ(_t0, primary_chain2.get_track_parent_pairs()
129
 
            ->at(1)->GetParent());
130
 
  EXPECT_EQ(_t0, primary_chain2.get_track_parent_pairs()
131
 
            ->at(2)->GetParent());
132
 
  EXPECT_EQ(_goodness_of_fit, primary_chain2.get_goodness_of_fit());
133
 
  ASSERT_EQ(1U, primary_chain2.get_comments().size());
134
 
  EXPECT_EQ(_test_comment_value,
135
 
            primary_chain2.get_comments().at(_test_comment_key));
 
99
  DataStructure::Global::PrimaryChain copied_chain(*_through_chain);
 
100
  EXPECT_EQ(copied_chain.get_chain_type(), DataStructure::Global::kThrough);
 
101
  EXPECT_EQ(copied_chain.get_multiplicity(), DataStructure::Global::kUnique);
 
102
  EXPECT_EQ(copied_chain.get_mapper_name(), "ThroughChain");
 
103
  EXPECT_NE(&copied_chain, _through_chain);
 
104
  // Child chains are not deep copied
 
105
  EXPECT_EQ(copied_chain.GetUSDaughter(), _us_chain);
 
106
  EXPECT_EQ(copied_chain.GetDSDaughter(), _ds_chain);
 
107
  DataStructure::Global::Track* pid_track = copied_chain.GetPIDTrack();
 
108
  EXPECT_EQ(pid_track, _pid_track);
136
109
}
137
110
 
138
111
TEST_F(PrimaryChainTestDS, test_assignment_operator) {
139
 
  MAUS::DataStructure::Global::PrimaryChain primary_chain2;
140
 
  primary_chain2 = *_primary_chain0;
141
 
 
142
 
  ASSERT_NE(&primary_chain2, _primary_chain0);
143
 
  ASSERT_EQ(3U, primary_chain2.get_track_parent_pairs()->size());
144
 
  EXPECT_EQ(_t0, primary_chain2.get_track_parent_pairs()->at(0)->GetTrack());
145
 
  EXPECT_EQ(_t1, primary_chain2.get_track_parent_pairs()->at(1)->GetTrack());
146
 
  EXPECT_EQ(_t2, primary_chain2.get_track_parent_pairs()->at(2)->GetTrack());
147
 
  EXPECT_EQ("t0", primary_chain2.get_track_parent_pairs()
148
 
            ->at(0)->GetTrack()->get_mapper_name());
149
 
  EXPECT_EQ("t1", primary_chain2.get_track_parent_pairs()
150
 
            ->at(1)->GetTrack()->get_mapper_name());
151
 
  EXPECT_EQ("t2", primary_chain2.get_track_parent_pairs()
152
 
            ->at(2)->GetTrack()->get_mapper_name());
153
 
  EXPECT_TRUE(NULL == primary_chain2.get_track_parent_pairs()
154
 
              ->at(0)->GetParent());
155
 
  EXPECT_EQ(_t0, primary_chain2.get_track_parent_pairs()
156
 
            ->at(1)->GetParent());
157
 
  EXPECT_EQ(_t0, primary_chain2.get_track_parent_pairs()
158
 
            ->at(2)->GetParent());
159
 
  EXPECT_EQ(_goodness_of_fit, primary_chain2.get_goodness_of_fit());
160
 
  ASSERT_EQ(1U, primary_chain2.get_comments().size());
161
 
  EXPECT_EQ(_test_comment_value,
162
 
            primary_chain2.get_comments().at(_test_comment_key));
163
 
}
164
 
 
165
 
TEST_F(PrimaryChainTestDS, test_Clone) {
166
 
  MAUS::DataStructure::Global::PrimaryChain* primary_chain2 =
167
 
      _primary_chain0->Clone();
168
 
 
169
 
  ASSERT_NE(primary_chain2, _primary_chain0);
170
 
  ASSERT_EQ(3U, primary_chain2->get_track_parent_pairs()->size());
171
 
  EXPECT_NE(_t0, primary_chain2->get_track_parent_pairs()->at(0)->GetTrack());
172
 
  EXPECT_NE(_t1, primary_chain2->get_track_parent_pairs()->at(1)->GetTrack());
173
 
  EXPECT_NE(_t2, primary_chain2->get_track_parent_pairs()->at(2)->GetTrack());
174
 
  EXPECT_EQ("t0", primary_chain2->get_track_parent_pairs()
175
 
            ->at(0)->GetTrack()->get_mapper_name());
176
 
  EXPECT_EQ("t1", primary_chain2->get_track_parent_pairs()
177
 
            ->at(1)->GetTrack()->get_mapper_name());
178
 
  EXPECT_EQ("t2", primary_chain2->get_track_parent_pairs()
179
 
            ->at(2)->GetTrack()->get_mapper_name());
180
 
  EXPECT_TRUE(NULL == primary_chain2->get_track_parent_pairs()
181
 
              ->at(0)->GetParent());
182
 
  EXPECT_NE(_t0, primary_chain2->get_track_parent_pairs()->at(1)->GetParent());
183
 
  EXPECT_EQ(primary_chain2->get_track_parent_pairs()->at(1)->GetParent(),
184
 
            primary_chain2->get_track_parent_pairs()->at(0)->GetTrack());
185
 
  EXPECT_NE(_t0, primary_chain2->get_track_parent_pairs()->at(2)->GetParent());
186
 
  EXPECT_EQ(primary_chain2->get_track_parent_pairs()->at(2)->GetParent(),
187
 
            primary_chain2->get_track_parent_pairs()->at(0)->GetTrack());
188
 
  EXPECT_EQ(_goodness_of_fit, primary_chain2->get_goodness_of_fit());
189
 
  ASSERT_EQ(1U, primary_chain2->get_comments().size());
190
 
  EXPECT_EQ(_test_comment_value,
191
 
            primary_chain2->get_comments().at(_test_comment_key));
192
 
}
193
 
 
194
 
TEST_F(PrimaryChainTestDS, test_TrackMethods) {
195
 
  MAUS::DataStructure::Global::PrimaryChain* primary_chain1 =
196
 
      new MAUS::DataStructure::Global::PrimaryChain();
197
 
 
198
 
  // AddTrack
199
 
  MAUS::DataStructure::Global::Track* t0 =
200
 
      new MAUS::DataStructure::Global::Track();
201
 
  MAUS::DataStructure::Global::Track* t1 =
202
 
      new MAUS::DataStructure::Global::Track();
203
 
  MAUS::DataStructure::Global::Track* t2 =
204
 
      new MAUS::DataStructure::Global::Track();
205
 
  MAUS::DataStructure::Global::Track* t3 =
206
 
      new MAUS::DataStructure::Global::Track();
207
 
  MAUS::DataStructure::Global::Track* t4 =
208
 
      new MAUS::DataStructure::Global::Track();
209
 
  MAUS::DataStructure::Global::Track* t5 =
210
 
      new MAUS::DataStructure::Global::Track();
211
 
 
212
 
  // Add Primaries, t0, t1
213
 
  primary_chain1->AddPrimaryTrack(t0);
214
 
  primary_chain1->AddPrimaryTrack(t1);
215
 
 
216
 
  // Add t0 daughters
217
 
  primary_chain1->AddTrack(t2, t0);
218
 
  primary_chain1->AddTrack(t3, t0);
219
 
 
220
 
  // Add t1 daughters
221
 
  primary_chain1->AddTrack(t4, t1);
222
 
 
223
 
  ASSERT_EQ(5U, primary_chain1->get_track_parent_pairs()->size());
224
 
  EXPECT_TRUE(NULL == primary_chain1->get_track_parent_pairs()
225
 
              ->at(0)->GetParent());
226
 
  EXPECT_TRUE(NULL == primary_chain1->get_track_parent_pairs()
227
 
              ->at(1)->GetParent());
228
 
  EXPECT_EQ(t0, primary_chain1->get_track_parent_pairs()->at(2)->GetParent());
229
 
  EXPECT_EQ(t0, primary_chain1->get_track_parent_pairs()->at(3)->GetParent());
230
 
  EXPECT_EQ(t1, primary_chain1->get_track_parent_pairs()->at(4)->GetParent());
231
 
 
232
 
  // RemoveTrack
233
 
  // HasTrack & HasTrackAsParent
234
 
  EXPECT_TRUE(primary_chain1->HasTrack(t0));
235
 
  EXPECT_TRUE(primary_chain1->HasTrack(t1));
236
 
  EXPECT_TRUE(primary_chain1->HasTrack(t2));
237
 
  EXPECT_TRUE(primary_chain1->HasTrack(t3));
238
 
  EXPECT_TRUE(primary_chain1->HasTrack(t4));
239
 
  EXPECT_FALSE(primary_chain1->HasTrack(t5));
240
 
 
241
 
  EXPECT_TRUE(primary_chain1->HasTrackAsParent(t0));
242
 
  EXPECT_TRUE(primary_chain1->HasTrackAsParent(t1));
243
 
  EXPECT_FALSE(primary_chain1->HasTrackAsParent(t2));
244
 
  EXPECT_FALSE(primary_chain1->HasTrackAsParent(t3));
245
 
  EXPECT_FALSE(primary_chain1->HasTrackAsParent(t4));
246
 
  EXPECT_FALSE(primary_chain1->HasTrackAsParent(t5));
247
 
 
248
 
  // IsPrimaryTrack
249
 
  EXPECT_TRUE(primary_chain1->IsPrimaryTrack(t0));
250
 
  EXPECT_TRUE(primary_chain1->IsPrimaryTrack(t1));
251
 
  EXPECT_FALSE(primary_chain1->IsPrimaryTrack(t2));
252
 
  EXPECT_FALSE(primary_chain1->IsPrimaryTrack(t3));
253
 
  EXPECT_FALSE(primary_chain1->IsPrimaryTrack(t4));
254
 
  EXPECT_FALSE(primary_chain1->IsPrimaryTrack(t5));
255
 
 
256
 
  // GetTrackParent
257
 
  EXPECT_TRUE(NULL == primary_chain1->GetTrackParent(t0));
258
 
  EXPECT_TRUE(NULL == primary_chain1->GetTrackParent(t1));
259
 
  EXPECT_EQ(t0, primary_chain1->GetTrackParent(t2));
260
 
  EXPECT_EQ(t0, primary_chain1->GetTrackParent(t3));
261
 
  EXPECT_EQ(t1, primary_chain1->GetTrackParent(t4));
262
 
  EXPECT_TRUE(NULL == primary_chain1->GetTrackParent(t5));
263
 
 
264
 
  // GetTrackDaughters
265
 
  ASSERT_EQ(2U, primary_chain1->GetTrackDaughters(t0).size());
266
 
  EXPECT_EQ(t2, primary_chain1->GetTrackDaughters(t0)[0]);
267
 
  EXPECT_EQ(t3, primary_chain1->GetTrackDaughters(t0)[1]);
268
 
  ASSERT_EQ(1U, primary_chain1->GetTrackDaughters(t1).size());
269
 
  EXPECT_EQ(t4, primary_chain1->GetTrackDaughters(t1)[0]);
270
 
  EXPECT_EQ(0U, primary_chain1->GetTrackDaughters(t4).size());
271
 
 
272
 
  // GetTracks
273
 
  ASSERT_EQ(5U, primary_chain1->GetTracks().size());
274
 
  EXPECT_EQ(t0, primary_chain1->GetTracks().at(0));
275
 
  EXPECT_EQ(t1, primary_chain1->GetTracks().at(1));
276
 
  EXPECT_EQ(t2, primary_chain1->GetTracks().at(2));
277
 
  EXPECT_EQ(t3, primary_chain1->GetTracks().at(3));
278
 
  EXPECT_EQ(t4, primary_chain1->GetTracks().at(4));
279
 
 
280
 
  // GetPrimaryTracks
281
 
  ASSERT_EQ(2U, primary_chain1->GetPrimaryTracks().size());
282
 
  EXPECT_EQ(t0, primary_chain1->GetPrimaryTracks().at(0));
283
 
  EXPECT_EQ(t1, primary_chain1->GetPrimaryTracks().at(1));
284
 
 
285
 
  // ClearTracks
286
 
  primary_chain1->ClearTracks();
287
 
  EXPECT_TRUE(primary_chain1->get_track_parent_pairs()->empty());
288
 
}
289
 
 
290
 
TEST_F(PrimaryChainTestDS, test_ParentMethods) {
291
 
  // SetParentChains
292
 
  MAUS::DataStructure::Global::PrimaryChain* primary_chain1 =
293
 
      new MAUS::DataStructure::Global::PrimaryChain();
294
 
  MAUS::DataStructure::Global::PrimaryChain* primary_chain2 =
295
 
      new MAUS::DataStructure::Global::PrimaryChain();
296
 
  _primary_chain0->set_track_parent_pairs(track_parent_pairs);
297
 
  _primary_chain0->AddParentChain(primary_chain1);
298
 
  _primary_chain0->AddParentChain(primary_chain2);
299
 
 
300
 
  // GetParentChains
301
 
  std::vector<MAUS::DataStructure::Global::PrimaryChain*> chains =
302
 
      _primary_chain0->GetParentChains();
303
 
  ASSERT_EQ(2U, chains.size());
304
 
  EXPECT_EQ(primary_chain1, chains.at(0));
305
 
  EXPECT_EQ(primary_chain2, chains.at(1));
306
 
}
307
 
 
308
 
TEST_F(PrimaryChainTestDS, test_Throws) {
309
 
  MAUS::DataStructure::Global::Track* t6 = NULL;
310
 
  MAUS::DataStructure::Global::Track* t7 =
311
 
      new MAUS::DataStructure::Global::Track();
312
 
  MAUS::DataStructure::Global::Track* t8 =
313
 
      new MAUS::DataStructure::Global::Track();
314
 
  MAUS::DataStructure::Global::Track* t9 =
315
 
      new MAUS::DataStructure::Global::Track();
316
 
 
317
 
  ASSERT_THROW(_primary_chain0->AddTrack(t6, t7), MAUS::Exceptions::Exception);
318
 
  ASSERT_THROW(_primary_chain0->AddPrimaryTrack(t6), MAUS::Exceptions::Exception);
319
 
 
320
 
  ASSERT_NO_THROW(_primary_chain0->AddTrack(t7, t6));
321
 
 
322
 
  ASSERT_THROW(_primary_chain0->AddTrack(t9, t8), MAUS::Exceptions::Exception);
323
 
}
 
112
  DataStructure::Global::PrimaryChain assigned_chain = *_through_chain;
 
113
  EXPECT_EQ(assigned_chain.get_chain_type(), DataStructure::Global::kThrough);
 
114
  EXPECT_EQ(assigned_chain.get_multiplicity(), DataStructure::Global::kUnique);
 
115
  EXPECT_EQ(assigned_chain.get_mapper_name(), "ThroughChain");
 
116
  EXPECT_NE(&assigned_chain, _through_chain);
 
117
  // Child chains are not deep copied
 
118
  EXPECT_EQ(assigned_chain.GetUSDaughter(), _us_chain);
 
119
  EXPECT_EQ(assigned_chain.GetDSDaughter(), _ds_chain);
 
120
  DataStructure::Global::Track* pid_track = assigned_chain.GetPIDTrack();
 
121
  EXPECT_EQ(pid_track, _pid_track);
 
122
}
 
123
 
 
124
TEST_F(PrimaryChainTestDS, test_getters_setters) {
 
125
  EXPECT_EQ(_through_chain->GetUSDaughter(), _us_chain);
 
126
  EXPECT_EQ(_through_chain->GetDSDaughter(), _ds_chain);
 
127
  DataStructure::Global::Track* matched_track =
 
128
      _through_chain->GetMatchedTrack(DataStructure::Global::kMuPlus);
 
129
  EXPECT_EQ(matched_track, _through_track);
 
130
  EXPECT_EQ(matched_track->get_mapper_name(), "MapCppGlobalTrackMatching");
 
131
  std::vector<DataStructure::Global::Track*> matched_tracks = _through_chain->GetMatchedTracks();
 
132
  EXPECT_EQ(matched_tracks.size(), 1);
 
133
  EXPECT_EQ(matched_tracks.at(0), _through_track);
 
134
  DataStructure::Global::Track* pid_track = _through_chain->GetPIDTrack();
 
135
  EXPECT_EQ(pid_track, _pid_track);
 
136
  EXPECT_EQ(pid_track->get_mapper_name(), "MapCppGlobalPID");
 
137
  DataStructure::Global::Track* fitted_track = _through_chain->GetFittedTrack();
 
138
  EXPECT_EQ(fitted_track, _fitted_track);
 
139
  EXPECT_EQ(fitted_track->get_mapper_name(), "MapCppGlobalTrackFitting");
 
140
  EXPECT_EQ(_through_chain->get_multiplicity(), DataStructure::Global::kUnique);
 
141
  _through_chain->set_multiplicity(DataStructure::Global::kMultipleDS);
 
142
  EXPECT_EQ(_through_chain->get_multiplicity(), DataStructure::Global::kMultipleDS);
 
143
}
 
144
 
 
145
 
324
146
} // ~namespace MAUS