← Back to branch summary

~chris-rogers/maus/emr_mc_digitization

« back to all changes in this revision

Viewing changes to src/common_cpp/Recon/Global/ParticleOpticalVector.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:
src/common_cpp/Recon/Global/ParticleOpticalVector.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
/* Author: Peter Lane
 
18
 */
 
19
 
 
20
#include "Recon/Global/ParticleOpticalVector.hh"
 
21
 
 
22
#include <cmath>
 
23
#include "CLHEP/Units/PhysicalConstants.h"
 
24
 
 
25
#include "DataStructure/ThreeVector.hh"
 
26
#include "src/common_cpp/Maths/Vector.hh"
 
27
#include "Interface/Squeak.hh"
 
28
#include "Recon/Global/Detector.hh"
 
29
#include "Recon/Global/Particle.hh"
 
30
 
 
31
namespace MAUS {
 
32
namespace recon {
 
33
namespace global {
 
34
 
 
35
ParticleOpticalVector::ParticleOpticalVector()
 
36
    : PhaseSpaceVector()
 
37
{ }
 
38
 
 
39
ParticleOpticalVector::ParticleOpticalVector(
 
40
    const PhaseSpaceVector& vector,
 
41
    const double t0, const double E0, const double P0)
 
42
    : PhaseSpaceVector() {
 
43
  const double beta0 = P0 / E0;
 
44
  const double gamma0 = 1. / ::sqrt(1 - beta0*beta0);
 
45
  // const double k = beta0 * ::CLHEP::c_light * gamma0 / (1 + gamma0);
 
46
  const double k = beta0 * gamma0 / (1 + gamma0);
 
47
 
 
48
  set_l(k * (vector.t() - t0));
 
49
  set_delta((vector.E() - E0) / E0);
 
50
  set_x(vector.x());
 
51
  set_a(vector.Px() / P0);
 
52
  set_y(vector.y());
 
53
  set_b(vector.Py() / P0);
 
54
}
 
55
 
 
56
ParticleOpticalVector::ParticleOpticalVector(
 
57
    const ParticleOpticalVector& original_instance)
 
58
    : PhaseSpaceVector(original_instance) { }
 
59
 
 
60
ParticleOpticalVector::ParticleOpticalVector(double const * const array)
 
61
    : PhaseSpaceVector(array) { }
 
62
 
 
63
ParticleOpticalVector::ParticleOpticalVector(
 
64
    const double l, const double delta,
 
65
    const double x, const double a,
 
66
    const double y, const double b)
 
67
    : PhaseSpaceVector(l, delta, x, a, y, b) { }
 
68
 
 
69
ParticleOpticalVector::~ParticleOpticalVector() {
 
70
}
 
71
 
 
72
// *************************
 
73
//  Assignment Operators
 
74
// *************************
 
75
 
 
76
ParticleOpticalVector & ParticleOpticalVector::operator=(
 
77
    const ParticleOpticalVector& rhs) {
 
78
  PhaseSpaceVector::operator=(rhs);
 
79
 
 
80
  return *this;
 
81
}
 
82
 
 
83
ParticleOpticalVector & ParticleOpticalVector::operator+=(
 
84
    const ParticleOpticalVector& rhs) {
 
85
  PhaseSpaceVector::operator+=(rhs);
 
86
 
 
87
  return *this;
 
88
}
 
89
 
 
90
ParticleOpticalVector & ParticleOpticalVector::operator-=(
 
91
    const ParticleOpticalVector& rhs) {
 
92
  PhaseSpaceVector::operator-=(rhs);
 
93
 
 
94
  return *this;
 
95
}
 
96
 
 
97
ParticleOpticalVector & ParticleOpticalVector::operator*=(
 
98
    const ParticleOpticalVector& rhs) {
 
99
  PhaseSpaceVector::operator*=(rhs);
 
100
 
 
101
  return *this;
 
102
}
 
103
 
 
104
ParticleOpticalVector & ParticleOpticalVector::operator/=(
 
105
    const ParticleOpticalVector& rhs) {
 
106
  PhaseSpaceVector::operator/=(rhs);
 
107
 
 
108
  return *this;
 
109
}
 
110
 
 
111
ParticleOpticalVector & ParticleOpticalVector::operator+=(const double& rhs) {
 
112
  PhaseSpaceVector::operator+=(rhs);
 
113
 
 
114
  return *this;
 
115
}
 
116
 
 
117
ParticleOpticalVector & ParticleOpticalVector::operator-=(const double& rhs) {
 
118
  PhaseSpaceVector::operator-=(rhs);
 
119
 
 
120
  return *this;
 
121
}
 
122
 
 
123
ParticleOpticalVector & ParticleOpticalVector::operator*=(const double& rhs) {
 
124
  PhaseSpaceVector::operator*=(rhs);
 
125
 
 
126
  return *this;
 
127
}
 
128
 
 
129
ParticleOpticalVector & ParticleOpticalVector::operator/=(const double& rhs) {
 
130
  PhaseSpaceVector::operator/=(rhs);
 
131
 
 
132
  return *this;
 
133
}
 
134
 
 
135
// *************************
 
136
//  Algebraic Operators
 
137
// *************************
 
138
 
 
139
const ParticleOpticalVector ParticleOpticalVector::operator+(
 
140
    const ParticleOpticalVector& rhs) const {
 
141
  return ParticleOpticalVector(*this) += rhs;
 
142
}
 
143
 
 
144
const ParticleOpticalVector ParticleOpticalVector::operator-(
 
145
    const ParticleOpticalVector& rhs) const {
 
146
  return ParticleOpticalVector(*this) -= rhs;
 
147
}
 
148
 
 
149
const ParticleOpticalVector ParticleOpticalVector::operator*(
 
150
    const ParticleOpticalVector& rhs) const {
 
151
  return ParticleOpticalVector(*this) *= rhs;
 
152
}
 
153
 
 
154
const ParticleOpticalVector ParticleOpticalVector::operator/(
 
155
    const ParticleOpticalVector& rhs) const {
 
156
  return ParticleOpticalVector(*this) /= rhs;
 
157
}
 
158
 
 
159
const ParticleOpticalVector ParticleOpticalVector::operator+(
 
160
    const double& rhs) const {
 
161
  return ParticleOpticalVector(*this) += rhs;
 
162
}
 
163
 
 
164
const ParticleOpticalVector ParticleOpticalVector::operator-(
 
165
    const double& rhs) const {
 
166
  return ParticleOpticalVector(*this) -= rhs;
 
167
}
 
168
 
 
169
const ParticleOpticalVector ParticleOpticalVector::operator*(
 
170
    const double& rhs) const {
 
171
  return ParticleOpticalVector(*this) *= rhs;
 
172
}
 
173
 
 
174
const ParticleOpticalVector ParticleOpticalVector::operator/(
 
175
    const double& rhs) const {
 
176
  return ParticleOpticalVector(*this) /= rhs;
 
177
}
 
178
 
 
179
// *************************
 
180
//  Comparison Operators
 
181
// *************************
 
182
 
 
183
const bool ParticleOpticalVector::operator==(
 
184
    const ParticleOpticalVector& rhs) const {
 
185
  if (static_cast<PhaseSpaceVector const * const>(this)->operator!=(rhs)) {
 
186
    return false;
 
187
  }
 
188
 
 
189
  return true;
 
190
}
 
191
 
 
192
const bool ParticleOpticalVector::operator!=(
 
193
    const ParticleOpticalVector& rhs) const {
 
194
  return !operator==(rhs);
 
195
}
 
196
 
 
197
std::ostream& operator<<(std::ostream& out,
 
198
                         const ParticleOpticalVector& point) {
 
199
  out << "l: " << point.l() << "  delta: "  << point.delta()
 
200
      << "  x: " << point.x()    << "  a: " << point.a()
 
201
      << "  y: " << point.y()    << "  b: " << point.b();
 
202
 
 
203
  return out;
 
204
}
 
205
 
 
206
}  // namespace global
 
207
}  // namespace recon
 
208
}  // namespace MAUS