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

// @(#) $Id$

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        * 
 * ALICE Experiment at CERN, All rights reserved.                         *
 *                                                                        *
 * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
 *                  Kenneth Aamodt   <Kenneth.aamodt@ift.uib.no>          *
 *                  for The ALICE HLT 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, Kenneth Aamodt
    @date   
    @brief  Container Class for TPC Pads.
*/

// see header file for class documentation
// or
// refer to README to build package
// or
// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt

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

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


//added by kenneth
#include "AliHLTTPCTransform.h"
#include "AliHLTTPCClusters.h"
#include <sys/time.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()
  :
  fClusterCandidates(),
  fUsedClusterCandidates(),
  fRowNo(-1),
  fPadNo(-1),
  fThreshold(0),
  fAverage(-1),
  fNofEvents(0),
  fSum(0),
  fCount(0),
  fTotal(0),
  fBLMax(-1),
  fBLMaxBin(-1),
  fBLMin(-1),
  fBLMinBin(-1),
  fFirstBLBin(0),
  fNofBins(0),
  fReadPos(0),
  fpRawData(NULL),
  fDataSignals(NULL),
  fSignalPositionArray(NULL),
  fSizeOfSignalPositionArray(0)
{
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  //  HLTInfo("Entering default constructor");
  fDataSignals= new AliHLTTPCSignal_t[AliHLTTPCTransform::GetNTimeBins()];
  memset( fDataSignals, 0xFF, sizeof(Int_t)*(AliHLTTPCTransform::GetNTimeBins()));

  fSignalPositionArray= new AliHLTTPCSignal_t[AliHLTTPCTransform::GetNTimeBins()];
  memset( fSignalPositionArray, 0xFF, sizeof(Int_t)*(AliHLTTPCTransform::GetNTimeBins()));
  fSizeOfSignalPositionArray=0;
}

AliHLTTPCPad::AliHLTTPCPad(Int_t offset, Int_t nofBins)
  :
  fClusterCandidates(),
  fUsedClusterCandidates(),
  fRowNo(-1),
  fPadNo(-1),
  fThreshold(0),
  fAverage(-1),
  fNofEvents(0),
  fSum(0),
  fCount(0),
  fTotal(0),
  fBLMax(-1),
  fBLMaxBin(-1),
  fBLMin(-1),
  fBLMinBin(-1),
  fFirstBLBin(offset),
  fNofBins(nofBins),
  fReadPos(0),
  fpRawData(NULL),
  fDataSignals(NULL),
  fSignalPositionArray(NULL),
  fSizeOfSignalPositionArray(0)
{
  // see header file for class documentation
}

AliHLTTPCPad::~AliHLTTPCPad()
{
  // see header file for class documentation
  if (fpRawData) {
    HLTWarning("event data acquisition not stopped");
    StopEvent();
  }
  if (fDataSignals) {
    AliHLTTPCSignal_t* pData=fDataSignals;
    fDataSignals=NULL;
   delete [] pData;
  }
  if (fSignalPositionArray) {
    AliHLTTPCSignal_t* pData=fSignalPositionArray;
    fSignalPositionArray=NULL;
    //   delete [] pData;
  }

}

Int_t AliHLTTPCPad::SetID(Int_t rowno, Int_t padno)
{
  // see header file for class documentation
  fRowNo=rowno;
  fPadNo=padno;
  return 0;
}

