Collaboration diagram for LArBadChannelHunter::Average:

Public Member Functions
	Average ()
void	finish (float)

Public Attributes
float	m_avPedRMS [CaloGain::LARNGAIN] {}
float	m_avPedRMSSD [CaloGain::LARNGAIN] {}
unsigned	m_nPed [CaloGain::LARNGAIN] {}
float	m_avAmpl [CaloGain::LARNGAIN] {}
float	m_avAmplSD [CaloGain::LARNGAIN] {}
unsigned	m_nAmpls [CaloGain::LARNGAIN] {}
float	m_avWid [CaloGain::LARNGAIN] {}
float	m_avWidSD [CaloGain::LARNGAIN] {}
unsigned	m_nWids [CaloGain::LARNGAIN] {}
float	m_avTmax [CaloGain::LARNGAIN] {}
float	m_avTmaxSD [CaloGain::LARNGAIN] {}
unsigned	m_nTmaxs [CaloGain::LARNGAIN] {}
std::vector< float >	m_vmedTmax [CaloGain::LARNGAIN]
std::vector< float >	m_vmedWid [CaloGain::LARNGAIN]
std::vector< float >	m_vmedAmpl [CaloGain::LARNGAIN]
std::vector< float >	m_vmedPedRMS [CaloGain::LARNGAIN]
float	m_medTmax [CaloGain::LARNGAIN] {}
float	m_medWid [CaloGain::LARNGAIN] {}
float	m_medAmpl [CaloGain::LARNGAIN] {}
float	m_medPedRMS [CaloGain::LARNGAIN] {}

Detailed Description

Definition at line 103 of file LArBadChannelHunter.h.

Constructor & Destructor Documentation

◆ Average()

LArBadChannelHunter::Average::Average ( )

Definition at line 489 of file LArBadChannelHunter.cxx.

                                    {
  for(unsigned igain=CaloGain::LARHIGHGAIN; igain<CaloGain::LARNGAIN; igain++){
    m_nPed[igain]=0;
    m_avPedRMS[igain]=0;
    m_avPedRMSSD[igain]=0;
 
    m_nAmpls[igain]=0;
    m_avAmpl[igain]=0.;
    m_avAmplSD[igain]=0.;
 
    m_nWids[igain]=0;
    m_avWid[igain]=0.;
    m_avWidSD[igain]=0.;
 
    m_nTmaxs[igain]=0;
    m_avTmax[igain]=0.;
    m_avTmaxSD[igain]=0.;
 
    m_medPedRMS[igain]=0;
    m_medAmpl[igain]=0;
    m_medWid[igain]=0;
    m_medTmax[igain]=0;
  }
}

Member Function Documentation

◆ finish()

void LArBadChannelHunter::Average::finish ( float my_recalcPer )

