EvtParticle.hh

Go to the documentation of this file.

 
/***********************************************************************
* Copyright 1998-2020 CERN for the benefit of the EvtGen authors       *
*                                                                      *
* This file is part of EvtGen.                                         *
*                                                                      *
* EvtGen is free software: you can redistribute it and/or modify       *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or    *
* (at your option) any later version.                                  *
*                                                                      *
* EvtGen is distributed in the hope that it will be useful,            *
* but WITHOUT ANY WARRANTY; without even the implied warranty of       *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        *
* GNU General Public License for more details.                         *
*                                                                      *
* You should have received a copy of the GNU General Public License    *
* along with EvtGen.  If not, see <https://www.gnu.org/licenses/>.     *
***********************************************************************/
 
#ifndef EVTPARTICLE_HH
#define EVTPARTICLE_HH
 
#include "EvtGenBase/EvtId.hh"
#include "EvtGenBase/EvtSpinDensity.hh"
#include "EvtGenBase/EvtSpinType.hh"
#include "EvtGenBase/EvtVector4R.hh"
 
#include <assert.h>
#include <map>
#include <string>
#include <vector>
 
class EvtDiracSpinor;
class EvtVector4C;
class EvtTensor4C;
class EvtStdHep;
class EvtSecondary;
class EvtRaritaSchwinger;
 
const int MAX_DAUG = 100;
const int MAX_LEVEL = 10;
const int MAX_TRIES = 10000;
 
class EvtParticle {
  public:
    EvtParticle();

    virtual ~EvtParticle();

    virtual EvtVector4C epsParent( int i ) const;

    virtual EvtVector4C eps( int i ) const;

    virtual EvtVector4C epsParentPhoton( int i ) const;

    virtual EvtVector4C epsPhoton( int i ) const;

    virtual EvtDiracSpinor spParent( int ) const;

    virtual EvtDiracSpinor sp( int ) const;

    virtual EvtDiracSpinor spParentNeutrino() const;

    virtual EvtDiracSpinor spNeutrino() const;

    virtual EvtTensor4C epsTensorParent( int i ) const;

    virtual EvtTensor4C epsTensor( int i ) const;

    virtual EvtRaritaSchwinger spRSParent( int ) const;

    virtual EvtRaritaSchwinger spRS( int ) const;

    virtual void init( EvtId part_n, const EvtVector4R& p4 ) = 0;

    void addDaug( EvtParticle* node );

    void decay();

    void deleteTree();
    void deleteDaughters( bool keepChannel = false );

    void setChannel( int i );

    void makeDaughters( size_t ndaug, const EvtId* id );

    void makeDaughters( size_t ndaug, const std::vector<EvtId> idVector );

    double initializePhaseSpace( size_t numdaughter, const EvtId* daughters,
                                 bool forceResetMasses = false,
                                 double poleSize = -1., int whichTwo1 = 0,
                                 int whichTwo2 = 1 );

    EvtParticle* getDaug( const int i ) { return m_daug[i]; }

    const EvtParticle* getDaug( const int i ) const { return m_daug[i]; }

    EvtParticle* nextIter( EvtParticle* rootOfTree = nullptr );

    void makeStdHep( EvtStdHep& stdhep, EvtSecondary& secondary,
                     EvtId* stable_parent_ihep );
    void makeStdHep( EvtStdHep& stdhep );

    EvtVector4R getP4Lab() const;

    EvtVector4R getP4LabBeforeFSR() const;

    EvtVector4R getP4Restframe() const;

    EvtVector4R get4Pos() const;

    EvtParticle* getParent() const;

    void insertDaugPtr( int idaug, EvtParticle* partptr )
    {
        m_daug[idaug] = partptr;
        partptr->m_parent = this;
    }

    double mass() const;

    int firstornot() const;
    void setFirstOrNot();
    void resetFirstOrNot();

    EvtId getId() const;

 
    int getPDGId() const;

 
    EvtSpinType::spintype getSpinType() const;

    int getSpinStates() const;

    const EvtVector4R& getP4() const;

    void setP4( const EvtVector4R& p4 )
    {
        m_p = p4;
        m_pBeforeFSR = p4;
    }
 
    void setP4WithFSR( const EvtVector4R& p4 ) { m_p = p4; }
 
    void setFSRP4toZero() { m_pBeforeFSR.set( 0.0, 0.0, 0.0, 0.0 ); }

    int getChannel() const;

    size_t getNDaug() const;
    void resetNDaug()
    {
        m_ndaug = 0;
        return;
    }

    void printTree() const;
 
    void printTreeRec( unsigned int level ) const;
 
    std::string treeStr() const;
    std::string treeStrRec( unsigned int level ) const;

    void printParticle() const;

    void setLifetime( double tau );

    void setLifetime();

    double getLifetime() const;

    void setDiagonalSpinDensity();

    void setVectorSpinDensity();

