AliceCommon.hh

#ifndef PROJECTIONS_ALICECOMMON_HH
#define PROJECTIONS_ALICECOMMON_HH
#include "Rivet/Tools/AliceCommon.hh"
#include "Rivet/Projections/FinalState.hh"
#include "Rivet/Projections/SingleValueProjection.hh"
#include "Rivet/Projections/TriggerProjection.hh"
#include "Rivet/Projections/PrimaryParticles.hh"
 
namespace Rivet {
  namespace ALICE {
 
 
 
    template <int MODE>
    class V0Multiplicity : public SingleValueProjection {
    public:
      V0Multiplicity() : SingleValueProjection() {
        setName(MODE<0 ? "ALICE::V0CMultiplicity":
        MODE>0 ? "ALICE::V0AMultiplicity":
        "ALICE::V0MMultiplicity");
        Cut cut;
        if      (MODE < 0) cut = V0Cacceptance;
        else if (MODE > 0) cut = V0Aacceptance;
        else               cut = (V0Aacceptance || V0Cacceptance);
        // Declare our projection.  Note, the cuts stipulate charged
        // particles, so we just use a final state (rather than
        // charged-final state) projection here.
        const FinalState fs(cut);
        this->declare(fs, "FinalState");
      }
 
      virtual ~V0Multiplicity() {}
 
      virtual void project(const Event& e) {
        clear();
        set(apply<FinalState>(e,"FinalState").particles().size());
      }
 
      virtual std::unique_ptr<Rivet::Projection> clone() const {
        return std::unique_ptr<Projection>(new V0Multiplicity<MODE>(*this));
      }
      virtual CmpState compare(const Projection& p) const {
    return dynamic_cast<const V0Multiplicity<MODE>*>(&p) ?
      CmpState::EQ : CmpState::NEQ;
      }
 
    };
 
    typedef V0Multiplicity<+1> V0AMultiplicity;
 
    typedef V0Multiplicity<-1> V0CMultiplicity;
 
    typedef V0Multiplicity<0> V0MMultiplicity;
 
 
 
    template <bool INNER>
    class CLMultiplicity : public SingleValueProjection {
    public:
 
      CLMultiplicity() : SingleValueProjection() {
        setName("ALICE::CLMultiplicity");
        Cut cut;
        if   (INNER) cut = CL0acceptance;
        else         cut = CL1acceptance;
        // Declare our projection.  Note, the cuts stipulate charged
        // particles, so we just use a final state (rather than
        // charged-final state) projection here.
        const FinalState fs(cut);
        this->declare(fs, "FinalState");
      }
 
      virtual ~CLMultiplicity() {}
 
      virtual void project(const Event& e) {
        clear();
        set(apply<FinalState>(e,"FinalState").particles().size());
      }
 
      virtual std::unique_ptr<Rivet::Projection> clone() const {
        return std::unique_ptr<Projection>(new CLMultiplicity<INNER>(*this));
      }
 
      virtual CmpState compare(const Projection& p) const {
    return dynamic_cast<const CLMultiplicity<INNER>*>(&p) ?
      CmpState::EQ : CmpState::NEQ;
      }
 
    };
 
 
    typedef CLMultiplicity<true>  CL0Multiplicity;
 
    typedef CLMultiplicity<false> CL1Multiplicity;
 
 
 
    template <int MODE>
    class V0Trigger : public TriggerProjection {
    public:
 
      V0Trigger() : TriggerProjection() {
        setName("ALICE::V0Trigger");
        // Declare our projection.  Note, the cuts stipulate charged
        // particles, so we just use a final state (rather than
        // charged-final state) projection here.
        const V0Multiplicity<MODE> fs;
        this->declare(fs, "FinalState");
      }
 
      virtual ~V0Trigger() {}
 
      virtual void project(const Event& e) {
        fail(); // Assume failure
        if (apply<V0Multiplicity<MODE>>(e, "FinalState")() > 0) pass();
      }
 
      virtual std::unique_ptr<Rivet::Projection> clone() const {
        return std::unique_ptr<Projection>(new V0Trigger<MODE>(*this));
      }
 
      virtual CmpState compare(const Projection& p) const {
    return dynamic_cast<const V0Trigger<MODE>*>(&p) ?
      CmpState::EQ : CmpState::NEQ;
      }
 
    };
 
    using V0ATrigger = V0Trigger<-1>;
 
    using V0CTrigger = V0Trigger<+1>;
 
    using V0OrTrigger = V0Trigger<0>;
 
 
 
    class V0AndTrigger : public TriggerProjection {
    public:
 
      V0AndTrigger() : TriggerProjection() {
        const V0ATrigger v0a;
        const V0CTrigger v0c;
        this->declare(v0a, "V0A");
        this->declare(v0c, "V0C");
      }
 
      virtual ~V0AndTrigger() {}
 
      virtual void project(const Event& e) {
        fail(); // Assume failure
        if (apply<V0ATrigger>(e,"V0A")() && apply<V0CTrigger>(e,"V0C")()) pass();
      }
 
      virtual CmpState compare(const Projection& p) const
      {
    return dynamic_cast<const V0AndTrigger*>(&p) ?
      CmpState::EQ : CmpState::NEQ;
      }
 
      virtual std::unique_ptr<Rivet::Projection> clone() const {
        return std::unique_ptr<Projection>(new V0AndTrigger(*this));
      }
 
    };
 
 
    class PrimaryParticles : public Rivet::PrimaryParticles {
    public:
 
      PrimaryParticles(const Cut& c=Cuts::open())
        : Rivet::PrimaryParticles({},c)
      { }
 
      virtual CmpState compare(const Projection& p) const {
    const PrimaryParticles* o = dynamic_cast<const PrimaryParticles*>(&p);
    if (_cuts != o->_cuts) return CmpState::NEQ;
    return mkPCmp(*o,"PrimaryParticles");
      }
 
      virtual std::unique_ptr<Rivet::Projection> clone() const {
        return std::unique_ptr<Projection>(new PrimaryParticles(*this));
      }
 
    protected:
 
       bool isPrimaryPID(ConstGenParticlePtr p) const {
        const int pdg = abs(p->pdg_id());
        // Check for nucleus
        if (pdg > 1000000000) return true;
 
        switch (pdg) {
        case Rivet::PID::MUON:
        case Rivet::PID::ELECTRON:
        case Rivet::PID::GAMMA:
        case Rivet::PID::PIPLUS:
        case Rivet::PID::KPLUS:
        case Rivet::PID::K0S:
        case Rivet::PID::K0L:
        case Rivet::PID::PROTON:
        case Rivet::PID::NEUTRON:
        case Rivet::PID::LAMBDA:
        case Rivet::PID::SIGMAMINUS:
        case Rivet::PID::SIGMAPLUS:
        case Rivet::PID::XIMINUS:
        case Rivet::PID::XI0:
        case Rivet::PID::OMEGAMINUS:
        case Rivet::PID::NU_E:
        case Rivet::PID::NU_MU:
        case Rivet::PID::NU_TAU:
          return true;
        }
        return false;
      }
 
    };
 
 
  }
}
 
#endif