← Back to branch summary

~mwinter4/maus/ckov-reco

« back to all changes in this revision

Viewing changes to src/common_cpp/Recon/Global/TrackPoint.cc

  • Committer: Durga Rajaram
  • Date: 2014-01-14 07:07:02 UTC
  • mfrom: (659.1.80 relcand)
  • Revision ID: durga@fnal.gov-20140114070702-2l1fuj1w6rraw7xe
Tags: MAUS-v0.7.6
MAUS-v0.7.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/common_cpp/Recon/Global/TrackPoint.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/TrackPoint.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 "src/common_cpp/Simulation/MAUSPrimaryGeneratorAction.hh"
28
 
#include "Interface/Squeak.hh"
29
 
#include "Recon/Global/Detector.hh"
30
 
#include "Recon/Global/Particle.hh"
31
 
 
32
 
namespace MAUS {
33
 
namespace recon {
34
 
namespace global {
35
 
 
36
 
TrackPoint::TrackPoint()
37
 
    : PhaseSpaceVector(),
38
 
      detector_id_(MAUS::DataStructure::Global::kUndefined),
39
 
      particle_id_(MAUS::DataStructure::Global::kNoPID),
40
 
      z_(0.0)
41
 
{ }
42
 
 
43
 
TrackPoint::TrackPoint(const TrackPoint& original_instance)
44
 
    : PhaseSpaceVector(original_instance),
45
 
      detector_id_(original_instance.detector_id_),
46
 
      uncertainties_(original_instance.uncertainties_),
47
 
      particle_id_(original_instance.particle_id_),
48
 
      z_(original_instance.z_)
49
 
{ }
50
 
 
51
 
TrackPoint::TrackPoint(const PhaseSpaceVector & original_instance,
52
 
                       const double z,
53
 
                       const MAUS::DataStructure::Global::PID pid)
54
 
    : PhaseSpaceVector(original_instance),
55
 
      detector_id_(MAUS::DataStructure::Global::kUndefined),
56
 
      particle_id_(pid), z_(z)
57
 
{ }
58
 
 
59
 
TrackPoint::TrackPoint(const Vector<double> & original_instance,
60
 
                       const double z,
61
 
                       const MAUS::DataStructure::Global::PID pid)
62
 
    : PhaseSpaceVector(original_instance),
63
 
      detector_id_(MAUS::DataStructure::Global::kUndefined),
64
 
      particle_id_(pid), z_(z)
65
 
{ }
66
 
 
67
 
TrackPoint::TrackPoint(const double time, const double energy,
68
 
                       const double x, const double px,
69
 
                       const double y, const double py,
70
 
                       const CovarianceMatrix & uncertainties,
71
 
                       const double z)
72
 
    : PhaseSpaceVector(time, energy, x, px, y, py),
73
 
      detector_id_(MAUS::DataStructure::Global::kUndefined),
74
 
      uncertainties_(uncertainties),
75
 
      particle_id_(MAUS::DataStructure::Global::kNoPID), z_(z) { }
76
 
 
77
 
TrackPoint::TrackPoint(const double time, const double energy,
78
 
                       const double x, const double px,
79
 
                       const double y, const double py,
80
 
                       const Detector & detector,
81
 
                       const double z)
82
 
    : PhaseSpaceVector(time, energy, x, px, y, py),
83
 
      detector_id_(detector.id()),
84
 
      uncertainties_(detector.uncertainties()),
85
 
      particle_id_(MAUS::DataStructure::Global::kNoPID), z_(z) { }
86
 
 
87
 
TrackPoint::TrackPoint(const double time, const double energy,
88
 
                       const double x, const double px,
89
 
                       const double y, const double py,
90
 
                       const MAUS::DataStructure::Global::PID particle_id,
91
 
                       const double z)
92
 
    : PhaseSpaceVector(time, energy, x, px, y, py),
93
 
      detector_id_(MAUS::DataStructure::Global::kUndefined),
94
 
      particle_id_(particle_id), z_(z) { }
95
 
 
96
 
TrackPoint::TrackPoint(double const * const array,
97
 
                       const double z)
98
 
    : PhaseSpaceVector(array),
99
 
      detector_id_(MAUS::DataStructure::Global::kUndefined),
100
 
