TileRawChannelBuilderFitFilterCool Class Reference

#include <TileRawChannelBuilderFitFilterCool.h>

Inheritance diagram for TileRawChannelBuilderFitFilterCool:

Collaboration diagram for TileRawChannelBuilderFitFilterCool:

Public Member Functions
	TileRawChannelBuilderFitFilterCool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor.
	~TileRawChannelBuilderFitFilterCool ()
	Destructor.
virtual StatusCode	initialize () override
	Initializer.
virtual StatusCode	finalize () override
virtual TileRawChannel *	rawChannel (const TileDigits *digits, const EventContext &ctx) override
	Builder virtual method to be implemented by subclasses.
virtual void	handle (const Incident &) override
virtual StatusCode	createContainer (const EventContext &ctx)
	Create container in SG with name given by parameter (m_rawChannelContainerKey).
virtual StatusCode	commitContainer (const EventContext &ctx)
	Commit RawChannelContiner in SG and make const.
void	initLog (const EventContext &ctx)
void	endLog ()
StatusCode	build (const TileDigitsCollection *collection, const EventContext &ctx)
void	resetDrawer ()
void	resetOverflows (void)
Overflows_t &	getOverflowedChannels (void)
std::string	getTileRawChannelContainerID (void)
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	AlgTool InterfaceID.
static double	correctAmp (double phase, bool of2=true)
	Amplitude correction factor according to the time when using weights for tau=0 without iterations.
static double	correctTime (double phase, bool of2=true)
	Time correction factor.
static int	CorruptedData (int ros, int drawer, int channel, int gain, const std::vector< float > &digits, float &dmin, float &dmax, float ADCmaxMinusEps, float ADCmaskValueMinusEps)
static const char *	BadPatternName (float ped)

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Protected Attributes
SG::ReadHandleKey< TileDQstatus >	m_DQstatusKey
SG::ReadHandleKey< TileRawChannelContainer >	m_DSPContainerKey {this, "DSPContainer", "", "DSP Container key"}
SG::WriteHandleKey< TileRawChannelContainer >	m_rawChannelContainerKey
std::unique_ptr< TileMutableRawChannelContainer >	m_rawChannelCnt
TileFragHash::TYPE	m_rChType
TileRawChannelUnit::UNIT	m_rChUnit
unsigned int	m_bsflags
int	m_firstSample
bool	m_calibrateEnergy
bool	m_correctTime
bool	m_useDSP
float	m_ampMinThresh
	correct amplitude if it's above amplitude threshold (in ADC counts)
float	m_timeMinThresh
	correct amplitude is time is above time min threshold
float	m_timeMaxThresh
	correct amplitude is time is below time max threshold
int	m_runType
const TileID *	m_tileID
const TileHWID *	m_tileHWID
ToolHandleArray< ITileRawChannelTool >	m_noiseFilterTools
ToolHandle< TileCondToolEmscale >	m_tileToolEmscale
ToolHandle< TileCondToolTiming >	m_tileToolTiming
ToolHandle< TileCondIdTransforms >	m_tileIdTransforms
ServiceHandle< TileCablingSvc >	m_cablingSvc
	Name of Tile cabling service.
const TileCablingService *	m_cabling
	TileCabling instance.
Gaudi::Property< std::vector< int > >	m_demoFragIDs
int	m_trigType
bool	m_idophys
bool	m_idolas
bool	m_idoped
bool	m_idocis
int	m_cischan
double	m_capdaq
unsigned int	m_evtCounter
unsigned int	m_chCounter
int	m_nChL
int	m_nChH
double	m_RChSumL
double	m_RChSumH
Overflows_t	m_overflows
int	m_dataPoollSize
int	m_error [MAX_CHANNELS]
int	m_lastDrawer = -1
bool	m_badDrawer = false
bool	m_notUpgradeCabling
std::string	m_infoName
const TileInfo *	m_tileInfo
int	m_i_ADCmax
float	m_f_ADCmax
int	m_i_ADCmaxPlus1
float	m_f_ADCmaxPlus1
float	m_ADCmaxMinusEps
float	m_ADCmaskValueMinusEps
	indicates channels which were masked in background dataset

Static Protected Attributes
static const int	MAX_CHANNELS = 48
static const int	MAX_DMUS = 16

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
void	pulseFit (const TileDigits *digit, double &amplitude, double &time, double &pedestal, double &chi2, const EventContext &ctx)
	Calculate energy, time and chi2 for one channel using fitted pulse shape.
double	pulse (double x, const std::vector< double > *xvec, const std::vector< double > *yvec, bool zeroOutside=false) const
	pulse interpolation
double	scaledPulse (double x, const std::vector< double > *xvec, const std::vector< double > *yvec) const
double	derivative (double x, const std::vector< double > *xvec, const std::vector< double > *yvec) const
void	fill_drawer_errors (const EventContext &ctx, const TileDigitsCollection *collection)
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Private Attributes
std::vector< double >	m_dummy
double	m_t0Fit
double	m_fnParameters [3] {}
int	m_iPeak0
double	m_minTime
double	m_maxTime
double	m_minTau
double	m_maxTau
std::vector< double >	m_gPhysLo
std::vector< double >	m_dgPhysLo
std::vector< double >	m_gPhysHi
std::vector< double >	m_dgPhysHi
int	m_frameLength
int	m_channelNoiseRMS
int	m_maxIterate
int	m_extraSamplesLeft
int	m_extraSamplesRight
double	m_saturatedSampleError
double	m_zeroSampleError
double	m_noiseThresholdRMS
double	m_maxTimeFromPeak
double	m_noiseLow
double	m_noiseHigh
const TilePulseShapesStruct *	m_pulseShapes
ToolHandle< TileCondToolPulseShape >	m_tileToolPulseShape
ToolHandle< TileCondToolPulseShape >	m_tileToolLeak100Shape
ToolHandle< TileCondToolPulseShape >	m_tileToolLeak5p2Shape
ToolHandle< TileCondToolPulseShape >	m_tileToolPulse5p2Shape
ToolHandle< TileCondToolNoiseSample >	m_tileToolNoiseSample
TilePulseShapesStruct *	m_shapes
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default).
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default).
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Detailed Description

Definition at line 52 of file TileRawChannelBuilderFitFilterCool.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

TileRawChannelBuilderFitFilterCool()

TileRawChannelBuilderFitFilterCool::TileRawChannelBuilderFitFilterCool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Constructor.

Definition at line 42 of file TileRawChannelBuilderFitFilterCool.cxx.

  : TileRawChannelBuilder(type, name, parent)
  , m_t0Fit(0.0)
  , m_iPeak0(0)
  , m_minTime(0.0)
  , m_maxTime(0.0)
  , m_minTau(0)
  , m_maxTau(0.0)
  , m_pulseShapes(0)
  , m_shapes(nullptr)
{  
  //declare interfaces
  declareInterface< TileRawChannelBuilder >( this );
  declareInterface< TileRawChannelBuilderFitFilterCool >(this);
 
  m_rawChannelContainerKey = "TileRawChannelFitCool";
 
  //declare properties
  declareProperty("FrameLength", m_frameLength = 9);
  declareProperty("MaxIterate", m_maxIterate = 9);
  declareProperty("NoiseLowGain", m_noiseLow = 0.6);
  declareProperty("NoiseHighGain", m_noiseHigh = 1.5);
  declareProperty("RMSChannelNoise", m_channelNoiseRMS = 3);
  declareProperty("ExtraSamplesLeft", m_extraSamplesLeft=0);   // increase window on left side
  declareProperty("ExtraSamplesRight", m_extraSamplesRight=0); // increase window on right side
  declareProperty("SaturatedSampleError", m_saturatedSampleError = 6.0);
  declareProperty("ZeroSampleError", m_zeroSampleError = 100.0);
  declareProperty("NoiseThresholdRMS", m_noiseThresholdRMS = 3.0);
  declareProperty("MaxTimeFromPeak", m_maxTimeFromPeak = 250.0);
}

~TileRawChannelBuilderFitFilterCool()

TileRawChannelBuilderFitFilterCool::~TileRawChannelBuilderFitFilterCool

(

)

Destructor.

Definition at line 77 of file TileRawChannelBuilderFitFilterCool.cxx.

                                                                        {
  if (m_shapes) delete m_shapes;
}

Member Function Documentation

BadPatternName()

const char * TileRawChannelBuilder::BadPatternName ( float ped )

staticinherited

Definition at line 458 of file TileRawChannelBuilder.cxx.

                                                            {
  static const char * const errname[26] = {
      "-10 - good signal",
      "-9 - underflow",
      "-8 - overflow",
      "-7 - underflow and overflow",
      "-6 - constant signal",
      "-5 - disconnected channel",
      "-4 - half a drawer masked",
      "-3 - bad DQ status",
      "-2 - underflow in all samples",  
      "-1 - overflow in all samples",
      "0 - unknown error",
      "1 - jump from zero to saturation",
      "2 - samples with zeros",
      "3 - at least two saturated. others - close to pedestal",
      "4 - two distinct levels with at least 2 samples each",
      "5 - pedestal with jump up in one sample",
      "6 - pedestal with jump down in one sample",
      "7 - signal with jump up in one sample",
      "8 - signal with jump down in one sample",
      "9 - base line above threshold in low gain",
      "10 - jump down in first sample in low gain",
      "11 - jump down in last sample in low gain",
      "12 - jump up in one sample above const",
      "13 - jump down in one sample below const",
      "14 - unrecoverable timing jump",
      "15 - unknown error"
  };
  
  return errname[std::min(25, std::max(0, int((ped + 500) * 1e-4)))];
}

build()

StatusCode TileRawChannelBuilder::build ( const TileDigitsCollection * collection, const EventContext & ctx )

inherited

Definition at line 492 of file TileRawChannelBuilder.cxx.

{
 
  int frag = coll->identify();
 
  // make sure that error array is up-to-date
  if (frag != m_lastDrawer && m_notUpgradeCabling) {
    fill_drawer_errors(ctx, coll);
  }
 
  // Iterate over all digits in this collection
  TileDigitsCollection::const_iterator digitItr = coll->begin();
  TileDigitsCollection::const_iterator lastDigit = coll->end();
 
  for (; digitItr != lastDigit; ++digitItr) {
 
    TileRawChannel* rch = rawChannel((*digitItr), ctx);
 
    if (m_notUpgradeCabling) {
 
      int err = m_error[m_tileHWID->channel(rch->adc_HWID())];
      
      if (err) {
        if (err == -8 || err == -7) m_overflows.push_back(std::make_pair(rch, (*digitItr)));
        float ped = rch->pedestal() + 100000 + 10000 * err;
        rch->setPedestal(ped);
        if (msgLvl(MSG::VERBOSE) && !m_badDrawer) {
          if (err < -5) {
            msg(MSG::VERBOSE) << "BadCh " << m_tileHWID->to_string(rch->adc_HWID())
                              << " warning = " << BadPatternName(ped) << endmsg;
          } else {
            msg(MSG::VERBOSE) << "BadCh " << m_tileHWID->to_string(rch->adc_HWID())
                              << " error = " << BadPatternName(ped) << endmsg;
          }
        }
      }
 
    }
 
    ATH_CHECK( m_rawChannelCnt->push_back (rch) );
  }
 
  IdentifierHash hash = m_rawChannelCnt->hashFunc().hash(coll->identify());
  TileRawChannelCollection* rawChannelCollection = m_rawChannelCnt->indexFindPtr(hash);
  rawChannelCollection->setLvl1Id(coll->getLvl1Id());
  rawChannelCollection->setLvl1Type(coll->getLvl1Type());
  rawChannelCollection->setDetEvType(coll->getDetEvType());
  rawChannelCollection->setRODBCID(coll->getRODBCID());
 
  return StatusCode::SUCCESS;
}

commitContainer()

StatusCode TileRawChannelBuilder::commitContainer ( const EventContext & ctx )

virtualinherited

Commit RawChannelContiner in SG and make const.

Definition at line 544 of file TileRawChannelBuilder.cxx.

{
 
  const TileDQstatus* DQstatus = SG::makeHandle (m_DQstatusKey, ctx).get();
 
  ToolHandleArray<ITileRawChannelTool>::iterator itrTool = m_noiseFilterTools.begin();
  ToolHandleArray<ITileRawChannelTool>::iterator endTool = m_noiseFilterTools.end();
 
  if ( m_useDSP && !m_DSPContainerKey.key().empty() &&
       (DQstatus->incompleteDigits() || m_chCounter<12288) && itrTool!=endTool )
  {
    const TileRawChannelContainer * dspCnt = SG::makeHandle (m_DSPContainerKey, ctx).get();
    ATH_MSG_DEBUG( "Incomplete container - use noise filter corrections from DSP container" );
 
    uint32_t bsFlags = dspCnt->get_bsflags();
    std::vector<IdentifierHash> hashes = m_rawChannelCnt->GetAllCurrentHashes();
    std::vector<IdentifierHash> dspHashes = dspCnt->GetAllCurrentHashes();
    if (bsFlags == 0) {
      ATH_MSG_WARNING("Problem in applying noise corrections: DSP container ("
                      << m_DSPContainerKey.key() << ") seems to be emtpy!");
    } else if (hashes != dspHashes) {
      ATH_MSG_ERROR( " Error in applying noise corrections; "
                     "hash vectors do not match.");
    } else {
      // Go through all TileRawChannelCollections
      for (IdentifierHash hash : hashes) {
        TileRawChannelCollection* coll = m_rawChannelCnt->indexFindPtr (hash);
        const TileRawChannelCollection* dcoll = dspCnt->indexFindPtr (hash);
 
        if (coll->identify() != dcoll->identify()) {
 
          ATH_MSG_ERROR( " Error in applying noise corrections " << MSG::hex 
                         << " collection IDs 0x" << coll->identify() <<  " and 0x" << dcoll->identify() 
                         << " do not match " << MSG::dec );
          break;
        }
      
        // iterate over all channels in a collection
        TileRawChannelCollection::const_iterator dspItr=dcoll->begin();
        TileRawChannelCollection::const_iterator dspLast=dcoll->end();
 
        for (TileRawChannel* rch : *coll) {
          HWIdentifier adc_id = rch->adc_HWID();
          while (dspItr != dspLast && adc_id != (*dspItr)->adc_HWID()) {
            ++dspItr;
          }
          if (dspItr != dspLast) {
            float corr = (*dspItr)->pedestal();
            ATH_MSG_VERBOSE( "Ch "<<m_tileHWID->to_string(adc_id)
                             <<" amp " << rch->amplitude() << " ped " << rch->pedestal() 
                             << " corr " << corr );
            if (corr<10000.) {
              rch->setAmplitude (rch->amplitude() - corr); // just baseline shift
              rch->setPedestal (rch->pedestal() + corr); // just baseline shift
            } else {
              float ped = rch->pedestal();
              if (corr > ped) {
                rch->setPedestal (fmod(ped,10000.) + int(corr)/10000 * 10000); // changing error status
                ATH_MSG_VERBOSE( "New error status in ped "<<rch->pedestal());
              }
            }
          } else {
            ATH_MSG_WARNING(" Problem in applying noise corrections " 
                            << " can not find channel in DSP container with HWID "
                            << m_tileHWID->to_string(adc_id) );
            dspItr = dcoll->begin();
          }
        }
      }
    }
    
  } else {
 
    for (ToolHandle<ITileRawChannelTool>& noiseFilterTool : m_noiseFilterTools) {
      if (noiseFilterTool->process(*m_rawChannelCnt.get(), ctx).isFailure()) {
        ATH_MSG_ERROR( " Error status returned from noise filter " );
      } else {
        ATH_MSG_DEBUG( "Noise filter applied to the container" );
      }
    }
 
  }
  
  ATH_MSG_DEBUG( " nCh=" << m_chCounter
                << " nChH/L=" << m_nChH << "/" << m_nChL
                << " RChSumH/L=" << m_RChSumH << "/" << m_RChSumL );
 
  SG::WriteHandle<TileRawChannelContainer> rawChannelsContainer(m_rawChannelContainerKey, ctx);
  ATH_CHECK( rawChannelsContainer.record(std::move(m_rawChannelCnt)) );
 
  endLog();
 
  return StatusCode::SUCCESS;
}

correctAmp()

double TileRawChannelBuilder::correctAmp ( double phase, bool of2 = true )

staticinherited

Amplitude correction factor according to the time when using weights for tau=0 without iterations.

