← Back to branch summary

~chris-rogers/maus/emr_mc_digitization

« back to all changes in this revision

Viewing changes to tests/cpp_unit/Simulation/MAUSPrimaryGeneratorActionTest.cc

  • Committer: Chris Rogers
  • Date: 2014-04-16 11:48:45 UTC
  • mfrom: (707 merge)
  • mto: This revision was merged to the branch mainline in revision 711.
  • Revision ID: chris.rogers@stfc.ac.uk-20140416114845-h3u3q7pdcxkxvovs
Update to trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/cpp_unit/Simulation/MAUSPrimaryGeneratorActionTest.cc
30
30
namespace {
31
31
class MAUSPrimaryGeneratorActionTest : public ::testing::Test {
32
32
 protected:
33
 
  MAUSPrimaryGeneratorActionTest() : primary(MAUSGeant4Manager::GetInstance()->GetPrimaryGenerator()) {}
 
33
  MAUSPrimaryGeneratorActionTest()
 
34
      : primary(MAUSGeant4Manager::GetInstance()->GetPrimaryGenerator()) {
 
35
    part_in.x = 1.;
 
36
    part_in.y = 2.;
 
37
    part_in.z = 3.;
 
38
    part_in.time = 4.;
 
39
    part_in.px = 5.;
 
40
    part_in.py = 6.;
 
41
    part_in.pz = 7.;
 
42
    part_in.energy = 200.;
 
43
    part_in.seed = 10;
 
44
    part_in.pid = -13;
 
45
  }
34
46
  virtual ~MAUSPrimaryGeneratorActionTest() {}
35
47
  virtual void SetUp() {}
36
48
  virtual void TearDown() {}
37
49
  MAUS::MAUSPrimaryGeneratorAction* primary;
 
50
  MAUS::MAUSPrimaryGeneratorAction::PGParticle part_in;
38
51
};
39
52
 
40
53
TEST_F(MAUSPrimaryGeneratorActionTest, PushPopTest) {
41
 
    MAUS::MAUSPrimaryGeneratorAction::PGParticle part_in, part_out;
42
 
    part_in.x = 1.;
43
 
    part_in.y = 2.;
44
 
    part_in.z = 3.;
45
 
    part_in.time = 4.;
46
 
    part_in.px = 5.;
47
 
    part_in.py = 6.;
48
 
    part_in.pz = 7.;
49
 
    part_in.energy = 200.;
50
 
    part_in.seed = 10;
51
 
    part_in.pid = -13;
 
54
    MAUS::MAUSPrimaryGeneratorAction::PGParticle part_out;
52
55
 
53
56
    primary->Push(part_in);
54
57
    part_out = primary->Pop();
64
67
}
65
68
 
66
69
TEST_F(MAUSPrimaryGeneratorActionTest, GeneratePrimariesTest) {
67
 
    MAUS::MAUSPrimaryGeneratorAction::PGParticle part_in;
68
 
    part_in.x = 1.;
69
 
    part_in.y = 2.;
70
 
    part_in.z = 3.;
71
 
    part_in.time = 4.;
72
 
    part_in.px = 5.;
73
 
    part_in.py = 6.;
74
 
    part_in.pz = 7.;
75
 
    part_in.energy = 200.;
76
 
    part_in.seed = 27;
77
 
    part_in.pid = -13;
78
 
 
79
70
    primary->Push(part_in);
80
71
    primary->Push(part_in);
81
72
 
91
82
    primary->Push(part_in);
92
83
    part_in.x = 1;  // outside world volume
93
84
 
 
85
    part_in.px = 1e-16;  // p too small (causes G4 hang)
 
86
    part_in.py = 1e-16;  // p too small (causes G4 hang)
 
87
    part_in.pz = 1e-16;  // p too small (causes G4 hang)
 
88
    primary->Push(part_in);
 
89
    part_in.px = 5.;
 
90
    part_in.py = 6.;
 
91
    part_in.pz = 7.;
 
92
 
94
93
    G4Event* event = new G4Event();
95
94
    for (size_t i=0; i<2; ++i) {
96
95
        primary->GeneratePrimaries(event);
112
111
    EXPECT_EQ(part_in.seed, CLHEP::HepRandom::getTheSeed());
113
112
    EXPECT_EQ(part_in.pid,  event->GetPrimaryVertex()->GetPrimary()->GetPDGcode());
114
113
 
115
 
    for (size_t i=0; i<5; ++i) {
116
 
        EXPECT_THROW(primary->GeneratePrimaries(event), Squeal);
 
114
    for (size_t i=0; i<6; ++i) {
 
115
        EXPECT_THROW(primary->GeneratePrimaries(event), MAUS::Exception);
117
116
    }
118
117
 
119
118
    delete event;
120
119
}
121
120
 
122
121
TEST_F(MAUSPrimaryGeneratorActionTest, PGParticleReadWriteTest) {
123
 
    MAUSPrimaryGeneratorAction::PGParticle part_in, part_out;
124
 
    part_in.x = 1.;
125
 
    part_in.y = 2.;
126
 
    part_in.z = 3.;
127
 
    part_in.time = 4.;
128
 
    part_in.px = 5.;
129
 
    part_in.py = 6.;
130
 
    part_in.pz = 7.;
131
 
    part_in.energy = 200.;
132
 
    part_in.seed = 27;
133
 
    part_in.pid = -13;
 
122
    MAUSPrimaryGeneratorAction::PGParticle part_out;
134
123
 
135
124
    Json::Value val = part_in.WriteJson();
136
125
    part_out.ReadJson(val);
145
134
    EXPECT_EQ(part_in.pid, part_out.pid);
146
135
    EXPECT_EQ(part_in.seed, part_out.seed);
147
136
 
 
137
    // Test bad (negative assigned to unsigned int) seed value in JSON
 
138
    bool passed = false;
 
139
    val["random_seed"] = Json::Value(-1);
 
140
    try {
 
141
      part_out.ReadJson(val);
 
142
    } catch (MAUS::Exception exc) {
 
143
      passed = true;
 
144
    }
 
145
    EXPECT_TRUE(passed);
148
146
}
149
147
 
150
148
TEST_F(MAUSPrimaryGeneratorActionTest, PGParticleFromVirtualHitTest) {
154
152
    hit.SetMomentum(CLHEP::Hep3Vector(5.,6.,7.));
155
153
    hit.SetEnergy(200.);
156
154
    hit.SetPID(-13);
157
 
    MAUSPrimaryGeneratorAction::PGParticle part_in(hit);
 
155
    MAUSPrimaryGeneratorAction::PGParticle part_virt(hit);
 
156
    EXPECT_NEAR(part_virt.x, 1., 1e-6);
 
157
    EXPECT_NEAR(part_virt.y, 2., 1e-6);
 
158
    EXPECT_NEAR(part_virt.z, 3., 1e-6);
 
159
    EXPECT_NEAR(part_virt.px, 5., 1e-6);
 
160
    EXPECT_NEAR(part_virt.py, 6., 1e-6);
 
161
    EXPECT_NEAR(part_virt.pz, 7., 1e-6);
 
162
    EXPECT_NEAR(part_virt.time, 4., 1e-6);
 
163
    EXPECT_NEAR(part_virt.energy, 200., 1e-6);
 
164
    EXPECT_EQ(part_virt.pid, -13);
 
165
    EXPECT_EQ(part_virt.seed, size_t(0));
 
166
 
 
167
}
 
168
 
 
169
TEST_F(MAUSPrimaryGeneratorActionTest, PGParticleMassShellConditionTest) {
 
170
    part_in.MassShellCondition();
158
171
    EXPECT_NEAR(part_in.x, 1., 1e-6);
159
172
    EXPECT_NEAR(part_in.y, 2., 1e-6);
160
173
    EXPECT_NEAR(part_in.z, 3., 1e-6);
161
 
    EXPECT_NEAR(part_in.px, 5., 1e-6);
162
 
    EXPECT_NEAR(part_in.py, 6., 1e-6);
163
 
    EXPECT_NEAR(part_in.pz, 7., 1e-6);
164
174
    EXPECT_NEAR(part_in.time, 4., 1e-6);
165
175
    EXPECT_NEAR(part_in.energy, 200., 1e-6);
166
176
    EXPECT_EQ(part_in.pid, -13);
167
 
    EXPECT_EQ(part_in.seed, size_t(0));
168
 
 
169
 
}
170
 
 
 
177
    EXPECT_EQ(part_in.seed, size_t(10));
 
178
    EXPECT_NEAR(part_in.px/part_in.pz, 5./7., 1e-6);
 
179
    EXPECT_NEAR(part_in.py/part_in.pz, 6./7., 1e-6);
 
180
    double mass = sqrt(part_in.energy*part_in.energy-
 
181
                        part_in.px*part_in.px-
 
182
                        part_in.py*part_in.py-
 
183
                        part_in.pz*part_in.pz);
 
184
    EXPECT_NEAR(mass, 105.658, 1e-3);
 
185
    part_in.px = 0.;
 
186
    part_in.py = 0.;
 
187
    part_in.pz = 0.;
 
188
    EXPECT_THROW(part_in.MassShellCondition(), MAUS::Exception);
 
189
    part_in.pz = 1.;
 
190
    part_in.energy = 100.;
 
191
    EXPECT_THROW(part_in.MassShellCondition(), MAUS::Exception);
 
192
}
 
193
 
 
194
TEST_F(MAUSPrimaryGeneratorActionTest, PGParticlePrimaryTest) {
 
195
    Primary prim = part_in.GetPrimary();
 
196
    EXPECT_NEAR(part_in.x, prim.GetPosition().x(), 1e-6);
 
197
    EXPECT_NEAR(part_in.y, prim.GetPosition().y(), 1e-6);
 
198
    EXPECT_NEAR(part_in.z, prim.GetPosition().z(), 1e-6);
 
199
    EXPECT_NEAR(part_in.px, prim.GetMomentum().x(), 1e-6);
 
200
    EXPECT_NEAR(part_in.py, prim.GetMomentum().y(), 1e-6);
 
201
    EXPECT_NEAR(part_in.pz, prim.GetMomentum().z(), 1e-6);
 
202
    EXPECT_NEAR(part_in.time, prim.GetTime(), 1e-6);
 
203
    EXPECT_NEAR(part_in.energy, prim.GetEnergy(), 1e-6);
 
204
    EXPECT_EQ(part_in.pid, prim.GetParticleId());
 
205
    EXPECT_EQ(part_in.seed, size_t(prim.GetRandomSeed()));
 
206
}
171
207
} //namespace end
172
208