Polarization.cc

// Matt.Dobbs@Cern.CH, September 1999
//
// Polarization object for a particle. All angles are in radians.

#include "HepMC/Polarization.h"

namespace HepMC {

    Polarization::Polarization( )
    : m_theta( 0. ),
      m_phi( 0. ),
      m_defined( false )
    { }

    Polarization::Polarization( double theta, double phi )
    : m_theta( valid_theta(theta) ),
      m_phi  ( valid_phi(phi) ),
      m_defined( true )
    { }

    Polarization::Polarization( const Polarization& inpolar )
    : m_theta( valid_theta( inpolar.theta() ) ),
      m_phi  ( valid_phi(   inpolar.phi()   ) ),
      m_defined( inpolar.is_defined() )
    { }

    Polarization::Polarization( const ThreeVector& vec3in ) 
    : m_theta( valid_theta( vec3in.theta() ) ),
      m_phi  ( valid_phi(   vec3in.phi()   ) ),
      m_defined( true )
    { }

    void Polarization::swap( Polarization & other)
    {
        std::swap( m_theta, other.m_theta );
        std::swap( m_phi,   other.m_phi   );
        std::swap( m_defined, other.m_defined );
    }

    Polarization& Polarization::operator=( const Polarization& inpolar ) {
        Polarization tmp( inpolar );
        swap( tmp ); 
        return *this;
    }

    void Polarization::print( std::ostream& ostr ) const {
        ostr << "Polarization: " << *this << std::endl;
    }

    // access methods //

    ThreeVector  Polarization::normal3d() const {
        // unit Hep3Vector for easy manipulation
        ThreeVector outvec(0,0,1);      // makes unit vector along Z
        outvec.setTheta( theta() ); // sets phi keeping mag and theta constant
        outvec.setPhi( phi() );     // sets theta keeping mag and phi constant
        return outvec;
    }

    double Polarization::set_theta( double theta ) {
        return m_theta = valid_theta( theta );
    }

    double Polarization::set_phi( double phi ) {
        return m_phi = valid_phi( phi );
    }
    
    bool Polarization::is_defined( ) const {
        return m_defined;
    }
    
    void Polarization::set_undefined() {
        m_defined = false;
        m_theta = 0.;
        m_phi = 0.;
    }

    void Polarization::set_theta_phi( double theta, double phi ) {
        set_theta( theta );
        set_phi( phi ) ;
        m_defined = true;
    }

    ThreeVector Polarization::set_normal3d( const ThreeVector& vec3in ) {
        set_theta( vec3in.theta() );
        set_phi( vec3in.phi() );
        m_defined = true;
        return vec3in;
    }

    // private methods //

    double Polarization::valid_theta( double theta ) {
        // this is just absolute value.
        theta = ( theta>0 ? theta : -theta );
        // translate to 0 < theta < 2pi
        theta = ( theta/(2*HepMC_pi) - int(theta/(2*HepMC_pi)) ) 
                * 2*HepMC_pi;
        // now translate to 0 < theta < pi
        if ( theta > HepMC_pi ) theta = 2*HepMC_pi - theta;
        return theta;
    }

    double Polarization::valid_phi( double phi ) {
        //
        // translate to -2pi < phi < 2pi
        phi = ( phi/(2*HepMC_pi) - int(phi/(2*HepMC_pi)) ) * 2*HepMC_pi;
        // translates to 0 < phi < 2pi
        if ( phi < 0 ) phi = 2*HepMC_pi + phi;
        return phi;
    }

    // Friends //

    std::ostream& operator<<( std::ostream& ostr, const Polarization& polar ) {
        return ostr << "(" << polar.theta() 
                    << ","  << polar.phi() << ")";
    }
    
} // HepMC