Definition at line 646 of file TileRawChannelBuilder.cxx.

                                                               {
 
 double corr = 1.0;
 if (of2) {
   // estimation from Belen for rel 14.0.0
   /*double a,b,c;
   if(fabs(phase)<5.){
   a=0.137; b=0.0877; c=0.0865;
   }else{
   a=0.565; b=0.116; c=0.0751;
   }
   corr=(1+(a+b*phase+c*phase*phase)/100.);
   */
 
  // estimation from Vakhtang for rel 14.4.0
  /*double k = (phase < 0.0 ? 0.0009400 : 0.0010160);
  corr = (1.0 + k * phase * phase);
  */
 
   // Parabolic correction from Tigran
   double a1,a2,b,c;
   a1 = phase < 0.0 ? 0.000940774 : 0.00102111;
   a2 = phase < 0.0 ? 0.000759051 : 0.000689625;
   b = phase < 0.0 ? -2.0 * 7.0 * (a1 - a2) : 2.0 * 12.5 * (a1 - a2);
   c = phase < 0.0 ? 1.0 - 7.0 * 7.0 * (a1-a2) :  1.0 - 12.5 * 12.5 * (a1-a2);
   if (phase < 12.5 && phase > -7.0) corr = a1 * phase * phase + 1.0;
   else corr = phase * ( a2  * phase + b) + c;
 
 
 } else {
  /*double a,b,c;
  if(phase<0){
     a=1.0002942; b=0.0003528; c=0.0005241;
  }else{
     a=1.0001841; b=-0.0004182; c=0.0006167;
  }
  corr = a + phase * ( b + c * phase);
  */
 
  /*double k = (phase < 0.0 ? 0.0005241 : 0.0006167);
  corr = (1.0 + k * phase * phase);
  */
 
  // 4th degree polynomial correction from Tigran
  double k1 = (phase < 0.0 ? -0.0000326707:0.000380336);
  double k2 = (phase < 0.0 ? -0.000560962:-0.000670487);
  double k3 = (phase < 0.0 ? -0.00000807869:0.00000501773);
  double k4 = (phase < 0.0 ? -0.000000145008:0.0000000584647);
 
  corr = 1.0 / (1.0 + (k1 + (k2  + (k3 + k4 *phase)*phase)*phase)*phase);
 
 
 }
 
  return corr;
}

correctTime()

double TileRawChannelBuilder::correctTime ( double phase, bool of2 = true )

staticinherited

Time correction factor.

Definition at line 705 of file TileRawChannelBuilder.cxx.

                                                                {
 
  double correction = 0.0;
  
  if (of2) {
    if(phase < 0)  {
      correction = (-0.00695743 + (0.0020673 - (0.0002976 + 0.00000361305 * phase) * phase) * phase) * phase;
    } else {
      correction = (0.0130013 + (0.00128769 + (-0.000550218 + 0.00000755344 * phase) * phase) * phase) * phase;
    }
  }
  // OF1 does not need correction
 
  return correction;
}

CorruptedData()

int TileRawChannelBuilder::CorruptedData ( int ros, int drawer, int channel, int gain, const std::vector< float > & digits, float & dmin, float & dmax, float ADCmaxMinusEps, float ADCmaskValueMinusEps )

staticinherited

Definition at line 723 of file TileRawChannelBuilder.cxx.

                                                                                                                                  {
  bool eb = (ros > 2);
  bool ebsp = ((ros == 3 && drawer == 14) || (ros == 4 && drawer == 17));
  bool empty = ((eb && ((channel > 23 && channel < 30) || channel > 41)) || (ebsp && channel < 3));
  bool not_gap = !(empty || (eb && (channel == 0 || channel == 1 || channel == 12 || channel == 13))
      || (ebsp && (channel == 18 || channel == 19)));
 
  const float epsilon = 4.1; // allow +/- 2 counts fluctuations around const value
  const float delta[4] = { 29.9, 29.9, 49.9, 99.9 }; // jump levels between constLG, constHG, non-constLG, non-constHG
  const float level1 = 99.9; // jump from this level to m_i_ADCmax is bad 
  const float level2 = 149.9; // base line at this level in low gain is bad
  const float narrowLevel[2] = { 29.9, 49.9 }; // minimal amplitude for narrow pulses
  const float delt = std::min(std::min(std::min(delta[0], delta[1]), std::min(delta[2], delta[3])),
      std::min(narrowLevel[0], narrowLevel[1]));
  const float secondMaxLevel = 0.3;
 
  int error = 0;
 
  unsigned int nSamp = digits.size();
  if (nSamp) {
    dmin = dmax = digits[0];
    unsigned int pmin = 0;
    unsigned int pmax = 0;
    unsigned int nzero = (dmin < 0.01) ? 1 : 0;
    unsigned int nover = (dmax > ADCmaxMinusEps) ? 1 : 0;
 
    for (unsigned int i = 1; i < nSamp; ++i) {
      float dig = digits[i];
      if (dig > dmax) {
        dmax = dig;
        pmax = i;
      } else if (dig < dmin) {
        dmin = dig;
        pmin = i;
      }
      if (dig < 0.01) ++nzero;
      else if (dig > ADCmaxMinusEps) ++nover;
    }
 
    float dmaxmin = dmax - dmin;
    //std::cout << " ros " << ros << " drawer " << drawer << " channel " << channel << " not_gap " << not_gap << " nzero " << nzero << " nover " << nover << std::endl;
 
    if (dmin > ADCmaxMinusEps) { // overflow in all samples
      error = (dmin > ADCmaskValueMinusEps) ? -3 : -1; // dmin=m_tileInfo->ADCmaskValue() - masking in overlay job (set in TileDigitsMaker)
 
    } else if (dmax < 0.01) { // underflow in all samples
      error = (empty) ? -5 : -2; // set different type of errors for exsiting and non-existing channels
 
    } else if (dmaxmin < 0.01) { // constant value in all samples
      error = -6;
 
    } else if (nzero && nover) { // jump from zero to saturation
      error = 1;
 
    } else if ((nzero && (not_gap || empty)) || nzero > 1) { // one sample at zero in normal channel
      error = 2;                                           // or 2 samples at zero in gap/crack/MBTS
 
    } else if (gain == 0 && dmin > level2) { // baseline above threshold in low gain is bad
      error = 9;
 
    } else if (dmaxmin > delt) { // check that max-min is above minimal allowed jump
 
      float abovemin = dmax;
      float belowmax = dmin;
      unsigned int nmin = 0;
      unsigned int nmax = 0;
      for (unsigned int i = 0; i < nSamp; ++i) {
        float smp = digits[i];
        if (smp - dmin < epsilon) {
          ++nmin;
        }
        if (dmax - smp < epsilon) {
          ++nmax;
        }
        if (smp < abovemin && smp > dmin) {
          abovemin = smp;
        }
        if (smp > belowmax && smp < dmax) {
          belowmax = smp;
        }
      }
      // more than two different values - shift index by 2, i.e. use thresholds for non-const levels
      int gainInd = (abovemin != dmax || belowmax != dmin) ? gain + 2 : gain;
      bool big_jump = (dmaxmin > delta[gainInd]);
      bool max_in_middle = (pmax > 0 && pmax < nSamp - 1);
      bool min_in_middle = (pmin > 0 && pmin < nSamp - 1);
 
      if (nover > 1 && belowmax < level1) {  // at least two saturated. others - close to pedestal
        error = 3;
      } else if (nmax + nmin == nSamp && big_jump) {
        if (nmax > 1 && nmin > 1) { // at least 2 samples at two distinct levels
          error = 4;
        } else if (nmax == 1) {
          if (max_in_middle) { // jump up in one sample, but not at the edge
            error = 5;
          }
        } else if (nmin == 1) { // jump down in one sample
          error = 6;
        }
      }
      if (error == 0 && dmaxmin > narrowLevel[gain]) {
        float secondMax = dmaxmin * secondMaxLevel;
        float dminPlus = dmin + secondMax;
        float dmaxMinus = dmax - secondMax;
        if (not_gap) { // jumps above two (or one) neighbour samples
          if (max_in_middle && std::max(digits[pmax - 1], digits[pmax + 1]) < dminPlus) {
            error = 7; // jump up in one sample in the middle, which is much higher than two neighbours
          } else if (min_in_middle && std::min(digits[pmin - 1], digits[pmin + 1]) > dmaxMinus) {
            error = 8; // jump down in one sample, which is much lower than two neighbours
          } else if (big_jump && gain == 0) { // check first and last sample only in low gain
            if (pmin == 0 && digits[1] > dmax - secondMax) {
              error = 10; // jump down in first sample. which is much lower than next one
            } else if (pmin == nSamp - 1 && digits[pmin - 1] > dmax - secondMax) {
              error = 11; // jump down in last sample. which is much lower than previous one
            }
          }
        }
        if (!error && big_jump) { // jumps above all samples 
          if ((max_in_middle || gain == 0) && nmax == 1 && belowmax < dminPlus) {
            error = 12; // jump up in one sample in the middle, which is much higher than all others
          } else if ((min_in_middle || gain == 0) && nmin == 1 && abovemin > dmaxMinus) {
            error = 13; // jump down in one sample, which is much lower than all others (
          }
        }
      }
    }
 
  } else {
    dmin = dmax = 0.0;
  }
 
  return error;
}

createContainer()

StatusCode TileRawChannelBuilder::createContainer ( const EventContext & ctx )

virtualinherited

Create container in SG with name given by parameter (m_rawChannelContainerKey).

