| [349] | 1 | //////////////////////////////////////////////////////////////////////////
|
|---|
| 2 | // Matt.Dobbs@Cern.CH, September 1999
|
|---|
| 3 | //
|
|---|
| 4 | // Polarization object for a particle. All angles are in radians.
|
|---|
| 5 | //////////////////////////////////////////////////////////////////////////
|
|---|
| 6 |
|
|---|
| 7 | #include "Polarization.h"
|
|---|
| 8 |
|
|---|
| 9 | namespace HepMC {
|
|---|
| 10 |
|
|---|
| [571] | 11 | Polarization::Polarization( )
|
|---|
| 12 | : m_theta( 0. ),
|
|---|
| 13 | m_phi( 0. ),
|
|---|
| 14 | m_defined( false )
|
|---|
| 15 | { }
|
|---|
| 16 |
|
|---|
| [349] | 17 | Polarization::Polarization( double theta, double phi )
|
|---|
| 18 | : m_theta( valid_theta(theta) ),
|
|---|
| [571] | 19 | m_phi ( valid_phi(phi) ),
|
|---|
| 20 | m_defined( true )
|
|---|
| [349] | 21 | { }
|
|---|
| 22 |
|
|---|
| 23 | Polarization::Polarization( const Polarization& inpolar )
|
|---|
| 24 | : m_theta( valid_theta( inpolar.theta() ) ),
|
|---|
| [571] | 25 | m_phi ( valid_phi( inpolar.phi() ) ),
|
|---|
| 26 | m_defined( inpolar.is_defined() )
|
|---|
| [349] | 27 | { }
|
|---|
| 28 |
|
|---|
| 29 | Polarization::Polarization( const ThreeVector& vec3in )
|
|---|
| 30 | : m_theta( valid_theta( vec3in.theta() ) ),
|
|---|
| [571] | 31 | m_phi ( valid_phi( vec3in.phi() ) ),
|
|---|
| 32 | m_defined( true )
|
|---|
| [349] | 33 | { }
|
|---|
| 34 |
|
|---|
| 35 | void Polarization::swap( Polarization & other)
|
|---|
| 36 | {
|
|---|
| 37 | std::swap( m_theta, other.m_theta );
|
|---|
| 38 | std::swap( m_phi, other.m_phi );
|
|---|
| [571] | 39 | std::swap( m_defined, other.m_defined );
|
|---|
| [349] | 40 | }
|
|---|
| 41 |
|
|---|
| 42 | Polarization& Polarization::operator=( const Polarization& inpolar ) {
|
|---|
| 43 | /// best practices implementation
|
|---|
| 44 | Polarization tmp( inpolar );
|
|---|
| 45 | swap( tmp );
|
|---|
| 46 | return *this;
|
|---|
| 47 | }
|
|---|
| 48 |
|
|---|
| 49 | void Polarization::print( std::ostream& ostr ) const {
|
|---|
| 50 | ostr << "Polarization: " << *this << std::endl;
|
|---|
| 51 | }
|
|---|
| 52 |
|
|---|
| 53 | ////////////////////
|
|---|
| 54 | // access methods //
|
|---|
| 55 | ////////////////////
|
|---|
| 56 |
|
|---|
| 57 | ThreeVector Polarization::normal3d() const {
|
|---|
| 58 | // unit Hep3Vector for easy manipulation
|
|---|
| 59 | ThreeVector outvec(0,0,1); // makes unit vector along Z
|
|---|
| 60 | outvec.setTheta( theta() ); // sets phi keeping mag and theta constant
|
|---|
| 61 | outvec.setPhi( phi() ); // sets theta keeping mag and phi constant
|
|---|
| 62 | return outvec;
|
|---|
| 63 | }
|
|---|
| 64 |
|
|---|
| 65 | double Polarization::set_theta( double theta ) {
|
|---|
| 66 | /// Theta is restricted to be between 0 --> pi
|
|---|
| 67 | /// if an out of range value is given, it is translated to this range.
|
|---|
| 68 | return m_theta = valid_theta( theta );
|
|---|
| 69 | }
|
|---|
| 70 |
|
|---|
| 71 | double Polarization::set_phi( double phi ) {
|
|---|
| 72 | /// Phi is restricted to be between 0 --> 2pi
|
|---|
| 73 | /// if an out of range value is given, it is translated to this range.
|
|---|
| 74 | return m_phi = valid_phi( phi );
|
|---|
| 75 | }
|
|---|
| [571] | 76 |
|
|---|
| 77 | bool Polarization::is_defined( ) const {
|
|---|
| 78 | return m_defined;
|
|---|
| 79 | }
|
|---|
| 80 |
|
|---|
| 81 | void Polarization::set_undefined() {
|
|---|
| 82 | m_defined = false;
|
|---|
| 83 | m_theta = 0.;
|
|---|
| 84 | m_phi = 0.;
|
|---|
| 85 | }
|
|---|
| [349] | 86 |
|
|---|
| 87 | void Polarization::set_theta_phi( double theta, double phi ) {
|
|---|
| 88 | set_theta( theta );
|
|---|
| 89 | set_phi( phi ) ;
|
|---|
| [571] | 90 | m_defined = true;
|
|---|
| [349] | 91 | }
|
|---|
| 92 |
|
|---|
| 93 | ThreeVector Polarization::set_normal3d( const ThreeVector& vec3in ) {
|
|---|
| 94 | set_theta( vec3in.theta() );
|
|---|
| 95 | set_phi( vec3in.phi() );
|
|---|
| [571] | 96 | m_defined = true;
|
|---|
| [349] | 97 | return vec3in;
|
|---|
| 98 | }
|
|---|
| 99 |
|
|---|
| 100 | /////////////////////
|
|---|
| 101 | // private methods //
|
|---|
| 102 | /////////////////////
|
|---|
| 103 |
|
|---|
| 104 | double Polarization::valid_theta( double theta ) {
|
|---|
| 105 | // this is just absolute value.
|
|---|
| 106 | theta = ( theta>0 ? theta : -theta );
|
|---|
| 107 | // translate to 0 < theta < 2pi
|
|---|
| 108 | theta = ( theta/(2*HepMC_pi) - int(theta/(2*HepMC_pi)) )
|
|---|
| 109 | * 2*HepMC_pi;
|
|---|
| 110 | // now translate to 0 < theta < pi
|
|---|
| 111 | if ( theta > HepMC_pi ) theta = 2*HepMC_pi - theta;
|
|---|
| 112 | return theta;
|
|---|
| 113 | }
|
|---|
| 114 |
|
|---|
| 115 | double Polarization::valid_phi( double phi ) {
|
|---|
| 116 | //
|
|---|
| 117 | // translate to -2pi < phi < 2pi
|
|---|
| 118 | phi = ( phi/(2*HepMC_pi) - int(phi/(2*HepMC_pi)) ) * 2*HepMC_pi;
|
|---|
| 119 | // translates to 0 < phi < 2pi
|
|---|
| 120 | if ( phi < 0 ) phi = 2*HepMC_pi + phi;
|
|---|
| 121 | return phi;
|
|---|
| 122 | }
|
|---|
| 123 |
|
|---|
| 124 | /////////////
|
|---|
| 125 | // Friends //
|
|---|
| 126 | /////////////
|
|---|
| 127 |
|
|---|
| 128 | /// write theta and phi to the output stream
|
|---|
| 129 | std::ostream& operator<<( std::ostream& ostr, const Polarization& polar ) {
|
|---|
| 130 | return ostr << "(" << polar.theta()
|
|---|
| 131 | << "," << polar.phi() << ")";
|
|---|
| 132 | }
|
|---|
| 133 |
|
|---|
| 134 | } // HepMC
|
|---|
| 135 |
|
|---|
| 136 |
|
|---|