Int_t AliHLTTPCPad::StartEvent()
{
  // see header file for class documentation
  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)
{
  // see header file for class documentation
  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()
{
  // see header file for class documentation
  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()
{
  // see header file for class documentation
  Int_t iResult=0;
  fAverage=-1;
  fNofEvents=0;
  return iResult;
}

Int_t AliHLTTPCPad::SetThreshold(AliHLTTPCSignal_t thresh)
{
  // see header file for class documentation
  Int_t iResult=0;
  fThreshold=thresh;
  return iResult;
}

Int_t AliHLTTPCPad::AddBaseLineValue(Int_t bin, AliHLTTPCSignal_t value)
{
  // see header file for class documentation
  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)
{
  // see header file for class documentation
  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) 
{
  // see header file for class documentation
  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)
{
  // see header file for class documentation
  fReadPos=(bZeroSuppression>0?0:fFirstBLBin)-1;
  return Next(bZeroSuppression);
}

AliHLTTPCSignal_t AliHLTTPCPad::GetRawData(Int_t bin) const
{
  // see header file for class documentation
  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
{
  // see header file for class documentation
  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
{
  // see header file for class documentation
  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
    val=fAverage;
#ifdef KEEP_NOISE
    const AliHLTTPCSignal_t kMaxDifference=15;
    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
{
  // see header file for class documentation
  return fAverage>0?fAverage:0;
}

Float_t AliHLTTPCPad::GetOccupancy() const
{
  // see header file for class documentation
  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
{
  // see header file for class documentation

  // history is not yet implemented
  return GetOccupancy();
}
void AliHLTTPCPad::PrintRawData()
{
  // see header file for class documentation
  for(Int_t bin=0;bin<AliHLTTPCTransform::GetNTimeBins();bin++){
    if(GetDataSignal(bin)>0)
      cout<<fRowNo<<"\t"<<fPadNo<<"\t"<<bin<<"\t"<<GetDataSignal(bin)<<endl;;
  }
  cout<<"bins: "<<AliHLTTPCTransform::GetNTimeBins()<<endl;
}

void AliHLTTPCPad::SetDataToDefault()
{
  // see header file for class documentation
  if(fpRawData){
    memset( fDataSignals, 0xFF, sizeof(Int_t)*(AliHLTTPCTransform::GetNTimeBins()));
    memset( fSignalPositionArray, 0xFF, sizeof(Int_t)*(AliHLTTPCTransform::GetNTimeBins()));
    fSizeOfSignalPositionArray=0;
  }
}

void AliHLTTPCPad::SetDataSignal(Int_t bin,Int_t signal)
{
  // see header file for class documentation
  fDataSignals[bin]=signal;
  fSignalPositionArray[fSizeOfSignalPositionArray]=bin;
  fSizeOfSignalPositionArray++;
}

Int_t AliHLTTPCPad::GetDataSignal(Int_t bin) const
{
  // see header file for class documentation
  return fDataSignals[bin];
}

void AliHLTTPCPad::FindClusterCandidates()
{
  // see header file for class documentation
  UInt_t seqcharge=0;
  UInt_t seqaverage=0;
  UInt_t seqerror=0;
  vector<Int_t> tmpPos;
  vector<Int_t> tmpSig;
  UInt_t isFalling=0;

  for(Int_t pos=fSizeOfSignalPositionArray-2;pos>=0;pos--){

    if(fSignalPositionArray[pos]==fSignalPositionArray[pos+1]+1){
      seqcharge+=fDataSignals[fSignalPositionArray[pos+1]];	
      seqaverage += fSignalPositionArray[pos+1]*fDataSignals[fSignalPositionArray[pos+1]];
      seqerror += fSignalPositionArray[pos+1]*fSignalPositionArray[pos+1]*fDataSignals[fSignalPositionArray[pos+1]];
	  
      tmpPos.push_back(fSignalPositionArray[pos+1]);
      tmpSig.push_back(fDataSignals[fSignalPositionArray[pos+1]]);

      if(fDataSignals[fSignalPositionArray[pos+1]]>fDataSignals[fSignalPositionArray[pos]]){
	isFalling=1;
      }
      if(fDataSignals[fSignalPositionArray[pos+1]]<fDataSignals[fSignalPositionArray[pos]]&&isFalling){
	Int_t seqmean=0;
	seqmean = seqaverage/seqcharge;
	
	//Calculate mean in pad direction:
	Int_t padmean = seqcharge*fPadNo;
	Int_t paderror = fPadNo*padmean;
	AliHLTTPCClusters candidate;
	candidate.fTotalCharge   = seqcharge;
	candidate.fPad       = padmean;
	candidate.fPad2      = paderror;
	candidate.fTime      = seqaverage;
	candidate.fTime2     = seqerror;
	candidate.fMean          = seqmean;
	candidate.fLastMergedPad = fPadNo;
	fClusterCandidates.push_back(candidate);
	fUsedClusterCandidates.push_back(0);
	isFalling=0;
	seqcharge=0;
	seqaverage=0;
	seqerror=0;

	tmpPos.clear();
	tmpSig.clear();

	continue;
      }
	 
      if(pos<1){
	seqcharge+=fDataSignals[fSignalPositionArray[0]];	
	seqaverage += fSignalPositionArray[0]*fDataSignals[fSignalPositionArray[0]];
	seqerror += fSignalPositionArray[0]*fSignalPositionArray[0]*fDataSignals[fSignalPositionArray[0]];
	tmpPos.push_back(fSignalPositionArray[0]);
	tmpSig.push_back(fDataSignals[fSignalPositionArray[0]]);
	  
	//Calculate mean of sequence:
	Int_t seqmean=0;
	seqmean = seqaverage/seqcharge;
	  
	//Calculate mean in pad direction:
	Int_t padmean = seqcharge*fPadNo;
	Int_t paderror = fPadNo*padmean;
	AliHLTTPCClusters candidate;
	candidate.fTotalCharge   = seqcharge;
	candidate.fPad       = padmean;
	candidate.fPad2      = paderror;
	candidate.fTime      = seqaverage;
	candidate.fTime2     = seqerror;
	candidate.fMean          = seqmean;
	candidate.fLastMergedPad = fPadNo;
	fClusterCandidates.push_back(candidate);
	fUsedClusterCandidates.push_back(0);
	isFalling=0;
	seqcharge=0;
	seqaverage=0;
	seqerror=0;

	tmpPos.clear();
	tmpSig.clear();
      }
    }
    else if(seqcharge>0){
      seqcharge+=fDataSignals[fSignalPositionArray[pos+1]];	
      seqaverage += fSignalPositionArray[pos+1]*fDataSignals[fSignalPositionArray[pos+1]];
	seqerror += fSignalPositionArray[pos+1]*fSignalPositionArray[pos+1]*fDataSignals[fSignalPositionArray[pos+1]];
	tmpPos.push_back(fSignalPositionArray[pos+1]);
	tmpSig.push_back(fDataSignals[fSignalPositionArray[pos+1]]);

	//Calculate mean of sequence:
	Int_t seqmean=0;
	seqmean = seqaverage/seqcharge;
	
	//Calculate mean in pad direction:
	Int_t padmean = seqcharge*fPadNo;
	Int_t paderror = fPadNo*padmean;
	AliHLTTPCClusters candidate;
	candidate.fTotalCharge   = seqcharge;
	candidate.fPad       = padmean;
	candidate.fPad2      = paderror;
	candidate.fTime      = seqaverage;
	candidate.fTime2     = seqerror;
	candidate.fMean          = seqmean;
	candidate.fLastMergedPad = fPadNo;
	fClusterCandidates.push_back(candidate);
	fUsedClusterCandidates.push_back(0);
	isFalling=0;
	seqcharge=0;
	seqaverage=0;
	seqerror=0;

	tmpPos.clear();
	tmpSig.clear();
    }
  }
}
Commit	Line	Data
2a083ac4	1	// @(#) $Id$
2a083ac4	2
46b33a24	3	/**************************************************************************
9be2600f	4	* This file is property of and copyright by the ALICE HLT Project *
9be2600f	5	* ALICE Experiment at CERN, All rights reserved. *
46b33a24	6	* *
9be2600f	7	* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
01f43166	8	* Kenneth Aamodt <Kenneth.aamodt@ift.uib.no> *
9be2600f	9	* for The ALICE HLT Project. *
46b33a24	10	* *
	11	* Permission to use, copy, modify and distribute this software and its *
	12	* documentation strictly for non-commercial purposes is hereby granted *
	13	* without fee, provided that the above copyright notice appears in all *
	14	* copies and that both the copyright notice and this permission notice *
	15	* appear in the supporting documentation. The authors make no claims *
	16	* about the suitability of this software for any purpose. It is *
	17	* provided "as is" without express or implied warranty. *
	18	**************************************************************************/
	19
	20	/** @file AliHLTTPCPad.cxx
01f43166	21	@author Matthias Richter, Kenneth Aamodt
46b33a24	22	@date
	23	@brief Container Class for TPC Pads.
	24	*/
	25
a1dbf058	26	// see header file for class documentation
	27	// or
	28	// refer to README to build package
	29	// or
	30	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
	31
46b33a24	32	#if __GNUC__>= 3
	33	using namespace std;
	34	#endif
	35
	36	#include <cerrno>
	37	#include "AliHLTTPCPad.h"
84645eb0	38	#include "AliHLTStdIncludes.h"
46b33a24	39
01f43166	40
	41	//added by kenneth
	42	#include "AliHLTTPCTransform.h"
	43	#include "AliHLTTPCClusters.h"
	44	#include <sys/time.h>
	45	//------------------------------
	46
46b33a24	47	/** margin for the base line be re-avaluated */
	48	#define ALIHLTPAD_BASELINE_MARGIN (2*fAverage)
	49
	50	/** ROOT macro for the implementation of ROOT specific class methods */
	51	ClassImp(AliHLTTPCPad)
	52
	53	AliHLTTPCPad::AliHLTTPCPad()
	54	:
a1dbf058	55	fClusterCandidates(),
a1dbf058	56	fUsedClusterCandidates(),
46b33a24	57	fRowNo(-1),
	58	fPadNo(-1),
	59	fThreshold(0),
	60	fAverage(-1),
	61	fNofEvents(0),
	62	fSum(0),
2a083ac4	63	fCount(0),
2a083ac4	64	fTotal(0),
46b33a24	65	fBLMax(-1),
46b33a24	66	fBLMaxBin(-1),
84645eb0	67	fBLMin(-1),
84645eb0	68	fBLMinBin(-1),
46b33a24	69	fFirstBLBin(0),
46b33a24	70	fNofBins(0),
2a083ac4	71	fReadPos(0),
01f43166	72	fpRawData(NULL),
01f43166	73	fDataSignals(NULL),
	74	fSignalPositionArray(NULL),
	75	fSizeOfSignalPositionArray(0)
46b33a24	76	{
2a083ac4	77	// see header file for class documentation
	78	// or
	79	// refer to README to build package
	80	// or
	81	// visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
01f43166	82	// HLTInfo("Entering default constructor");
	83	fDataSignals= new AliHLTTPCSignal_t[AliHLTTPCTransform::GetNTimeBins()];
	84	memset( fDataSignals, 0xFF, sizeof(Int_t)*(AliHLTTPCTransform::GetNTimeBins()));
	85
	86	fSignalPositionArray= new AliHLTTPCSignal_t[AliHLTTPCTransform::GetNTimeBins()];
	87	memset( fSignalPositionArray, 0xFF, sizeof(Int_t)*(AliHLTTPCTransform::GetNTimeBins()));
	88	fSizeOfSignalPositionArray=0;
46b33a24	89	}
	90
	91	AliHLTTPCPad::AliHLTTPCPad(Int_t offset, Int_t nofBins)
	92	:
a1dbf058	93	fClusterCandidates(),
a1dbf058	94	fUsedClusterCandidates(),
46b33a24	95	fRowNo(-1),
	96	fPadNo(-1),
	97	fThreshold(0),
	98	fAverage(-1),
	99	fNofEvents(0),
	100	fSum(0),
2a083ac4	101	fCount(0),
2a083ac4	102	fTotal(0),
46b33a24	103	fBLMax(-1),
46b33a24	104	fBLMaxBin(-1),
84645eb0	105	fBLMin(-1),
84645eb0	106	fBLMinBin(-1),
46b33a24	107	fFirstBLBin(offset),
46b33a24	108	fNofBins(nofBins),
2a083ac4	109	fReadPos(0),
01f43166	110	fpRawData(NULL),
01f43166	111	fDataSignals(NULL),
	112	fSignalPositionArray(NULL),
	113	fSizeOfSignalPositionArray(0)
46b33a24	114	{
2a083ac4	115	// see header file for class documentation
46b33a24	116	}
46b33a24	117
46b33a24	118	AliHLTTPCPad::~AliHLTTPCPad()
46b33a24	119	{
2a083ac4	120	// see header file for class documentation
46b33a24	121	if (fpRawData) {
	122	HLTWarning("event data acquisition not stopped");
	123	StopEvent();
	124	}
01f43166	125	if (fDataSignals) {
	126	AliHLTTPCSignal_t* pData=fDataSignals;
	127	fDataSignals=NULL;
	128	delete [] pData;
	129	}
	130	if (fSignalPositionArray) {
	131	AliHLTTPCSignal_t* pData=fSignalPositionArray;
	132	fSignalPositionArray=NULL;
	133	// delete [] pData;
	134	}
	135
46b33a24	136	}
	137
	138	Int_t AliHLTTPCPad::SetID(Int_t rowno, Int_t padno)
	139	{
2a083ac4	140	// see header file for class documentation
46b33a24	141	fRowNo=rowno;
46b33a24	142	fPadNo=padno;
2a083ac4	143	return 0;
46b33a24	144	}
	145
	146	Int_t AliHLTTPCPad::StartEvent()
	147	{
2a083ac4	148	// see header file for class documentation
46b33a24	149	Int_t iResult=0;
	150	if (fpRawData==NULL) {
	151	fBLMax=-1;
	152	fBLMaxBin=-1;
84645eb0	153	fBLMin=-1;
84645eb0	154	fBLMinBin=-1;
46b33a24	155	fSum=0;
	156	fCount=0;
	157	fTotal=0;
	158	if (fNofBins>0) {
	159	fpRawData=new AliHLTTPCSignal_t[fNofBins];
	160	if (fpRawData) {
	161	for (int i=0; i<fNofBins; i++) fpRawData[i]=-1;
	162	} else {
	163	HLTError("memory allocation failed");
	164	iResult=-ENOMEM;
	165	}
	166	}
	167	} else {
	168	HLTWarning("event data acquisition already started");
	169	iResult=-EALREADY;
	170	}
	171	return iResult;
	172	}
	173
	174	Int_t AliHLTTPCPad::CalculateBaseLine(Int_t reqMinCount)
	175	{
2a083ac4	176	// see header file for class documentation
46b33a24	177	Int_t iResult=0;
46b33a24	178	AliHLTTPCSignal_t avBackup=fAverage;
84645eb0	179	//HLTDebug("reqMinCount=%d fCount=%d fTotal=%d fSum=%d fBLMax=%d fBLMin=%d", reqMinCount, fCount, fTotal, fSum, fBLMax, fBLMin);
46b33a24	180	if (fCount>=reqMinCount && fCount>=fTotal/2) {
	181	fAverage=fCount>0?fSum/fCount:0;
	182	if (fAverage>0) {
84645eb0	183	//HLTDebug("average for current event %d (%d - %d)", fAverage, fBLMax, fBLMin);
46b33a24	184	fCount=0;fSum=-1;
	185	if (fBLMax>ALIHLTPAD_BASELINE_MARGIN) {
	186	// calculate again
21b6a334	187	//HLTDebug("maximum value %d exceeds margin for base line (%d) "
21b6a334	188	// "-> re-evaluate base line", fBLMax, ALIHLTPAD_BASELINE_MARGIN);
46b33a24	189	if (fpRawData) {
	190	for (Int_t i=fFirstBLBin; i<fNofBins; i++)
	191	if (fpRawData[i]>=0) AddBaseLineValue(i, fpRawData[i]);
	192	if (fCount>0 && fCount>=reqMinCount && fCount>=fTotal/2) {
	193	fAverage=fSum/fCount;
3cde846d	194	//HLTDebug("new average %d", fAverage);
46b33a24	195	} else {
3cde846d	196	// HLTDebug("baseline re-eveluation skipped because of to few "
	197	// "contributing bins: total=%d, contributing=%d, req=%d"
	198	// "\ndata might be already zero suppressed"
	199	// , fTotal, fCount, reqMinCount);
46b33a24	200	iResult=-ENODATA;
	201	}
	202	fCount=0;fSum=-1;
	203	} else {
	204	HLTError("missing raw data for base line calculation");
	205	iResult=-ENOBUFS;
	206	}
	207	}
	208	if (iResult>=0) {
	209	// calculate average for all events
	210	fAverage=((avBackup*fNofEvents)+fAverage)/(fNofEvents+1);
84645eb0	211	//HLTDebug("base line average for %d event(s): %d", fNofEvents+1, fAverage);
46b33a24	212	} else {
	213	fAverage=avBackup;
	214	}
	215	} else {
	216	fAverage=avBackup;
	217	}
	218	} else {
3cde846d	219	// HLTDebug("baseline calculation skipped because of to few contributing "
	220	// "bins: total=%d, contributing=%d, required=%d \ndata might be "
	221	// "already zero suppressed", fTotal, fCount, reqMinCount);
46b33a24	222	}
	223
	224	return iResult;
	225	}
	226
	227	Int_t AliHLTTPCPad::StopEvent()
	228	{
2a083ac4	229	// see header file for class documentation
46b33a24	230	Int_t iResult=0;
	231	if (fpRawData) {
	232	AliHLTTPCSignal_t* pData=fpRawData;
	233	fpRawData=NULL;
	234	delete [] pData;
	235	fTotal=0;
	236	fNofEvents++;
	237	Rewind();
	238	} else if (fNofBins>0) {
	239	HLTError("event data acquisition not started");
	240	iResult=-EBADF;
	241	}
	242	return iResult;
	243	}
	244
	245	Int_t AliHLTTPCPad::ResetHistory()
	246	{
2a083ac4	247	// see header file for class documentation
46b33a24	248	Int_t iResult=0;
	249	fAverage=-1;
	250	fNofEvents=0;
	251	return iResult;
	252	}
	253
	254	Int_t AliHLTTPCPad::SetThreshold(AliHLTTPCSignal_t thresh)
	255	{
2a083ac4	256	// see header file for class documentation
46b33a24	257	Int_t iResult=0;
	258	fThreshold=thresh;
	259	return iResult;
	260	}
	261
	262	Int_t AliHLTTPCPad::AddBaseLineValue(Int_t bin, AliHLTTPCSignal_t value)
	263	{
2a083ac4	264	// see header file for class documentation
46b33a24	265	Int_t iResult=0;
	266	if (bin>=fFirstBLBin) {
	267	if (fAverage<0 \|\| value<ALIHLTPAD_BASELINE_MARGIN) {
	268	// add to the current sum and count
	269	fSum+=value;
	270	fCount++;
	271	if (fBLMax<value) {
	272	// keep the maximum value for later quality control of the base
	273	// line calculation
	274	fBLMax=value;
	275	fBLMaxBin=bin;
	276	}
84645eb0	277	if (fBLMin<0 \|\| fBLMin>value) {
	278	// keep the minimum value for later quality control of the base
	279	// line calculation
	280	fBLMin=value;
	281	fBLMinBin=bin;
	282	}
46b33a24	283	} else {
3cde846d	284	// HLTDebug("ignoring value %d (bin %d) for base line calculation "
	285	// "(current average is %d)",
	286	// value, bin, fAverage);
46b33a24	287	}
	288	}
	289	return iResult;
	290	}
	291
	292	Int_t AliHLTTPCPad::SetRawData(Int_t bin, AliHLTTPCSignal_t value)
	293	{
2a083ac4	294	// see header file for class documentation
46b33a24	295	Int_t iResult=0;
	296	if (fpRawData) {
	297	if (bin<fNofBins) {
	298	if (value>=0) {
	299	if (fpRawData[bin]<0) {
	300	AddBaseLineValue(bin, value);
	301	fTotal++;
	302	} else {
	303	// ignore value for average calculation
84645eb0	304	HLTWarning("overriding content of bin %d (%d)", bin, fpRawData[bin]);
46b33a24	305	}
	306	fpRawData[bin]=value;
	307	} else {
	308	HLTWarning("ignoring neg. raw data");
	309	}
	310	} else {
	311	HLTWarning("bin %d out of range (%d)", bin, fNofBins);
	312	iResult=-ERANGE;
	313	}
	314	} else if (fNofBins>0) {
	315	HLTError("event cycle not started");
	316	iResult=-EBADF;
	317	}
	318	return iResult;
	319	}
	320
	321	Int_t AliHLTTPCPad::Next(Int_t bZeroSuppression)
	322	{
2a083ac4	323	// see header file for class documentation
46b33a24	324	if (fpRawData==NULL) return 0;
	325	Int_t iResult=fReadPos<fNofBins;
	326	if (iResult>0 && (iResult=(++fReadPos<fNofBins))>0) {
	327	if (bZeroSuppression) {
	328	while ((iResult=(fReadPos<fNofBins))>0 &&
	329	GetCorrectedData(fReadPos)<=0)
	330	fReadPos++;
	331	}
	332	}
	333	return iResult;
	334	}
	335
	336	Int_t AliHLTTPCPad::Rewind(Int_t bZeroSuppression)
	337	{
2a083ac4	338	// see header file for class documentation
46b33a24	339	fReadPos=(bZeroSuppression>0?0:fFirstBLBin)-1;
	340	return Next(bZeroSuppression);
	341	}
	342
	343	AliHLTTPCSignal_t AliHLTTPCPad::GetRawData(Int_t bin) const
	344	{
2a083ac4	345	// see header file for class documentation
46b33a24	346	AliHLTTPCSignal_t data=0;
	347	if (fpRawData) {
	348	if (bin<fNofBins) {
	349	data=fpRawData[bin];
	350	} else {
	351	HLTWarning("requested bin %d out of range (%d)", bin, fNofBins);
	352	}
	353	} else if (fNofBins>0) {
	354	HLTWarning("data only available within event cycle");
	355	}
	356	return data;
	357	}
	358
	359	AliHLTTPCSignal_t AliHLTTPCPad::GetCorrectedData(Int_t bin) const
	360	{
2a083ac4	361	// see header file for class documentation
46b33a24	362	AliHLTTPCSignal_t data=GetRawData(bin)-GetBaseLine(bin);
5235c3e9	363	AliHLTTPCSignal_t prev=0;
	364	if (bin>1) prev=GetRawData(bin-1)-GetBaseLine(bin-1);
	365	AliHLTTPCSignal_t succ=0;
	366	if (bin+1<GetSize()) succ=GetRawData(bin+1)-GetBaseLine(bin+1);
	367	if (fThreshold>0) {
	368	data-=fThreshold;
	369	prev-=fThreshold;
	370	succ-=fThreshold;
	371	}
	372
	373	// case 1:
	374	// the signal is below the base-line and threshold
46b33a24	375	if (data<0) data=0;
5235c3e9	376
	377	//case 2:
	378	// the neighboring bins are both below base-line/threshold
	379	// a real signal is always more than one bin wide because of the shaper
	380	if (prev<=0 && succ<=0) data=0;
	381
	382	// case 3:
	383	// the bin is inside the range of ignored bins
46b33a24	384	if (bin<fFirstBLBin) data=0;
84645eb0	385	//HLTDebug("fReadPos=%d data=%d threshold=%d raw data=%d base line=%d", fReadPos, data, fThreshold, GetRawData(bin), GetBaseLine(bin));
46b33a24	386	return data;
	387	}
	388
	389	AliHLTTPCSignal_t AliHLTTPCPad::GetBaseLine(Int_t bin) const
	390	{
2a083ac4	391	// see header file for class documentation
84645eb0	392	AliHLTTPCSignal_t val=0;
	393	if (fAverage>0) {
	394	// we take the minumum value as the base line if it doesn't differ from
	395	// the average to much
84645eb0	396	val=fAverage;
5235c3e9	397	#ifdef KEEP_NOISE
2a083ac4	398	const AliHLTTPCSignal_t kMaxDifference=15;
84645eb0	399	if ((fAverage-fBLMin)<=kMaxDifference) val=fBLMin;
84645eb0	400	else val>kMaxDifference?val-=kMaxDifference:0;
5235c3e9	401	#endif
84645eb0	402	}
	403	if (val<0) {
	404	// here we should never get
	405	val=0;
	406	HLTFatal("wrong base line value");
	407	}
	408	return val;
46b33a24	409	}
	410
	411	AliHLTTPCSignal_t AliHLTTPCPad::GetAverage() const
	412	{
2a083ac4	413	// see header file for class documentation
46b33a24	414	return fAverage>0?fAverage:0;
	415	}
	416
5235c3e9	417	Float_t AliHLTTPCPad::GetOccupancy() const
5235c3e9	418	{
2a083ac4	419	// see header file for class documentation
5235c3e9	420	Float_t occupancy=0;
	421	if (fpRawData && fNofBins>0) {
	422	for (Int_t i=fFirstBLBin; i<fNofBins; i++) {
	423	if (GetCorrectedData(i)>0) occupancy+=1;
	424	}
	425	if (fNofBins-fFirstBLBin>0)
	426	occupancy/=fNofBins-fFirstBLBin;
	427	}
	428	return occupancy;
	429	}
	430
	431	Float_t AliHLTTPCPad::GetAveragedOccupancy() const
	432	{
2a083ac4	433	// see header file for class documentation
2a083ac4	434
5235c3e9	435	// history is not yet implemented
	436	return GetOccupancy();
	437	}
a1dbf058	438	void AliHLTTPCPad::PrintRawData()
	439	{
	440	// see header file for class documentation
01f43166	441	for(Int_t bin=0;bin<AliHLTTPCTransform::GetNTimeBins();bin++){
	442	if(GetDataSignal(bin)>0)
	443	cout<<fRowNo<<"\t"<<fPadNo<<"\t"<<bin<<"\t"<<GetDataSignal(bin)<<endl;;
	444	}
	445	cout<<"bins: "<<AliHLTTPCTransform::GetNTimeBins()<<endl;
	446	}
	447
a1dbf058	448	void AliHLTTPCPad::SetDataToDefault()
	449	{
	450	// see header file for class documentation
01f43166	451	if(fpRawData){
	452	memset( fDataSignals, 0xFF, sizeof(Int_t)*(AliHLTTPCTransform::GetNTimeBins()));
	453	memset( fSignalPositionArray, 0xFF, sizeof(Int_t)*(AliHLTTPCTransform::GetNTimeBins()));
	454	fSizeOfSignalPositionArray=0;
	455	}
	456	}
a1dbf058	457
	458	void AliHLTTPCPad::SetDataSignal(Int_t bin,Int_t signal)
	459	{
	460	// see header file for class documentation
01f43166	461	fDataSignals[bin]=signal;
	462	fSignalPositionArray[fSizeOfSignalPositionArray]=bin;
	463	fSizeOfSignalPositionArray++;
	464	}
a1dbf058	465
	466	Int_t AliHLTTPCPad::GetDataSignal(Int_t bin) const
	467	{
	468	// see header file for class documentation
01f43166	469	return fDataSignals[bin];
01f43166	470	}
a1dbf058	471
	472	void AliHLTTPCPad::FindClusterCandidates()
	473	{
	474	// see header file for class documentation
01f43166	475	UInt_t seqcharge=0;
	476	UInt_t seqaverage=0;
	477	UInt_t seqerror=0;
	478	vector<Int_t> tmpPos;
	479	vector<Int_t> tmpSig;
	480	UInt_t isFalling=0;
	481
	482	for(Int_t pos=fSizeOfSignalPositionArray-2;pos>=0;pos--){
	483
	484	if(fSignalPositionArray[pos]==fSignalPositionArray[pos+1]+1){
	485	seqcharge+=fDataSignals[fSignalPositionArray[pos+1]];
	486	seqaverage += fSignalPositionArray[pos+1]*fDataSignals[fSignalPositionArray[pos+1]];
	487	seqerror += fSignalPositionArray[pos+1]fSignalPositionArray[pos+1]fDataSignals[fSignalPositionArray[pos+1]];
	488
	489	tmpPos.push_back(fSignalPositionArray[pos+1]);
	490	tmpSig.push_back(fDataSignals[fSignalPositionArray[pos+1]]);
	491
	492	if(fDataSignals[fSignalPositionArray[pos+1]]>fDataSignals[fSignalPositionArray[pos]]){
	493	isFalling=1;
	494	}
	495	if(fDataSignals[fSignalPositionArray[pos+1]]<fDataSignals[fSignalPositionArray[pos]]&&isFalling){
	496	Int_t seqmean=0;
	497	seqmean = seqaverage/seqcharge;
	498
	499	//Calculate mean in pad direction:
	500	Int_t padmean = seqcharge*fPadNo;
	501	Int_t paderror = fPadNo*padmean;
	502	AliHLTTPCClusters candidate;
	503	candidate.fTotalCharge = seqcharge;
	504	candidate.fPad = padmean;
	505	candidate.fPad2 = paderror;
	506	candidate.fTime = seqaverage;
	507	candidate.fTime2 = seqerror;
	508	candidate.fMean = seqmean;
	509	candidate.fLastMergedPad = fPadNo;
	510	fClusterCandidates.push_back(candidate);
	511	fUsedClusterCandidates.push_back(0);
	512	isFalling=0;
	513	seqcharge=0;
	514	seqaverage=0;
	515	seqerror=0;
	516
	517	tmpPos.clear();
	518	tmpSig.clear();
	519
	520	continue;
	521	}
	522
	523	if(pos<1){
	524	seqcharge+=fDataSignals[fSignalPositionArray[0]];
	525	seqaverage += fSignalPositionArray[0]*fDataSignals[fSignalPositionArray[0]];
	526	seqerror += fSignalPositionArray[0]fSignalPositionArray[0]fDataSignals[fSignalPositionArray[0]];
	527	tmpPos.push_back(fSignalPositionArray[0]);
	528	tmpSig.push_back(fDataSignals[fSignalPositionArray[0]]);
	529
	530	//Calculate mean of sequence:
	531	Int_t seqmean=0;
	532	seqmean = seqaverage/seqcharge;
	533
	534	//Calculate mean in pad direction:
	535	Int_t padmean = seqcharge*fPadNo;
	536	Int_t paderror = fPadNo*padmean;
	537	AliHLTTPCClusters candidate;
	538	candidate.fTotalCharge = seqcharge;
539	candidate.fPad = padmean;
540	candidate.fPad2 = paderror;
541	candidate.fTime = seqaverage;
542	candidate.fTime2 = seqerror;
543	candidate.fMean = seqmean;
544	candidate.fLastMergedPad = fPadNo;
545	fClusterCandidates.push_back(candidate);
546	fUsedClusterCandidates.push_back(0);
547	isFalling=0;
548	seqcharge=0;
549	seqaverage=0;
550	seqerror=0;
551
552	tmpPos.clear();
553	tmpSig.clear();
554	}
555	}
556	else if(seqcharge>0){
557	seqcharge+=fDataSignals[fSignalPositionArray[pos+1]];
558	seqaverage += fSignalPositionArray[pos+1]*fDataSignals[fSignalPositionArray[pos+1]];
559	seqerror += fSignalPositionArray[pos+1]fSignalPositionArray[pos+1]fDataSignals[fSignalPositionArray[pos+1]];
560	tmpPos.push_back(fSignalPositionArray[pos+1]);
561	tmpSig.push_back(fDataSignals[fSignalPositionArray[pos+1]]);
562
563	//Calculate mean of sequence:
564	Int_t seqmean=0;
565	seqmean = seqaverage/seqcharge;
566
567	//Calculate mean in pad direction:
568	Int_t padmean = seqcharge*fPadNo;
569	Int_t paderror = fPadNo*padmean;
570	AliHLTTPCClusters candidate;
571	candidate.fTotalCharge = seqcharge;
572	candidate.fPad = padmean;
573	candidate.fPad2 = paderror;
574	candidate.fTime = seqaverage;
575	candidate.fTime2 = seqerror;
576	candidate.fMean = seqmean;
577	candidate.fLastMergedPad = fPadNo;
578	fClusterCandidates.push_back(candidate);
579	fUsedClusterCandidates.push_back(0);
580	isFalling=0;
581	seqcharge=0;
582	seqaverage=0;
583	seqerror=0;
584
585	tmpPos.clear();
586	tmpSig.clear();
587	}
588	}
589	}