Definition at line 233 of file TileRawChannelBuilder.cxx.

                                                                         {
  initLog(ctx);
 
  // create TRC container
  m_rawChannelCnt = std::make_unique<TileMutableRawChannelContainer>(true, m_rChType, m_rChUnit, SG::VIEW_ELEMENTS);
  ATH_CHECK( m_rawChannelCnt->status() );
  m_rawChannelCnt->set_bsflags(m_bsflags);
 
  ATH_MSG_DEBUG( "Created TileRawChannelContainer '" << m_rawChannelContainerKey.key() << "'" );
 
  return StatusCode::SUCCESS;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

derivative()

double TileRawChannelBuilderFitFilterCool::derivative ( double x, const std::vector< double > * xvec, const std::vector< double > * yvec ) const

inlineprivate

Definition at line 87 of file TileRawChannelBuilderFitFilterCool.h.

                                                                                                      {
      return pulse(x, xvec, yvec, true);
    }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

endLog()

void TileRawChannelBuilder::endLog ( )

inherited

Definition at line 639 of file TileRawChannelBuilder.cxx.

                                   {
  m_chCounter = 0;
  m_nChL = m_nChH = 0;
  m_RChSumL = m_RChSumH = 0.0;
 
}

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

fill_drawer_errors()

void TileRawChannelBuilder::fill_drawer_errors ( const EventContext & ctx, const TileDigitsCollection * collection )

privateinherited

Definition at line 300 of file TileRawChannelBuilder.cxx.

{
  const TileDQstatus* DQstatus = SG::makeHandle (m_DQstatusKey, ctx).get();
 
  int frag = coll->identify();
  int ros = (frag >> 8);
  int drawer = (frag & 0xff);
 
  m_lastDrawer = frag;
 
  memset(m_error, 0, sizeof(m_error));
  int dmuerr[MAX_DMUS] = {0};
  int nch = 0;
  bool bigain = DQstatus->isBiGain();
  if (!bigain) { // in bigain runs we don't have DQ status fragment
    for (int ch = 0; ch < MAX_CHANNELS; ch += 3) {
      if (!DQstatus->isAdcDQgood(ros, drawer, ch, 0)) {
        m_error[ch + 2] = m_error[ch + 1] = m_error[ch] = -3;
        dmuerr[ch / 3] = 3;
        nch += 3;
      }
    }
  }
  if (nch == MAX_CHANNELS) { // all bad - nothing to do
    m_badDrawer = true;
    ATH_MSG_VERBOSE( "Drawer 0x" << MSG::hex << frag << MSG::dec
                    << " is bad - skipping bad patterns check " );
    return;
  } else {
    m_badDrawer = false;
    ATH_MSG_VERBOSE(  "Drawer 0x" << MSG::hex << frag << MSG::dec
                    << " looking for bad patterns in digits" );
  }
 
  float mindig, maxdig;
  int nchbad[2] = { 0, 0 };
 
  // Iterate over all digits in this collection
  TileDigitsCollection::const_iterator digitItr = coll->begin();
  TileDigitsCollection::const_iterator lastDigit = coll->end();
 
  for (; digitItr != lastDigit; ++digitItr) {
    const TileDigits * pDigits = (*digitItr);
    HWIdentifier adcId = pDigits->adc_HWID();
    int channel = m_tileHWID->channel(adcId);
    int gain = m_tileHWID->adc(adcId);
 
    if (m_error[channel]) {
      ATH_MSG_VERBOSE( "BadCh " << ros
                        << "/" << drawer
                        << "/" << channel
                        << "/" << gain << " BAD DQ STATUS ");
 
    } else {
 
      int err = CorruptedData(ros, drawer, channel, gain, pDigits->samples(), mindig, maxdig, m_ADCmaxMinusEps, m_ADCmaskValueMinusEps);
 
      if (err) {
 
        m_error[channel] = err;
        if (err > -5) {
          ++dmuerr[channel / 3];
          ++nchbad[channel / 24];
        }
 
        if (msgLvl(MSG::VERBOSE)) {
 
          msg(MSG::VERBOSE) << "BadCh " << ros
                            << "/" << drawer
                            << "/" << channel
                            << "/" << gain;
          if (err < -5) msg(MSG::VERBOSE) << " Warning " << err;
          else msg(MSG::VERBOSE) << " Error " << err;
          if (mindig > m_ADCmaskValueMinusEps) msg(MSG::VERBOSE) << " BADDQ";
          if (maxdig > m_ADCmaxMinusEps) msg(MSG::VERBOSE) << " Overflow";
          if (mindig < 0.1) msg(MSG::VERBOSE) << " Underflow";
          if (err < 0) msg(MSG::VERBOSE) << " Const";
 
          msg(MSG::VERBOSE) << " samp=";
          std::vector<float> digits = pDigits->samples();
          for (unsigned int i = 0; i < digits.size(); ++i) {
            msg(MSG::VERBOSE) << " " << digits[i];
          }
          msg(MSG::VERBOSE) << endmsg;
        }
 
      } else {
        if (mindig < 0.01) err += 1;
        if (maxdig > m_ADCmaxMinusEps) err += 2;
        if (err) m_error[channel] = err - 10;
      }
    }
  }
 
  // check if we want to mask half a drawer 
  // in this case set error = -4 for channels which were good before
 
  int ndmubad[2] = { 0, 0 };
  int dmu = 0;
  for (; dmu < MAX_DMUS / 2; ++dmu) { // first half
    if (dmuerr[dmu] > 1)
      ++ndmubad[0]; // count DMUs with at least two bad channels
  }
  for (; dmu < MAX_DMUS; ++dmu) { // second half
    if (dmuerr[dmu] > 1)
      ++ndmubad[1]; // count DMUs with at least two bad channels
  }
 
  int ndmulimit[2] = { 3, 3 }; // max number of bad DMUs when half-drawer is not yet masked
                               // if 4 DMUs will be bad - mask whole half-drawer
  if (frag > 0x2ff) { // if extended barrel
    if (frag == 0x30e || frag == 0x411)
      ndmulimit[0] = 4; // in EB special one DMU is always bad (missing)
    ndmulimit[1] = 5; // in second half of EB 4 DMUs ara always bad (missing)
                      // only if 7 DMUs are bad, mask whole half-drawer
  }
 
  bool printall = true;
  for (int p = 0; p < 2; ++p) {
    if (ndmubad[p] > ndmulimit[p] && nchbad[p] > 0) {
      if (msgLvl(MSG::VERBOSE)) {
        msg(MSG::VERBOSE) << "Drawer 0x" << MSG::hex << frag << MSG::dec
                          << " masking whole " << ((p) ? "second" : "first")
                          << " half" << endmsg;
        if (printall) {
          msg(MSG::VERBOSE) << "nDMuErr ";
          for (int d = 0; d < MAX_DMUS; ++d) {
            msg(MSG::VERBOSE) << " " << dmuerr[d];
          }
          msg(MSG::VERBOSE) << " total " << ndmubad[p] << " errors" << endmsg;
 
          msg(MSG::VERBOSE) << "ChErr ";
          int ch = 0;
          while (ch < MAX_CHANNELS-2) {
            msg(MSG::VERBOSE) << " " << m_error[ch++];
            msg(MSG::VERBOSE) << " " << m_error[ch++];
            msg(MSG::VERBOSE) << " " << m_error[ch++];
            msg(MSG::VERBOSE) << "  ";
          }
 
          msg(MSG::VERBOSE) << " total " << nchbad[p]
                            << " bad patterns" << endmsg;
          printall = false;
        }
      }
      int ch = (p) ? MAX_CHANNELS / 2 : 0;
      int chmax = (p) ? MAX_CHANNELS : MAX_CHANNELS / 2;
      for (; ch < chmax; ++ch) {
        if (m_error[ch] == 0 || m_error[ch] < -5) { // channel was good before
          m_error[ch] = -4;
        }
      }
    }
  }
 
}

finalize()

StatusCode TileRawChannelBuilderFitFilterCool::finalize ( )

overridevirtual

Reimplemented from TileRawChannelBuilder.

Definition at line 527 of file TileRawChannelBuilderFitFilterCool.cxx.

                                                        {
 
  ATH_MSG_DEBUG( "Finalizing" );
 
  return StatusCode::SUCCESS;
}

getOverflowedChannels()

Overflows_t & TileRawChannelBuilder::getOverflowedChannels ( void )

inherited

Definition at line 38 of file TileRawChannelBuilder.cxx.

                                                          {
  return m_overflows;
}

getTileRawChannelContainerID()

std::string TileRawChannelBuilder::getTileRawChannelContainerID ( void )

inherited

Definition at line 42 of file TileRawChannelBuilder.cxx.

                                                              {
  return m_rawChannelContainerKey.key();
}

handle()

void TileRawChannelBuilderFitFilterCool::handle ( const Incident & inc )

overridevirtual

Definition at line 164 of file TileRawChannelBuilderFitFilterCool.cxx.

                                                                   {
 
  // -------- get pulse shapes from COOL
 
  ATH_MSG_INFO( "TileRawChannelBuilderFitFilterCool handle" << inc.type() );
 
  const EventContext &ctx = inc.context();
 
  if (inc.type() == "BeginRun") {
    // Do run initializations here...
 
    ATH_MSG_DEBUG( "m_trigType " << m_trigType
                  << " m_runType " << m_runType
                  << " m_idophys " << m_idophys
                  << " m_idolas " << m_idolas
                  << " m_idoped " << m_idoped
                  << " m_idocis " << m_idocis );
 
    if (m_shapes) delete m_shapes;
 
    m_shapes = new TilePulseShapesStruct;
    float y, dy;
    unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(0, 0);
 
    float phase = 0;
    if (m_idolas) {
      // --- low gain
      m_shapes->m_yllas.reserve(MAX_LO_PULSE_LAS);
      m_shapes->m_tllas.reserve(MAX_LO_PULSE_LAS);
      m_shapes->m_ydllas.reserve(MAX_LO_PULSE_LAS);
      m_shapes->m_tdllas.reserve(MAX_LO_PULSE_LAS);
      phase = LAS_START_T_LO;
      for (int i = 0; i < MAX_LO_PULSE_LAS; i++) {
        //                drawerIdx, channel,gain, phase+25*(i-3), py, pdy
        m_tileToolPulseShape->getPulseShapeYDY(drawerIdx, 0, 0, phase, y, dy, ctx);
        m_shapes->m_tllas.push_back(phase);
        m_shapes->m_yllas.push_back(y);
        m_shapes->m_tdllas.push_back(phase);
        m_shapes->m_ydllas.push_back(dy);
        if (msgLvl(MSG::DEBUG)) {
          msg(MSG::DEBUG) << "new  tllas= " << m_shapes->m_tllas[i]
                          << " yllas= " << m_shapes->m_yllas[i]
                          << " ydllas " << m_shapes->m_ydllas[i] << endmsg;
 
          msg(MSG::DEBUG) << " old  tllas= " << m_pulseShapes->m_tllas[i]
                          << " yllas= " << m_pulseShapes->m_yllas[i]
                          << " ydllas " << m_pulseShapes->m_ydllas[i] << endmsg;
        }
        phase += LAS_DT_LO;
      }
      // --- high gain
      m_shapes->m_yhlas.reserve(MAX_HI_PULSE_LAS);
      m_shapes->m_thlas.reserve(MAX_HI_PULSE_LAS);
      m_shapes->m_ydhlas.reserve(MAX_HI_PULSE_LAS);
      m_shapes->m_tdhlas.reserve(MAX_HI_PULSE_LAS);
      phase = LAS_START_T_HI;
      for (int i = 0; i < MAX_HI_PULSE_LAS; i++) {
        //                drawerIdx, channel,gain, phase+25*(i-3), py, pdy
        m_tileToolPulseShape->getPulseShapeYDY(drawerIdx, 0, 1, phase, y, dy, ctx);
        m_shapes->m_thlas.push_back(phase);
        m_shapes->m_yhlas.push_back(y);
        m_shapes->m_tdhlas.push_back(phase);
        m_shapes->m_ydhlas.push_back(dy);
        if (msgLvl(MSG::DEBUG)) {
          msg(MSG::DEBUG) << "n ew  thlas= " << m_shapes->m_thlas[i]
                          << " yhlas= " << m_shapes->m_yhlas[i]
                          << " ydhlas " << m_shapes->m_ydhlas[i] << endmsg;
 
          msg(MSG::DEBUG) << " old  thlas= " << m_pulseShapes->m_thlas[i]
                          << " yhlas= " << m_pulseShapes->m_yhlas[i]
                          << " ydhlas " << m_pulseShapes->m_ydhlas[i] << endmsg;
        }
        phase += LAS_DT_HI;
      }
    } else if (m_idocis || m_idophys || m_idoped) {
      // --- low gain
      m_shapes->m_ylphys.reserve(MAX_LO_PULSE_PHYS);
      m_shapes->m_tlphys.reserve(MAX_LO_PULSE_PHYS);
      m_shapes->m_ydlphys.reserve(MAX_LO_PULSE_PHYS);
      m_shapes->m_tdlphys.reserve(MAX_LO_PULSE_PHYS);
      phase = PHYS_START_T_LO;
      for (int i = 0; i < MAX_LO_PULSE_PHYS; i++) {
        //                drawerIdx, channel,gain, phase+25*(i-3), py, pdy
        m_tileToolPulseShape->getPulseShapeYDY(drawerIdx, 0, 0, phase, y, dy, ctx);
        m_shapes->m_tlphys.push_back(phase);
        m_shapes->m_ylphys.push_back(y);
        m_shapes->m_tdlphys.push_back(phase);
        m_shapes->m_ydlphys.push_back(dy);
        if (msgLvl(MSG::DEBUG)) {
          msg(MSG::DEBUG) << " new  tlphys= " << m_shapes->m_tlphys[i]
                          << " ylphys= " << m_shapes->m_ylphys[i]
                          << " ydlphys " << m_shapes->m_ydlphys[i] << endmsg;
 
          msg(MSG::DEBUG) << " old  tlphys= " << m_pulseShapes->m_tlphys[i]
                          << " ylphys= " << m_pulseShapes->m_ylphys[i]
                          << " ydlphys " << m_pulseShapes->m_ydlphys[i] << endmsg;
        }
        phase += PHYS_DT_LO;
      }
      // --- high gain
      m_shapes->m_yhphys.reserve(MAX_HI_PULSE_PHYS);
      m_shapes->m_thphys.reserve(MAX_HI_PULSE_PHYS);
      m_shapes->m_ydhphys.reserve(MAX_HI_PULSE_PHYS);
      m_shapes->m_tdhphys.reserve(MAX_HI_PULSE_PHYS);
      phase = PHYS_START_T_HI;
      for (int i = 0; i < MAX_HI_PULSE_PHYS; i++) {
        //                drawerIdx, channel,gain, phase+25*(i-3), py, pdy
        m_tileToolPulseShape->getPulseShapeYDY(drawerIdx, 0, 1, phase, y, dy, ctx);
        m_shapes->m_thphys.push_back(phase);
        m_shapes->m_yhphys.push_back(y);
        m_shapes->m_tdhphys.push_back(phase);
        m_shapes->m_ydhphys.push_back(dy);
        if (msgLvl(MSG::DEBUG)) {
          msg(MSG::DEBUG) << " new  thphys= " << m_shapes->m_thphys[i]
                          << " yhphys= " << m_shapes->m_yhphys[i]
                          << " ydhphys " << m_shapes->m_ydhphys[i] << endmsg;
 
          msg(MSG::DEBUG) << " old  thphys= " << m_pulseShapes->m_thphys[i]
                          << " yhphys= " << m_pulseShapes->m_yhphys[i]
                          << " ydhphys " << m_pulseShapes->m_ydhphys[i] << endmsg;
        }
        phase += PHYS_DT_HI;
      }
 
      //================================================
      // Speedup for physics processing (max_iter=1):
      //  read initial pulse shapes into arrays
      m_fnParameters[0] = 0.0;
      m_fnParameters[1] = 0.0;
      m_fnParameters[2] = 1.0;
      m_t0Fit = 0.0;
      
      m_gPhysLo.reserve(m_frameLength);
      m_dgPhysLo.reserve(m_frameLength);
      m_gPhysHi.reserve(m_frameLength);
      m_dgPhysHi.reserve(m_frameLength);
      
      double rsamp;
      for (int isamp = 0; isamp < m_frameLength; ++isamp) {
        rsamp = (isamp) * 1.0;
        m_gPhysLo.push_back(scaledPulse(rsamp, &(m_pulseShapes->m_tlphys), &(m_pulseShapes->m_ylphys)));
        m_dgPhysLo.push_back(pulse(rsamp, &(m_pulseShapes->m_tdlphys), &(m_pulseShapes->m_ydlphys)));
        m_gPhysHi.push_back(scaledPulse(rsamp, &(m_pulseShapes->m_thphys), &(m_pulseShapes->m_yhphys)));
        m_dgPhysHi.push_back(pulse(rsamp, &(m_pulseShapes->m_tdhphys), &(m_pulseShapes->m_ydhphys)));
      }
    } else {
      ATH_MSG_ERROR( " Unknown run type "
                    << "idophys=" << m_idophys
                    << " idolas=" << m_idolas
                    << " idocis=" << m_idocis
                    << " idoped= " << m_idoped );
    }
 
    // -------------- CIS shapes
 
    if (m_idocis) {
      // --- low gain 100 pF Pulse
      m_shapes->m_ylcis.reserve(MAX_LO_PULSE_CIS);
      m_shapes->m_tlcis.reserve(MAX_LO_PULSE_CIS);
      m_shapes->m_ydlcis.reserve(MAX_LO_PULSE_CIS);
      m_shapes->m_tdlcis.reserve(MAX_LO_PULSE_CIS);
      phase = CIS_START_T_LO;
      for (int i = 0; i < MAX_LO_PULSE_CIS; i++) {
        //                drawerIdx, channel,gain, phase+25*(i-3), py, pdy
        m_tileToolPulseShape->getPulseShapeYDY(drawerIdx, 0, 0, phase, y, dy, ctx);
        m_shapes->m_tlcis.push_back(phase);
        m_shapes->m_ylcis.push_back(y);
        m_shapes->m_tdlcis.push_back(phase);
        m_shapes->m_ydlcis.push_back(dy);
        //aa    m_shapes->m_ydlcis.push_back(m_pulsevar->m_ydlcis[i]);
        if (msgLvl(MSG::DEBUG)) {
          msg(MSG::DEBUG) << " new  tlcis= " << m_shapes->m_tlcis[i]
                          << " ylcis= " << m_shapes->m_ylcis[i]
                          << " ydlcis " << m_shapes->m_ydlcis[i] << endmsg;
 
          msg(MSG::DEBUG) << " old  tlcis= " << m_pulseShapes->m_tlcis[i]
                          << " ylcis= " << m_pulseShapes->m_ylcis[i]
                          << " ydlcis " << m_pulseShapes->m_ydlcis[i] << endmsg;
        }
        phase += CIS_DT_LO;
      }
      // --- high gain 100 pF Pulse
      m_shapes->m_yhcis.reserve(MAX_HI_PULSE_CIS);
      m_shapes->m_thcis.reserve(MAX_HI_PULSE_CIS);
      m_shapes->m_ydhcis.reserve(MAX_HI_PULSE_CIS);
      m_shapes->m_tdhcis.reserve(MAX_HI_PULSE_CIS);
      phase = CIS_START_T_HI;
      for (int i = 0; i < MAX_HI_PULSE_CIS; i++) {
        //                drawerIdx, channel,gain, phase+25*(i-3), py, pdy
        m_tileToolPulseShape->getPulseShapeYDY(drawerIdx, 0, 1, phase, y, dy, ctx);
        m_shapes->m_thcis.push_back(phase);
        m_shapes->m_yhcis.push_back(y);
        m_shapes->m_tdhcis.push_back(phase);
        m_shapes->m_ydhcis.push_back(dy);
        //aa    m_shapes->m_ydhcis.push_back(m_pulsevar->m_ydhcis[i]);
        if (msgLvl(MSG::DEBUG)) {
          msg(MSG::DEBUG) << " new  thcis= " << m_shapes->m_thcis[i]
                          << " yhcis= " << m_shapes->m_yhcis[i]
                          << " ydhcis " << m_shapes->m_ydhcis[i] << endmsg;
 
          msg(MSG::DEBUG) << " old  thcis= " << m_pulseShapes->m_thcis[i]
                          << " yhcis= " << m_pulseShapes->m_yhcis[i]
                          << " ydhcis " << m_pulseShapes->m_ydhcis[i] << endmsg;
        }
        phase += CIS_DT_HI;
      }
 
      // --- low gain 5.2 pF Pulse
      m_shapes->m_yslcis.reserve(MAX_LO_PULSE_CIS_SMALL);
      m_shapes->m_tslcis.reserve(MAX_LO_PULSE_CIS_SMALL);
      m_shapes->m_ydslcis.reserve(MAX_LO_PULSE_CIS_SMALL);
      m_shapes->m_tdslcis.reserve(MAX_LO_PULSE_CIS_SMALL);
      phase = SCIS_START_T_LO;
      for (int i = 0; i < MAX_LO_PULSE_CIS; i++) {
        //                drawerIdx, channel,gain, phase+25*(i-3), py, pdy
        m_tileToolPulse5p2Shape->getPulseShapeYDY(drawerIdx, 0, 0, phase, y, dy, ctx);
        m_shapes->m_tslcis.push_back(phase);
        m_shapes->m_yslcis.push_back(y);
        m_shapes->m_tdslcis.push_back(phase);
        m_shapes->m_ydslcis.push_back(dy);
        //aa    m_shapes->m_ydslcis.push_back(m_pulsevar->m_ydslcis[i]);
        if (msgLvl(MSG::DEBUG)) {
          msg(MSG::DEBUG) << " new  tslcis= " << m_shapes->m_tslcis[i]
                          << " yslcis= " << m_shapes->m_yslcis[i]
                          << " ydslcis " << m_shapes->m_ydslcis[i] << endmsg;
 
          msg(MSG::DEBUG) << " old  tslcis= " << m_pulseShapes->m_tslcis[i]
                          << " yslcis= " << m_pulseShapes->m_yslcis[i]
                          << " ydslcis " << m_pulseShapes->m_ydslcis[i] << endmsg;
        }
        phase += CIS_DT_LO;
      }
      // --- high gain 5.2 pF Pulse
      m_shapes->m_yshcis.reserve(MAX_HI_PULSE_CIS_SMALL);
      m_shapes->m_tshcis.reserve(MAX_HI_PULSE_CIS_SMALL);
      m_shapes->m_ydshcis.reserve(MAX_HI_PULSE_CIS_SMALL);
      m_shapes->m_tdshcis.reserve(MAX_HI_PULSE_CIS_SMALL);
      phase = SCIS_START_T_HI;
      for (int i = 0; i < MAX_HI_PULSE_CIS; i++) {
        //                drawerIdx, channel,gain, phase+25*(i-3), py, pdy
        m_tileToolPulse5p2Shape->getPulseShapeYDY(drawerIdx, 0, 1, phase, y, dy, ctx);
        m_shapes->m_tshcis.push_back(phase);
        m_shapes->m_yshcis.push_back(y);
        m_shapes->m_tdshcis.push_back(phase);
        m_shapes->m_ydshcis.push_back(dy);
        //aa    m_shapes->m_ydshcis.push_back(m_pulsevar->m_ydshcis[i]);
        if (msgLvl(MSG::DEBUG)) {
          msg(MSG::DEBUG) << " new  tshcis= " << m_shapes->m_tshcis[i]
                          << " yshcis= " << m_shapes->m_yshcis[i]
                          << " ydshcis " << m_shapes->m_ydshcis[i] << endmsg;
 
          msg(MSG::DEBUG) << " old  tshcis= " << m_pulseShapes->m_tshcis[i]
                          << " yshcis= " << m_pulseShapes->m_yshcis[i]
                          << " ydshcis " << m_pulseShapes->m_ydshcis[i] << endmsg;
        }
        phase += CIS_DT_HI;
      }
 
      // --- low gain 100 pF Leak
      m_shapes->m_leaklo.reserve(MAX_LO_PULSE_CIS);
      m_shapes->m_tleaklo.reserve(MAX_LO_PULSE_CIS);
      m_shapes->m_dleaklo.reserve(MAX_LO_PULSE_CIS);
      m_shapes->m_tdleaklo.reserve(MAX_LO_PULSE_CIS);
      phase = LEAK_START_T_LO;
      for (int i = 0; i < MAX_LO_PULSE_CIS; i++) {
        //                drawerIdx, channel,gain, phase+25*(i-3), py, pdy
        m_tileToolLeak100Shape->getPulseShapeYDY(drawerIdx, 0, 0, phase, y, dy, ctx);
        m_shapes->m_tleaklo.push_back(phase);
        m_shapes->m_leaklo.push_back(y);
        m_shapes->m_tdleaklo.push_back(phase);
        //aa m_shapes->m_dleaklo.push_back(m_pulsevar->m_dleaklo[i]);
        m_shapes->m_dleaklo.push_back(dy);
        if (msgLvl(MSG::DEBUG)) {
          msg(MSG::DEBUG) << " new tleaklo = " << m_shapes->m_tleaklo[i]
                          << " leaklo = " << m_shapes->m_leaklo[i]
                          << " dleaklo  " << m_shapes->m_dleaklo[i] << endmsg;
 
          msg(MSG::DEBUG) << " old  tleaklo= " << m_pulseShapes->m_tleaklo[i]
                          << " leaklo= " << m_pulseShapes->m_leaklo[i]
                          << " dleaklo " << m_pulseShapes->m_dleaklo[i] << endmsg;
        }
        phase += CIS_DT_LO;
      }
      // --- high gain 100 pF Leak
      m_shapes->m_leakhi.reserve(MAX_HI_PULSE_CIS);
      m_shapes->m_tleakhi.reserve(MAX_HI_PULSE_CIS);
      m_shapes->m_dleakhi.reserve(MAX_HI_PULSE_CIS);
      m_shapes->m_tdleakhi.reserve(MAX_HI_PULSE_CIS);
      phase = LEAK_START_T_HI;
      for (int i = 0; i < MAX_HI_PULSE_CIS; i++) {
        //                drawerIdx, channel,gain, phase+25*(i-3), py, pdy
        m_tileToolLeak100Shape->getPulseShapeYDY(drawerIdx, 0, 1, phase, y, dy, ctx);
        m_shapes->m_tleakhi.push_back(phase);
        m_shapes->m_leakhi.push_back(y);
        m_shapes->m_tdleakhi.push_back(phase);
        m_shapes->m_dleakhi.push_back(dy);
        //aa    m_shapes->m_dleakhi.push_back(m_pulsevar->m_dleakhi[i]);
        if (msgLvl(MSG::DEBUG)) {
          msg(MSG::DEBUG) << " new tleakhi = " << m_shapes->m_tleakhi[i]
                          << " leakhi= " << m_shapes->m_leakhi[i]
                          << " dleakhi " << m_shapes->m_dleakhi[i] << endmsg;
 
          msg(MSG::DEBUG) << " old tleakhi = " << m_pulseShapes->m_tleakhi[i]
                          << " leakhi= " << m_pulseShapes->m_leakhi[i]
                          << " dleakhi " << m_pulseShapes->m_dleakhi[i] << endmsg;
        }
        phase += CIS_DT_HI;
      }
 
      // --- low gain 5.2 pF Leak
      m_shapes->m_sleaklo.reserve(MAX_LO_PULSE_CIS_SMALL);
      m_shapes->m_tsleaklo.reserve(MAX_LO_PULSE_CIS_SMALL);
      m_shapes->m_dsleaklo.reserve(MAX_LO_PULSE_CIS_SMALL);
      m_shapes->m_tdsleaklo.reserve(MAX_LO_PULSE_CIS_SMALL);
      phase = SLEAK_START_T_LO;
      for (int i = 0; i < MAX_LO_PULSE_CIS; i++) {
        //                drawerIdx, channel,gain, phase+25*(i-3), py, pdy
        m_tileToolLeak5p2Shape->getPulseShapeYDY(drawerIdx, 0, 0, phase, y, dy, ctx);
        m_shapes->m_tsleaklo.push_back(phase);
        m_shapes->m_sleaklo.push_back(y);
        m_shapes->m_tdsleaklo.push_back(phase);
        m_shapes->m_dsleaklo.push_back(dy);
        //aa    m_shapes->m_dsleaklo.push_back(m_pulsevar->m_dsleaklo[i]);
        if (msgLvl(MSG::DEBUG)) {
          msg(MSG::DEBUG) << " new tsleaklo = " << m_shapes->m_tsleaklo[i]
                          << " sleaklo = " << m_shapes->m_sleaklo[i]
                          << " dsleaklo " << m_shapes->m_dsleaklo[i] << endmsg;
 
          msg(MSG::DEBUG) << " old tsleaklo = " << m_pulseShapes->m_tslcis[i]
                          << " sleaklo= " << m_pulseShapes->m_sleaklo[i]
                          << " dsleaklo " << m_pulseShapes->m_dsleaklo[i] << endmsg;
        }
        phase += CIS_DT_LO;
      }
      // --- high gain 5.2 pF Leak
      m_shapes->m_sleakhi.reserve(MAX_HI_PULSE_CIS_SMALL);
      m_shapes->m_tsleakhi.reserve(MAX_HI_PULSE_CIS_SMALL);
      m_shapes->m_dsleakhi.reserve(MAX_HI_PULSE_CIS_SMALL);
      m_shapes->m_tdsleakhi.reserve(MAX_HI_PULSE_CIS_SMALL);
      phase = SLEAK_START_T_HI;
      for (int i = 0; i < MAX_HI_PULSE_CIS; i++) {
        //                drawerIdx, channel,gain, phase+25*(i-3), py, pdy
        m_tileToolLeak5p2Shape->getPulseShapeYDY(drawerIdx, 0, 1, phase, y, dy, ctx);
        m_shapes->m_tsleakhi.push_back(phase);
        m_shapes->m_sleakhi.push_back(y);
        m_shapes->m_tdsleakhi.push_back(phase);
        m_shapes->m_dsleakhi.push_back(dy);
        //aa    m_shapes->m_dsleakhi.push_back(m_pulsevar->m_dsleakhi[i]);
        if (msgLvl(MSG::DEBUG)) {
          msg(MSG::DEBUG) << " new  tsleakhi= " << m_shapes->m_tsleakhi[i]
                          << " sleakhi = " << m_shapes->m_sleakhi[i]
                          << " dsleakhi " << m_shapes->m_dsleakhi[i] << endmsg;
 
          msg(MSG::DEBUG) << " old  tsleakhi= " << m_pulseShapes->m_tsleakhi[i]
                          << " sleakhi= " << m_pulseShapes->m_sleakhi[i]
                          << " dsleakhi " << m_pulseShapes->m_dsleakhi[i] << endmsg;
        }
        phase += CIS_DT_HI;
      }
    } // endif(m_idocis)
  } // endif "beginrun"
}

initialize()

StatusCode TileRawChannelBuilderFitFilterCool::initialize ( )

overridevirtual

Initializer.

Reimplemented from TileRawChannelBuilder.

Definition at line 84 of file TileRawChannelBuilderFitFilterCool.cxx.

                                                          {
 
  ATH_MSG_INFO( "TileRawChannelBuilderFitFilterCool::initialize()" );
 
  m_rChType = TileFragHash::FitFilterCool;
 
  // init in superclass
  ATH_CHECK( TileRawChannelBuilder::initialize() );
  
  // Get pulse shapes from TileInfo
  m_pulseShapes = m_tileInfo->getPulseShapes();
 
  // Determine peak sample position 
  // peak sample position defines t=0 
  m_iPeak0 = (int) (m_frameLength) / 2 + (m_frameLength % 2) - 1;
 
  // Min and max time are now calculated based on m_framelength - i.e. on the
  // number of 25 ns samples read out. Don't forget t=0 corresponds to 
  // m_ipeak0-th sample
  m_minTime = DTIME * (0 - m_iPeak0 - m_extraSamplesLeft);
  m_maxTime = DTIME * (m_frameLength - 1 - m_iPeak0 + m_extraSamplesRight);
  // maximal jump during one iteration
  m_maxTau = (m_maxTime - m_minTime);
  m_minTau = -m_maxTau;
 
  ATH_MSG_DEBUG( " ipeak0=" << m_iPeak0
                << " min_time=" << m_minTime
                << " max_time=" << m_maxTime
                << " min_tau=" << m_minTau
                << " max_tau=" << m_maxTau
                << " physize=" << m_pulseShapes->m_ylphys.size()
                << " cissize=" << m_pulseShapes->m_ylcis.size()
                << " xpmin=" << m_pulseShapes->m_tlphys[0]
                << " xpmax=" << m_pulseShapes->m_tlphys[MAX_LO_PULSE_PHYS - 1]
                << " ypmin=" << m_pulseShapes->m_ylphys[0]
                << " ypmax=" << m_pulseShapes->m_ylphys[MAX_LO_PULSE_PHYS - 1] );
  
  //=== get TileCondToolPulseShape
  ATH_CHECK( m_tileToolPulseShape.retrieve() );
 
  if (m_idocis) {
    ATH_CHECK( m_tileToolLeak100Shape.retrieve() );
    ATH_CHECK( m_tileToolLeak5p2Shape.retrieve() );
    ATH_CHECK( m_tileToolPulse5p2Shape.retrieve() );
  } else {
    m_tileToolLeak100Shape.disable();
    m_tileToolLeak5p2Shape.disable();
    m_tileToolPulse5p2Shape.disable();
  }
 
  //=== TileCondToolNoiseSample
  ATH_CHECK( m_tileToolNoiseSample.retrieve() );
 
  // Incident Service:
  ServiceHandle<IIncidentSvc> incSvc("IncidentSvc", this->name());
  ATH_CHECK(incSvc.retrieve());
  //start listening to "BeginRun"
  incSvc->addListener(this, "BeginRun");
 
  if (msgLvl(MSG::DEBUG)) {
    if (m_channelNoiseRMS) {
      msg(MSG::DEBUG) << " noise for all channels from Conditions DB ";
      if (TileCablingService::getInstance()->getTestBeam()) {
        const EventContext &ctx = Gaudi::Hive::currentContext();
        msg(MSG::DEBUG) << " rmsLow(LBA01/0) = " << m_tileToolNoiseSample->getHfn(20, 0, TileID::LOWGAIN, TileRawChannelUnit::ADCcounts, ctx)
                        << " rmsHi(LBA01/0) = " << m_tileToolNoiseSample->getHfn(20, 0, TileID::HIGHGAIN, TileRawChannelUnit::ADCcounts, ctx)
                        << endmsg;
      } else {
        msg(MSG::DEBUG) << endmsg;
      }
    } else {
      msg(MSG::DEBUG) << " common noise for all channels (OBSOLETE): " << endmsg;
      msg(MSG::DEBUG) << " rmsLow = " << m_noiseLow
                      << " rmsHi = " << m_noiseHigh << endmsg;
    }
  }
 
  return StatusCode::SUCCESS;
}

initLog()

void TileRawChannelBuilder::initLog ( const EventContext & ctx )

inherited

Definition at line 246 of file TileRawChannelBuilder.cxx.

                                                           {
 
  const TileDQstatus* DQstatus = SG::makeHandle (m_DQstatusKey, ctx).get();
 
  // update only if there is new event
  if (m_evtCounter != ctx.evt()) {
 
    m_evtCounter = ctx.evt();
    if (m_runType != 0) m_trigType = m_runType;
    else m_trigType = DQstatus->trigType();
 
    if (0 == m_trigType) {
      m_idophys = (DQstatus->calibMode() == 0);
      m_idolas = false;
      m_idoped = false;
      m_idocis = (DQstatus->calibMode() == 1);
    } else {
      m_idophys = (m_trigType <= 1);
      m_idolas = ((m_trigType == 2) || (m_trigType == 3));
      m_idoped = ((m_trigType == 4) || (m_trigType == 5));
      m_idocis = ((m_trigType == 8) || (m_trigType == 9));
    }
 
    const unsigned int *cispar = DQstatus->cispar();
    if (0 == cispar[7]) { // if capdaq not set, it can't be CIS event
      if (m_idocis) { // cis flag was set incorrectly, change to ped
        m_idoped = true;
        m_idocis = false;
      }
      m_capdaq = 0.0;
    } else {
      m_capdaq = (cispar[7] < 10) ? 5.2 : 100.0;
    }
    m_cischan = cispar[8] - 1; // channel where CIS is fired (-1 = all channels)
 
    ATH_MSG_DEBUG( "Trig type is " << m_trigType
                  << "; dophys is " << ((m_idophys) ? "true" : "false")
                  << "; dolas is " << ((m_idolas) ? "true" : "false")
                  << "; doped is " << ((m_idoped) ? "true" : "false")
                  << "; docis is " << ((m_idocis) ? "true" : "false")
                  << "; capacitor is " << m_capdaq
                  << "; cis chan is " << m_cischan );
  }
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & TileRawChannelBuilderFitFilterCool::interfaceID ( )

static

AlgTool InterfaceID.

Definition at line 34 of file TileRawChannelBuilderFitFilterCool.cxx.

                                                                    { 
  return IID_ITileRawChannelBuilderFitFilterCool;
  //return TileRawChannelBuilderCool::interfaceID();
}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

pulse()

double TileRawChannelBuilderFitFilterCool::pulse ( double x, const std::vector< double > * xvec, const std::vector< double > * yvec, bool zeroOutside = false ) const

private

pulse interpolation

Definition at line 1825 of file TileRawChannelBuilderFitFilterCool.cxx.

                                                              {
 
  int size1 = xvec->size() - 1;
  if (size1 < 1) return 0.0;
 
  const double delta = 1.e-6;
  
  double xpmin = xvec->at(0);
  double xpmax = xvec->at(size1);
 
  double xp = (x - m_iPeak0) * DTIME - m_t0Fit - m_fnParameters[0];
 
  double val = 0.0;
  double tdiv = (xpmax - xpmin) / size1;
 
  if (xp < xpmin + delta) {
    if (zeroOutside && xp < xpmin - delta)
      val = 0.0;
    else
      val = yvec->at(0);
#ifdef EXTRAPOLATE_TO_ZERO
    if (xp < xpmin - delta && val != 0.0) {
      double newval = val + ((yvec->at(1) - val) / tdiv) * (xp - xpmin);
      if (val * newval < 0.0) {
        val = 0.0;
      } else if (fabs(newval) < fabs(val)) {
        val = newval;
      }
    }
#endif
  } else if (xp > xpmax - delta) {
    if (zeroOutside && xp > xpmax + delta)
      val = 0.0;
    else
      val = yvec->at(size1);
#ifdef EXTRAPOLATE_TO_ZERO
    if (xp > xpmax + delta && val != 0.0) {
      double newval = val + ((yvec->at(size1 - 1) - val) / tdiv) * (xp - xpmax);
      if (val * newval < 0.0) {
        val = 0.0;
      } else if (fabs(newval) < fabs(val)) {
        val = newval;
      }
    }
#endif
  } else {
    int j = (int) ((xp - xpmin) / tdiv);
    val = yvec->at(j) + ((yvec->at(j + 1) - yvec->at(j)) / tdiv) * (xp - xvec->at(j));
  }
  
  return val;
}

pulseFit()

void TileRawChannelBuilderFitFilterCool::pulseFit ( const TileDigits * digit, double & amplitude, double & time, double & pedestal, double & chi2, const EventContext & ctx )

private

Calculate energy, time and chi2 for one channel using fitted pulse shape.

Method uses HFITV.

Parameters

samples

TileDigits

Definition at line 603 of file TileRawChannelBuilderFitFilterCool.cxx.

                                                                             {
 
  amplitude = 0.0;
  time = 0.0;
  pedestal = 0.0;
  chi2 = MAX_CHI2;
 
  const HWIdentifier adcId = digit->adc_HWID();
  int ros = m_tileHWID->ros(adcId);
  int channel = m_tileHWID->channel(adcId);
  int igain = m_tileHWID->adc(adcId);
 
  int drawer = m_tileHWID->drawer(adcId);
  unsigned int drawerIdx = TileCalibUtils::getDrawerIdx(ros, drawer);
 
  // Estimate channel noise
  double rms = 0.0;
  int noise_channel = (ros < 3) ? channel : channel + 48;
 
  if (igain == 0) {
    switch (m_channelNoiseRMS) {
      case 3:
        rms = m_tileToolNoiseSample->getHfn(drawerIdx, channel, igain, TileRawChannelUnit::ADCcounts, ctx);
        if (rms > 0.0) break;
        /* FALLTHROUGH */
      case 2:
        rms = m_pulseShapes->m_noiseNkLo[noise_channel];
        if (rms > 0.0) break;
        /* FALLTHROUGH */
      case 1:
        rms = m_pulseShapes->m_noiseOrigLo[noise_channel];
        if (rms > 0.0) break;
        /* FALLTHROUGH */
      default:
        rms = m_noiseLow;
    }
  } else if (igain == 1) {
    switch (m_channelNoiseRMS) {
      case 3:
        rms = m_tileToolNoiseSample->getHfn(drawerIdx, channel, igain, TileRawChannelUnit::ADCcounts, ctx);
        if (rms > 0.0) break;
        /* FALLTHROUGH */
      case 2:
        rms = m_pulseShapes->m_noiseNkHi[noise_channel];
        if (rms > 0.0) break;
        /* FALLTHROUGH */
      case 1:
        rms = m_pulseShapes->m_noiseOrigHi[noise_channel];
        if (rms > 0.0) break;
        /* FALLTHROUGH */
      default:
        rms = m_noiseHigh;
    }
  } else {
    // neither low nor hi-gain, (e.g. adder data)
    chi2 = -1.0;
    return;
  }
 
  ATH_MSG_VERBOSE ( "PulseFit:"
                   << " ROS=" << ros
                   << " Channel=" << channel
                   << " gain=" << igain
                   << " RMS=" << rms
                   << " RMSChNoise=" << m_channelNoiseRMS );
 
  // First sample to fit, number of samples to fit
  int ifit1 = 0;
  int nfit = std::min(m_frameLength, digit->NtimeSamples());
 
  int ipeakMax = m_iPeak0;
  int ipeakMin = m_iPeak0;
 
  ATH_MSG_VERBOSE ( "ipeak0=" << m_iPeak0
                   << " ifit1=" << ifit1
                   << " ifit2=" << ifit1 + nfit - 1
                   << " nfit=" << nfit
                   << " idolas=" << m_idolas
                   << " idocis=" << m_idocis
                   << " CISchan=" << m_cischan
                   << " capdaq=" << m_capdaq );
 
  std::vector<float> samples = digit->samples();
  double maxsamp = 0.0;
  double minsamp = SATURATED_ADC_VALUE;
 
  double xvec[MAX_SAMPLES], yvec0[MAX_SAMPLES];
  double yvec[MAX_SAMPLES], eyvec[MAX_SAMPLES];
 
  bool no_signal = true;
  pedestal = samples[0];
  const double delta = 1.e-6;
 
  for (int isamp = 0; isamp < nfit; ++isamp) {
    int j = isamp + ifit1;
    xvec[isamp] = j;
    yvec0[isamp] = samples[j];
    if (no_signal) no_signal = (fabs(samples[j] - pedestal) < delta);
 
    // Check for saturated or zero samples and de-weight accordingly
    if ((yvec0[isamp] < SATURATED_ADC_VALUE) && (yvec0[isamp] > 0)) {
      eyvec[isamp] = rms;
    } else {
      if (yvec0[isamp] >= SATURATED_ADC_VALUE) {
        eyvec[isamp] = m_saturatedSampleError * rms;
        ATH_MSG_VERBOSE ( "Saturated ADC value yvec0[" << isamp << "]=" << yvec0[isamp]
                         << " (MAX=" << SATURATED_ADC_VALUE << " ) RMS=" << eyvec[isamp] );
      } else { // must be yvec0[isamp]==0
        eyvec[isamp] = m_zeroSampleError * rms;
        ATH_MSG_VERBOSE ( "Zero ADC value yvec0[" << isamp << "]=" << yvec0[isamp]
                         << " RMS=" << eyvec[isamp] );
      }
    }
    
    if (yvec0[isamp] > maxsamp) {
      // initial time guess based on
      // sample with maximum value
      maxsamp = yvec0[isamp];
      ipeakMax = j;
    }
    if (yvec0[isamp] < minsamp) {
      minsamp = yvec0[isamp];
      ipeakMin = j;
    }
    ATH_MSG_VERBOSE ( "isamp=" << isamp
                     << ", xvec=" << xvec[isamp]
                     << ", yvec0=" << yvec0[isamp]
                     << ", eyvec=" << eyvec[isamp] );
  }
 
  if (no_signal) {
    ATH_MSG_VERBOSE ( "No signal detected" );
    return;
  }
 
  // Make an initial guess about pedestal
  double pedg = (yvec0[0] + yvec0[nfit - 1]) / 2.0;
 
  // Position of max sample compared to nominal peak position
  int delta_peak = 0;
  // Time offset in pulse functions
  m_t0Fit = 0.0;
  // Flag for fixed time in fit
  bool fixedTime = (m_maxIterate < 0);
  
  if (!fixedTime) {
    if (maxsamp - pedg > m_noiseThresholdRMS * rms) {
      delta_peak = ipeakMax - m_iPeak0;  // Adjust initial phase guess,
      m_t0Fit = (delta_peak) * DTIME;       // positive amplitude
    } else if (pedg - minsamp > m_noiseThresholdRMS * rms) {
      delta_peak = ipeakMin - m_iPeak0;       // Adjust initial phase guess,
      m_t0Fit = (delta_peak) * DTIME;     // negative amplitude
    } else {
      fixedTime = true; // no signal above noise
      m_t0Fit = 0.0;    // fit with fixed time
    }
  }
  
  ATH_MSG_VERBOSE ( " initial value of t0fit=" << m_t0Fit
                   << " ipeakMax=" << ipeakMax
                   << " ipeakMin=" << ipeakMin
                   << " fixedTime=" << ((fixedTime) ? "true" : "false") );
 
  const std::vector<double>* tpulse = &m_dummy;
  const std::vector<double>* ypulse = &m_dummy;
  const std::vector<double>* tdpulse = &m_dummy;
  const std::vector<double>* dpulse = &m_dummy;
  const std::vector<double>* tleak = &m_dummy;
  const std::vector<double>* yleak = &m_dummy;
  const std::vector<double>* tdleak = &m_dummy;
  const std::vector<double>* dleak = &m_dummy;
  
  if (m_idocis && ((m_cischan == -1) || (channel == m_cischan))) { // CIS pulse
    if (igain == 0) { // low gain
      if (m_capdaq > 10) { // 100 pF capacitor
        tpulse = &(m_pulseShapes->m_tlcis);
        ypulse = &(m_pulseShapes->m_ylcis);
        tdpulse = &(m_pulseShapes->m_tdlcis);
        dpulse = &(m_pulseShapes->m_ydlcis);
        tleak = &(m_pulseShapes->m_tleaklo);
        yleak = &(m_pulseShapes->m_leaklo);
        tdleak = &(m_pulseShapes->m_tdleaklo);
        dleak = &(m_pulseShapes->m_dleaklo);
      } else { // 5.2 pF capacitor
        tpulse = &(m_pulseShapes->m_tslcis);
        ypulse = &(m_pulseShapes->m_yslcis);
        tdpulse = &(m_pulseShapes->m_tdslcis);
        dpulse = &(m_pulseShapes->m_ydslcis);
        tleak = &(m_pulseShapes->m_tsleaklo);
        yleak = &(m_pulseShapes->m_sleaklo);
        tdleak = &(m_pulseShapes->m_tdsleaklo);
        dleak = &(m_pulseShapes->m_dsleaklo);
      }
    } else { // igain==1 => high-gain
      if (m_capdaq > 10) { // 100 pF capacitor
        tpulse = &(m_pulseShapes->m_thcis);
        ypulse = &(m_pulseShapes->m_yhcis);
        tdpulse = &(m_pulseShapes->m_tdhcis);
        dpulse = &(m_pulseShapes->m_ydhcis);
        tleak = &(m_pulseShapes->m_tleakhi);
        yleak = &(m_pulseShapes->m_leakhi);
        tdleak = &(m_pulseShapes->m_tdleakhi);
        dleak = &(m_pulseShapes->m_dleakhi);
      } else { // 5.2 pF capacitor
        tpulse = &(m_pulseShapes->m_tshcis);
        ypulse = &(m_pulseShapes->m_yshcis);
        tdpulse = &(m_pulseShapes->m_tdshcis);
        dpulse = &(m_pulseShapes->m_ydshcis);
        tleak = &(m_pulseShapes->m_tsleakhi);
        yleak = &(m_pulseShapes->m_sleakhi);
        tdleak = &(m_pulseShapes->m_tdsleakhi);
        dleak = &(m_pulseShapes->m_dsleakhi);
      }
    }
  } else {
    if (m_idolas) { // laser pulse
      if (igain == 0) { // low gain
        tpulse = &(m_pulseShapes->m_tllas);
        ypulse = &(m_pulseShapes->m_yllas);
        tdpulse = &(m_pulseShapes->m_tdllas);
        dpulse = &(m_pulseShapes->m_ydllas);
      } else { // igain==1 => high-gain
        tpulse = &(m_pulseShapes->m_thlas);
        ypulse = &(m_pulseShapes->m_yhlas);
        tdpulse = &(m_pulseShapes->m_tdhlas);
        dpulse = &(m_pulseShapes->m_ydhlas);
      }
    } else { // physics pulse
      if (igain == 0) { // low gain
        tpulse = &(m_pulseShapes->m_tlphys);
        ypulse = &(m_pulseShapes->m_ylphys);
        tdpulse = &(m_pulseShapes->m_tdlphys);
        dpulse = &(m_pulseShapes->m_ydlphys);
      } else { // igain==1 => high-gain
        tpulse = &(m_pulseShapes->m_thphys);
        ypulse = &(m_pulseShapes->m_yhphys);
        tdpulse = &(m_pulseShapes->m_tdhphys);
        dpulse = &(m_pulseShapes->m_ydhphys);
      }
    }
  }
  
  // Variables used for iterative fitting
  double gval, gpval, sy, syg, sygp, sg, sgp, sgg, sgpgp, sggp, serr, err2;
  double dgg0, dgg, dggp, dgpgp, dyg, dygp, dg, dc, xd;
  double sllp, sylp, slplp, dleakage, leakage;
  double fixtau = 0.0, fixped = 0.0, fixampl = 0.0, fixchi2 = MAX_CHI2;
  double leaktau = 0.0, leakped = 0.0, leakampl = 0.0, leakchi2 = MAX_CHI2;
  double cistau = 0.0, cisped = 0.0, cisampl = 0.0, cisatau = 0.0, cischi2 = MAX_CHI2;
  double tau, ped, ampl, atau = 0.0, tempChi2 = MAX_CHI2, oldchi2 = MAX_CHI2 / 2;
 
  // number of iterations
  int niter = 0;
  do {
    ++niter;
    ATH_MSG_VERBOSE ( "niter=" << niter << " maxIterate=" << m_maxIterate );
 
    if (tempChi2 < oldchi2) oldchi2 = tempChi2; // best chi2 up to now
 
    // parameters for pulse shape functions
    // 0. phase
    m_fnParameters[0] = 0.0;
    // 1. pedestal 
    m_fnParameters[1] = 0.0;
    // 2. amplitude
    m_fnParameters[2] = 1.0;
 
    // CIS events linear fit
    if (m_idocis && ((m_cischan == -1) || (channel == m_cischan))) {
      ATH_MSG_VERBOSE ( "Fit time with leakage" );
      // CIS Part (A): fit for time using leakage pulse
      sllp = 0.0;
      sylp = 0.0;
      slplp = 0.0;
      for (int isamp = 0; isamp < nfit; ++isamp) {
        ATH_MSG_VERBOSE ( "Lo gain leakage xvec[" << isamp << "]=" << xvec[isamp] );
 
        leakage = pulse(xvec[isamp], tleak, yleak);
        dleakage = derivative(xvec[isamp], tdleak, dleak);
 
        // Samples with pedestal subtracted
        yvec[isamp] = yvec0[isamp] - pedg;
 
        ATH_MSG_VERBOSE ( " yvec[" << isamp << "]=" << yvec[isamp]
                         << " yvec0[" << isamp << "]=" << yvec0[isamp]
                         << " pedg=" << pedg );
 
        sllp += leakage * dleakage;
        sylp += yvec[isamp] * dleakage;
        slplp += dleakage * dleakage;
      }
      // Also allow for fixed-time fit to CIS events
      if (fabs(slplp) > EPS_DG && !fixedTime) {
        leaktau = (sllp - sylp) / slplp;
        // Also have to check the range for leaktau
        if (leaktau > m_maxTau)
          leaktau = m_maxTau;
        else if (leaktau < m_minTau) leaktau = m_minTau;
      } else {
        leaktau = 0.0;
      }
      
      ATH_MSG_VERBOSE ( " sllp=" << sllp
                      << " sylp=" << sylp
                      << " slplp=" << slplp
                      << " leaktau=" << leaktau );
 
      // CIS Part (B): using phase determined in part (A), 
      // subtract leakage pedestal and fit for amplitude, pedestal
      m_fnParameters[0] = leaktau;
      sy = 0.0;
      sg = 0.0;
      syg = 0.0;
      sgg = 0.0;
      serr = 0.0;
      for (int isamp = 0; isamp < nfit; ++isamp) {
        leakage = pulse(xvec[isamp], tleak, yleak);
        gval = scaledPulse(xvec[isamp], tpulse, ypulse);
        yvec[isamp] = yvec0[isamp] - leakage;
 
        ATH_MSG_VERBOSE ( " yvec[" << isamp << "]=" << yvec[isamp]
                         << " yvec0[" << isamp << "]=" << yvec0[isamp]
                         << " leakage=" << leakage );
 
        err2 = eyvec[isamp] * eyvec[isamp];
        sy += yvec[isamp] / err2;
        sg += gval / err2;
        syg += yvec[isamp] * gval / err2;
        sgg += gval * gval / err2;
        serr += 1.0 / err2;
      }
      dgg0 = sg * sg - serr * sgg;
      if (fabs(dgg0) > EPS_DG) {
        leakampl = (sy * sg - serr * syg) / dgg0;
        leakped = (syg * sg - sy * sgg) / dgg0;
      } else {
        leakampl = 0.0;
        leakped = sy / serr;
      }
 
      // Determine Chi2 for corresponding function  for CIS leakage + pulse
      ATH_MSG_VERBOSE ( " Determine Chi2 for CIS leakage + pulse" );
      
      leakchi2 = 0.0;
      m_fnParameters[0] = leaktau;
      m_fnParameters[1] = leakped;
      m_fnParameters[2] = leakampl;
      for (int isamp = 0; isamp < nfit; ++isamp) {
        gval = scaledPulse(xvec[isamp], tpulse, ypulse);
        leakage = pulse(xvec[isamp], tleak, yleak);
        xd = yvec0[isamp] - (gval + leakage);
        leakchi2 = leakchi2 + (xd * xd) / (eyvec[isamp] * eyvec[isamp]);
 
        ATH_MSG_VERBOSE ( " isamp=" << isamp
                         << " yvec0[" << isamp << "]=" << yvec0[isamp]
                         << " gval=" << gval
                         << ", leakage=" << leakage
                         << ", xd=" << xd );
      }
      leakchi2 = leakchi2 / (nfit - 3.0);
 
      ATH_MSG_VERBOSE ( " leaktau=" << leaktau
                       << " leakped=" << leakped
                       << " leakampl=" << leakampl
                       << " leakchi2=" << leakchi2 );
      
      // CIS Part C: Least-squares fit with 3 parameters for pulse+leakage
      if (!fixedTime) {
        m_fnParameters[0] = 0.0;
        m_fnParameters[1] = 0.0;
        m_fnParameters[2] = 0.0;
        for (int isamp = 0; isamp < nfit; ++isamp) {
          leakage = pulse(xvec[isamp], tleak, yleak);
 
          // Subtract leakage from samples
          yvec[isamp] = yvec0[isamp] - leakage;
 
          ATH_MSG_VERBOSE ( " isamp=" << isamp
                          << " yvec0[" << isamp << "]=" << yvec0[isamp]
                          << " leakage=" << leakage
                          << " yvec[" << isamp << "]=" << yvec[isamp] );
        }
        m_fnParameters[0] = 0.0;
        m_fnParameters[1] = 0.0;
        m_fnParameters[2] = 1.0;
        sy = 0.0;
        sg = 0.0;
        sgp = 0.0;
        syg = 0.0;
        sygp = 0.0;
        sgg = 0.0;
        sggp = 0.0;
        sgpgp = 0.0;
        serr = 0.0;
        for (int isamp = 0; isamp < nfit; ++isamp) {
          gval = scaledPulse(xvec[isamp], tpulse, ypulse);
          gpval = derivative(xvec[isamp], tdpulse, dpulse);
          err2 = eyvec[isamp] * eyvec[isamp];
          sy += yvec[isamp] / err2;
          sg += gval / err2;
          sgp += gpval / err2;
          syg += yvec[isamp] * gval / err2;
          sygp += yvec[isamp] * gpval / err2;
          sgg += gval * gval / err2;
          sggp += gval * gpval / err2;
          sgpgp += gpval * gpval / err2;
          serr += 1.0 / err2;
        }
        dgg = sgg - sg * sg / serr;
        dggp = sggp - sg * sgp / serr;
        dgpgp = sgpgp - sgp * sgp / serr;
        dyg = syg - sy * sg / serr;
        dygp = sygp - sy * sgp / serr;
        dg = dgg * dgpgp - dggp * dggp;
 
        if (fabs(dg) > EPS_DG) {
          cisampl = (dyg * dgpgp - dygp * dggp) / dg;
          cisatau = (dyg * dggp - dygp * dgg) / dg;
          cisped = (sy
              - (dyg * dgpgp * sg - dygp * dggp * sg + dyg * dggp * sgp - dygp * dgg * sgp) / dg)
              / serr;
 
          if (fabs(cisampl) > EPS_DG) {
            cistau = cisatau / cisampl;
            if (cistau > m_maxTau)
              cistau = m_maxTau;
            else if (cistau < m_minTau) cistau = m_minTau;
          } else {
            cistau = 0.0;
          }
        } else {
          cisampl = 0.0;
          cisatau = 0.0;
          cistau = 0.0;
          cisped = sy / serr;
        }
 
        if (msgLvl(MSG::VERBOSE)) {
          msg(MSG::VERBOSE) << " sy=" << sy
                            << " sg=" << sg
                            << " sgp=" << sgp
                            << " syg=" << syg
                            << " sygp=" << sygp
                            << " sgg=" << sgg
                            << " sggp=" << sggp
                            << " sgpgp=" << sgpgp << endmsg;
 
          msg(MSG::VERBOSE) << " dgg=" << dgg
                            << " dggp=" << dggp
                            << " sgpgp=" << sgpgp
                            << " dyg=" << dyg
                            << " dygp=" << dygp
                            << " dg=" << dg << endmsg;
 
          msg(MSG::VERBOSE) << " cistau=" << cistau
                            << " cisped=" << cisped
                            << " cisampl=" << cisampl << endmsg;
        }
 
        // Determine Chi2 for pulse shape + leakage fit CIS Part C
        cischi2 = 0.0;
        m_fnParameters[0] = cistau;
        m_fnParameters[1] = cisped;
        m_fnParameters[2] = cisampl;
        for (int isamp = 0; isamp < nfit; ++isamp) {
          gval = scaledPulse(xvec[isamp], tpulse, ypulse);
          leakage = pulse(xvec[isamp], tleak, yleak);
          // Subtract leakage from samples
          yvec[isamp] = yvec0[isamp] - leakage;
          xd = yvec[isamp] - gval;
          cischi2 = cischi2 + (xd * xd) / (eyvec[isamp] * eyvec[isamp]);
 
          ATH_MSG_VERBOSE( " yvec0[" << isamp << "]=" << yvec0[isamp]
                          << " yvec[" << isamp << "]=" << yvec[isamp]
                          << " leakage=" << leakage
                          << " gval=" << gval
                          << " xd=" << xd );
        }
        cischi2 = cischi2 / (nfit - 3.0);
        
        ATH_MSG_VERBOSE ( " cischi2=" << cischi2 );
      }
 
      // Determine which set of parameters to use from CIS fit methods based on minimum chi2
      if ((cischi2 < leakchi2) && !fixedTime) {
        tau = cistau;
        ped = cisped;
        ampl = cisampl;
        tempChi2 = cischi2;
      } else {
        tau = leaktau;
        ped = leakped;
        ampl = leakampl;
        tempChi2 = leakchi2;
      }
    }
    // End of fit for CIS events
 
    else {    // Physics and laser events
 
      if (niter == 1) { /* For first iteration, also calculate 2-Parameter Fit
       for pedestal and amplitude */
        double t0fit_old = m_t0Fit;
        m_t0Fit = 0.0;
 
        sy = 0.0;
        sg = 0.0;
        sgg = 0.0;
        syg = 0.0;
        serr = 0.0;
 
        for (int isamp = 0; isamp < nfit; ++isamp) {
          if (!m_idolas) {
            // Use initial values for speeding up the physics events
            int jsamp = (int) xvec[isamp] - delta_peak;
            if (jsamp < 0)
              jsamp = 0;
            else if (jsamp >= nfit) jsamp = nfit - 1;
 
            if (igain == 0) {
              gval = m_gPhysLo[jsamp];
            } else {
              gval = m_gPhysHi[jsamp];
            }
          } else {
            gval = scaledPulse(xvec[isamp], tpulse, ypulse);
          }
          err2 = eyvec[isamp] * eyvec[isamp];
          sy += yvec0[isamp] / err2;
          sg += gval / err2;
          syg += yvec0[isamp] * gval / err2;
          sgg += gval * gval / err2;
          serr += 1.0 / err2;
        }
        fixtau = 0.0;
        dgg0 = sg * sg - serr * sgg;
        if (fabs(dgg0) > EPS_DG) {
          fixampl = (sy * sg - serr * syg) / dgg0;
          fixped = (syg * sg - sy * sgg) / dgg0;
          ATH_MSG_VERBOSE ( "  2-par fit:"
                           << " fixampl = " << fixampl
                           << " fixped = " << fixped );
        } else {
          fixampl = 0.0;
          fixped = sy / serr;
          ATH_MSG_VERBOSE ( "  2-par fit:"
                          << " small dgg0 = " << dgg0
                          << ", fixampl = " << fixampl
                          << " fixped = " << fixped  );
        }
        m_fnParameters[0] = fixtau; /* 2-Par fit Calculate chi2 for physics events */
        m_fnParameters[1] = fixped;
        m_fnParameters[2] = fixampl;
        fixchi2 = 0.0;
        for (int isamp = 0; isamp < nfit; ++isamp) {
          dc = yvec0[isamp] - scaledPulse(xvec[isamp], tpulse, ypulse);
          fixchi2 = fixchi2 + (dc * dc) / (eyvec[isamp] * eyvec[isamp]);
          ATH_MSG_VERBOSE ( "   isamp= " << isamp
                           << " yvec0[" << isamp << "]= " << yvec0[isamp]
                           << " eyvec[" << isamp << "]= " << eyvec[isamp]
                           << " fixchi2= " << fixchi2  );
        }
        fixchi2 = fixchi2 / (nfit - 2.0);
        ATH_MSG_VERBOSE ( "  fixchi2/(nfit-2.0)=" << fixchi2 << " nfit=" << nfit );
 
        m_t0Fit = t0fit_old;
 
        // restore initial parameters for pulse shape functions - to be used in 3-par fit
        m_fnParameters[0] = 0.0;
        m_fnParameters[1] = 0.0;
        m_fnParameters[2] = 1.0;
      } /* end of 2-par fit in first iteration */
 
      if (fixedTime) {
        m_t0Fit = 0.0;
        tau = fixtau;
        ped = fixped;
        ampl = fixampl;
        tempChi2 = oldchi2 = -fabs(fixchi2);
      } else {
 
        sy = 0.0;
        sg = 0.0;
        sgp = 0.0;
        syg = 0.0;
        sygp = 0.0;
        sgg = 0.0;
        sggp = 0.0;
        sgpgp = 0.0;
        serr = 0.0;
 
        for (int isamp = 0; isamp < nfit; ++isamp) {
          if ((niter == 1) && (!m_idolas)) {
            // Use initial function values stored in array for niter=1 physics
            // XXX: double->int
            int jsamp = (int) xvec[isamp] - delta_peak;
            if (jsamp < 0)
              jsamp = 0;
            else if (jsamp >= nfit) jsamp = nfit - 1;
 
            if (igain == 0) {       // igain ==0 => low-gain
              gval = m_gPhysLo[jsamp];
              gpval = m_dgPhysLo[jsamp];
            } else {              // must be igain==1 => high-gain
              gval = m_gPhysHi[jsamp];
              gpval = m_dgPhysHi[jsamp];
            }
          } else {
            // Use the respective function values
            gval = scaledPulse(xvec[isamp], tpulse, ypulse);
            gpval = derivative(xvec[isamp], tdpulse, dpulse);
          }
 
          err2 = eyvec[isamp] * eyvec[isamp];
          sy += yvec0[isamp] / err2;
          sg += gval / err2;
          sgp += gpval / err2;
          syg += yvec0[isamp] * gval / err2;
          sygp += yvec0[isamp] * gpval / err2;
          sgg += gval * gval / err2;
          sggp += gval * gpval / err2;
          sgpgp += gpval * gpval / err2;
          serr += 1.0 / err2;
 
          ATH_MSG_VERBOSE ( " isamp=" << isamp
                          << " gval=" << gval
                          << " sg=" << sg
                          << " gpval=" << gpval
                          << " sgp=" << sgp );
        }
 
        dgg = sgg - sg * sg / serr;
        dggp = sggp - sg * sgp / serr;
        dgpgp = sgpgp - sgp * sgp / serr;
        dyg = syg - sy * sg / serr;
        dygp = sygp - sy * sgp / serr;
        dg = dgg * dgpgp - dggp * dggp;
 
        // Fit for time, pedestal, and amplitude
        if (fabs(dg) > EPS_DG) {
          // Amplitude           : ampl
          ampl = (dyg * dgpgp - dygp * dggp) / dg;
          // and Amplitude * time: atau
          atau = (dyg * dggp - dygp * dgg) / dg;
          // Pedestal
          ped = (sy - ((dyg * dgpgp - dygp * dggp) * sg + (dyg * dggp - dygp * dgg) * sgp) / dg)
              / serr;
 
          if (fabs(ampl) > EPS_DG) {
            // Time
            tau = atau / ampl;
            if (tau > m_maxTau)
              tau = m_maxTau;
            else if (tau < m_minTau) tau = m_minTau;
          } else {
            tau = 0.0;
          }
        } else {
          ampl = 0.0;
          atau = 0.0;
          tau = 0.0;
          ped = sy / serr;
        }
 
        if (msgLvl(MSG::VERBOSE)) {
          msg(MSG::VERBOSE) << " ped=" << ped << endmsg;
          msg(MSG::VERBOSE) << " sy=" << sy
                            << " sg=" << sg
                            << " sgp=" << sgp << endmsg;
 
          msg(MSG::VERBOSE) << " syg=" << syg
                            << " sygp=" << sygp
                            << " sgg=" << sgg << endmsg;
 
          msg(MSG::VERBOSE) << " sggp=" << sggp
                            << " sgpgp=" << sgpgp << endmsg;
 
          msg(MSG::VERBOSE) << " ampl = (dyg*dgpgp - dygp*dggp)= " << ampl << endmsg;
 
          msg(MSG::VERBOSE) << " dyg=" << dyg
                            << " dgpgp=" << dgpgp
                            << " dyg*dgpgp=" << (dyg * dgpgp) << endmsg;
 
          msg(MSG::VERBOSE) << " dygp=" << dygp
                            << " dggp=" << dggp
                            << " dygp*dggp=" << (dygp * dggp) << endmsg;
 
          msg(MSG::VERBOSE) << " dyg=" << dyg
                            << " dggp=" << dggp
                            << " dyg*dggp=" << (dyg * dggp) << endmsg;
 
          msg(MSG::VERBOSE) << " dygp=" << dygp
                            << " dgg=" << dgg
                            << " dygp*dgg=" << (dygp * dgg) << endmsg;
 
          msg(MSG::VERBOSE) << " dg=" << dg
                            << " atau=" << atau
                            << " tau=" << tau << endmsg;
        }
 
        m_fnParameters[0] = tau;
        m_fnParameters[1] = ped;
        m_fnParameters[2] = ampl;
 
        tempChi2 = 0;
        // Calculate chi2 for physics and laser events
        for (int isamp = 0; isamp < nfit; ++isamp) {
          dc = yvec0[isamp] - scaledPulse(xvec[isamp], tpulse, ypulse);
          tempChi2 = tempChi2 + (dc * dc) / (eyvec[isamp] * eyvec[isamp]);
          ATH_MSG_VERBOSE ( " isamp=" << isamp
                            << " yvec0[" << isamp << "]=" << yvec0[isamp]
                            << " eyvec[" << isamp << "]=" << eyvec[isamp]
                            << " dc=" << dc << " chi2=" << tempChi2 );
        }
        tempChi2 = tempChi2 / (nfit - 3.0);
        ATH_MSG_VERBOSE ( " chi2/(nfit-3.0)=" << tempChi2 << " nfit=" << nfit );
      } // end if fixedTime
    } // end of physics and laser specific part
 
    if (msgLvl(MSG::VERBOSE))
      msg(MSG::VERBOSE) << " t0fit: " << m_t0Fit << ((tau < 0.0) ? " - " : " + ") << fabs(tau);
 
    // avoid infinite loop at the boundary
    if (fabs(m_t0Fit - m_maxTime) < 0.001 && tau >= 0.0) { // trying to go outside max boudary second time
      m_t0Fit = fixtau + (m_minTime - fixtau) * niter / m_maxIterate; // jump to negative time
      if (msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << " jumping to " << m_t0Fit << endmsg;
      tempChi2 = MAX_CHI2;
    } else if (fabs(m_t0Fit - m_minTime) < 0.001 && tau <= 0.0) { // trying to go outside min boudary second time
      m_t0Fit = fixtau + (m_maxTime - fixtau) * niter / m_maxIterate; // jump to positive time
      if (msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << " jumping to " << m_t0Fit << endmsg;
      tempChi2 = MAX_CHI2;
    } else {
 
      // Iteration with parameter for time 
      m_t0Fit += tau;
      if (msgLvl(MSG::VERBOSE)) msg(MSG::VERBOSE) << " = " << m_t0Fit << endmsg;
 
      // Check if total time does not exceed the limits:
      if (m_t0Fit > m_maxTime) {
        m_t0Fit = m_maxTime;
        tempChi2 = MAX_CHI2;
      } else if (m_t0Fit < m_minTime) {
        m_t0Fit = m_minTime;
        tempChi2 = MAX_CHI2;
      }
    }
    
    // save values of the best iteration
    if (tempChi2 < chi2) {
      time = m_t0Fit;
      pedestal = ped;
      amplitude = ampl;
      chi2 = tempChi2;
    }
 
    if (!fixedTime && tempChi2 < MAX_CHI2 && fabs(tau) < EPS_DG) { // too small tau
      if (m_t0Fit > fixtau)
        m_t0Fit = fixtau + (m_minTime - fixtau) * niter / m_maxIterate; // jump to negative time
      else
        m_t0Fit = fixtau + (m_maxTime - fixtau) * niter / m_maxIterate; // jump to positive time
 
      ATH_MSG_VERBOSE ( " too small tau - jump to " << m_t0Fit );
    }
    
    ATH_MSG_VERBOSE ( " iter=" << niter
                     << " t0fit=" << m_t0Fit
                     << " phase=" << tau
                     << " ped=" << ped
                     << " ampl=" << ampl
                     << " chi2=" << tempChi2 );
 
  } while (fabs(tempChi2 - oldchi2) > DELTA_CHI2 && (niter < m_maxIterate));
  
  //NGO never use the 2par fit result if non-pedestal event was detected!
//   if ((fabs(fixchi2) <= fabs(p_chi2)) && 
//       !(m_idocis && ((m_cischan == -1) || (channel == m_cischan)))) {
//     /* results from 2-par fit */
//     p_time      = fixtau;
//     p_pedestal  = fixped;
//     p_amplitude = fixampl;
//     p_chi2      = - fabs(fixchi2);
//   }
 
// TD: fit converged, now one extra iteration, leaving out the samples that
// are more then m_MaxTimeFromPeak ns from the peak. We want to avoid to 
// extrapolate the pulse shape beyond the region where it is known.
 
// Do it only in case when at least last sample is beyond m_MaxTimeFromPeak:
  if ((nfit - 1 - m_iPeak0) * DTIME > time + m_maxTimeFromPeak) {
 
    ATH_MSG_VERBOSE ( "Result before last iteration:"
                     << " Time=" << time
                     << " Ped=" << pedestal
                     << " Amplitude=" << amplitude
                     << " Chi2=" << chi2);
 
    m_t0Fit = time;
    int nfit_real;
 
    // parameters for pulse shape functions
    // 0. phase
    m_fnParameters[0] = 0.0;
    // 1. pedestal 
    m_fnParameters[1] = 0.0;
    // 2. amplitude
    m_fnParameters[2] = 1.0;
 
    // CIS events linear fit
    if (m_idocis && ((m_cischan == -1) || (channel == m_cischan))) {
      if (!fixedTime) {
        ATH_MSG_VERBOSE ( "Fit time with leakage" );
        // CIS Part (A): fit for time using leakage pulse
        sllp = 0.0;
        sylp = 0.0;
        slplp = 0.0;
        for (int isamp = 0;
            (isamp < nfit) && (DTIME * (isamp - m_iPeak0) - m_t0Fit < m_maxTimeFromPeak); ++isamp) {
          ATH_MSG_VERBOSE ( "Lo gain leakage xvec[" << isamp << "]=" << xvec[isamp] );
 
          leakage = pulse(xvec[isamp], tleak, yleak);
          dleakage = derivative(xvec[isamp], tdleak, dleak);
 
          // Samples with pedestal subtracted
          yvec[isamp] = yvec0[isamp] - pedg;
 
          ATH_MSG_VERBOSE ( " yvec[" << isamp << "]=" << yvec[isamp]
                           << " yvec0[" << isamp << "]=" << yvec0[isamp]
                           << " pedg=" << pedg );
 
          sllp += leakage * dleakage;
          sylp += yvec[isamp] * dleakage;
          slplp += dleakage * dleakage;
        }
        // Also allow for fixed-time fit to CIS events
        if (fabs(slplp) > EPS_DG && !fixedTime) {
          leaktau = (sllp - sylp) / slplp;
          // Also have to check the range for leaktau
          if (leaktau > m_maxTau)
            leaktau = m_maxTau;
          else if (leaktau < m_minTau) leaktau = m_minTau;
        } else {
          leaktau = 0.0;
        }
 
        ATH_MSG_VERBOSE ( " sllp=" << sllp
                        << " sylp=" << sylp
                        << " slplp=" << slplp
                        << " leaktau=" << leaktau );
 
        // CIS Part (B): using phase determined in part (A), 
        // subtract leakage pedestal and fit for amplitude, pedestal
        m_fnParameters[0] = leaktau;
        sy = 0.0;
        sg = 0.0;
        syg = 0.0;
        sgg = 0.0;
        serr = 0.0;
        for (int isamp = 0;
            (isamp < nfit) && (DTIME * (isamp - m_iPeak0) - m_t0Fit < m_maxTimeFromPeak); ++isamp) {
          leakage = pulse(xvec[isamp], tleak, yleak);
          gval = scaledPulse(xvec[isamp], tpulse, ypulse);
          yvec[isamp] = yvec0[isamp] - leakage;
 
          ATH_MSG_VERBOSE ( " yvec[" << isamp << "]=" << yvec[isamp]
                           << " yvec0[" << isamp << "]=" << yvec0[isamp]
                           << " leakage=" << leakage );
 
          err2 = eyvec[isamp] * eyvec[isamp];
          sy += yvec[isamp] / err2;
          sg += gval / err2;
          syg += yvec[isamp] * gval / err2;
          sgg += gval * gval / err2;
          serr += 1.0 / err2;
        }
        dgg0 = sg * sg - serr * sgg;
        if (fabs(dgg0) > EPS_DG) {
          leakampl = (sy * sg - serr * syg) / dgg0;
          leakped = (syg * sg - sy * sgg) / dgg0;
        } else {
          leakampl = 0.0;
          if (serr == 0.)[[unlikely]]{
            ATH_MSG_ERROR("serr is zero in TileRawChannelBuilderFitFilterCool::pulseFit");
            return;
          }
          leakped = sy / serr;
        }
 
        // Determine Chi2 for corresponding function  for CIS leakage + pulse
        ATH_MSG_VERBOSE( " Determine Chi2 for CIS leakage + pulse");
 
        leakchi2 = 0.0;
        nfit_real = 0;
        m_fnParameters[0] = leaktau;
        m_fnParameters[1] = leakped;
        m_fnParameters[2] = leakampl;
        for (int isamp = 0;
            (isamp < nfit) && (DTIME * (isamp - m_iPeak0) - m_t0Fit < m_maxTimeFromPeak); ++isamp) {
          ++nfit_real;
          gval = scaledPulse(xvec[isamp], tpulse, ypulse);
          leakage = pulse(xvec[isamp], tleak, yleak);
          xd = yvec0[isamp] - (gval + leakage);
          leakchi2 = leakchi2 + (xd * xd) / (eyvec[isamp] * eyvec[isamp]);
 
          ATH_MSG_VERBOSE ( " isamp=" << isamp
                           << " yvec0[" << isamp << "]=" << yvec0[isamp]
                           << " gval=" << gval
                           << ", leakage=" << leakage
                           << ", xd=" << xd );
        }
        leakchi2 = leakchi2 / (nfit_real - 3.0);
 
        ATH_MSG_VERBOSE ( " leaktau=" << leaktau
                         << " leakped=" << leakped
                         << " leakampl=" << leakampl
                         << " leakchi2=" << leakchi2 );
 
        // CIS Part C: Least-squares fit with 3 parameters for pulse+leakage
        m_fnParameters[0] = 0.0;
        m_fnParameters[1] = 0.0;
        m_fnParameters[2] = 0.0;
        for (int isamp = 0;
            (isamp < nfit) && (DTIME * (isamp - m_iPeak0) - m_t0Fit < m_maxTimeFromPeak); ++isamp) {
 
          leakage = pulse(xvec[isamp], tleak, yleak);
 
          // Subtract leakage from samples
          yvec[isamp] = yvec0[isamp] - leakage;
 
          ATH_MSG_VERBOSE ( " isamp=" << isamp
                           << " yvec0[" << isamp << "]=" << yvec0[isamp]
                           << " leakage=" << leakage
                           << " yvec[" << isamp << "]=" << yvec[isamp] );
        }
        m_fnParameters[0] = 0.0;
        m_fnParameters[1] = 0.0;
        m_fnParameters[2] = 1.0;
        sy = 0.0;
        sg = 0.0;
        sgp = 0.0;
        syg = 0.0;
        sygp = 0.0;
        sgg = 0.0;
        sggp = 0.0;
        sgpgp = 0.0;
        serr = 0.0;
        for (int isamp = 0;
            (isamp < nfit) && (DTIME * (isamp - m_iPeak0) - m_t0Fit < m_maxTimeFromPeak); ++isamp) {
          gval = scaledPulse(xvec[isamp], tpulse, ypulse);
          gpval = derivative(xvec[isamp], tdpulse, dpulse);
          err2 = eyvec[isamp] * eyvec[isamp];
          sy += yvec[isamp] / err2;
          sg += gval / err2;
          sgp += gpval / err2;
          syg += yvec[isamp] * gval / err2;
          sygp += yvec[isamp] * gpval / err2;
          sgg += gval * gval / err2;
          sggp += gval * gpval / err2;
          sgpgp += gpval * gpval / err2;
          serr += 1.0 / err2;
        }
        if (serr == 0) serr = 1;
        dgg = sgg - sg * sg / serr;
        dggp = sggp - sg * sgp / serr;
        dgpgp = sgpgp - sgp * sgp / serr;
        dyg = syg - sy * sg / serr;
        dygp = sygp - sy * sgp / serr;
        dg = dgg * dgpgp - dggp * dggp;
 
        if (fabs(dg) > EPS_DG) {
          cisampl = (dyg * dgpgp - dygp * dggp) / dg;
          cisatau = (dyg * dggp - dygp * dgg) / dg;
          cisped = (sy
              - (dyg * dgpgp * sg - dygp * dggp * sg + dyg * dggp * sgp - dygp * dgg * sgp) / dg)
              / serr;
 
          if (fabs(cisampl) > EPS_DG) {
            cistau = cisatau / cisampl;
            if (cistau > m_maxTau)
              cistau = m_maxTau;
            else if (cistau < m_minTau) cistau = m_minTau;
          } else {
            cistau = 0.0;
          }
        } else {
          cisampl = 0.0;
          cisatau = 0.0;
          cistau = 0.0;
          cisped = sy / serr;
        }
 
        if (msgLvl(MSG::VERBOSE)) {
          msg(MSG::VERBOSE) << " sy=" << sy
                            << " sg=" << sg
                            << " sgp=" << sgp
                            << " syg=" << syg
                            << " sygp=" << sygp
                            << " sgg=" << sgg
                            << " sggp=" << sggp
                            << " sgpgp=" << sgpgp << endmsg;
 
          msg(MSG::VERBOSE) << " dgg=" << dgg
                            << " dggp=" << dggp
                            << " sgpgp=" << sgpgp
                            << " dyg=" << dyg
                            << " dygp=" << dygp
                            << " dg=" << dg << endmsg;
 
          msg(MSG::VERBOSE) << " cistau=" << cistau
                            << " cisped=" << cisped
                            << " cisampl=" << cisampl << endmsg;
        }
 
        // Determine Chi2 for pulse shape + leakage fit CIS 
        cischi2 = 0.0;
        nfit_real = 0;
        m_fnParameters[0] = cistau;
        m_fnParameters[1] = cisped;
        m_fnParameters[2] = cisampl;
        for (int isamp = 0;
            (isamp < nfit) && (DTIME * (isamp - m_iPeak0) - m_t0Fit < m_maxTimeFromPeak); ++isamp) {
          ++nfit_real;
          gval = scaledPulse(xvec[isamp], tpulse, ypulse);
          leakage = pulse(xvec[isamp], tleak, yleak);
          // Subtract leakage from samples
          yvec[isamp] = yvec0[isamp] - leakage;
          xd = yvec[isamp] - gval;
          cischi2 = cischi2 + (xd * xd) / (eyvec[isamp] * eyvec[isamp]);
 
          ATH_MSG_VERBOSE ( " yvec0[" << isamp << "]=" << yvec0[isamp]
                           << " yvec[" << isamp << "]=" << yvec[isamp]
                           << " leakage=" << leakage
                           << " gval=" << gval
                           << " xd=" << xd );
        }
        cischi2 = cischi2 / (nfit_real - 3.0);
 
        ATH_MSG_VERBOSE ( " cischi2=" << cischi2 );
 
        // Determine which set of parameters to use from CIS fit methods based on minimum chi2
        if ((cischi2 < leakchi2) && !fixedTime) {
          tau = cistau;
          ped = cisped;
          ampl = cisampl;
          tempChi2 = cischi2;
        } else {
          tau = leaktau;
          ped = leakped;
          ampl = leakampl;
          tempChi2 = leakchi2;
        }
        // End of fit for CIS events
      }
    } else {    // Physics and laser events
      if (!fixedTime) {
 
        // restore initial parameters for pulse shape functions - to be used in 3-par fit
        m_fnParameters[0] = 0.0;
        m_fnParameters[1] = 0.0;
        m_fnParameters[2] = 1.0;
 
        sy = 0.0;
        sg = 0.0;
        sgp = 0.0;
        syg = 0.0;
        sygp = 0.0;
        sgg = 0.0;
        sggp = 0.0;
        sgpgp = 0.0;
        serr = 0.0;
 
        for (int isamp = 0;
            (isamp < nfit) && (DTIME * (isamp - m_iPeak0) - m_t0Fit < m_maxTimeFromPeak); ++isamp) {
          // Use the respective function values
          gval = scaledPulse(xvec[isamp], tpulse, ypulse);
          gpval = derivative(xvec[isamp], tdpulse, dpulse);
 
          err2 = eyvec[isamp] * eyvec[isamp];
          sy += yvec0[isamp] / err2;
          sg += gval / err2;
          sgp += gpval / err2;
          syg += yvec0[isamp] * gval / err2;
          sygp += yvec0[isamp] * gpval / err2;
          sgg += gval * gval / err2;
          sggp += gval * gpval / err2;
          sgpgp += gpval * gpval / err2;
          serr += 1.0 / err2;
 
          ATH_MSG_VERBOSE ( " isamp=" << isamp
                           << " gval=" << gval
                           << " sg=" << sg
                           << " gpval=" << gpval
                           << " sgp=" << sgp );
        }
 
        dgg = sgg - sg * sg / serr;
        dggp = sggp - sg * sgp / serr;
        dgpgp = sgpgp - sgp * sgp / serr;
        dyg = syg - sy * sg / serr;
        dygp = sygp - sy * sgp / serr;
        dg = dgg * dgpgp - dggp * dggp;
 
        // Fit for time, pedestal, and amplitude
        if (fabs(dg) > EPS_DG) {
          // Amplitude           : ampl 
          ampl = (dyg * dgpgp - dygp * dggp) / dg;
          // and Amplitude * time: atau
          atau = (dyg * dggp - dygp * dgg) / dg;
          // Pedestal
          ped = (sy - ((dyg * dgpgp - dygp * dggp) * sg + (dyg * dggp - dygp * dgg) * sgp) / dg)
              / serr;
 
          if (fabs(ampl) > EPS_DG) {
            // Time
            tau = atau / ampl;
            if (tau > m_maxTau)
              tau = m_maxTau;
            else if (tau < m_minTau) tau = m_minTau;
          } else {
            tau = 0.0;
          }
        } else {
          ampl = 0.0;
          atau = 0.0;
          tau = 0.0;
          ped = sy / serr;
        }
 
        if (msgLvl(MSG::VERBOSE)) {
          msg(MSG::VERBOSE) << " ped=" << ped << endmsg;
          msg(MSG::VERBOSE) << " sy=" << sy
                            << " sg=" << sg
                            << " sgp=" << sgp << endmsg;
 
          msg(MSG::VERBOSE) << " syg=" << syg
                            << " sygp=" << sygp
                            << " sgg=" << sgg << endmsg;
 
          msg(MSG::VERBOSE) << " sggp=" << sggp
                            << " sgpgp=" << sgpgp << endmsg;
 
          msg(MSG::VERBOSE) << " ampl = (dyg*dgpgp - dygp*dggp)= " << ampl << endmsg;
          msg(MSG::VERBOSE) << " dyg=" << dyg
                            << " dgpgp=" << dgpgp
                            << " dyg*dgpgp=" << (dyg * dgpgp) << endmsg;
 
          msg(MSG::VERBOSE) << " dygp=" << dygp
                            << " dggp=" << dggp
                            << " dygp*dggp=" << (dygp * dggp) << endmsg;
 
          msg(MSG::VERBOSE) << " dyg=" << dyg
                            << " dggp=" << dggp
                            << " dyg*dggp=" << (dyg * dggp) << endmsg;
 
          msg(MSG::VERBOSE) << " dygp=" << dygp
                            << " dgg=" << dgg
                            << " dygp*dgg=" << (dygp * dgg) << endmsg;
 
          msg(MSG::VERBOSE) << " dg=" << dg
                            << " atau=" << atau
                            << " tau=" << tau << endmsg;
        }
 
        m_fnParameters[0] = tau;
        m_fnParameters[1] = ped;
        m_fnParameters[2] = ampl;
 
        tempChi2 = 0;
        nfit_real = 0;
        // Calculate chi2 for physics and laser events
        for (int isamp = 0;
            (isamp < nfit) && (DTIME * (isamp - m_iPeak0) - m_t0Fit < m_maxTimeFromPeak); ++isamp) {
          ++nfit_real;
          dc = yvec0[isamp] - scaledPulse(xvec[isamp], tpulse, ypulse);
          tempChi2 = tempChi2 + (dc * dc) / (eyvec[isamp] * eyvec[isamp]);
          ATH_MSG_VERBOSE ( " isamp=" << isamp
                           << " yvec0[" << isamp << "]=" << yvec0[isamp]
                           << " eyvec[" << isamp << "]=" << eyvec[isamp]
                           << " dc=" << dc
                           << " chi2=" << tempChi2 );
        }
        tempChi2 = tempChi2 / (nfit_real - 3.0);
        ATH_MSG_VERBOSE ( " chi2/(nfit_real-3.0)=" << tempChi2
                         << " nfit_real=" << nfit_real );
      } // end if fixedTime
    } // end of physics and laser specific part
 
    if (msgLvl(MSG::VERBOSE))
      msg(MSG::VERBOSE) << " t0fit: " << m_t0Fit << ((tau < 0.0) ? " - " : " + ") << fabs(tau);
    // Iteration with parameter for time 
    m_t0Fit += tau;
    ATH_MSG_VERBOSE ( " = " << m_t0Fit );
 
    // Check if total time does not exceed the limits:
    if (m_t0Fit > m_maxTime) {
      m_t0Fit = m_maxTime;
      tempChi2 = MAX_CHI2;
    } else if (m_t0Fit < m_minTime) {
      m_t0Fit = m_minTime;
      tempChi2 = MAX_CHI2;
    }
 
    if (tempChi2 < MAX_CHI2) {
      time = m_t0Fit;
      pedestal = ped;
      amplitude = ampl;
      chi2 = tempChi2;
    } // otherwise using the previous iteration
    
  } // end if to use extra iteration
  
  ATH_MSG_VERBOSE ( "Result:"
                   << " Time=" << time
                   << " Ped=" << pedestal
                   << " Amplitude=" << amplitude
                   << " Chi2=" << chi2 );
}

rawChannel()

TileRawChannel * TileRawChannelBuilderFitFilterCool::rawChannel ( const TileDigits * digits, const EventContext & ctx )

overridevirtual

Builder virtual method to be implemented by subclasses.

Parameters

digits

Pointer to TileDigitsContainer

Reimplemented from TileRawChannelBuilder.

Definition at line 534 of file TileRawChannelBuilderFitFilterCool.cxx.

                                                                                                                {
 
  ++m_chCounter;
 
  const HWIdentifier adcId = digits->adc_HWID();
 
  ATH_MSG_VERBOSE ( "Running FitFilter for TileRawChannel with HWID "
                   << m_tileHWID->to_string(adcId) );
  
  // tmp variables for filtering
  double amplitude = 0.0;
  double chi2 = 0.0;
  double time = 0.0;
  double pedestal = 0.0;
 
  // use fit filter
  pulseFit(digits, amplitude, time, pedestal, chi2, ctx);
 
  unsigned int drawerIdx(0), channel(0), adc(0);
  m_tileIdTransforms->getIndices(adcId, drawerIdx, channel, adc);
  
  // fit filter calib
  // note that when called from TileROD_Decoder, m_calibrateEnergy is set
  // from TileROD_Decoder...
  if (m_calibrateEnergy) {
    amplitude = m_tileToolEmscale->doCalibCis(drawerIdx, channel, adc, amplitude);
  }
 
  ATH_MSG_VERBOSE ( "Creating RawChannel"
                   << " a=" << amplitude
                   << " t=" << time
                   << " q=" << chi2
                   << " ped=" << pedestal );
 
  // return new TileRawChannel
  //  TileRawChannel *rawCh = new TileRawChannel(adcId,amplitude,time,chi2,pedestal);
 
  DataPool<TileRawChannel> tileRchPool(m_dataPoollSize);
  TileRawChannel *rawCh = tileRchPool.nextElementPtr();
  rawCh->assign (adcId,
                 amplitude,
                 time,
                 chi2,
                 pedestal);
 
  if (m_correctTime && chi2 > 0) {
    time -= m_tileToolTiming->getSignalPhase(drawerIdx, channel, adc);
    rawCh->insertTime(time);
    ATH_MSG_VERBOSE ( "Correcting time, new time=" << rawCh->time() );
 
  }
  
  int gain = m_tileHWID->adc(adcId);
  if (TileID::HIGHGAIN == gain) {
    ++m_nChH;
    m_RChSumH += amplitude;
  } else {
    ++m_nChL;
    m_RChSumL += amplitude;
  }
 
  return rawCh;
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

resetDrawer()

void TileRawChannelBuilder::resetDrawer ( )

inherited

Definition at line 29 of file TileRawChannelBuilder.cxx.

                                        {
  m_lastDrawer = -1;
  m_badDrawer = false;
}

resetOverflows()

void TileRawChannelBuilder::resetOverflows ( void )

inherited

Definition at line 34 of file TileRawChannelBuilder.cxx.

                                           {
  m_overflows.clear();
}

scaledPulse()

double TileRawChannelBuilderFitFilterCool::scaledPulse ( double x, const std::vector< double > * xvec, const std::vector< double > * yvec ) const

inlineprivate

Definition at line 83 of file TileRawChannelBuilderFitFilterCool.h.

                                                                                                       {
      return m_fnParameters[1] + m_fnParameters[2] * pulse(x, xvec, yvec, false);
    }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_ADCmaskValueMinusEps

float TileRawChannelBuilder::m_ADCmaskValueMinusEps

protectedinherited

indicates channels which were masked in background dataset

Definition at line 222 of file TileRawChannelBuilder.h.

m_ADCmaxMinusEps

float TileRawChannelBuilder::m_ADCmaxMinusEps

protectedinherited

Definition at line 221 of file TileRawChannelBuilder.h.

m_ampMinThresh

float TileRawChannelBuilder::m_ampMinThresh

protectedinherited

correct amplitude if it's above amplitude threshold (in ADC counts)

Definition at line 152 of file TileRawChannelBuilder.h.

m_badDrawer

bool TileRawChannelBuilder::m_badDrawer = false

protectedinherited

Definition at line 210 of file TileRawChannelBuilder.h.

m_bsflags

unsigned int TileRawChannelBuilder::m_bsflags

protectedinherited

Definition at line 138 of file TileRawChannelBuilder.h.

m_cabling

const TileCablingService* TileRawChannelBuilder::m_cabling

protectedinherited

TileCabling instance.

Definition at line 182 of file TileRawChannelBuilder.h.

m_cablingSvc

ServiceHandle<TileCablingSvc> TileRawChannelBuilder::m_cablingSvc

protectedinherited

Initial value:

{ this,
        "TileCablingSvc", "TileCablingSvc", "The Tile cabling service"}

Name of Tile cabling service.

Definition at line 179 of file TileRawChannelBuilder.h.

                                              { this,
        "TileCablingSvc", "TileCablingSvc", "The Tile cabling service"};

m_calibrateEnergy

bool TileRawChannelBuilder::m_calibrateEnergy

protectedinherited

Definition at line 142 of file TileRawChannelBuilder.h.

m_capdaq

double TileRawChannelBuilder::m_capdaq

protectedinherited

Definition at line 193 of file TileRawChannelBuilder.h.

m_channelNoiseRMS

int TileRawChannelBuilderFitFilterCool::m_channelNoiseRMS

private

Definition at line 112 of file TileRawChannelBuilderFitFilterCool.h.

m_chCounter

unsigned int TileRawChannelBuilder::m_chCounter

protectedinherited

Definition at line 196 of file TileRawChannelBuilder.h.

m_cischan

int TileRawChannelBuilder::m_cischan

protectedinherited

Definition at line 192 of file TileRawChannelBuilder.h.

m_correctTime

bool TileRawChannelBuilder::m_correctTime

protectedinherited

Definition at line 145 of file TileRawChannelBuilder.h.

m_dataPoollSize

int TileRawChannelBuilder::m_dataPoollSize

protectedinherited

Definition at line 204 of file TileRawChannelBuilder.h.

m_demoFragIDs

Gaudi::Property<std::vector<int> > TileRawChannelBuilder::m_demoFragIDs

protectedinherited

Initial value:

{this,
          "DemoFragIDs", {}, "List of Tile frag IDs with new electronics (demonstrator)"}

Definition at line 184 of file TileRawChannelBuilder.h.

                                               {this,
          "DemoFragIDs", {}, "List of Tile frag IDs with new electronics (demonstrator)"};

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default).

Definition at line 393 of file AthCommonDataStore.h.

m_dgPhysHi

std::vector<double> TileRawChannelBuilderFitFilterCool::m_dgPhysHi

private

Definition at line 108 of file TileRawChannelBuilderFitFilterCool.h.

m_dgPhysLo

std::vector<double> TileRawChannelBuilderFitFilterCool::m_dgPhysLo

private

Definition at line 106 of file TileRawChannelBuilderFitFilterCool.h.

m_DQstatusKey

SG::ReadHandleKey<TileDQstatus> TileRawChannelBuilder::m_DQstatusKey

protectedinherited

Initial value:

{this, "TileDQstatus", 
                                                  "TileDQstatus", 
                                                  "TileDQstatus key"}

Definition at line 120 of file TileRawChannelBuilder.h.

                                               {this, "TileDQstatus", 
                                                  "TileDQstatus", 
                                                  "TileDQstatus key"};

m_DSPContainerKey

SG::ReadHandleKey<TileRawChannelContainer> TileRawChannelBuilder::m_DSPContainerKey {this, "DSPContainer", "", "DSP Container key"}

protectedinherited

Definition at line 125 of file TileRawChannelBuilder.h.

{this, "DSPContainer", "",  "DSP Container key"};

m_dummy

std::vector<double> TileRawChannelBuilderFitFilterCool::m_dummy

private

Definition at line 91 of file TileRawChannelBuilderFitFilterCool.h.

m_error

int TileRawChannelBuilder::m_error[MAX_CHANNELS]

protectedinherited

Definition at line 208 of file TileRawChannelBuilder.h.

m_evtCounter

unsigned int TileRawChannelBuilder::m_evtCounter

protectedinherited

Definition at line 195 of file TileRawChannelBuilder.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default).

Definition at line 390 of file AthCommonDataStore.h.

m_extraSamplesLeft

int TileRawChannelBuilderFitFilterCool::m_extraSamplesLeft

private

Definition at line 114 of file TileRawChannelBuilderFitFilterCool.h.

m_extraSamplesRight

int TileRawChannelBuilderFitFilterCool::m_extraSamplesRight

private

Definition at line 115 of file TileRawChannelBuilderFitFilterCool.h.

m_f_ADCmax

float TileRawChannelBuilder::m_f_ADCmax

protectedinherited

Definition at line 218 of file TileRawChannelBuilder.h.

m_f_ADCmaxPlus1

float TileRawChannelBuilder::m_f_ADCmaxPlus1

protectedinherited

Definition at line 220 of file TileRawChannelBuilder.h.

m_firstSample

int TileRawChannelBuilder::m_firstSample

protectedinherited

Definition at line 140 of file TileRawChannelBuilder.h.

m_fnParameters

double TileRawChannelBuilderFitFilterCool::m_fnParameters[3] {}

private

Definition at line 97 of file TileRawChannelBuilderFitFilterCool.h.

{};

m_frameLength

int TileRawChannelBuilderFitFilterCool::m_frameLength

private

Definition at line 111 of file TileRawChannelBuilderFitFilterCool.h.

m_gPhysHi

std::vector<double> TileRawChannelBuilderFitFilterCool::m_gPhysHi

private

Definition at line 107 of file TileRawChannelBuilderFitFilterCool.h.

m_gPhysLo

std::vector<double> TileRawChannelBuilderFitFilterCool::m_gPhysLo

private

Definition at line 105 of file TileRawChannelBuilderFitFilterCool.h.

m_i_ADCmax

int TileRawChannelBuilder::m_i_ADCmax

protectedinherited

Definition at line 217 of file TileRawChannelBuilder.h.

m_i_ADCmaxPlus1

int TileRawChannelBuilder::m_i_ADCmaxPlus1

protectedinherited

Definition at line 219 of file TileRawChannelBuilder.h.

m_idocis

bool TileRawChannelBuilder::m_idocis

protectedinherited

Definition at line 191 of file TileRawChannelBuilder.h.

m_idolas

bool TileRawChannelBuilder::m_idolas

protectedinherited

Definition at line 189 of file TileRawChannelBuilder.h.

m_idoped

bool TileRawChannelBuilder::m_idoped

protectedinherited

Definition at line 190 of file TileRawChannelBuilder.h.

m_idophys

bool TileRawChannelBuilder::m_idophys

protectedinherited

Definition at line 188 of file TileRawChannelBuilder.h.

m_infoName

std::string TileRawChannelBuilder::m_infoName

protectedinherited

Definition at line 215 of file TileRawChannelBuilder.h.

m_iPeak0

int TileRawChannelBuilderFitFilterCool::m_iPeak0

private

Definition at line 98 of file TileRawChannelBuilderFitFilterCool.h.

m_lastDrawer

int TileRawChannelBuilder::m_lastDrawer = -1

protectedinherited

Definition at line 209 of file TileRawChannelBuilder.h.

m_maxIterate

int TileRawChannelBuilderFitFilterCool::m_maxIterate

private

Definition at line 113 of file TileRawChannelBuilderFitFilterCool.h.

m_maxTau

double TileRawChannelBuilderFitFilterCool::m_maxTau

private

Definition at line 102 of file TileRawChannelBuilderFitFilterCool.h.

m_maxTime

double TileRawChannelBuilderFitFilterCool::m_maxTime

private

Definition at line 100 of file TileRawChannelBuilderFitFilterCool.h.

m_maxTimeFromPeak

double TileRawChannelBuilderFitFilterCool::m_maxTimeFromPeak

private

Definition at line 120 of file TileRawChannelBuilderFitFilterCool.h.

m_minTau

double TileRawChannelBuilderFitFilterCool::m_minTau

private

Definition at line 101 of file TileRawChannelBuilderFitFilterCool.h.

m_minTime

double TileRawChannelBuilderFitFilterCool::m_minTime

private

Definition at line 99 of file TileRawChannelBuilderFitFilterCool.h.

m_nChH

int TileRawChannelBuilder::m_nChH

protectedinherited

Definition at line 199 of file TileRawChannelBuilder.h.

m_nChL

int TileRawChannelBuilder::m_nChL

protectedinherited

Definition at line 198 of file TileRawChannelBuilder.h.

m_noiseFilterTools

ToolHandleArray<ITileRawChannelTool> TileRawChannelBuilder::m_noiseFilterTools

protectedinherited

Initial value:

{this,
        "NoiseFilterTools", {}, "Tile noise filter tools"}

Definition at line 163 of file TileRawChannelBuilder.h.

                                                           {this,
        "NoiseFilterTools", {}, "Tile noise filter tools"};

m_noiseHigh

double TileRawChannelBuilderFitFilterCool::m_noiseHigh

private

Definition at line 123 of file TileRawChannelBuilderFitFilterCool.h.

m_noiseLow

double TileRawChannelBuilderFitFilterCool::m_noiseLow

private

Definition at line 122 of file TileRawChannelBuilderFitFilterCool.h.

m_noiseThresholdRMS

double TileRawChannelBuilderFitFilterCool::m_noiseThresholdRMS

private

Definition at line 119 of file TileRawChannelBuilderFitFilterCool.h.

m_notUpgradeCabling

bool TileRawChannelBuilder::m_notUpgradeCabling

protectedinherited

Definition at line 212 of file TileRawChannelBuilder.h.

m_overflows

Overflows_t TileRawChannelBuilder::m_overflows

protectedinherited

Definition at line 203 of file TileRawChannelBuilder.h.

m_pulseShapes

const TilePulseShapesStruct* TileRawChannelBuilderFitFilterCool::m_pulseShapes

private

Definition at line 126 of file TileRawChannelBuilderFitFilterCool.h.

m_rawChannelCnt

std::unique_ptr<TileMutableRawChannelContainer> TileRawChannelBuilder::m_rawChannelCnt

protectedinherited

Definition at line 133 of file TileRawChannelBuilder.h.

m_rawChannelContainerKey

SG::WriteHandleKey<TileRawChannelContainer> TileRawChannelBuilder::m_rawChannelContainerKey

protectedinherited

Initial value:

{this,"TileRawChannelContainer","TileRawChannelFiltered",
                                                                         "Output Tile raw channels container key"}

Definition at line 129 of file TileRawChannelBuilder.h.

                                                                      {this,"TileRawChannelContainer","TileRawChannelFiltered",
                                                                         "Output Tile raw channels container key"};

m_RChSumH

double TileRawChannelBuilder::m_RChSumH

protectedinherited

Definition at line 201 of file TileRawChannelBuilder.h.

m_RChSumL

double TileRawChannelBuilder::m_RChSumL

protectedinherited

Definition at line 200 of file TileRawChannelBuilder.h.

m_rChType

TileFragHash::TYPE TileRawChannelBuilder::m_rChType

protectedinherited

Definition at line 136 of file TileRawChannelBuilder.h.

m_rChUnit

TileRawChannelUnit::UNIT TileRawChannelBuilder::m_rChUnit

protectedinherited

Definition at line 137 of file TileRawChannelBuilder.h.

m_runType

int TileRawChannelBuilder::m_runType

protectedinherited

Definition at line 157 of file TileRawChannelBuilder.h.

m_saturatedSampleError

double TileRawChannelBuilderFitFilterCool::m_saturatedSampleError

private

Definition at line 117 of file TileRawChannelBuilderFitFilterCool.h.

m_shapes

TilePulseShapesStruct* TileRawChannelBuilderFitFilterCool::m_shapes

private

Definition at line 143 of file TileRawChannelBuilderFitFilterCool.h.

m_t0Fit

double TileRawChannelBuilderFitFilterCool::m_t0Fit

private

Definition at line 94 of file TileRawChannelBuilderFitFilterCool.h.

m_tileHWID

const TileHWID* TileRawChannelBuilder::m_tileHWID

protectedinherited

Definition at line 161 of file TileRawChannelBuilder.h.

m_tileID

const TileID* TileRawChannelBuilder::m_tileID

protectedinherited

Definition at line 160 of file TileRawChannelBuilder.h.

m_tileIdTransforms

ToolHandle<TileCondIdTransforms> TileRawChannelBuilder::m_tileIdTransforms

protectedinherited

Initial value:

{this,
        "TileCondIdTransforms", "TileCondIdTransforms",
        "Tile tool to tranlate hardware identifier to the drawerIdx, channel, and adc"}

Definition at line 172 of file TileRawChannelBuilder.h.

                                                       {this,
        "TileCondIdTransforms", "TileCondIdTransforms",
        "Tile tool to tranlate hardware identifier to the drawerIdx, channel, and adc"};

m_tileInfo

const TileInfo* TileRawChannelBuilder::m_tileInfo

protectedinherited

Definition at line 216 of file TileRawChannelBuilder.h.

m_tileToolEmscale

ToolHandle<TileCondToolEmscale> TileRawChannelBuilder::m_tileToolEmscale

protectedinherited

Initial value:

{this,
        "TileCondToolEmscale", "TileCondToolEmscale", "Tile EM scale calibration tool"}

Definition at line 166 of file TileRawChannelBuilder.h.

                                                     {this,
        "TileCondToolEmscale", "TileCondToolEmscale", "Tile EM scale calibration tool"};

m_tileToolLeak100Shape

ToolHandle<TileCondToolPulseShape> TileRawChannelBuilderFitFilterCool::m_tileToolLeak100Shape

private

Initial value:

{this,
        "TileCondToolLeak100Shape", "", "Tile CIS leakage shape for 100 pF capacitor tool"}

Definition at line 131 of file TileRawChannelBuilderFitFilterCool.h.

                                                             {this,
        "TileCondToolLeak100Shape", "", "Tile CIS leakage shape for 100 pF capacitor tool"};

m_tileToolLeak5p2Shape

ToolHandle<TileCondToolPulseShape> TileRawChannelBuilderFitFilterCool::m_tileToolLeak5p2Shape

private

Initial value:

{this,
        "TileCondToolLeak5p2Shape", "", "Tile CIS leakage shape for 5.2 pF capacitor tool"}

Definition at line 134 of file TileRawChannelBuilderFitFilterCool.h.

                                                             {this,
        "TileCondToolLeak5p2Shape", "", "Tile CIS leakage shape for 5.2 pF capacitor tool"};

m_tileToolNoiseSample

ToolHandle<TileCondToolNoiseSample> TileRawChannelBuilderFitFilterCool::m_tileToolNoiseSample

private

Initial value:

{this,
        "TileCondToolNoiseSample", "TileCondToolNoiseSample", "Tile sample noise tool"}

Definition at line 140 of file TileRawChannelBuilderFitFilterCool.h.

                                                             {this,
        "TileCondToolNoiseSample", "TileCondToolNoiseSample", "Tile sample noise tool"};

m_tileToolPulse5p2Shape

ToolHandle<TileCondToolPulseShape> TileRawChannelBuilderFitFilterCool::m_tileToolPulse5p2Shape

private

Initial value:

{this,
        "TileCondToolPulse5p2Shape", "", "Tile CIS pulse shape for 5.2 pF capacitor tool"}

Definition at line 137 of file TileRawChannelBuilderFitFilterCool.h.

                                                              {this,
        "TileCondToolPulse5p2Shape", "", "Tile CIS pulse shape for 5.2 pF capacitor tool"};

m_tileToolPulseShape

ToolHandle<TileCondToolPulseShape> TileRawChannelBuilderFitFilterCool::m_tileToolPulseShape

private

Initial value:

{this,
        "TileCondToolPulseShape", "TileCondToolPulseShape", "Tile pulse shape tool"}

Definition at line 128 of file TileRawChannelBuilderFitFilterCool.h.

                                                           {this,
        "TileCondToolPulseShape", "TileCondToolPulseShape", "Tile pulse shape tool"};

m_tileToolTiming

ToolHandle<TileCondToolTiming> TileRawChannelBuilder::m_tileToolTiming

protectedinherited

Initial value:

{this,
        "TileCondToolTiming", "TileCondToolTiming", "Tile timing tool"}

Definition at line 169 of file TileRawChannelBuilder.h.

                                                   {this,
        "TileCondToolTiming", "TileCondToolTiming", "Tile timing tool"};

m_timeMaxThresh

float TileRawChannelBuilder::m_timeMaxThresh

protectedinherited

correct amplitude is time is below time max threshold

Definition at line 154 of file TileRawChannelBuilder.h.

m_timeMinThresh

float TileRawChannelBuilder::m_timeMinThresh

protectedinherited

correct amplitude is time is above time min threshold

Definition at line 153 of file TileRawChannelBuilder.h.

m_trigType

int TileRawChannelBuilder::m_trigType

protectedinherited

Definition at line 187 of file TileRawChannelBuilder.h.

m_useDSP

bool TileRawChannelBuilder::m_useDSP

protectedinherited

Definition at line 149 of file TileRawChannelBuilder.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

m_zeroSampleError

double TileRawChannelBuilderFitFilterCool::m_zeroSampleError

private

Definition at line 118 of file TileRawChannelBuilderFitFilterCool.h.

MAX_CHANNELS

const int TileRawChannelBuilder::MAX_CHANNELS = 48

staticprotectedinherited

Definition at line 206 of file TileRawChannelBuilder.h.

MAX_DMUS

const int TileRawChannelBuilder::MAX_DMUS = 16

staticprotectedinherited

Definition at line 207 of file TileRawChannelBuilder.h.

---

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

• TileRawChannelBuilderFitFilterCool.h
• TileRawChannelBuilderFitFilterCool.cxx