      particle_id_(MAUS::DataStructure::Global::kNoPID), z_(z) {
101
 
}
102
 
 
103
 
TrackPoint::~TrackPoint() {
104
 
}
105
 
 
106
 
TrackPoint & TrackPoint::operator=(const TrackPoint& rhs) {
107
 
  PhaseSpaceVector::operator=(rhs);
108
 
  particle_id_ = rhs.particle_id_;
109
 
  uncertainties_ = rhs.uncertainties_;
110
 
  detector_id_ = rhs.detector_id_;
111
 
  z_ = rhs.z_;
112
 
 
113
 
  return *this;
114
 
}
115
 
 
116
 
const bool TrackPoint::operator==(const TrackPoint& rhs) const {
117
 
  if (static_cast<PhaseSpaceVector const * const>(this)->operator!=(rhs)) {
118
 
    return false;
119
 
  } else if (rhs.detector_id_ != detector_id_) {
120
 
    return false;
121
 
  } else if (rhs.uncertainties_ != uncertainties_) {
122
 
    return false;
123
 
  } else if (rhs.particle_id_ != particle_id_) {
124
 
    return false;
125
 
  } else if (rhs.z_ != z_) {
126
 
    return false;
127
 
  }
128
 
 
129
 
  return true;
130
 
}
131
 
 
132
 
const bool TrackPoint::operator!=(const TrackPoint& rhs) const {
133
 
  return !operator==(rhs);
134
 
}
135
 
 
136
 
const bool TrackPoint::operator<(const TrackPoint& rhs) const {
137
 
  return z() < rhs.z();
138
 
}
139
 
 
140
 
const bool TrackPoint::operator>(const TrackPoint& rhs) const {
141
 
  return z() > rhs.z();
142
 
}
143
 
 
144
 
void TrackPoint::set_particle_id(const MAUS::DataStructure::Global::PID id) {
145
 
  particle_id_ = id;
146
 
}
147
 
 
148
 
MAUS::DataStructure::Global::PID TrackPoint::particle_id() const {
149
 
  return particle_id_;
150
 
}
151
 
 
152
 
void TrackPoint::set_detector_id(
153
 
    const MAUS::DataStructure::Global::DetectorPoint id) {
154
 
  detector_id_ = id;
155
 
}
156
 
 
157
 
MAUS::DataStructure::Global::DetectorPoint TrackPoint::detector_id() const {
158
 
  return detector_id_;
159
 
}
160
 
 
161
 
void TrackPoint::set_uncertainties(const CovarianceMatrix & uncertainties) {
162
 
  uncertainties_ = uncertainties;
163
 
}
164
 
 
165
 
const CovarianceMatrix & TrackPoint::uncertainties() const {
166
 
  return uncertainties_;
167
 
}
168
 
 
169
 
double TrackPoint::z_momentum() const {
170
 
  if (particle_id_ == MAUS::DataStructure::Global::kNoPID) {
171
 
    throw(Squeal(Squeal::recoverable,
172
 
                 "Attempting to calculate the momentum of a non-particle",
173
 
                 "MAUS::recon::global::TrackPoint::z_momentum()"));
174
 
  }
175
 
  const double mass = Particle::GetInstance()->GetMass(particle_id_);
176
 
  const double energy = (*this)[1];
177
 
  const double px = (*this)[3];
178
 
  const double py = (*this)[5];
179
 
 
180
 
  if (energy < mass) {
181
 
    throw(Squeal(Squeal::recoverable,
182
 
                 "Attempting to calculate the momentum of a "
183
 
                 "particle that is off mass shell.",
184
 
                 "MAUS::recon::global::TrackPoint::z_momentum()"));
185
 
  }
186
 
 
187
 
  return ::sqrt(energy*energy - mass*mass - px*px - py*py);
188
 
}
189
 
 
190
 
MAUS::MAUSPrimaryGeneratorAction::PGParticle
191
 
PrimaryGeneratorParticle(const TrackPoint & point) {
192
 
  MAUSPrimaryGeneratorAction::PGParticle particle;
193
 
  particle.time = point.t();
194
 
  particle.energy = point.E();
195
 
  particle.x = point.x();
196
 
  particle.px = point.Px();
197
 
  particle.y = point.y();
198
 
  particle.py = point.Py();
199
 
  particle.z = point.z();
200
 
  particle.pz = point.Pz();
201
 
  particle.pid = point.particle_id();
202
 
  particle.seed = 0;
203
 
 
204
 
  return particle;
205
 
}
206
 
 
207
 
std::ostream& operator<<(std::ostream& out, const TrackPoint& point) {
208
 
  out << "t: " << point.time() << "  E: "  << point.energy()
209
 
      << "  x: " << point.x()    << "  Px: " << point.Px()
210
 
      << "  y: " << point.y()    << "  Py: " << point.Py()
211
 
      << "  z: " << point.z()
212
 
      << "  PID: " << point.particle_id() << "  DID: " << point.detector_id()
213
 
      << "  Uncertainties: " << point.uncertainties();
214
 
 
215
 
  return out;
216
 
}
217
 
 
218
 
}  // namespace global
219
 
}  // namespace recon
220
 
}  // namespace MAUS