[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCPad.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
 *          for The ALICE Off-line Project.                               *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/** @file   AliHLTTPCPad.cxx
    @author Matthias Richter
    @date   
    @brief  Container Class for TPC Pads.
*/

#if __GNUC__>= 3
using namespace std;
#endif

#include <cerrno>
#include "AliHLTTPCPad.h"
#include "AliHLTStdIncludes.h"

/** margin for the base line be re-avaluated */
#define ALIHLTPAD_BASELINE_MARGIN (2*fAverage)

/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTPCPad)

AliHLTTPCPad::AliHLTTPCPad()
  :
  fRowNo(-1),
  fPadNo(-1),
  fThreshold(0),
  fAverage(-1),
  fNofEvents(0),
  fSum(0),
  fBLMax(-1),
  fBLMaxBin(-1),
  fBLMin(-1),
  fBLMinBin(-1),
  fCount(0),
  fTotal(0),
  fpRawData(NULL),
  fFirstBLBin(0),
  fNofBins(0),
  fReadPos(0)
{
}

AliHLTTPCPad::AliHLTTPCPad(Int_t offset, Int_t nofBins)
  :
  fRowNo(-1),
  fPadNo(-1),
  fThreshold(0),
  fAverage(-1),
  fNofEvents(0),
  fSum(0),
  fBLMax(-1),
  fBLMaxBin(-1),
  fBLMin(-1),
  fBLMinBin(-1),
  fCount(0),
  fTotal(0),
  fpRawData(NULL),
  fFirstBLBin(offset),
  fNofBins(nofBins),
  fReadPos(0)
{
}

AliHLTTPCPad::AliHLTTPCPad(const AliHLTTPCPad& srcPad)
  :
  fRowNo(srcPad.fRowNo),
  fPadNo(srcPad.fPadNo),
  fThreshold(0),
  fAverage(-1),
  fNofEvents(0),
  fSum(0),
  fBLMax(-1),
  fBLMaxBin(-1),
  fBLMin(-1),
  fBLMinBin(-1),
  fCount(0),
  fTotal(0),
  fpRawData(NULL),
  fFirstBLBin(0),
  fNofBins(0),
  fReadPos(0)
{
  HLTFatal("copy constructor not implemented");
}

AliHLTTPCPad& AliHLTTPCPad::operator=(const AliHLTTPCPad&)
{
  HLTFatal("assignment operator not implemented");
  return (*this);
}

AliHLTTPCPad::~AliHLTTPCPad()
{
  if (fpRawData) {
    HLTWarning("event data acquisition not stopped");
    StopEvent();
  }
}

Int_t AliHLTTPCPad::SetID(Int_t rowno, Int_t padno)
{
  fRowNo=rowno;
  fPadNo=padno;
}

Int_t AliHLTTPCPad::StartEvent()
{
  Int_t iResult=0;
  if (fpRawData==NULL) {
    fBLMax=-1;
    fBLMaxBin=-1;
    fBLMin=-1;
    fBLMinBin=-1;
    fSum=0;
    fCount=0;
    fTotal=0;
    if (fNofBins>0) {
      fpRawData=new AliHLTTPCSignal_t[fNofBins];
      if (fpRawData) {
	for (int i=0; i<fNofBins; i++) fpRawData[i]=-1;
      } else {
	HLTError("memory allocation failed");
	iResult=-ENOMEM;
      }
    }
  } else {
    HLTWarning("event data acquisition already started");
    iResult=-EALREADY;
  }
  return iResult;
}

