TrigMissingET.cxx File Reference

#include "TrigMissingEtEvent/TrigMissingET.h"
#include "TrigMissingEtEvent/TrigMissingEtComponent.h"
#include "CxxUtils/StrFormat.h"
#include "GaudiKernel/MsgStream.h"
#include <stdio.h>
#include <string.h>

Include dependency graph for TrigMissingET.cxx:

Go to the source code of this file.

Functions
bool	operator== (const TrigMissingET &a, const TrigMissingET &b)
	Operator comparing two objects for equality.
std::string	str (const TrigMissingET &a)
	conversion to formatted string: multi-line!
MsgStream &	operator<< (MsgStream &m, const TrigMissingET &d)
void	diff (const TrigMissingET &a, const TrigMissingET &b, std::map< std::string, double > &variableChange)
	Comparison with feedback.

Function Documentation

diff()

void diff	(	const TrigMissingET &	a,
		const TrigMissingET &	b,
		std::map< std::string, double > &	variableChange )

Comparison with feedback.

Definition at line 335 of file TrigMissingET.cxx.

                                                {
 
  const double DELTA=1e-3; // distance used to compare floats
 
  int Na = a.getNumOfComponents();
  int Nb = b.getNumOfComponents();
  if( Na != Nb )
    variableChange[ "NumOfComponents" ] = Na - Nb;
 
  unsigned aFlag = (unsigned) a.getFlag();
  unsigned bFlag = (unsigned) b.getFlag();
  if( aFlag != bFlag )
    variableChange[ "FlagsXOR" ] = aFlag ^ bFlag;
 
  unsigned long aRoI = (unsigned long) a.RoIword();
  unsigned long bRoI = (unsigned long) b.RoIword();
  if( aRoI != bRoI )
    variableChange[ "RoIwordsXOR" ] = aRoI ^ bRoI;
 
  float aEx = a.ex();
  float bEx = b.ex();
  if( fabsf(aEx - bEx) > DELTA )
     variableChange[ "Ex" ] = aEx - bEx;
 
  float aEy = a.ey();
  float bEy = b.ey();
  if( fabsf(aEy - bEy) > DELTA )
     variableChange[ "Ey" ] = aEy - bEy;
 
  float aEz = a.ez();
  float bEz = b.ez();
  if( fabsf(aEz - bEz) > DELTA )
     variableChange[ "Ez" ] = aEz - bEz;
 
  float aSumEt = a.sumEt();
  float bSumEt = b.sumEt();
  if( fabsf(aSumEt - bSumEt) > DELTA )
     variableChange[ "sumEt" ] = aSumEt - bSumEt;
 
  float aSumE = a.sumE();
  float bSumE = b.sumE();
  if( fabsf(aSumE - bSumE) > DELTA )
     variableChange[ "sumE" ] = aSumE - bSumE;
 
  for (unsigned u=0; u<a.getNumOfComponents(); ++u) {
    std::string num = CxxUtils::strformat("%02u", u);
    std::string key;
 
    if( a.getNameOfComponent(u) != b.getNameOfComponent(u) ) {
      key="CompNameStrCmp";  key+=num;
      variableChange[ key.c_str() ] = 
    strcmp(a.getNameOfComponent(u).c_str(),
           b.getNameOfComponent(u).c_str());
    }
 
    unsigned aFlag = (unsigned) a.getStatus(u);
    unsigned bFlag = (unsigned) b.getStatus(u);
    if( aFlag != bFlag ) {
      key="CompStatusXOR";  key+=num;
      variableChange[ key.c_str() ] = aFlag ^ bFlag;
    }
 
    int aSigns = a.getSumOfSigns(u);
    int bSigns = b.getSumOfSigns(u);
    if( aSigns != bSigns ) {
      key="CompSumSigns";  key+=num;
      variableChange[ key.c_str() ] = aSigns - bSigns;
    }
 
    int aChans = a.getUsedChannels(u);
    int bChans = b.getUsedChannels(u);
    if( aChans != bChans ) {
      key="CompUsedChans";  key+=num;
      variableChange[ key.c_str() ] = aChans - bChans;
    }
 
    float aEx = a.getExComponent(u);
    float bEx = b.getExComponent(u);
    if( fabsf(aEx - bEx) > DELTA ) {
      key="CompEx";  key+=num;
      variableChange[ key.c_str() ] = aEx - bEx;
    }
 
    float aEy = a.getEyComponent(u);
    float bEy = b.getEyComponent(u);
    if( fabsf(aEy - bEy) > DELTA ) {
      key="CompEy";  key+=num;
      variableChange[ key.c_str() ] = aEy - bEy;
    }
 
    float aEz = a.getEzComponent(u);
    float bEz = b.getEzComponent(u);
    if( fabsf(aEz - bEz) > DELTA ) {
      key="CompEz";  key+=num;
      variableChange[ key.c_str() ] = aEz - bEz;
    }
 
    float aSumEt = a.getSumEtComponent(u);
    float bSumEt = b.getSumEtComponent(u);
    if( fabsf(aSumEt - bSumEt) > DELTA ) {
      key="CompSumEt";  key+=num;
      variableChange[ key.c_str() ] = aSumEt - bSumEt;
    }
 
    float aSumE = a.getSumEComponent(u);
    float bSumE = b.getSumEComponent(u);
    if( fabsf(aSumE - bSumE) > DELTA ) {
      key="CompSumE";  key+=num;
      variableChange[ key.c_str() ] = aSumE - bSumE;
    }
 
    float aCalib0 = a.getComponentCalib0(u);
    float bCalib0 = b.getComponentCalib0(u);
    if( fabsf(aCalib0 - bCalib0) > DELTA ) {
      key="CompCalib0_";  key+=num;
      variableChange[ key.c_str() ] = aCalib0 - bCalib0;
    }
 
    float aCalib1 = a.getComponentCalib1(u);
    float bCalib1 = b.getComponentCalib1(u);
    if( fabsf(aCalib1 - bCalib1) > DELTA ) {
      key="CompCalib1_";  key+=num;
      variableChange[ key.c_str() ] = aCalib1 - bCalib1;
    }
  }
 
  return;
}

