Particle.h

Go to the documentation of this file.

#ifndef AMPGEN_PARTICLE_H
#define AMPGEN_PARTICLE_H
 
#include <complex>
#include <vector>
#include <memory>
 
// hack to include optional from https://codereview.stackexchange.com/questions/136350/seamlessly-migrating-experimental-optional-to-optional
#if __cplusplus >= 201703L
#include <optional>
namespace stdx {
  using namespace ::std;
}
#elif __cplusplus >= 201402L
#include <experimental/optional>
namespace stdx {
  using namespace ::std;
  using namespace ::std::experimental;
}
#else
#error "Require c++ std >=14"
#endif
 
#include "AmpGen/EventType.h"
#include "AmpGen/Expression.h"
#include "AmpGen/Tensor.h"
#include "AmpGen/QuarkContent.h"
#include "AmpGen/Property.h"
#include "AmpGen/enum.h"
#include "AmpGen/Units.h"
#include "AmpGen/Configurable.h"
 
namespace AmpGen {
  class ParticleProperties;
 
  declare_enum(spinFormalism, Covariant, Canonical);
  declare_enum(spinBasis, Dirac, Weyl);
 
  class Particle : public Configurable<Particle> {
  public:
    Particle();

    Particle(const std::string &name, const Particle &p1, const Particle &p2);

    Particle(const int &pdg_id, const Particle &p1, const Particle &p2);

    Particle(const std::string &name, const unsigned int &index);

    Particle(const std::string &decayString, const std::vector<std::string> &finalStates = {}, const bool &orderDaughters = true);

    Particle(const std::string &name, const std::vector<Particle> &particles);

    Particle conj(bool invertHead = true, bool reorder = true);
 
    virtual ~Particle() {}
 
    void conjThis();
 
    static bool isValidDecayDescriptor(const std::string &decayDescriptor);
    void setOrbital(const unsigned int &orbital);

    void setLineshape(const std::string &lineshape);

    void setDaughter(const Particle &particle, const unsigned int &index);

    void setParent(const Particle *particle);

    void setIndex(const unsigned int &index, const bool &setOri = false);

    void clearDecayProducts();

    void addModifier(const std::string &mod);

    void parseModifier(const std::string &mod);

    void setOrdering(const std::vector<size_t> &ordering);

    void setName(const std::string &name);

    void addDaughter(const std::shared_ptr<Particle> &particle);

    void setPolarisationState(const int &state);
    void setPolarisationState(const std::vector<int> &state);

    std::pair<size_t, size_t> orbitalRange(const bool &converseParity = true) const;

    std::vector<std::pair<double, double>> spinOrbitCouplings(const bool &conserveParity = true) const;
 
    void setDaughters(const std::vector<Particle> &particles);

    stdx::optional<std::string> attribute(const std::string &key) const;

    const ParticleProperties *props() const;
 
    QuarkContent quarks() const; 
 
    QuarkContent daughterQuarks() const; 
 
    int parity() const;           
    int finalStateParity() const; 
 
    int polState() const; 
    int CP() const;       
    int C() const;        
    double mass() const;  
    double spin() const;  
    double S() const;     
    unsigned L() const;   
 
    bool isHead() const;                            
    bool isWeakDecay() const;                       
    bool isStateGood() const;                       
    bool isStable() const;                          
    bool isQuasiStable() const;                     
    bool conservesParity(unsigned int L = 0) const; 
 
    unsigned index() const; 
    unsigned originalIndex() const; 
    std::string name() const;       
    std::string lineshape() const;  
 
    std::string
    uniqueString() const; 
    std::string
    decayDescriptor() const; 

    std::string topologicalString() const;

    std::string orbitalString() const;

    std::string texLabel(const bool &printHead = false, const bool &recurse = true) const;

    EventType eventType() const;

    const Particle *parent() const;
    std::shared_ptr<Particle> daughter(const size_t &index);

    std::shared_ptr<Particle> daughter(const size_t &index) const;

    std::shared_ptr<Particle> daughter(const std::string &name, const int &maxDepth = -1) const;

    std::vector<std::shared_ptr<Particle>> daughters() const;

