MuonFeature.h File Reference

#include <string>
#include <map>
#include "AthenaKernel/CLASS_DEF.h"
#include "AthContainers/DataVector.h"

Include dependency graph for MuonFeature.h:

Go to the source code of this file.

Classes
class	MuonFeature

Functions
std::string	str (const MuonFeature &muon)
	Helper function for printing the object.
MsgStream &	operator<< (MsgStream &m, const MuonFeature &muon)
	Helper operator for printing the object.
bool	operator== (const MuonFeature &left, const MuonFeature &right)
	Operator comparing two MuonFeature objects for equality.
bool	operator!= (const MuonFeature &left, const MuonFeature &right)
	Operator comparing two MuonFeature objects for inequality.
void	diff (const MuonFeature &left, const MuonFeature &right, std::map< std::string, double > &varChange)
	Comparison with feedback.

Function Documentation

diff()

void diff	(	const MuonFeature &	left,
		const MuonFeature &	right,
		std::map< std::string, double > &	varChange )

Comparison with feedback.

Definition at line 236 of file MuonFeature.cxx.

                                                    {
 
   if( std::abs( left.algoId() - right.algoId() ) > DELTA ) {
      varChange[ "algoId" ] = static_cast< double >( left.algoId() - right.algoId() );
   }
   if( left.saddress() != right.saddress() ) {
      varChange[ "saddress" ] = static_cast< double >( left.saddress() - right.saddress() );
   }
   if( std::abs( left.pt() - right.pt() ) > DELTA ) {
      varChange[ "pt" ] = left.pt() - right.pt();
   }
   if( std::abs( left.radius() - right.radius() ) > DELTA ) {
      varChange[ "radius" ] = left.radius() - right.radius();
   }
   if( std::abs( left.eta() - right.eta() ) > DELTA ) {
      varChange[ "eta" ] = left.eta() - right.eta();
   }
   if( std::abs( left.phi() - right.phi() ) > DELTA ) {
      varChange[ "phi" ] = left.phi() - right.phi();
   }
   if( std::abs( left.dir_phi() - right.dir_phi() ) > DELTA ) {
      varChange[ "dir_phi" ] = left.dir_phi() - right.dir_phi();
   }
   if( std::abs( left.zeta() - right.zeta() ) > DELTA ) {
      varChange[ "zeta" ] = left.zeta() - right.zeta();
   }
   if( std::abs( left.dir_zeta() - right.dir_zeta() ) > DELTA ) {
      varChange[ "dir_zeta" ] = left.dir_zeta() - right.dir_zeta();
   }
   if( std::abs( left.beta() - right.beta() ) > DELTA ) {
      varChange[ "beta" ] = left.beta() - right.beta();
   }
   if( std::abs( left.sp1_r() - right.sp1_r() ) > DELTA ) {
      varChange[ "sp1_r" ] = left.sp1_r() - right.sp1_r();
   }
   if( std::abs( left.sp1_z() - right.sp1_z() ) > DELTA ) {
      varChange[ "sp1_z" ] = left.sp1_z() - right.sp1_z();
   }
   if( std::abs( left.sp1_slope() - right.sp1_slope() ) > DELTA ) {
      varChange[ "sp1_slope" ] = left.sp1_slope() - right.sp1_slope();
   }
   if( std::abs( left.sp2_r() - right.sp2_r() ) > DELTA ) {
      varChange[ "sp2_r" ] = left.sp2_r() - right.sp2_r();
   }
   if( std::abs( left.sp2_z() - right.sp2_z() ) > DELTA ) {
      varChange[ "sp2_z" ] = left.sp2_z() - right.sp2_z();
   }
   if( std::abs( left.sp2_slope() - right.sp2_slope() ) > DELTA ) {
      varChange[ "sp2_slope" ] = left.sp2_slope() - right.sp2_slope();
   }
   if( std::abs( left.sp3_r() - right.sp3_r() ) > DELTA ) {
      varChange[ "sp3_r" ] = left.sp3_r() - right.sp3_r();
   }
   if( std::abs( left.sp3_z() - right.sp3_z() ) > DELTA ) {
      varChange[ "sp3_z" ] = left.sp3_z() - right.sp3_z();
   }
   if( std::abs( left.sp3_slope() - right.sp3_slope() ) > DELTA ) {
      varChange[ "sp3_slope" ] = left.sp3_slope() - right.sp3_slope();
   }
   if( std::abs( left.br_radius() - right.br_radius() ) > DELTA ) {
      varChange[ "br_radius" ] = left.br_radius() - right.br_radius();
   }
   if( std::abs( left.br_sagitta() - right.br_sagitta() ) > DELTA ) {
      varChange[ "br_sagitta" ] = left.br_sagitta() - right.br_sagitta();
   }
   if( std::abs( left.ec_alpha() - right.ec_alpha() ) > DELTA ) {
      varChange[ "ec_alpha" ] = left.ec_alpha() - right.ec_alpha();
   }
   if( std::abs( left.ec_beta() - right.ec_beta() ) > DELTA ) {
      varChange[ "ec_beta" ] = left.ec_beta() - right.ec_beta();
   }
   if( std::abs( left.dq_var1() - right.dq_var1() ) > DELTA ) {
      varChange[ "dq_var1" ] = left.dq_var1() - right.dq_var1();
   }
   if( std::abs( left.dq_var2() - right.dq_var2() ) > DELTA ) {
      varChange[ "dq_var2" ] = left.dq_var2() - right.dq_var2();
   }
 
   return;
}