Int_t AliHLTTPCPad::CalculateBaseLine(Int_t reqMinCount)
{
  Int_t iResult=0;
  AliHLTTPCSignal_t avBackup=fAverage;
  //HLTDebug("reqMinCount=%d fCount=%d fTotal=%d fSum=%d fBLMax=%d fBLMin=%d", reqMinCount, fCount, fTotal, fSum, fBLMax, fBLMin);
  if (fCount>=reqMinCount && fCount>=fTotal/2) {
    fAverage=fCount>0?fSum/fCount:0;
    if (fAverage>0) {
      //HLTDebug("average for current event %d (%d - %d)", fAverage, fBLMax, fBLMin);
      fCount=0;fSum=-1;
      if (fBLMax>ALIHLTPAD_BASELINE_MARGIN) {
	// calculate again
	HLTDebug("maximum value %d exceeds margin for base line (%d) "
		 "-> re-evaluate base line", fBLMax, ALIHLTPAD_BASELINE_MARGIN);
	if (fpRawData) {
	  for (Int_t i=fFirstBLBin; i<fNofBins; i++)
	    if (fpRawData[i]>=0) AddBaseLineValue(i, fpRawData[i]);
	  if (fCount>0 && fCount>=reqMinCount && fCount>=fTotal/2) {
	    fAverage=fSum/fCount;
	    HLTDebug("new average %d", fAverage);
	  } else {
	    HLTDebug("baseline re-eveluation skipped because of to few "
		       "contributing bins: total=%d, contributing=%d, req=%d"
		       "\ndata might be already zero suppressed"
		       , fTotal, fCount, reqMinCount);
	    iResult=-ENODATA;
	  }
	  fCount=0;fSum=-1;
	} else {
	  HLTError("missing raw data for base line calculation");
	  iResult=-ENOBUFS;
	}
      }
      if (iResult>=0) {
	// calculate average for all events
	fAverage=((avBackup*fNofEvents)+fAverage)/(fNofEvents+1);
	//HLTDebug("base line average for %d event(s): %d", fNofEvents+1, fAverage);
      } else {
	fAverage=avBackup;      
      }
    } else {
      fAverage=avBackup;
    }
  } else {
    HLTDebug("baseline calculation skipped because of to few contributing "
	       "bins: total=%d, contributing=%d, required=%d \ndata might be "
	       "already zero suppressed", fTotal, fCount, reqMinCount);
  }

  return iResult;
}

Int_t AliHLTTPCPad::StopEvent()
{
  Int_t iResult=0;
  if (fpRawData) {
    AliHLTTPCSignal_t* pData=fpRawData;
    fpRawData=NULL;
    delete [] pData;
    fTotal=0;
    fNofEvents++;
    Rewind();
  } else if (fNofBins>0) {
    HLTError("event data acquisition not started");
    iResult=-EBADF;
  }
  return iResult;
}

Int_t AliHLTTPCPad::ResetHistory()
{
  Int_t iResult=0;
  fAverage=-1;
  fNofEvents=0;
  return iResult;
}

Int_t AliHLTTPCPad::SetThreshold(AliHLTTPCSignal_t thresh)
{
  Int_t iResult=0;
  fThreshold=thresh;
  return iResult;
}

Int_t AliHLTTPCPad::AddBaseLineValue(Int_t bin, AliHLTTPCSignal_t value)
{
  Int_t iResult=0;
  if (bin>=fFirstBLBin) {
    if (fAverage<0 || value<ALIHLTPAD_BASELINE_MARGIN) {
      // add to the current sum and count
      fSum+=value;
      fCount++;
      if (fBLMax<value) {
	// keep the maximum value for later quality control of the base 
	// line calculation
	fBLMax=value;
	fBLMaxBin=bin;
      }
      if (fBLMin<0 || fBLMin>value) {
	// keep the minimum value for later quality control of the base 
	// line calculation
	fBLMin=value;
	fBLMinBin=bin;
      }
    } else {
      HLTDebug("ignoring value %d (bin %d) for base line calculation "
	       "(current average is %d)",
	       value, bin, fAverage);
    }
  }
  return iResult;
}