    std::vector<std::vector<size_t>> identicalDaughterOrderings() const;

    std::vector<std::shared_ptr<Particle>> getFinalStateParticles(const bool &sort = true) const;

    Particle quasiStableTree() const;

    Tensor P() const;

    Tensor Q() const;

    Tensor spinTensor(DebugSymbols *db = nullptr) const;

    Tensor externalSpinTensor(const int &polState, DebugSymbols *db = nullptr) const;

    Expression massSq() const;

    Expression propagator(DebugSymbols *db = nullptr) const;

    Expression getExpression(DebugSymbols *db = nullptr, const std::vector<int> & = {});

    bool lineshapeContains(const std::vector<std::string> &container) const {
      for(auto &st : container)
        if(m_lineshape.find(st) != std::string::npos) return true;
      return false;
    }

    Tensor transitionMatrix(DebugSymbols *db = nullptr);
    bool operator<(const Particle &other);
    bool operator>(const Particle &other);
 
    enum MatchState {
      None = (1 << 0),
      Exact = (1 << 1),
      PartialExpansion = (1 << 2),
      DifferentOrbital = (1 << 3),
      DifferentPolarisation = (1 << 4),
    };

    unsigned int matches(const Particle &other) const;
    std::string makeUniqueString(); 
    Particle clone() const;
    void setDaughter(const unsigned int &index, const Particle &p);
 
    bool expand(const Particle &particle);
 
  private:
    std::string m_name = {""};                           
    const ParticleProperties *m_props = {nullptr};       
    std::string m_lineshape = {"BW"};                    
    std::string m_vertexName = {""};                     
    std::string m_uniqueString = {""};                   
    int m_parity = {0};                                  
    int m_polState = {0};                                
    unsigned m_index = {999};                            
    unsigned m_originalIndex = {999};                    
    unsigned m_orbital = {0};                            
    unsigned m_spinConfigurationNumber = {0};            
    unsigned m_minL = {0};                               
    bool m_usesDefaultLineshape = {false};               
    bool m_isStateGood = {true};                         
    std::vector<std::shared_ptr<Particle>> m_daughters;  
    std::vector<std::string> m_modifiers;                
    const Particle *m_parent = {nullptr};                
    void pdgLookup(bool quiet = false);                  
    bool hasModifier(const std::string &modifier) const; 
    std::string modifierString() const;                  
    void sortDaughters();                                
 
    static constexpr std::string_view spin_basis_help = "Basis to use for calculating external polarisation tensors / spinors."
                                                        "\n\033[3m Dirac \033[0m: [default] Quantises along the z-axis"
                                                        "\n\033[3m Weyl \033[0m: Quantises along the direction of motion";
 
    Property<spinFormalism> m_spinFormalism
      = {this, "Particle::SpinFormalism", spinFormalism::Covariant,
         helpStringOptions(
           "Formalism to use for spin calculations",
           std::make_pair("Covariant", "[default] Covariant Tensor, based on Rarita-Schwinger constraints on the allowed covariant wavefunctions."),
           std::make_pair(
             "Canonical",
             "Canonical formulation, based on rotational properties of wavefunctions, i.e. Wigner D-matrices and Clebsch-Gordan for (L,S) expansion."))};
    Property<spinBasis> m_spinBasis = {this, "Particle::SpinBasis", spinBasis::Dirac, spin_basis_help};
    Property<std::string> m_defaultModifier = {
      this, "Particle::DefaultModifier", "", "Default modifier to use for lineshapes, for example to use normalised vs unnormalised Blatt-Weisskopf factors."};
    Property<bool> m_movingHead
      = {this, "Particle::MovingHead", true, "Assume the head of the decay chain is not at rest, only applies in canonical formulation."};
    Property<bool> m_alignFrames
      = {this, "Particle::AlignFrames", true, "Align the helicity definition of all particles to a common frame, that of the head of the decay chain."};
    Property<double> m_stableThreshold = {this, "Particle::StableThreshold", KeV, "Lifetime threshold at which particle is considered stable (or quasistable)"};
  };
  std::ostream &operator<<(std::ostream &os, const Particle &particle);
} // namespace AmpGen
 
#endif