[u/mrichter/AliRoot.git] / PWG / TRD / AliTRDTriggerAnalysis.cxx

/**************************************************************************
 * Copyright(c) 2013, ALICE Experiment at CERN, All rights reserved.      *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * 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.                  *
 **************************************************************************/

// evaluate TRD trigger conditions,
// potentially with hardened conditions to remove
// triggers caused by conversions of low-pt photons
// at large radii
//
// Author: Jochen Klein <jochen.klein@cern.ch>

#include "AliLog.h"
#include "AliVTrack.h"
#include "AliVEvent.h"
#include "AliESDEvent.h"
#include "AliAODEvent.h"
#include "AliVTrdTrack.h"
#include "AliESDTrdTrigger.h"

#include "AliTRDTriggerAnalysis.h"

AliTRDTriggerAnalysis::AliTRDTriggerAnalysis() :
  TObject(),
  fTriggerFlags(),
  fTriggerInputs(0),
  fTriggerClasses(0),
  fVerbosity(0),
  fRequireMatch(kFALSE),
  fRequireMatchElectron(kFALSE),
  fRequireInTime(kTRUE),
  fJetTriggerMode(kHJTDefault),
  fTRDlayerMaskEl(0x1),
  fTRDnTrackletsEl(5),
  fTRDptHSE(3.),
  fTRDpidHSE(144),
  fTRDptHQU(2.),
  fTRDpidHQU(164),
  fTRDptHEE(3.),
  fTRDpidHEE(144),
  fTRDminSectorHEE(6),
  fTRDmaxSectorHEE(8),
  fTRDptHJT(3.),
  fTRDnHJT(3)
{
  // ctor

  memset(fTriggerFlags, 0, sizeof(fTriggerFlags));
  memset(fTriggerContribs, 0, sizeof(fTriggerContribs));
}

AliTRDTriggerAnalysis::~AliTRDTriggerAnalysis()
{
  // dtor
}

void AliTRDTriggerAnalysis::ResetTriggers()
{
  // reset internal cache of trigger status

  memset(fTriggerFlags, 0, sizeof(fTriggerFlags));
  fTriggerInputs = fTriggerClasses = 0;
}