operator!=()

bool operator!= ( const MuonFeature & left, const MuonFeature & right )

inline

Operator comparing two MuonFeature objects for inequality.

Definition at line 119 of file MuonFeature.h.

                                                                             {
   return !( left == right );
}

operator<<()

MsgStream & operator<<	(	MsgStream &	m,
		const MuonFeature &	muon )

Helper operator for printing the object.

Definition at line 192 of file MuonFeature.cxx.

                                                                {
 
   return ( m << str( muon ) );
 
}

operator==()

bool operator==	(	const MuonFeature &	left,
		const MuonFeature &	right )

Operator comparing two MuonFeature objects for equality.

Definition at line 198 of file MuonFeature.cxx.

                                                                      {
 
   if( ( left.algoId() != right.algoId() ) || 
       ( left.saddress() != right.saddress() ) ||
       ( std::abs( left.pt() - right.pt() ) > DELTA ) ||
       ( std::abs( left.radius() - right.radius() ) > DELTA ) ||
       ( std::abs( left.eta() - right.eta() ) > DELTA ) ||
       ( std::abs( left.phi() - right.phi() ) > DELTA ) ||
       ( std::abs( left.dir_phi() - right.dir_phi() ) > DELTA ) ||
       ( std::abs( left.zeta() - right.zeta() ) > DELTA ) ||
       ( std::abs( left.dir_zeta() - right.dir_zeta() ) > DELTA ) ||
       ( std::abs( left.beta() - right.beta() ) > DELTA ) ||
       ( std::abs( left.sp1_r() - right.sp1_r() ) > DELTA ) ||
       ( std::abs( left.sp1_z() - right.sp1_z() ) > DELTA ) ||
       ( std::abs( left.sp1_slope() - right.sp1_slope() ) > DELTA ) ||
       ( std::abs( left.sp2_r() - right.sp2_r() ) > DELTA ) ||
       ( std::abs( left.sp2_z() - right.sp2_z() ) > DELTA ) ||
       ( std::abs( left.sp2_slope() - right.sp2_slope() ) > DELTA ) ||
       ( std::abs( left.sp3_r() - right.sp3_r() ) > DELTA ) ||
       ( std::abs( left.sp3_z() - right.sp3_z() ) > DELTA ) ||
       ( std::abs( left.sp3_slope() - right.sp3_slope() ) > DELTA ) ||
       ( std::abs( left.br_radius() - right.br_radius() ) > DELTA ) ||
       ( std::abs( left.br_sagitta() - right.br_sagitta() ) > DELTA ) ||
       ( std::abs( left.ec_alpha() - right.ec_alpha() ) > DELTA ) ||
       ( std::abs( left.ec_beta() - right.ec_beta() ) > DELTA ) ||
       ( std::abs( left.dq_var1() - right.dq_var1() ) > DELTA ) ||
       ( std::abs( left.dq_var2() - right.dq_var2() ) > DELTA ) ) {
 
      return false;
 
   } else {
 
      return true;
 
   }
 
}

str()

std::string str

(

const MuonFeature &

muon

)

Helper function for printing the object.

Definition at line 180 of file MuonFeature.cxx.

                                         {
 
   std::stringstream stream;
   stream << "RoI ID: " << muon.roiId()
          << "; saddress: " << muon.saddress()
          << "; eta: " << muon.eta()
          << "; phi: " << muon.phi()
          << "; pt: " << muon.pt();
 
   return stream.str();
}