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 <iostream.h>
#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 );

    virtual EvtVector4C epsPhoton( int i );

    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( unsigned int ndaug, EvtId* id );

    void makeDaughters( unsigned int ndaug, std::vector<EvtId> idVector );

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

    EvtParticle* getDaug( int i );

    EvtParticle* nextIter( EvtParticle* rootOfTree = 0 );

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

    EvtVector4R getP4Lab() const;

    EvtVector4R getP4LabBeforeFSR();

    EvtVector4R getP4Restframe() const;

    EvtVector4R get4Pos() const;

    EvtParticle* getParent() const;

    void insertDaugPtr( int idaug, EvtParticle* partptr )
    {
        _daug[idaug] = partptr;
        partptr->_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 )
    {
        _p = p4;
        _pBeforeFSR = p4;
    }

    void setP4WithFSR( const EvtVector4R& p4 ) { _p = p4; }

    void setFSRP4toZero() { _pBeforeFSR.set( 0.0, 0.0, 0.0, 0.0 ); }

    int getChannel() const;

    size_t getNDaug() const;
    void resetNDaug()
    {
        _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();

    void setDiagonalSpinDensity();

    void setVectorSpinDensity();

    void setSpinDensityForward( const EvtSpinDensity& rho )
    {
        _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 _rhoForward; }

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

    EvtSpinDensity getSpinDensityBackward() { return _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() { _genlifetime = 0; }

    //lange - April 29, 2002
    void setId( EvtId id ) { _id = id; }
    void initDecay( bool useMinMass = false );
    bool generateMassTree();

    double compMassProb();

    //setMass will blow away any existing 4vector
    void setMass( double m ) { _p = EvtVector4R( m, 0.0, 0.0, 0.0 ); }

    //void setMixed() {_mix=true;}
    //void setUnMixed() {_mix=false;}
    //bool getMixed() {return _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 _isInit; }
    bool hasValidP4() { return _validP4; }
    bool isDecayed() { return _isDecayed; }

    // decay prob - only relevent if already decayed
    // and is a scalar particle
    // returned is a double* that should be prob/probMax
    double* decayProb() { return _decayProb; }
    void setDecayProb( double p );

    // Return the name of the particle (from the EvtId number)
    std::string getName();

    // 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 )
    {
        _intAttributes[attName] = attValue;
    }

    // Retrieve the integer value for the given attribute name
    int getAttribute( std::string attName );

    // 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 )
    {
        _dblAttributes[attName] = attValue;
    }

    // Retrieve the double value for the given attribute name
    double getAttributeDouble( std::string attName );

  protected:
    void setp( double e, double px, double py, double pz )
    {
        _p.set( e, px, py, pz );
        _pBeforeFSR = _p;
    }

    void setp( const EvtVector4R& p4 )
    {
        _p = p4;
        _pBeforeFSR = _p;
    }

    void setpart_num( EvtId particle_number )
    {
        assert( _channel == -10 || _id.getId() == particle_number.getId() ||
                _id.getId() == -1 );
        _id = particle_number;
    }
    bool _validP4;

    // A typedef to define the attribute (name, integer) map
    typedef std::map<std::string, int> EvtAttIntMap;
    EvtAttIntMap _intAttributes;

    // A typedef to define the attribute (name, double) map
    typedef std::map<std::string, double> EvtAttDblMap;
    EvtAttDblMap _dblAttributes;

  private:
    EvtParticle* _daug[MAX_DAUG];
    size_t _ndaug;
    EvtParticle* _parent;
    int _channel;
    int _first;
    EvtId _id;
    EvtVector4R _p;
    EvtVector4R _pBeforeFSR;
    double _t;
    bool _isInit;
    bool _isDecayed;

    //bool _mix;

    EvtSpinDensity _rhoForward;
    EvtSpinDensity _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 _genlifetime;

    //should never be used, therefor is private.
    //these does _not_ have an implementation
    EvtParticle& operator=( const EvtParticle& p );
    EvtParticle( const EvtParticle& p );

    double* _decayProb;
};

#endif