Bool_t AliTRDTriggerAnalysis::CalcTriggers(const AliVEvent *event)
{
  // evaluate the TRD trigger conditions,
  // so far HCO, HSE, HQU, HJT, HEE

  ResetTriggers();

  if (!event) {
    AliErrorClass("event pointer is null");
    return kFALSE;
  }

  // GTU information
  UInt_t header = 0x0;

  if (fVerbosity > 0)
    printf("******************************************************************\n");
  const AliESDEvent *esdEvent = dynamic_cast<const AliESDEvent*> (event);
  if (esdEvent) {
    AliESDTrdTrigger* trdTriggerInfo = esdEvent->GetTrdTrigger();

    if (trdTriggerInfo) {
      for (Int_t iSector = 0; iSector < 18; ++iSector) {
	UInt_t  trgFlags = trdTriggerInfo->GetFlags(iSector);

	UInt_t trgContribs = fTriggerContribs[iSector] = trgFlags & 0xfff;
	header |= trgContribs;
	if (fVerbosity > 0)
	  printf("sector %2i: %5s %5s %5s %5s %5s %5s %5s %5s (0x%03x)\n", iSector,
		 trgContribs & (1 << 7) ? "TO" : "--",
		 trgContribs & (1 << 6) ? "E2" : "--",
		 trgContribs & (1 << 5) ? "E1" : "--",
		 trgContribs & (1 << 4) ? "J1" : "--",
		 trgContribs & (1 << 3) ? "H2" : "--",
		 trgContribs & (1 << 2) ? "H1" : "--",
		 trgContribs & (1 << 1) ? "E3" : "--",
		 trgContribs & (1 << 0) ? "M1" : "--",
		 trgContribs);

	// trackingDoneTimeSMU = ((trgFlags >> 12) & 0x3ff) * 1./120.;

	// for (Int_t iStack = 0; iStack < 5; ++iStack) {
	//   trackingDoneTMU = ((trgFlags >> 27) & (1 << iStack)) ? kTRUE : kFALSE;  // TMU-level tracking done flag
	//   trackingDoneSMUStack = ((trgFlags >> 22) & (1 << iStack)) ? kTRUE : kFALSE;  // SMU-level stack-related tracking done flag

	//   lmeFlags = trdTriggerInfo->GetLME(iStack) & 0xffffff;
	//   crcErrorFlags = (~(trdTriggerInfo->GetLME(iStack) >> 24)) & 0x3;
	// }
      }
    }
    if (fVerbosity > 0) {
      printf("------------------------------------------------------------------\n");
      printf("total    : %5s %5s %5s %5s %5s %5s %5s %5s (0x%03x)\n",
	     header & (1 << 7) ? "TO" : "--",
	     header & (1 << 6) ? "E2" : "--",
	     header & (1 << 5) ? "E1" : "--",
	     header & (1 << 4) ? "J1" : "--",
	     header & (1 << 3) ? "H2" : "--",
	     header & (1 << 2) ? "H1" : "--",
	     header & (1 << 1) ? "E3" : "--",
	     header & (1 << 0) ? "M1" : "--",
	     header);
    }
  }

  // evaluate trigger classes
  TString trgClasses = event->GetFiredTriggerClasses();
  if (trgClasses.Contains("TRDCO2"))
    MarkClass(kHCO);
  if (trgClasses.Contains("WUHJT"))
    MarkClass(kHJT);
  if (trgClasses.Contains("WUHSE"))
    MarkClass(kHSE);
  if (trgClasses.Contains("WUHQU"))
    MarkClass(kHQU);
  if (trgClasses.Contains("WUHEE"))
    MarkClass(kHEE);

  // evaluate trigger inputs
  UInt_t  trgInputs = 0;
  if (esdEvent)
    trgInputs  = esdEvent->GetHeader()->GetL1TriggerInputs();
  else if (const AliAODEvent *aodEvent = dynamic_cast<const AliAODEvent*> (event))
    trgInputs  = aodEvent->GetHeader()->GetL1TriggerInputs();
  else
    AliError("failed to retrieve L1 trigger inputs");

  if (trgInputs & (1 <<  8))
    MarkInput(kHCO);
  if (trgInputs & (1 <<  9))
    MarkInput(kHJT);
  if (trgInputs & (1 << 10))
    MarkInput(kHSE);
  if (trgInputs & (1 << 12))
    MarkInput(kHQU);
  if (trgInputs & (1 << 13))
    MarkInput(kHEE);

  // evaluate TRD GTU tracks
  const Int_t nStacks = (fJetTriggerMode == kHJTWindowZPhi) ? 360 : 90;
  Int_t nTracks[360] = { 0 }; // stack-wise counted number of tracks above pt threshold

  Int_t nTrdTracks = event->GetNumberOfTrdTracks();

  for (Int_t iTrack = 0; iTrack < nTrdTracks; ++iTrack) {
    AliVTrdTrack *trdTrack = event->GetTrdTrack(iTrack);
    if (!trdTrack) {
      AliError(Form("Failed to get track %i", iTrack));
      continue;
    }

    Int_t globalStack = 5*trdTrack->GetSector() + trdTrack->GetStack();

    MarkCondition(kHCO, globalStack);

    for (Int_t iLayer = 0; iLayer < 6; ++iLayer) {
      if (trdTrack->GetLayerMask() & (1 << iLayer)) {
	AliVTrdTracklet *trkl = trdTrack->GetTracklet(iLayer);
	if (!trkl) {
	  AliError(Form("no tracklet in layer %i where one should be for track %i",
		   iLayer, iTrack));
	}
      }
    }

    // ignore the track if it was not in time
    // (if required)
    if (fRequireInTime && !trdTrack->GetTrackInTime())
      continue;

    AliVTrack *match = trdTrack->GetTrackMatch();
    AliDebug(2, Form("GTU track %2i with pt = %5.2f has match: %p (pt = %5.2f)",
		     iTrack, trdTrack->Pt(), match, match ? match->Pt() : 0));

    // ignore the track if it does not have a matched global track
    // (if required)
    if (fRequireMatch && !match)
      continue;

    // stack-wise counting of tracks above pt threshold for jet trigger
    if (TMath::Abs(trdTrack->Pt()) >= fTRDptHJT) {
      if (fJetTriggerMode == kHJTDefault)
	++nTracks[globalStack];
      else if (fJetTriggerMode == kHJTWindowZPhi) {
	AliESDTrdTrack *esdTrdTrack = dynamic_cast<AliESDTrdTrack*> (trdTrack);
	if (esdTrdTrack) {
	  Double_t a = esdTrdTrack->GetA()/128.;
	  Double_t b = esdTrdTrack->GetB()/128.;
	  Double_t c = esdTrdTrack->GetC()/256. / TMath::Tan( -2.0 / 180.0 * TMath::Pi() );
	  Double_t x = 297.759; // L0: 297.759, L1: 309.17

	  Double_t ypos = -a + x*b + (a >= 0. ? -0.253 : 0.253);
	  Double_t zpos = c*x + (c >= 0. ? -0.84 : 0.84);

	  const Float_t zStackCenter[5] = {241, 117, 0, -117, -241};

	  Bool_t upperHalfPhi = ypos >= 0.;
	  Bool_t upperHalfZ = zpos >= zStackCenter[esdTrdTrack->GetStack()];

	  Int_t stackIdx = 20 * esdTrdTrack->GetSector() + (upperHalfPhi ? 10 : 0) + 2 * esdTrdTrack->GetStack() + (upperHalfZ ? 1 : 0);
	  ++nTracks[stackIdx];
	  ++nTracks[stackIdx - 10 + (((stackIdx - 10) < 0) ? 360 : 0)];
	  if ((stackIdx % 10) != 0) {
	    ++nTracks[stackIdx -  1];
	    ++nTracks[stackIdx - 11 + (((stackIdx - 11) < 0) ? 360 : 0)];
	  }
	}
      }
    }

    // ignore the track for the electron triggers
    // if it does not have a matched global track
    // (if required)
    if (fRequireMatchElectron && !match)
      continue;

    // ignore the track for the electron triggers
    // if it does not fulfill the tracklet requirement
    if (trdTrack->GetNTracklets() < fTRDnTrackletsEl)
      continue;
    if ((trdTrack->GetLayerMask() & fTRDlayerMaskEl) != fTRDlayerMaskEl)
      continue;

    if ((TMath::Abs(trdTrack->Pt()) >= fTRDptHQU) && (trdTrack->GetPID() >= fTRDpidHQU))
      MarkCondition(kHQU, globalStack);

    if ((TMath::Abs(trdTrack->Pt()) >= fTRDptHSE) && (trdTrack->GetPID() >= fTRDpidHSE))
      MarkCondition(kHSE, globalStack);

    if ((trdTrack->GetSector() >= fTRDminSectorHEE) && (trdTrack->GetSector() <= fTRDmaxSectorHEE) &&
	(TMath::Abs(trdTrack->Pt()) >= fTRDptHEE) && (trdTrack->GetPID() >= fTRDpidHEE))
      MarkCondition(kHEE, globalStack);
  }

  // check if HJT condition is fulfilled in any stack
  for (Int_t iStack = 0; iStack < nStacks; ++iStack) {
    if (nTracks[iStack] >= fTRDnHJT) {
      MarkCondition(kHJT, iStack);
      break;
    }
  }

  return kTRUE;
}
Commit	Line	Data
99d87d49	1	/**************************************************************************
	2	* Copyright(c) 2013, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	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	// evaluate TRD trigger conditions,
	17	// potentially with hardened conditions to remove
	18	// triggers caused by conversions of low-pt photons
	19	// at large radii
	20	//
	21	// Author: Jochen Klein <jochen.klein@cern.ch>
	22
	23	#include "AliLog.h"
	24	#include "AliVTrack.h"
d384e2d6	25	#include "AliVEvent.h"
16edfc85 AG	26	#include "AliESDEvent.h"
16edfc85 AG	27	#include "AliAODEvent.h"
d384e2d6	28	#include "AliVTrdTrack.h"
16edfc85	29	#include "AliESDTrdTrigger.h"
99d87d49	30
	31	#include "AliTRDTriggerAnalysis.h"
	32
	33	AliTRDTriggerAnalysis::AliTRDTriggerAnalysis() :
	34	TObject(),
16edfc85	35	fTriggerFlags(),
99d87d49	36	fTriggerInputs(0),
99d87d49	37	fTriggerClasses(0),
16edfc85	38	fVerbosity(0),
99d87d49	39	fRequireMatch(kFALSE),
16edfc85 AG	40	fRequireMatchElectron(kFALSE),
16edfc85 AG	41	fRequireInTime(kTRUE),
007212be	42	fJetTriggerMode(kHJTDefault),
16edfc85 AG	43	fTRDlayerMaskEl(0x1),
16edfc85 AG	44	fTRDnTrackletsEl(5),
99d87d49	45	fTRDptHSE(3.),
	46	fTRDpidHSE(144),
	47	fTRDptHQU(2.),
	48	fTRDpidHQU(164),
	49	fTRDptHEE(3.),
	50	fTRDpidHEE(144),
	51	fTRDminSectorHEE(6),
	52	fTRDmaxSectorHEE(8),
	53	fTRDptHJT(3.),
	54	fTRDnHJT(3)
	55	{
	56	// ctor
16edfc85 AG	57
16edfc85 AG	58	memset(fTriggerFlags, 0, sizeof(fTriggerFlags));
51d42792	59	memset(fTriggerContribs, 0, sizeof(fTriggerContribs));
99d87d49	60	}
	61
	62	AliTRDTriggerAnalysis::~AliTRDTriggerAnalysis()
	63	{
	64	// dtor
	65	}
	66
16edfc85 AG	67	void AliTRDTriggerAnalysis::ResetTriggers()
	68	{
	69	// reset internal cache of trigger status
	70
	71	memset(fTriggerFlags, 0, sizeof(fTriggerFlags));
	72	fTriggerInputs = fTriggerClasses = 0;
	73	}
	74
d384e2d6	75	Bool_t AliTRDTriggerAnalysis::CalcTriggers(const AliVEvent *event)
99d87d49	76	{
	77	// evaluate the TRD trigger conditions,
	78	// so far HCO, HSE, HQU, HJT, HEE
	79
	80	ResetTriggers();
	81
d384e2d6	82	if (!event) {
d384e2d6	83	AliErrorClass("event pointer is null");
99d87d49	84	return kFALSE;
	85	}
	86
16edfc85 AG	87	// GTU information
	88	UInt_t header = 0x0;
	89
	90	if (fVerbosity > 0)
	91	printf("******************************************************************\n");
	92	const AliESDEvent esdEvent = dynamic_cast<const AliESDEvent> (event);
	93	if (esdEvent) {
	94	AliESDTrdTrigger* trdTriggerInfo = esdEvent->GetTrdTrigger();
	95
565b0415	96	if (trdTriggerInfo) {
	97	for (Int_t iSector = 0; iSector < 18; ++iSector) {
	98	UInt_t trgFlags = trdTriggerInfo->GetFlags(iSector);
	99
	100	UInt_t trgContribs = fTriggerContribs[iSector] = trgFlags & 0xfff;
	101	header \|= trgContribs;
	102	if (fVerbosity > 0)
	103	printf("sector %2i: %5s %5s %5s %5s %5s %5s %5s %5s (0x%03x)\n", iSector,
	104	trgContribs & (1 << 7) ? "TO" : "--",
	105	trgContribs & (1 << 6) ? "E2" : "--",
	106	trgContribs & (1 << 5) ? "E1" : "--",
	107	trgContribs & (1 << 4) ? "J1" : "--",
	108	trgContribs & (1 << 3) ? "H2" : "--",
	109	trgContribs & (1 << 2) ? "H1" : "--",
	110	trgContribs & (1 << 1) ? "E3" : "--",
	111	trgContribs & (1 << 0) ? "M1" : "--",
	112	trgContribs);
	113
	114	// trackingDoneTimeSMU = ((trgFlags >> 12) & 0x3ff) * 1./120.;
	115
	116	// for (Int_t iStack = 0; iStack < 5; ++iStack) {
	117	// trackingDoneTMU = ((trgFlags >> 27) & (1 << iStack)) ? kTRUE : kFALSE; // TMU-level tracking done flag
	118	// trackingDoneSMUStack = ((trgFlags >> 22) & (1 << iStack)) ? kTRUE : kFALSE; // SMU-level stack-related tracking done flag
	119
	120	// lmeFlags = trdTriggerInfo->GetLME(iStack) & 0xffffff;
	121	// crcErrorFlags = (~(trdTriggerInfo->GetLME(iStack) >> 24)) & 0x3;
	122	// }
	123	}
16edfc85 AG	124	}
	125	if (fVerbosity > 0) {
	126	printf("------------------------------------------------------------------\n");
	127	printf("total : %5s %5s %5s %5s %5s %5s %5s %5s (0x%03x)\n",
	128	header & (1 << 7) ? "TO" : "--",
	129	header & (1 << 6) ? "E2" : "--",
	130	header & (1 << 5) ? "E1" : "--",
	131	header & (1 << 4) ? "J1" : "--",
	132	header & (1 << 3) ? "H2" : "--",
	133	header & (1 << 2) ? "H1" : "--",
	134	header & (1 << 1) ? "E3" : "--",
	135	header & (1 << 0) ? "M1" : "--",
	136	header);
	137	}
	138	}
99d87d49	139
16edfc85 AG	140	// evaluate trigger classes
	141	TString trgClasses = event->GetFiredTriggerClasses();
	142	if (trgClasses.Contains("TRDCO2"))
	143	MarkClass(kHCO);
	144	if (trgClasses.Contains("WUHJT"))
	145	MarkClass(kHJT);
	146	if (trgClasses.Contains("WUHSE"))
	147	MarkClass(kHSE);
	148	if (trgClasses.Contains("WUHQU"))
	149	MarkClass(kHQU);
	150	if (trgClasses.Contains("WUHEE"))
	151	MarkClass(kHEE);
	152
	153	// evaluate trigger inputs
	154	UInt_t trgInputs = 0;
	155	if (esdEvent)
	156	trgInputs = esdEvent->GetHeader()->GetL1TriggerInputs();
	157	else if (const AliAODEvent aodEvent = dynamic_cast<const AliAODEvent> (event))
	158	trgInputs = aodEvent->GetHeader()->GetL1TriggerInputs();
	159	else
	160	AliError("failed to retrieve L1 trigger inputs");
	161
	162	if (trgInputs & (1 << 8))
	163	MarkInput(kHCO);
	164	if (trgInputs & (1 << 9))
	165	MarkInput(kHJT);
	166	if (trgInputs & (1 << 10))
	167	MarkInput(kHSE);
	168	if (trgInputs & (1 << 12))
	169	MarkInput(kHQU);
	170	if (trgInputs & (1 << 13))
	171	MarkInput(kHEE);
	172
	173	// evaluate TRD GTU tracks
007212be	174	const Int_t nStacks = (fJetTriggerMode == kHJTWindowZPhi) ? 360 : 90;
007212be	175	Int_t nTracks[360] = { 0 }; // stack-wise counted number of tracks above pt threshold
99d87d49	176
d384e2d6	177	Int_t nTrdTracks = event->GetNumberOfTrdTracks();
99d87d49	178
99d87d49	179	for (Int_t iTrack = 0; iTrack < nTrdTracks; ++iTrack) {
d384e2d6	180	AliVTrdTrack *trdTrack = event->GetTrdTrack(iTrack);
16edfc85 AG	181	if (!trdTrack) {
16edfc85 AG	182	AliError(Form("Failed to get track %i", iTrack));
99d87d49	183	continue;
16edfc85 AG	184	}
	185
	186	Int_t globalStack = 5*trdTrack->GetSector() + trdTrack->GetStack();
	187
	188	MarkCondition(kHCO, globalStack);
	189
	190	for (Int_t iLayer = 0; iLayer < 6; ++iLayer) {
	191	if (trdTrack->GetLayerMask() & (1 << iLayer)) {
	192	AliVTrdTracklet *trkl = trdTrack->GetTracklet(iLayer);
	193	if (!trkl) {
	194	AliError(Form("no tracklet in layer %i where one should be for track %i",
	195	iLayer, iTrack));
	196	}
	197	}
	198	}
99d87d49	199
	200	// ignore the track if it was not in time
	201	// (if required)
	202	if (fRequireInTime && !trdTrack->GetTrackInTime())
	203	continue;
	204
	205	AliVTrack *match = trdTrack->GetTrackMatch();
	206	AliDebug(2, Form("GTU track %2i with pt = %5.2f has match: %p (pt = %5.2f)",
	207	iTrack, trdTrack->Pt(), match, match ? match->Pt() : 0));
	208
	209	// ignore the track if it does not have a matched global track
	210	// (if required)
	211	if (fRequireMatch && !match)
	212	continue;
	213
99d87d49	214	// stack-wise counting of tracks above pt threshold for jet trigger
16edfc85	215	if (TMath::Abs(trdTrack->Pt()) >= fTRDptHJT) {
007212be	216	if (fJetTriggerMode == kHJTDefault)
	217	++nTracks[globalStack];
	218	else if (fJetTriggerMode == kHJTWindowZPhi) {
	219	AliESDTrdTrack esdTrdTrack = dynamic_cast<AliESDTrdTrack> (trdTrack);
	220	if (esdTrdTrack) {
	221	Double_t a = esdTrdTrack->GetA()/128.;
	222	Double_t b = esdTrdTrack->GetB()/128.;
	223	Double_t c = esdTrdTrack->GetC()/256. / TMath::Tan( -2.0 / 180.0 * TMath::Pi() );
	224	Double_t x = 297.759; // L0: 297.759, L1: 309.17
	225
	226	Double_t ypos = -a + x*b + (a >= 0. ? -0.253 : 0.253);
	227	Double_t zpos = c*x + (c >= 0. ? -0.84 : 0.84);
	228
	229	const Float_t zStackCenter[5] = {241, 117, 0, -117, -241};
	230
	231	Bool_t upperHalfPhi = ypos >= 0.;
	232	Bool_t upperHalfZ = zpos >= zStackCenter[esdTrdTrack->GetStack()];
	233
	234	Int_t stackIdx = 20 * esdTrdTrack->GetSector() + (upperHalfPhi ? 10 : 0) + 2 * esdTrdTrack->GetStack() + (upperHalfZ ? 1 : 0);
	235	++nTracks[stackIdx];
	236	++nTracks[stackIdx - 10 + (((stackIdx - 10) < 0) ? 360 : 0)];
	237	if ((stackIdx % 10) != 0) {
	238	++nTracks[stackIdx - 1];
	239	++nTracks[stackIdx - 11 + (((stackIdx - 11) < 0) ? 360 : 0)];
	240	}
	241	}
	242	}
99d87d49	243	}
	244
	245	// ignore the track for the electron triggers
	246	// if it does not have a matched global track
	247	// (if required)
	248	if (fRequireMatchElectron && !match)
	249	continue;
	250
16edfc85 AG	251	// ignore the track for the electron triggers
	252	// if it does not fulfill the tracklet requirement
	253	if (trdTrack->GetNTracklets() < fTRDnTrackletsEl)
	254	continue;
	255	if ((trdTrack->GetLayerMask() & fTRDlayerMaskEl) != fTRDlayerMaskEl)
	256	continue;
	257
	258	if ((TMath::Abs(trdTrack->Pt()) >= fTRDptHQU) && (trdTrack->GetPID() >= fTRDpidHQU))
	259	MarkCondition(kHQU, globalStack);
99d87d49	260
16edfc85 AG	261	if ((TMath::Abs(trdTrack->Pt()) >= fTRDptHSE) && (trdTrack->GetPID() >= fTRDpidHSE))
16edfc85 AG	262	MarkCondition(kHSE, globalStack);
99d87d49	263
99d87d49	264	if ((trdTrack->GetSector() >= fTRDminSectorHEE) && (trdTrack->GetSector() <= fTRDmaxSectorHEE) &&
16edfc85 AG	265	(TMath::Abs(trdTrack->Pt()) >= fTRDptHEE) && (trdTrack->GetPID() >= fTRDpidHEE))
16edfc85 AG	266	MarkCondition(kHEE, globalStack);
99d87d49	267	}
	268
	269	// check if HJT condition is fulfilled in any stack
007212be	270	for (Int_t iStack = 0; iStack < nStacks; ++iStack) {
99d87d49	271	if (nTracks[iStack] >= fTRDnHJT) {
16edfc85	272	MarkCondition(kHJT, iStack);
99d87d49	273	break;
	274	}
	275	}
	276
	277	return kTRUE;
	278	}