Int_t AliHLTTPCPad::SetRawData(Int_t bin, AliHLTTPCSignal_t value)
{
  Int_t iResult=0;
  if (fpRawData) {
    if (bin<fNofBins) {
      if (value>=0) {
	if (fpRawData[bin]<0) {
	  AddBaseLineValue(bin, value);
	  fTotal++;
	} else {
	  // ignore value for average calculation
	  HLTWarning("overriding content of bin %d (%d)", bin, fpRawData[bin]);
	}
	fpRawData[bin]=value;
      } else {
	HLTWarning("ignoring neg. raw data");
      }
    } else {
      HLTWarning("bin %d out of range (%d)", bin, fNofBins);
      iResult=-ERANGE;
    }
  } else if (fNofBins>0) {
    HLTError("event cycle not started");
    iResult=-EBADF;
  }
  return iResult;
}

Int_t AliHLTTPCPad::Next(Int_t bZeroSuppression) 
{
  if (fpRawData==NULL) return 0;
  Int_t iResult=fReadPos<fNofBins;
  if (iResult>0 && (iResult=(++fReadPos<fNofBins))>0) {
    if (bZeroSuppression) {
      while ((iResult=(fReadPos<fNofBins))>0 &&
	     GetCorrectedData(fReadPos)<=0)
	fReadPos++;
    }
  }
  return iResult;
}

Int_t AliHLTTPCPad::Rewind(Int_t bZeroSuppression)
{
  fReadPos=(bZeroSuppression>0?0:fFirstBLBin)-1;
  return Next(bZeroSuppression);
}

AliHLTTPCSignal_t AliHLTTPCPad::GetRawData(Int_t bin) const
{
  AliHLTTPCSignal_t data=0;
  if (fpRawData) {
    if (bin<fNofBins) {
      data=fpRawData[bin];
    } else {
      HLTWarning("requested bin %d out of range (%d)", bin, fNofBins);
    }
  } else if (fNofBins>0) {
    HLTWarning("data only available within event cycle");
  }
  return data;
}

AliHLTTPCSignal_t AliHLTTPCPad::GetCorrectedData(Int_t bin) const
{
  AliHLTTPCSignal_t data=GetRawData(bin)-GetBaseLine(bin);
  AliHLTTPCSignal_t prev=0;
  if (bin>1) prev=GetRawData(bin-1)-GetBaseLine(bin-1);
  AliHLTTPCSignal_t succ=0;
  if (bin+1<GetSize()) succ=GetRawData(bin+1)-GetBaseLine(bin+1);
  if (fThreshold>0) {
    data-=fThreshold;
    prev-=fThreshold;
    succ-=fThreshold;
  }
 
  // case 1:
  // the signal is below the base-line and threshold
  if (data<0) data=0;

  //case 2:
  // the neighboring bins are both below base-line/threshold
  // a real signal is always more than one bin wide because of the shaper 
  if (prev<=0 && succ<=0) data=0;
 
  // case 3:
  // the bin is inside the range of ignored bins
  if (bin<fFirstBLBin) data=0;
  //HLTDebug("fReadPos=%d data=%d threshold=%d raw data=%d base line=%d", fReadPos, data, fThreshold, GetRawData(bin), GetBaseLine(bin));
  return data;
}

AliHLTTPCSignal_t AliHLTTPCPad::GetBaseLine(Int_t bin) const
{
  AliHLTTPCSignal_t val=0;
  if (fAverage>0) {
    // we take the minumum value as the base line if it doesn't differ from
    // the average to much
    const AliHLTTPCSignal_t kMaxDifference=15;
    val=fAverage;
#ifdef KEEP_NOISE
    if ((fAverage-fBLMin)<=kMaxDifference) val=fBLMin;
    else val>kMaxDifference?val-=kMaxDifference:0;
#endif
  }
  if (val<0) {
    // here we should never get
    val=0;
    HLTFatal("wrong base line value");
  }
  return val;
}

AliHLTTPCSignal_t AliHLTTPCPad::GetAverage() const
{
  return fAverage>0?fAverage:0;
}

