[u/mrichter/AliRoot.git] / HLT / trigger / AliL3Trigger.cxx


#include "AliL3Trigger.h"
#include "AliL3TrackArray.h"
#include "AliL3Transform.h"
#include "AliL3Vertex.h"
#include "AliL3Defs.h"
#include "AliL3DigitData.h"
#include "AliL3Logging.h"
#include "AliL3Track.h"
#include "AliL3MemHandler.h"

ClassImp(AliL3Trigger)

AliL3Trigger::AliL3Trigger()
{
  fDataSize=0;
  fTracks=0;
  fDigitRowData=0;
  fOutput=0;
  fVertex=0;
}

AliL3Trigger::~AliL3Trigger()
{
  if(fTracks)
    delete fTracks;
}

void AliL3Trigger::InitTrigger()
{
  if(fTracks)
    delete fTracks;
  fTracks = new AliL3TrackArray();
}

void AliL3Trigger::InitPatch(Int_t slice,Int_t patch)
{
  fSlice=slice;
  fPatch=patch;
  fTracks->Reset();
}

void AliL3Trigger::FillTracks(Int_t ntracks,AliL3TrackSegmentData *tr)
{
  fTracks->FillTracks(ntracks,tr);
}

void AliL3Trigger::FillData(AliL3DigitRowData *data)
{
  fDigitRowData = data;
}

void AliL3Trigger::SetParameters(Float_t zcut,Int_t timematch,Int_t padmatch)
{
  fZcut=zcut;
  fTimeMatch=timematch;
  fPadMatch=padmatch;
}

void AliL3Trigger::SetOutputData(AliL3DigitRowData *ptr)
{
  fOutput=ptr;
}

void AliL3Trigger::RemovePileupTracks()
{
  Double_t xc,yc,zc;
  for(Int_t i=0; i<fTracks->GetNTracks(); i++)
    {
      AliL3Track *track = fTracks->GetCheckedTrack(i);
      if(!track) continue;
      track->Rotate(fSlice,kTRUE);
      track->CalculateHelix();
      track->GetClosestPoint(fVertex,xc,yc,zc);
      if(fabs(zc) > fZcut)
	{
	  fTracks->Remove(i);
	  continue;
	}
    }
  fTracks->Compress();
}

