Rivet  3.1.0
AliceCommon.hh
1 #ifndef PROJECTIONS_ALICECOMMON_HH
2 #define PROJECTIONS_ALICECOMMON_HH
3 #include "Rivet/Tools/AliceCommon.hh"
4 #include "Rivet/Projections/FinalState.hh"
5 #include "Rivet/Projections/SingleValueProjection.hh"
6 #include "Rivet/Projections/TriggerProjection.hh"
7 #include "Rivet/Projections/PrimaryParticles.hh"
8 
9 namespace Rivet {
10  namespace ALICE {
11 
14 
15 
24  template <int MODE>
26  public:
28  setName("ALICE::V0Multiplicity");
29  Cut cut;
30  if (MODE < 0) cut = V0Cacceptance;
31  else if (MODE > 0) cut = V0Aacceptance;
32  else cut = (V0Aacceptance || V0Cacceptance);
33  // Declare our projection. Note, the cuts stipulate charged
34  // particles, so we just use a final state (rather than
35  // charged-final state) projection here.
36  const FinalState fs(cut);
37  this->declare(fs, "FinalState");
38  }
39 
41  virtual ~V0Multiplicity() {}
42 
48  virtual void project(const Event& e) {
49  clear();
50  set(apply<FinalState>(e,"FinalState").particles().size());
51  }
52 
56  virtual std::unique_ptr<Rivet::Projection> clone() const {
57  return std::unique_ptr<Projection>(new V0Multiplicity<MODE>(*this));
58  }
62  virtual CmpState compare(const Projection& p) const {
63  return dynamic_cast<const V0Multiplicity<MODE>*>(&p) ?
64  CmpState::EQ : CmpState::NEQ;
65  }
66 
67  };
68 
73 
78 
83 
84 
85 
93  template <bool INNER>
95  public:
96 
99  setName("ALICE::CLMultiplicity");
100  Cut cut;
101  if (INNER) cut = CL0acceptance;
102  else cut = CL1acceptance;
103  // Declare our projection. Note, the cuts stipulate charged
104  // particles, so we just use a final state (rather than
105  // charged-final state) projection here.
106  const FinalState fs(cut);
107  this->declare(fs, "FinalState");
108  }
109 
111  virtual ~CLMultiplicity() {}
112 
118  virtual void project(const Event& e) {
119  clear();
120  set(apply<FinalState>(e,"FinalState").particles().size());
121  }
122 
126  virtual std::unique_ptr<Rivet::Projection> clone() const {
127  return std::unique_ptr<Projection>(new CLMultiplicity<INNER>(*this));
128  }
129 
133  virtual CmpState compare(const Projection& p) const {
134  return dynamic_cast<const CLMultiplicity<INNER>*>(&p) ?
135  CmpState::EQ : CmpState::NEQ;
136  }
137 
138  };
139 
140 
145 
150 
151 
152 
160  template <int MODE>
161  class V0Trigger : public TriggerProjection {
162  public:
163 
166  setName("ALICE::V0Trigger");
167  // Declare our projection. Note, the cuts stipulate charged
168  // particles, so we just use a final state (rather than
169  // charged-final state) projection here.
170  const V0Multiplicity<MODE> fs;
171  this->declare(fs, "FinalState");
172  }
173 
175  virtual ~V0Trigger() {}
176 
181  virtual void project(const Event& e) {
182  fail(); // Assume failure
183  if (apply<V0Multiplicity<MODE>>(e, "FinalState")() > 0) pass();
184  }
185 
189  virtual std::unique_ptr<Rivet::Projection> clone() const {
190  return std::unique_ptr<Projection>(new V0Trigger<MODE>(*this));
191  }
192 
199  virtual CmpState compare(const Projection& p) const {
200  return dynamic_cast<const V0Trigger<MODE>*>(&p) ?
201  CmpState::EQ : CmpState::NEQ;
202  }
203 
204  };
205 
209  using V0ATrigger = V0Trigger<-1>;
210 
215 
220 
221 
222 
225  public:
226 
229  const V0ATrigger v0a;
230  const V0CTrigger v0c;
231  this->declare(v0a, "V0A");
232  this->declare(v0c, "V0C");
233  }
234 
236  virtual ~V0AndTrigger() {}
237 
242  virtual void project(const Event& e) {
243  fail(); // Assume failure
244  if (apply<V0ATrigger>(e,"V0A")() && apply<V0CTrigger>(e,"V0C")()) pass();
245  }
246 
250  virtual CmpState compare(const Projection& p) const
251  {
252  return dynamic_cast<const V0AndTrigger*>(&p) ?
253  CmpState::EQ : CmpState::NEQ;
254  }
255 
259  virtual std::unique_ptr<Rivet::Projection> clone() const {
260  return std::unique_ptr<Projection>(new V0AndTrigger(*this));
261  }
262 
263  };
264 
265 
273  public:
274 
275  PrimaryParticles(const Cut& c=Cuts::open())
277  { }
278 
286  virtual CmpState compare(const Projection& p) const {
287  const PrimaryParticles* o = dynamic_cast<const PrimaryParticles*>(&p);
288  if (_cuts != o->_cuts) return CmpState::NEQ;
289  return mkPCmp(*o,"PrimaryParticles");
290  }
291 
293  virtual std::unique_ptr<Rivet::Projection> clone() const {
294  return std::unique_ptr<Projection>(new PrimaryParticles(*this));
295  }
296 
297  protected:
298 
312  bool isPrimaryPID(ConstGenParticlePtr p) const {
313  const int pdg = abs(p->pdg_id());
314  // Check for nucleus
315  if (pdg > 1000000000) return true;
316 
317  switch (pdg) {
318  case Rivet::PID::MUON:
319  case Rivet::PID::ELECTRON:
320  case Rivet::PID::GAMMA:
321  case Rivet::PID::PIPLUS:
322  case Rivet::PID::KPLUS:
323  case Rivet::PID::K0S:
324  case Rivet::PID::K0L:
325  case Rivet::PID::PROTON:
326  case Rivet::PID::NEUTRON:
327  case Rivet::PID::LAMBDA:
328  case Rivet::PID::SIGMAMINUS:
329  case Rivet::PID::SIGMAPLUS:
330  case Rivet::PID::XIMINUS:
331  case Rivet::PID::XI0:
332  case Rivet::PID::OMEGAMINUS:
333  case Rivet::PID::NU_E:
334  case Rivet::PID::NU_MU:
335  case Rivet::PID::NU_TAU:
336  return true;
337  }
338  return false;
339  }
340 
341  };
342 
343 
344  }
345 }
346 
347 #endif
void setName(const std::string &name)
Used by derived classes to set their name.
Definition: Projection.hh:142
Definition: MC_Cent_pPb.hh:10
virtual ~CLMultiplicity()
Destructor.
Definition: AliceCommon.hh:111
V0Multiplicity<+1 > V0CMultiplicity
Definition: AliceCommon.hh:77
V0AndTrigger()
Constructor.
Definition: AliceCommon.hh:228
virtual void project(const Event &e)
Definition: AliceCommon.hh:48
virtual void project(const Event &e)
Definition: AliceCommon.hh:181
Base class for projections returning a single floating point value.
Definition: SingleValueProjection.hh:17
CLMultiplicity< false > CL1Multiplicity
Definition: AliceCommon.hh:149
virtual ~V0Multiplicity()
Destructor.
Definition: AliceCommon.hh:41
Project out primary particles according to definition.
Definition: PrimaryParticles.hh:19
Definition: AliceCommon.hh:161
virtual CmpState compare(const Projection &p) const
Definition: AliceCommon.hh:62
const Cut & open()
Fully open cut singleton, accepts everything.
virtual CmpState compare(const Projection &p) const
Definition: AliceCommon.hh:250
CLMultiplicity()
Constructor.
Definition: AliceCommon.hh:98
V0Multiplicity<-1 > V0AMultiplicity
Definition: AliceCommon.hh:72
const Cut V0Aacceptance
Definition: AliceCommon.hh:24
Representation of a HepMC event, and enabler of Projection caching.
Definition: Event.hh:22
Cmp< Projection > mkPCmp(const Projection &otherparent, const std::string &pname) const
Base class for projections returning a bool corresponding to a trigger.
Definition: TriggerProjection.hh:19
bool isPrimaryPID(ConstGenParticlePtr p) const
Definition: AliceCommon.hh:312
const PROJ & apply(const Event &evt, const Projection &proj) const
Definition: ProjectionApplier.hh:86
virtual CmpState compare(const Projection &p) const
Definition: AliceCommon.hh:133
void fail()
Set the projection in an unvalid state.
Definition: Projection.hh:147
Definition: AliceCommon.hh:25
virtual ~V0AndTrigger()
Destructor.
Definition: AliceCommon.hh:236
virtual CmpState compare(const Projection &p) const
Definition: AliceCommon.hh:199
Project out all final-state particles in an event. Probably the most important projection in Rivet! ...
Definition: FinalState.hh:12
const PROJ & declare(const PROJ &proj, const std::string &name)
Register a contained projection (user-facing version)
Definition: ProjectionApplier.hh:160
Trigger projection for the ALICE V0-AND (a.k.a. CINT7) requirement.
Definition: AliceCommon.hh:224
virtual void project(const Event &e)
Definition: AliceCommon.hh:118
virtual CmpState compare(const Projection &p) const
Definition: AliceCommon.hh:286
const Cut CL0acceptance
Definition: AliceCommon.hh:36
virtual std::unique_ptr< Rivet::Projection > clone() const
Definition: AliceCommon.hh:189
V0Trigger()
Constructor.
Definition: AliceCommon.hh:165
SingleValueProjection()
The default constructor.
Definition: SingleValueProjection.hh:21
const Cut CL1acceptance
Definition: AliceCommon.hh:42
virtual void project(const Event &e)
Definition: AliceCommon.hh:242
virtual std::unique_ptr< Rivet::Projection > clone() const
Definition: AliceCommon.hh:126
virtual std::unique_ptr< Rivet::Projection > clone() const
Clone this projection.
Definition: AliceCommon.hh:293
Definition: AliceCommon.hh:94
Base class for all Rivet projections.
Definition: Projection.hh:29
CLMultiplicity< true > CL0Multiplicity
Definition: AliceCommon.hh:144
virtual std::unique_ptr< Rivet::Projection > clone() const
Definition: AliceCommon.hh:56
Standard ALICE primary particle definition.
Definition: AliceCommon.hh:272
virtual ~V0Trigger()
Destructor.
Definition: AliceCommon.hh:175
virtual std::unique_ptr< Rivet::Projection > clone() const
Definition: AliceCommon.hh:259
V0Multiplicity< 0 > V0MMultiplicity
Definition: AliceCommon.hh:82
void clear()
Unset the value.
Definition: SingleValueProjection.hh:54
const Cut V0Cacceptance
Definition: AliceCommon.hh:30