Float_t AliHLTTPCPad::GetOccupancy() const
{
  Float_t occupancy=0;
  if (fpRawData && fNofBins>0) {
    for (Int_t i=fFirstBLBin; i<fNofBins; i++) {
      if (GetCorrectedData(i)>0) occupancy+=1;
    }
    if (fNofBins-fFirstBLBin>0)
      occupancy/=fNofBins-fFirstBLBin;
  }
  return occupancy;
}

Float_t AliHLTTPCPad::GetAveragedOccupancy() const
{
  // history is not yet implemented
  return GetOccupancy();
}
Commit	Line	Data
46b33a24	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
	5	* for The ALICE Off-line Project. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/** @file AliHLTTPCPad.cxx
	17	@author Matthias Richter
	18	@date
	19	@brief Container Class for TPC Pads.
	20	*/
	21
	22	#if __GNUC__>= 3
	23	using namespace std;
	24	#endif
	25
	26	#include <cerrno>
	27	#include "AliHLTTPCPad.h"
84645eb0	28	#include "AliHLTStdIncludes.h"
46b33a24	29
	30	/** margin for the base line be re-avaluated */
	31	#define ALIHLTPAD_BASELINE_MARGIN (2*fAverage)
	32
	33	/** ROOT macro for the implementation of ROOT specific class methods */
	34	ClassImp(AliHLTTPCPad)
	35
	36	AliHLTTPCPad::AliHLTTPCPad()
	37	:
	38	fRowNo(-1),
	39	fPadNo(-1),
	40	fThreshold(0),
	41	fAverage(-1),
	42	fNofEvents(0),
	43	fSum(0),
	44	fBLMax(-1),
	45	fBLMaxBin(-1),
84645eb0	46	fBLMin(-1),
84645eb0	47	fBLMinBin(-1),
46b33a24	48	fCount(0),
	49	fTotal(0),
	50	fpRawData(NULL),
	51	fFirstBLBin(0),
	52	fNofBins(0),
	53	fReadPos(0)
	54	{
	55	}
	56
	57	AliHLTTPCPad::AliHLTTPCPad(Int_t offset, Int_t nofBins)
	58	:
	59	fRowNo(-1),
	60	fPadNo(-1),
	61	fThreshold(0),
	62	fAverage(-1),
	63	fNofEvents(0),
	64	fSum(0),
	65	fBLMax(-1),
	66	fBLMaxBin(-1),
84645eb0	67	fBLMin(-1),
84645eb0	68	fBLMinBin(-1),
46b33a24	69	fCount(0),
	70	fTotal(0),
	71	fpRawData(NULL),
	72	fFirstBLBin(offset),
	73	fNofBins(nofBins),
	74	fReadPos(0)
	75	{
	76	}
	77
	78	AliHLTTPCPad::AliHLTTPCPad(const AliHLTTPCPad& srcPad)
	79	:
	80	fRowNo(srcPad.fRowNo),
	81	fPadNo(srcPad.fPadNo),
	82	fThreshold(0),
	83	fAverage(-1),
	84	fNofEvents(0),
	85	fSum(0),
	86	fBLMax(-1),
	87	fBLMaxBin(-1),