void AliL3Trigger::RemovePileupData()
{
  Float_t hit[3];
  Int_t sector,row;
  struct rowhit {Int_t pad; Int_t time;};
  rowhit row_cross[(fTracks->GetNTracks())];
  Int_t digitcount[(NumRows[fPatch])];
  Int_t totalcount=0;
  AliL3DigitRowData *rowPt = fDigitRowData;
  for(Int_t i=NRows[fPatch][0]; i<=NRows[fPatch][1]; i++)
    {
      digitcount[(i-NRows[fPatch][0])]=0;
      for(Int_t j=0; j<fTracks->GetNTracks(); j++)
	{
	  AliL3Track *track = fTracks->GetCheckedTrack(j);
	  if(!track) continue;
	  track->GetCrossingPoint(i,hit);
	  AliL3Transform::Slice2Sector(fSlice,i,sector,row);
	  AliL3Transform::Local2Raw(hit,sector,row);
	  row_cross[j].pad = (Int_t)rint(hit[1]);
	  row_cross[j].time = (Int_t)rint(hit[2]);
	}
      AliL3DigitData *digPt = (AliL3DigitData*)rowPt->fDigitData;
      Bool_t mark;
      for(Int_t k=0; k<rowPt->fNDigit; k++)
	{
	  mark = kFALSE;
	  for(Int_t l=0; l<fTracks->GetNTracks(); l++)
	    {
	      if(abs((Int_t)digPt[k].fPad-row_cross[l].pad) < fPadMatch &&
		 abs((Int_t)digPt[k].fTime-row_cross[l].time) < fTimeMatch)
		{
		  digitcount[(i-NRows[fPatch][0])]++;
		  totalcount++;
		  mark=kTRUE;
		  break;
		}
	    }
	  if(mark==kTRUE)
	    digPt[k].fCharge=0;
	}
      AliL3MemHandler::UpdateRowPointer(rowPt);
    }
  
  Int_t size = totalcount*sizeof(AliL3DigitData) + NumRows[fPatch]*sizeof(AliL3DigitRowData);
  fDataSize = size;
  LOG(AliL3Log::kDebug,"AliL3Trigger::RemovePileupData","Memory")
    <<"Allocating "<<size<<" bytes of data for trigger event"<<ENDLOG;
  Byte_t *data = new Byte_t[size];
  memset(data,0,size);
  AliL3DigitRowData *tempPt = (AliL3DigitRowData*)data;
  rowPt = fDigitRowData;
  
  Int_t localcount;
  for(Int_t i=NRows[fPatch][0]; i<=NRows[fPatch][1]; i++)
    {
      tempPt->fRow = i;
      tempPt->fNDigit = digitcount[(i-NRows[fPatch][0])];
      AliL3DigitData *digPt = (AliL3DigitData*)rowPt->fDigitData;
      localcount=0;
      for(Int_t j=0; j<rowPt->fNDigit; j++)
	{
	  if(digPt[j].fCharge==0) continue;
	  if(localcount >= digitcount[(i-NRows[fPatch][0])])
	    {
Commit	Line	Data
5a806c0e	1
	2	#include "AliL3Trigger.h"
	3	#include "AliL3TrackArray.h"
	4	#include "AliL3Transform.h"
	5	#include "AliL3Vertex.h"
	6	#include "AliL3Defs.h"
	7	#include "AliL3DigitData.h"
	8	#include "AliL3Logging.h"
	9	#include "AliL3Track.h"
	10	#include "AliL3MemHandler.h"
	11
	12	ClassImp(AliL3Trigger)
	13
	14	AliL3Trigger::AliL3Trigger()
	15	{
	16	fDataSize=0;
	17	fTracks=0;
5a806c0e	18	fDigitRowData=0;
	19	fOutput=0;
	20	fVertex=0;
	21	}
	22
	23	AliL3Trigger::~AliL3Trigger()
	24	{
	25	if(fTracks)
	26	delete fTracks;
5a806c0e	27	}
	28
	29	void AliL3Trigger::InitTrigger()
	30	{
	31	if(fTracks)
	32	delete fTracks;
5a806c0e	33	fTracks = new AliL3TrackArray();
5a806c0e	34	}
	35
	36	void AliL3Trigger::InitPatch(Int_t slice,Int_t patch)
	37	{
	38	fSlice=slice;
	39	fPatch=patch;
	40	fTracks->Reset();
	41	}
	42
	43	void AliL3Trigger::FillTracks(Int_t ntracks,AliL3TrackSegmentData *tr)
	44	{
	45	fTracks->FillTracks(ntracks,tr);
	46	}
	47
	48	void AliL3Trigger::FillData(AliL3DigitRowData *data)
	49	{
	50	fDigitRowData = data;
	51	}
	52
	53	void AliL3Trigger::SetParameters(Float_t zcut,Int_t timematch,Int_t padmatch)
	54	{
	55	fZcut=zcut;
	56	fTimeMatch=timematch;
	57	fPadMatch=padmatch;
	58	}
	59
	60	void AliL3Trigger::SetOutputData(AliL3DigitRowData *ptr)
	61	{
	62	fOutput=ptr;
	63	}
	64
	65	void AliL3Trigger::RemovePileupTracks()
	66	{
	67	Double_t xc,yc,zc;
	68	for(Int_t i=0; i<fTracks->GetNTracks(); i++)
	69	{
	70	AliL3Track *track = fTracks->GetCheckedTrack(i);
	71	if(!track) continue;
	72	track->Rotate(fSlice,kTRUE);
	73	track->CalculateHelix();
	74	track->GetClosestPoint(fVertex,xc,yc,zc);
	75	if(fabs(zc) > fZcut)
	76	{
	77	fTracks->Remove(i);
	78	continue;
	79	}
	80	}
	81	fTracks->Compress();
	82	}
	83
	84	void AliL3Trigger::RemovePileupData()
	85	{
	86	Float_t hit[3];
	87	Int_t sector,row;
	88	struct rowhit {Int_t pad; Int_t time;};
	89	rowhit row_cross[(fTracks->GetNTracks())];
	90	Int_t digitcount[(NumRows[fPatch])];
	91	Int_t totalcount=0;
	92	AliL3DigitRowData *rowPt = fDigitRowData;
	93	for(Int_t i=NRows[fPatch][0]; i<=NRows[fPatch][1]; i++)
	94	{
	95	digitcount[(i-NRows[fPatch][0])]=0;
	96	for(Int_t j=0; j<fTracks->GetNTracks(); j++)
	97	{
98	AliL3Track *track = fTracks->GetCheckedTrack(j);
99	if(!track) continue;
100	track->GetCrossingPoint(i,hit);
4ab9f8f0	101	AliL3Transform::Slice2Sector(fSlice,i,sector,row);
4ab9f8f0	102	AliL3Transform::Local2Raw(hit,sector,row);
5a806c0e	103	row_cross[j].pad = (Int_t)rint(hit[1]);
	104	row_cross[j].time = (Int_t)rint(hit[2]);
	105	}
	106	AliL3DigitData digPt = (AliL3DigitData)rowPt->fDigitData;
	107	Bool_t mark;
	108	for(Int_t k=0; k<rowPt->fNDigit; k++)
	109	{
	110	mark = kFALSE;
	111	for(Int_t l=0; l<fTracks->GetNTracks(); l++)
	112	{
	113	if(abs((Int_t)digPt[k].fPad-row_cross[l].pad) < fPadMatch &&
	114	abs((Int_t)digPt[k].fTime-row_cross[l].time) < fTimeMatch)
	115	{
	116	digitcount[(i-NRows[fPatch][0])]++;
	117	totalcount++;
	118	mark=kTRUE;
	119	break;
	120	}
	121	}
	122	if(mark==kTRUE)
	123	digPt[k].fCharge=0;
	124	}
	125	AliL3MemHandler::UpdateRowPointer(rowPt);
	126	}
	127
	128	Int_t size = totalcountsizeof(AliL3DigitData) + NumRows[fPatch]sizeof(AliL3DigitRowData);
	129	fDataSize = size;
	130	LOG(AliL3Log::kDebug,"AliL3Trigger::RemovePileupData","Memory")
	131	<<"Allocating "<<size<<" bytes of data for trigger event"<<ENDLOG;
	132	Byte_t *data = new Byte_t[size];
	133	memset(data,0,size);
	134	AliL3DigitRowData tempPt = (AliL3DigitRowData)data;
	135	rowPt = fDigitRowData;
	136
	137	Int_t localcount;
	138	for(Int_t i=NRows[fPatch][0]; i<=NRows[fPatch][1]; i++)
	139	{
	140	tempPt->fRow = i;
	141	tempPt->fNDigit = digitcount[(i-NRows[fPatch][0])];
	142	AliL3DigitData digPt = (AliL3DigitData)rowPt->fDigitData;
	143	localcount=0;
	144	for(Int_t j=0; j<rowPt->fNDigit; j++)
	145	{
	146	if(digPt[j].fCharge==0) continue;
	147	if(localcount >= digitcount[(i-NRows[fPatch][0])])
	148	{
	149