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/NamedParameter.h"
#include "AmpGen/enum.h"
namespace AmpGen
{
  class ParticleProperties; 
      
  declare_enum( spinFormalism, Covariant, Canonical )
  declare_enum( spinBasis    , Dirac    , Weyl ) 
 
  class 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);

 
      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();                                  
 
      NamedParameter<spinFormalism> m_spinFormalism  = {"Particle::SpinFormalism"  ,spinFormalism::Covariant, 
             optionalHelpString("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.")  ) };
      NamedParameter<spinBasis>     m_spinBasis      = {"Particle::SpinBasis", spinBasis::Dirac, 
        optionalHelpString("Basis to use for calculating external polarisation tensors / spinors.",
                      std::make_pair("Dirac", "[default] Quantises along the z-axis")
                    , std::make_pair("Weyl", "Quantises along the direction of motion") )};
      NamedParameter<std::string> m_defaultModifier = {"Particle::DefaultModifier","", "Default modifier to use for lineshapes, for example to use normalised vs unnormalised Blatt-Weisskopf factors."};
  };
  std::ostream& operator<<( std::ostream& os, const Particle& particle );
} // namespace AmpGen
 
#endif