    void setSpinDensityForward( const EvtSpinDensity& rho )
    {
        m_rhoForward = rho;
    }

    void setSpinDensityForwardHelicityBasis( const EvtSpinDensity& rho );
    void setSpinDensityForwardHelicityBasis( const EvtSpinDensity& rho,
                                             double alpha, double beta,
                                             double gamma );

    virtual EvtSpinDensity rotateToHelicityBasis() const = 0;
    virtual EvtSpinDensity rotateToHelicityBasis( double alpha, double beta,
                                                  double gamma ) const = 0;

    EvtSpinDensity getSpinDensityForward() { return m_rhoForward; }

    void setSpinDensityBackward( const EvtSpinDensity& rho )
    {
        m_rhoBackward = rho;
    }

    EvtSpinDensity getSpinDensityBackward() { return m_rhoBackward; }
 
    //Hacks will be removed when better solutions are thought of!
    //This is used to suppress use of random numbers when doing initialization
    //of some models.
    void noLifeTime() { m_genlifetime = 0; }
 
    //lange - April 29, 2002
    void setId( EvtId id ) { m_id = id; }
    void initDecay( bool useMinMass = false );
    bool generateMassTree();
 
    double compMassProb();
 
    //setMass will blow away any existing 4vector
    void setMass( double m ) { m_p = EvtVector4R( m, 0.0, 0.0, 0.0 ); }
 
    //void setMixed() {m_mix=true;}
    //void setUnMixed() {m_mix=false;}
    //bool getMixed() {return m_mix;}
 
    //void takeCConj() {EvtGenReport(EVTGEN_INFO,"EvtGen") << "should take conj\n";}
 
    //this means that the particle has gone through initDecay
    // and thus has a mass
    bool isInitialized() { return m_isInit; }
    bool hasValidP4() { return m_validP4; }
    bool isDecayed() { return m_isDecayed; }
 
    // decay prob - only relevent if already decayed
    // and is a scalar particle
    // returned is a double* that should be prob/probMax
    // FIXME - this should probably be changed to std::optional
    const double* decayProb() const { return m_decayProb; }
    void setDecayProb( double p );
 
    // Return the name of the particle (from the EvtId number)
    std::string getName() const;
 
    // Specify whether the particle has a special named attribute with
    // a set value. By default, nothing is set, but derived classes
    // can set this to mean something specific, e.g. if a photon is FSR
    void setAttribute( std::string attName, int attValue )
    {
        m_intAttributes[attName] = attValue;
    }
 
    // Retrieve the integer value for the given attribute name
    int getAttribute( std::string attName ) const;
 
    // Specify if the particle has a double attribute value, e.g. amplitude weight.
    // By default, nothing is set, but derived classes can set this to mean something specific
    void setAttributeDouble( std::string attName, double attValue )
    {
        m_dblAttributes[attName] = attValue;
    }
 
    // Retrieve the double value for the given attribute name
    double getAttributeDouble( std::string attName ) const;
 
  protected:
    void setp( double e, double px, double py, double pz )
    {
        m_p.set( e, px, py, pz );
        m_pBeforeFSR = m_p;
    }
 
    void setp( const EvtVector4R& p4 )
    {
        m_p = p4;
        m_pBeforeFSR = m_p;
    }
 
    void setpart_num( EvtId particle_number )
    {
        assert( m_channel == -10 || m_id.getId() == particle_number.getId() ||
                m_id.getId() == -1 );
        m_id = particle_number;
    }
    bool m_validP4;
 
    // A typedef to define the attribute (name, integer) map
    typedef std::map<std::string, int> EvtAttIntMap;
    EvtAttIntMap m_intAttributes;
 
    // A typedef to define the attribute (name, double) map
    typedef std::map<std::string, double> EvtAttDblMap;
    EvtAttDblMap m_dblAttributes;
 
  private:
    EvtParticle* m_daug[MAX_DAUG];
    size_t m_ndaug;
    EvtParticle* m_parent;
    int m_channel;
    int m_first;
    EvtId m_id;
    EvtVector4R m_p;
    EvtVector4R m_pBeforeFSR;
    double m_t;
    bool m_isInit;
    bool m_isDecayed;
 
    //bool m_mix;
 
    EvtSpinDensity m_rhoForward;
    EvtSpinDensity m_rhoBackward;
 
    void makeStdHepRec( int firstparent, int lastparent, EvtStdHep& stdhep,
                        EvtSecondary& secondary, EvtId* stable_parent_ihep );
    void makeStdHepRec( int firstparent, int lastparent, EvtStdHep& stdhep );
 
    //This is a hack until things gets straightened out. (Ryd)
    int m_genlifetime;
 
    //should never be used, therefor is private.
    //these does _not_ have an implementation
    EvtParticle& operator=( const EvtParticle& p );
    EvtParticle( const EvtParticle& p );
 
    double* m_decayProb;
};
 
#endif