Definition at line 515 of file LArBadChannelHunter.cxx.

                                                          {
  for(unsigned igain=CaloGain::LARHIGHGAIN; igain<CaloGain::LARNGAIN; igain++) {
 
    if (m_nPed[igain]) {
      m_avPedRMS[igain]/=m_nPed[igain];
      //sample standard deviation of average
      m_avPedRMSSD[igain]=(m_avPedRMSSD[igain]-(m_nPed[igain]*m_avPedRMS[igain]*m_avPedRMS[igain]))/(m_nPed[igain]);
      m_avPedRMSSD[igain]=sqrt(m_avPedRMSSD[igain]);
      //Find median
      std::sort(m_vmedPedRMS[igain].begin(),m_vmedPedRMS[igain].end());
      m_medPedRMS[igain]=m_vmedPedRMS[igain].at(m_vmedPedRMS[igain].size()/2);
    }
    if (m_nAmpls[igain]) {
      m_avAmpl[igain]/=m_nAmpls[igain];
      //sample standard deviation of average
      m_avAmplSD[igain]=(m_avAmplSD[igain]-(m_nAmpls[igain]*m_avAmpl[igain]*m_avAmpl[igain]))/(m_nAmpls[igain]);
      m_avAmplSD[igain]=sqrt(m_avAmplSD[igain]);
      //Find median
      std::sort(m_vmedAmpl[igain].begin(),m_vmedAmpl[igain].end());
      m_medAmpl[igain]=m_vmedAmpl[igain].at(m_vmedAmpl[igain].size()/2);
    }
    if (m_nWids[igain]) {
      m_avWid[igain]/=m_nWids[igain];
      //sample standard deviation of average
      m_avWidSD[igain]=(m_avWidSD[igain]-(m_nWids[igain]*m_avWid[igain]*m_avWid[igain]))/(m_nWids[igain]);
      m_avWidSD[igain]=sqrt(m_avWidSD[igain]);
      //Find median
      std::sort(m_vmedWid[igain].begin(),m_vmedWid[igain].end());
      m_medWid[igain]=m_vmedWid[igain].at(m_vmedWid[igain].size()/2);
    }
    if (m_nTmaxs[igain]) {
      m_avTmax[igain]/=m_nTmaxs[igain];
      //sample standard deviation of average
      m_avTmaxSD[igain]=(m_avTmaxSD[igain]-(m_nTmaxs[igain]*m_avTmax[igain]*m_avTmax[igain]))/(m_nTmaxs[igain]);
      m_avTmaxSD[igain]=sqrt(m_avTmaxSD[igain]);
      //Find median
      std::sort(m_vmedTmax[igain].begin(),m_vmedTmax[igain].end());
      m_medTmax[igain]=m_vmedTmax[igain].at(m_vmedTmax[igain].size()/2);
    }
 
   
  if (my_recalcPer>=0.){  
   if ( m_avPedRMSSD[igain]>my_recalcPer*m_avPedRMS[igain]) {
    float re_avPed=0.; float re_avPedSD=0.; int re_nPed=0;
    std::vector<float>::iterator p_loop = m_vmedPedRMS[igain].begin();
    std::vector<float>::iterator p_loop_e=m_vmedPedRMS[igain].end();
    for (;p_loop!=p_loop_e; ++p_loop){
      if ( fabs(*p_loop-m_medPedRMS[igain])<my_recalcPer*m_medPedRMS[igain] ){
         re_avPed+=*p_loop;
         re_avPedSD+=*p_loop*(*p_loop);
         re_nPed++;
      }
    }
    if (re_nPed > 0) {
      re_avPed/=re_nPed;
      re_avPedSD=(re_avPedSD- re_nPed*re_avPed*re_avPed)/(re_nPed);
    }
    re_avPedSD=sqrt(re_avPedSD);
    std::cout <<" PedRMS mean && RMS are recalc: Orig (recalc) are: "<< m_avPedRMS[igain]<< " ( "<< re_avPed 
          <<" ) and "<< m_avPedRMSSD[igain]<<" ( "<<re_avPedSD<<" )"<<std::endl;
    m_avPedRMS[igain]=re_avPed; m_avPedRMSSD[igain]=re_avPedSD; 
   }
   if ( m_avAmplSD[igain]>my_recalcPer*m_avAmpl[igain] ) {
    float re_avAmpl=0.; float re_avAmplSD=0.; int   re_nAmpl=0;
    std::vector<float>::iterator re_loop = m_vmedAmpl[igain].begin();
    std::vector<float>::iterator re_loop_e=m_vmedAmpl[igain].end();
    for (;re_loop!=re_loop_e; ++re_loop){
      if ( fabs(*re_loop-m_medAmpl[igain])<my_recalcPer*m_medAmpl[igain] ){
     re_avAmpl+=*re_loop;
     re_avAmplSD+=*re_loop*(*re_loop);
     re_nAmpl++;
      }
    }
    if (re_nAmpl > 0) {
      re_avAmpl/=re_nAmpl;
      re_avAmplSD=(re_avAmplSD- re_nAmpl*re_avAmpl*re_avAmpl)/(re_nAmpl);
    }
    re_avAmplSD=sqrt(re_avAmplSD);
    std::cout <<" MaxAmp mean && RMS are recalc: Orig (recalc) are: "<< m_avAmpl[igain]<< " ( "<< re_avAmpl
              <<" ) and "<< m_avAmplSD[igain]<<" ( "<<re_avAmplSD<<" )"<<std::endl;
    m_avAmpl[igain]=re_avAmpl; m_avAmplSD[igain]=re_avAmplSD;
   }
   if ( m_avWidSD[igain]>my_recalcPer*m_avWid[igain] ) {
    float re_avWid=0.; float re_avWidSD=0.; int   re_nWid=0; 
    std::vector<float>::iterator w_loop = m_vmedWid[igain].begin();
    std::vector<float>::iterator w_loop_e=m_vmedWid[igain].end(); 
    for (;w_loop!=w_loop_e; ++w_loop){
      if ( fabs(*w_loop-m_medWid[igain])<my_recalcPer*m_medWid[igain] ){
         re_avWid+=*w_loop;
         re_avWidSD+=*w_loop*(*w_loop);
         re_nWid++;
      }
    }
    if (re_nWid > 0) {
      re_avWid/=re_nWid;
      re_avWidSD=(re_avWidSD- re_nWid*re_avWid*re_avWid)/(re_nWid);
    }
    re_avWidSD=sqrt(re_avWidSD);
    std::cout <<"   FWHM mean && RMS are recalc: Orig (recalc) are: "<< m_avWid[igain]<< " ( "<< re_avWid
          <<" ) and "<< m_avWidSD[igain]<<" ( "<<re_avWidSD<<" )"<<std::endl;
    m_avWid[igain]=re_avWid; m_avWidSD[igain]=re_avWidSD;
   }
   if ( m_avTmaxSD[igain]>my_recalcPer*m_avTmax[igain] ) { 
    float re_avTmax=0.; float re_avTmaxSD=0.; int   re_nTmax=0;
    std::vector<float>::iterator t_loop = m_vmedTmax[igain].begin();
    std::vector<float>::iterator t_loop_e=m_vmedTmax[igain].end();
    for (;t_loop!=t_loop_e; ++t_loop){
      if ( fabs(*t_loop-m_medTmax[igain])<my_recalcPer*m_medTmax[igain] ){
         re_avTmax+=*t_loop;
         re_avTmaxSD+=*t_loop*(*t_loop);
         re_nTmax++;
      }
    }
    if (re_nTmax > 0) {
      re_avTmax/=re_nTmax;
      re_avTmaxSD=(re_avTmaxSD- re_nTmax*re_avTmax*re_avTmax)/(re_nTmax);
    }
    re_avTmaxSD=sqrt(re_avTmaxSD);
    std::cout <<"TmaxAmp mean && RMS are recalc: Orig (recalc) are: "<< m_avTmax[igain]<< " ( "<< re_avTmax
          <<" ) and "<< m_avTmaxSD[igain]<<" ( "<<re_avTmaxSD<<" )"<<std::endl;
    m_avTmax[igain]=re_avTmax; m_avTmaxSD[igain]=re_avTmaxSD;
   } 
  } 
 
  }//end loop over gains
}