operator<<()

MsgStream & operator<<	(	MsgStream &	m,
		const TrigMissingET &	d )

Definition at line 329 of file TrigMissingET.cxx.

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

operator==()

bool operator==	(	const TrigMissingET &	a,
		const TrigMissingET &	b )

Operator comparing two objects for equality.

Definition at line 234 of file TrigMissingET.cxx.

                                                                   {
 
   const double DELTA=1e-3; // distance used to compare floats
 
   if( a.getNumOfComponents() != b.getNumOfComponents() )
      return false;
   if( a.getFlag() != b.getFlag() )
      return false;
   if( a.RoIword() != b.RoIword() )
      return false;
 
   if( fabsf(a.ex() - b.ex()) > DELTA )
      return false;
   if( fabsf(a.ey() - b.ey()) > DELTA )
      return false;
   if( fabsf(a.ez() - b.ez()) > DELTA )
      return false;
   if( fabsf(a.sumEt() - b.sumEt()) > DELTA )
      return false;
   if( fabsf(a.sumE() - b.sumE()) > DELTA )
      return false;
 
   for (unsigned u=0; u<a.getNumOfComponents(); ++u) {
     if( a.getNameOfComponent(u) != b.getNameOfComponent(u) )
       return false;
     if( a.getStatus(u) != b.getStatus(u) )
       return false;
     if( a.getSumOfSigns(u) != b.getSumOfSigns(u) )
       return false;
     if( a.getUsedChannels(u) != b.getUsedChannels(u) )
       return false;
     if( fabsf(a.getExComponent(u) - b.getExComponent(u)) > DELTA )
       return false;
     if( fabsf(a.getEyComponent(u) - b.getEyComponent(u)) > DELTA )
       return false;
     if( fabsf(a.getEzComponent(u) - b.getEzComponent(u)) > DELTA )
       return false;
     if( fabsf(a.getSumEtComponent(u) - b.getSumEtComponent(u)) > DELTA )
       return false;
     if( fabsf(a.getSumEComponent(u) - b.getSumEComponent(u)) > DELTA )
       return false;
     if( fabsf(a.getComponentCalib0(u) - b.getComponentCalib0(u)) > DELTA )
       return false;
     if( fabsf(a.getComponentCalib1(u) - b.getComponentCalib1(u)) > DELTA )
       return false;
   }
 
   return true;
}

str()

std::string str

(

const TrigMissingET &

a

)

conversion to formatted string: multi-line!

Definition at line 285 of file TrigMissingET.cxx.

                                      {
  std::string s="";
 
  using CxxUtils::strformat;
 
  s += strformat("MEx   = %10.2f MeV\n", a.ex());
  s += strformat("MEy   = %10.2f MeV\n", a.ey());
  s += strformat("MEz   = %10.2f MeV\n", a.ez());
 
  float et = std::sqrt(a.ex()*a.ex()+a.ey()*a.ey());
  s += strformat("MEt   = %10.2f MeV\n", et);
  s += strformat("SumEt = %10.2f MeV\n", a.sumEt());
  s += strformat("SumE  = %10.2f MeV\n", a.sumE());
 
  s += strformat("Event status = 0x%08x\n", (unsigned)a.getFlag());
  unsigned int N = a.getNumOfComponents();
  s += strformat("Auxiliary components = %4u\n", N);
 
  if (N==0) return s; // basic info only
 
  // header
  s += "__name_____status__usedCh.__sumOfSigns__calib1_calib0";
  s += "/MeV___Ex/MeV_____Ey/MeV_____Ez/MeV___SumE/MeV__SumEt/MeV\n";
 
  for (unsigned int i=0; i<N; ++i){
    s += strformat(
      "%10s 0x%04x %8d %11d %7.2f %8.2f %10.2f %10.2f %10.2f %10.2f %10.2f\n", 
         a.getNameOfComponent(i).c_str(), 
         (unsigned)a.getStatus(i),
         a.getUsedChannels(i),
         a.getSumOfSigns(i),
         a.getComponentCalib1(i),
         a.getComponentCalib0(i),
         a.getExComponent(i),
         a.getEyComponent(i),
         a.getEzComponent(i),
         a.getSumEComponent(i),
         a.getSumEtComponent(i));
  }
 
  return s;
}