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("ALICE::V0Multiplicity");
    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 int compare(const Projection& p) const
      {
    return dynamic_cast<const V0Multiplicity<MODE>*>(&p) ?
      EQUIVALENT : UNDEFINED;
      } 
    };
    //----------------------------------------------------------------
    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 int compare(const Projection& p) const
      {
    return dynamic_cast<const CLMultiplicity<INNER>*>(&p) ?
      EQUIVALENT : UNDEFINED;
      } 
    };
    //----------------------------------------------------------------
    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 int compare(const Projection& p) const
      {
    return dynamic_cast<const V0Trigger<MODE>*>(&p) ?
      EQUIVALENT : UNDEFINED;
      }
    };
    //----------------------------------------------------------------
    // typedef V0Trigger<-1> V0ATrigger;
    using V0ATrigger = V0Trigger<-1>;
    // typedef V0Trigger<+1> V0CTrigger;
    using V0CTrigger = V0Trigger<+1>;
    // typedef V0Trigger<0> V0OrTrigger;
    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 int compare(const Projection& p) const
      {
    return dynamic_cast<const V0AndTrigger*>(&p) ?
      EQUIVALENT : UNDEFINED;
      }
      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 int compare(const Projection& p) const
      {
    const PrimaryParticles* o = dynamic_cast<const PrimaryParticles*>(&p);
    if (_cuts != o->_cuts) return UNDEFINED;
    return mkPCmp(*o,"PrimaryParticles");
      }
      virtual std::unique_ptr<Rivet::Projection> clone() const
      {
    return std::unique_ptr<Projection>(new PrimaryParticles(*this));
      }
    protected:
      bool isPrimaryPID(const HepMC::GenParticle* p) const
      {
    int pdg = PID::abspid(p->pdg_id());
    // Check for nuclus 
    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
//
// EOF
//