Member Data Documentation

◆ m_avAmpl

float LArBadChannelHunter::Average::m_avAmpl[CaloGain::LARNGAIN] {}

Definition at line 108 of file LArBadChannelHunter.h.

108{};

◆ m_avAmplSD

float LArBadChannelHunter::Average::m_avAmplSD[CaloGain::LARNGAIN] {}

Definition at line 109 of file LArBadChannelHunter.h.

109{};

◆ m_avPedRMS

float LArBadChannelHunter::Average::m_avPedRMS[CaloGain::LARNGAIN] {}

Definition at line 105 of file LArBadChannelHunter.h.

105{};

◆ m_avPedRMSSD

float LArBadChannelHunter::Average::m_avPedRMSSD[CaloGain::LARNGAIN] {}

Definition at line 106 of file LArBadChannelHunter.h.

106{};

◆ m_avTmax

float LArBadChannelHunter::Average::m_avTmax[CaloGain::LARNGAIN] {}

Definition at line 114 of file LArBadChannelHunter.h.

114{};

◆ m_avTmaxSD

float LArBadChannelHunter::Average::m_avTmaxSD[CaloGain::LARNGAIN] {}

Definition at line 115 of file LArBadChannelHunter.h.

115{};

◆ m_avWid

float LArBadChannelHunter::Average::m_avWid[CaloGain::LARNGAIN] {}

Definition at line 111 of file LArBadChannelHunter.h.

111{};

◆ m_avWidSD

float LArBadChannelHunter::Average::m_avWidSD[CaloGain::LARNGAIN] {}

Definition at line 112 of file LArBadChannelHunter.h.

112{};

◆ m_medAmpl

float LArBadChannelHunter::Average::m_medAmpl[CaloGain::LARNGAIN] {}

Definition at line 124 of file LArBadChannelHunter.h.

124{};

◆ m_medPedRMS

float LArBadChannelHunter::Average::m_medPedRMS[CaloGain::LARNGAIN] {}

Definition at line 125 of file LArBadChannelHunter.h.

125{};

◆ m_medTmax

float LArBadChannelHunter::Average::m_medTmax[CaloGain::LARNGAIN] {}

Definition at line 122 of file LArBadChannelHunter.h.

122{};

◆ m_medWid

float LArBadChannelHunter::Average::m_medWid[CaloGain::LARNGAIN] {}

Definition at line 123 of file LArBadChannelHunter.h.

123{};

◆ m_nAmpls

unsigned LArBadChannelHunter::Average::m_nAmpls[CaloGain::LARNGAIN] {}

Definition at line 110 of file LArBadChannelHunter.h.

110{};

◆ m_nPed

unsigned LArBadChannelHunter::Average::m_nPed[CaloGain::LARNGAIN] {}

Definition at line 107 of file LArBadChannelHunter.h.

107{};

◆ m_nTmaxs

unsigned LArBadChannelHunter::Average::m_nTmaxs[CaloGain::LARNGAIN] {}

Definition at line 116 of file LArBadChannelHunter.h.

116{};

◆ m_nWids

unsigned LArBadChannelHunter::Average::m_nWids[CaloGain::LARNGAIN] {}

Definition at line 113 of file LArBadChannelHunter.h.

113{};

◆ m_vmedAmpl

std::vector<float> LArBadChannelHunter::Average::m_vmedAmpl[CaloGain::LARNGAIN]

Definition at line 120 of file LArBadChannelHunter.h.

◆ m_vmedPedRMS

std::vector<float> LArBadChannelHunter::Average::m_vmedPedRMS[CaloGain::LARNGAIN]

Definition at line 121 of file LArBadChannelHunter.h.

◆ m_vmedTmax

std::vector<float> LArBadChannelHunter::Average::m_vmedTmax[CaloGain::LARNGAIN]

Definition at line 118 of file LArBadChannelHunter.h.

◆ m_vmedWid

std::vector<float> LArBadChannelHunter::Average::m_vmedWid[CaloGain::LARNGAIN]

Definition at line 119 of file LArBadChannelHunter.h.

The documentation for this class was generated from the following files:

Public Member Functions

Public Attributes