84645eb0	88	fBLMin(-1),
84645eb0	89	fBLMinBin(-1),
46b33a24	90	fCount(0),
	91	fTotal(0),
	92	fpRawData(NULL),
	93	fFirstBLBin(0),
	94	fNofBins(0),
	95	fReadPos(0)
	96	{
	97	HLTFatal("copy constructor not implemented");
	98	}
	99
	100	AliHLTTPCPad& AliHLTTPCPad::operator=(const AliHLTTPCPad&)
	101	{
	102	HLTFatal("assignment operator not implemented");
	103	return (*this);
	104	}
	105
	106	AliHLTTPCPad::~AliHLTTPCPad()
	107	{
	108	if (fpRawData) {
	109	HLTWarning("event data acquisition not stopped");
	110	StopEvent();
	111	}
	112	}
	113
	114	Int_t AliHLTTPCPad::SetID(Int_t rowno, Int_t padno)
	115	{
	116	fRowNo=rowno;
	117	fPadNo=padno;
	118	}
	119
	120	Int_t AliHLTTPCPad::StartEvent()
	121	{
	122	Int_t iResult=0;
	123	if (fpRawData==NULL) {
	124	fBLMax=-1;
	125	fBLMaxBin=-1;
84645eb0	126	fBLMin=-1;
84645eb0	127	fBLMinBin=-1;
46b33a24	128	fSum=0;
	129	fCount=0;
	130	fTotal=0;
	131	if (fNofBins>0) {
	132	fpRawData=new AliHLTTPCSignal_t[fNofBins];
	133	if (fpRawData) {
	134	for (int i=0; i<fNofBins; i++) fpRawData[i]=-1;
	135	} else {
	136	HLTError("memory allocation failed");
	137	iResult=-ENOMEM;
	138	}
	139	}
	140	} else {
	141	HLTWarning("event data acquisition already started");
	142	iResult=-EALREADY;
	143	}
	144	return iResult;
	145	}
	146
	147	Int_t AliHLTTPCPad::CalculateBaseLine(Int_t reqMinCount)
	148	{
	149	Int_t iResult=0;
	150	AliHLTTPCSignal_t avBackup=fAverage;
84645eb0	151	//HLTDebug("reqMinCount=%d fCount=%d fTotal=%d fSum=%d fBLMax=%d fBLMin=%d", reqMinCount, fCount, fTotal, fSum, fBLMax, fBLMin);
46b33a24	152	if (fCount>=reqMinCount && fCount>=fTotal/2) {
	153	fAverage=fCount>0?fSum/fCount:0;
	154	if (fAverage>0) {
84645eb0	155	//HLTDebug("average for current event %d (%d - %d)", fAverage, fBLMax, fBLMin);
46b33a24	156	fCount=0;fSum=-1;
	157	if (fBLMax>ALIHLTPAD_BASELINE_MARGIN) {
	158	// calculate again
84645eb0	159	HLTDebug("maximum value %d exceeds margin for base line (%d) "
46b33a24	160	"-> re-evaluate base line", fBLMax, ALIHLTPAD_BASELINE_MARGIN);
	161	if (fpRawData) {
	162	for (Int_t i=fFirstBLBin; i<fNofBins; i++)
	163	if (fpRawData[i]>=0) AddBaseLineValue(i, fpRawData[i]);
	164	if (fCount>0 && fCount>=reqMinCount && fCount>=fTotal/2) {
	165	fAverage=fSum/fCount;
84645eb0	166	HLTDebug("new average %d", fAverage);
46b33a24	167	} else {
db16520a	168	HLTDebug("baseline re-eveluation skipped because of to few "
46b33a24	169	"contributing bins: total=%d, contributing=%d, req=%d"
	170	"\ndata might be already zero suppressed"
	171	, fTotal, fCount, reqMinCount);
	172	iResult=-ENODATA;
	173	}
	174	fCount=0;fSum=-1;
	175	} else {
	176	HLTError("missing raw data for base line calculation");
	177	iResult=-ENOBUFS;
	178	}
	179	}
	180	if (iResult>=0) {
	181	// calculate average for all events
	182	fAverage=((avBackup*fNofEvents)+fAverage)/(fNofEvents+1);
84645eb0	183	//HLTDebug("base line average for %d event(s): %d", fNofEvents+1, fAverage);
46b33a24	184	} else {
	185	fAverage=avBackup;
	186	}
	187	} else {
	188	fAverage=avBackup;
	189	}
	190	} else {
db16520a	191	HLTDebug("baseline calculation skipped because of to few contributing "
46b33a24	192	"bins: total=%d, contributing=%d, required=%d \ndata might be "
	193	"already zero suppressed", fTotal, fCount, reqMinCount);
	194	}
	195
	196	return iResult;
	197	}
	198
	199	Int_t AliHLTTPCPad::StopEvent()
	200	{
	201	Int_t iResult=0;
	202	if (fpRawData) {
	203	AliHLTTPCSignal_t* pData=fpRawData;
	204	fpRawData=NULL;
	205	delete [] pData;
	206	fTotal=0;
	207	fNofEvents++;
	208	Rewind();
	209	} else if (fNofBins>0) {
	210	HLTError("event data acquisition not started");
	211	iResult=-EBADF;
	212	}
	213	return iResult;
	214	}
	215
	216	Int_t AliHLTTPCPad::ResetHistory()
	217	{
	218	Int_t iResult=0;
	219	fAverage=-1;
	220	fNofEvents=0;
	221	return iResult;
	222	}
	223
	224	Int_t AliHLTTPCPad::SetThreshold(AliHLTTPCSignal_t thresh)
	225	{
	226	Int_t iResult=0;
	227	fThreshold=thresh;
	228	return iResult;
	229	}
	230
	231	Int_t AliHLTTPCPad::AddBaseLineValue(Int_t bin, AliHLTTPCSignal_t value)
	232	{
	233	Int_t iResult=0;
	234	if (bin>=fFirstBLBin) {
	235	if (fAverage<0 \|\| value<ALIHLTPAD_BASELINE_MARGIN) {
	236	// add to the current sum and count
	237	fSum+=value;
	238	fCount++;
	239	if (fBLMax<value) {
	240	// keep the maximum value for later quality control of the base
	241	// line calculation
	242	fBLMax=value;
	243	fBLMaxBin=bin;
	244	}
84645eb0	245	if (fBLMin<0 \|\| fBLMin>value) {
	246	// keep the minimum value for later quality control of the base
	247	// line calculation
	248	fBLMin=value;
	249	fBLMinBin=bin;
	250	}
46b33a24	251	} else {
84645eb0	252	HLTDebug("ignoring value %d (bin %d) for base line calculation "
84645eb0	253	"(current average is %d)",
46b33a24	254	value, bin, fAverage);
	255	}
	256	}
	257	return iResult;
	258	}
	259
	260	Int_t AliHLTTPCPad::SetRawData(Int_t bin, AliHLTTPCSignal_t value)
	261	{
	262	Int_t iResult=0;
	263	if (fpRawData) {
	264	if (bin<fNofBins) {
	265	if (value>=0) {
	266	if (fpRawData[bin]<0) {
	267	AddBaseLineValue(bin, value);
	268	fTotal++;
	269	} else {
	270	// ignore value for average calculation
84645eb0	271	HLTWarning("overriding content of bin %d (%d)", bin, fpRawData[bin]);
46b33a24	272	}
	273	fpRawData[bin]=value;
	274	} else {
	275	HLTWarning("ignoring neg. raw data");
	276	}
	277	} else {
	278	HLTWarning("bin %d out of range (%d)", bin, fNofBins);
	279	iResult=-ERANGE;
	280	}
	281	} else if (fNofBins>0) {
	282	HLTError("event cycle not started");
	283	iResult=-EBADF;
	284	}
	285	return iResult;
	286	}
	287
	288	Int_t AliHLTTPCPad::Next(Int_t bZeroSuppression)
	289	{
	290	if (fpRawData==NULL) return 0;
	291	Int_t iResult=fReadPos<fNofBins;
	292	if (iResult>0 && (iResult=(++fReadPos<fNofBins))>0) {
	293	if (bZeroSuppression) {
	294	while ((iResult=(fReadPos<fNofBins))>0 &&
	295	GetCorrectedData(fReadPos)<=0)
	296	fReadPos++;
	297	}
	298	}
	299	return iResult;
	300	}
	301
	302	Int_t AliHLTTPCPad::Rewind(Int_t bZeroSuppression)
	303	{
	304	fReadPos=(bZeroSuppression>0?0:fFirstBLBin)-1;
	305	return Next(bZeroSuppression);
	306	}
	307
	308	AliHLTTPCSignal_t AliHLTTPCPad::GetRawData(Int_t bin) const
	309	{
	310	AliHLTTPCSignal_t data=0;
	311	if (fpRawData) {
	312	if (bin<fNofBins) {
	313	data=fpRawData[bin];
	314	} else {
	315	HLTWarning("requested bin %d out of range (%d)", bin, fNofBins);
	316	}
	317	} else if (fNofBins>0) {
	318	HLTWarning("data only available within event cycle");
	319	}
	320	return data;
	321	}
	322
	323	AliHLTTPCSignal_t AliHLTTPCPad::GetCorrectedData(Int_t bin) const
	324	{
	325	AliHLTTPCSignal_t data=GetRawData(bin)-GetBaseLine(bin);
5235c3e9	326	AliHLTTPCSignal_t prev=0;
	327	if (bin>1) prev=GetRawData(bin-1)-GetBaseLine(bin-1);
	328	AliHLTTPCSignal_t succ=0;
	329	if (bin+1<GetSize()) succ=GetRawData(bin+1)-GetBaseLine(bin+1);
	330	if (fThreshold>0) {
	331	data-=fThreshold;
	332	prev-=fThreshold;
	333	succ-=fThreshold;
	334	}
	335
	336	// case 1:
	337	// the signal is below the base-line and threshold
46b33a24	338	if (data<0) data=0;
5235c3e9	339
	340	//case 2:
	341	// the neighboring bins are both below base-line/threshold
	342	// a real signal is always more than one bin wide because of the shaper
	343	if (prev<=0 && succ<=0) data=0;
	344
	345	// case 3:
	346	// the bin is inside the range of ignored bins
46b33a24	347	if (bin<fFirstBLBin) data=0;
84645eb0	348	//HLTDebug("fReadPos=%d data=%d threshold=%d raw data=%d base line=%d", fReadPos, data, fThreshold, GetRawData(bin), GetBaseLine(bin));
46b33a24	349	return data;
	350	}
	351
	352	AliHLTTPCSignal_t AliHLTTPCPad::GetBaseLine(Int_t bin) const
	353	{
84645eb0	354	AliHLTTPCSignal_t val=0;
	355	if (fAverage>0) {
	356	// we take the minumum value as the base line if it doesn't differ from
	357	// the average to much
	358	const AliHLTTPCSignal_t kMaxDifference=15;
	359	val=fAverage;
5235c3e9	360	#ifdef KEEP_NOISE
84645eb0	361	if ((fAverage-fBLMin)<=kMaxDifference) val=fBLMin;
84645eb0	362	else val>kMaxDifference?val-=kMaxDifference:0;
5235c3e9	363	#endif
84645eb0	364	}
	365	if (val<0) {
	366	// here we should never get
	367	val=0;
	368	HLTFatal("wrong base line value");
	369	}
	370	return val;
46b33a24	371	}
	372
	373	AliHLTTPCSignal_t AliHLTTPCPad::GetAverage() const
	374	{
	375	return fAverage>0?fAverage:0;
	376	}
	377
5235c3e9	378	Float_t AliHLTTPCPad::GetOccupancy() const
	379	{
	380	Float_t occupancy=0;
	381	if (fpRawData && fNofBins>0) {
	382	for (Int_t i=fFirstBLBin; i<fNofBins; i++) {
	383	if (GetCorrectedData(i)>0) occupancy+=1;
	384	}
	385	if (fNofBins-fFirstBLBin>0)
	386	occupancy/=fNofBins-fFirstBLBin;
	387	}
	388	return occupancy;
	389	}
	390
	391	Float_t AliHLTTPCPad::GetAveragedOccupancy() const
	392	{
	393	// history is not yet implemented
	394	return GetOccupancy();
	395	}