[u/mrichter/AliRoot.git] / TRD / AliTRDTriggerL1.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, 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.                  *
 **************************************************************************/

///////////////////////////////////////////////////////
//                                                   //
//                                                   //
//  TRD main trigger class for L1                    //
//                                                   //
//                                                   //
///////////////////////////////////////////////////////

#include <TMath.h>

#include "AliRun.h"
#include "AliTriggerInput.h"

#include "AliTRDTriggerL1.h"
#include "AliTRDtrigParam.h"
#include "AliTRDtrigger.h"
#include "AliTRDgtuTrack.h"
#include "AliTRDgeometry.h"

ClassImp(AliTRDTriggerL1)

//_____________________________________________________________________________
AliTRDTriggerL1::AliTRDTriggerL1():AliTriggerDetector()
{

  SetName("TRD");

}

//_____________________________________________________________________________
void AliTRDTriggerL1::CreateInputs()
{

  fInputs.AddLast(new AliTriggerInput( "TRD_HadrLPt_L1",          "Single hadron low pt ",        0x01 ));
  fInputs.AddLast(new AliTriggerInput( "TRD_HadrHPt_L1",          "Single hadron high pt",        0x02 ));
  fInputs.AddLast(new AliTriggerInput( "TRD_Unlike_EPair_L1",     "Unlike electron pair",         0x04 ));
  fInputs.AddLast(new AliTriggerInput( "TRD_Unlike_EPair_HPt_L1", "Unlike electron pair high pt", 0x08 ));
  fInputs.AddLast(new AliTriggerInput( "TRD_Like_EPair_L1",       "Like electron pair",           0x10 ));
  fInputs.AddLast(new AliTriggerInput( "TRD_Like_EPair_HPt_L1",   "Like electron pair high pt",   0x20 ));
  fInputs.AddLast(new AliTriggerInput( "TRD_Electron_L1",         "Single electron",              0x40 ));
  fInputs.AddLast(new AliTriggerInput( "TRD_Electron_HPt_L1",     "Single electron high pt",      0x80 ));

}

//_____________________________________________________________________________
void AliTRDTriggerL1::Trigger()
{

  AliRunLoader* runLoader = gAlice->GetRunLoader();

  AliLoader *loader=runLoader->GetLoader("TRDLoader");

  Int_t nEvents = runLoader->GetNumberOfEvents();

  // Trigger (tracklets, LTU)

  AliTRDgeometry *geo = AliTRDgeometry::GetGeometry(runLoader);

  AliTRDtrigger trdTrigger("Trigger","Trigger class"); 

  AliTRDtrigParam *trigp = new AliTRDtrigParam("TRDtrigParam","TRD Trigger parameters");

  gAlice = runLoader->GetAliRun();
  Double_t x[3] = { 0.0, 0.0, 0.0 };
  Double_t b[3];
  gAlice->Field(x,b);  // b[] is in kilo Gauss
  Float_t field = b[2] * 0.1; // Tesla
  Info("Trigger","Trigger set for magnetic field = %f Tesla \n",field);

  trigp->SetField(field);
  trigp->Init();

  trdTrigger.SetParameter(trigp);
  trdTrigger.SetRunLoader(runLoader);
  trdTrigger.Init();

  for (Int_t iEvent = 0; iEvent < nEvents; iEvent++) {

    trdTrigger.Open(runLoader->GetFileName(), iEvent);
    trdTrigger.ReadDigits();
    trdTrigger.MakeTracklets(kTRUE);
    trdTrigger.WriteTracklets(-1);

  }

  // Trigger (tracks, GTU)

  Float_t highPt = trigp->GetHighPt();

  Float_t pid, pt;
  Int_t   det, sec;
  Bool_t  isElectron;

  const Int_t maxEle = 1000;

  Int_t   electronPlus,          electronMinus;
  Int_t   sectorElePlus[maxEle], sectorEleMinus[maxEle];
  Float_t ptElePlus[maxEle],     ptEleMinus[maxEle];
  Int_t   hadronLowPt=0, hadronHighPt=0;

  electronPlus  = 0;
  electronMinus = 0;

  AliTRDgtuTrack *gtuTrack;
  Int_t nTracks = trdTrigger.GetNumberOfTracks();
  for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {

    gtuTrack = trdTrigger.GetTrack(iTrack);

    pid        = gtuTrack->GetPID();
    isElectron = gtuTrack->IsElectron();
    pt         = gtuTrack->GetPt();
    det        = gtuTrack->GetDetector();

    sec        = geo->GetSector(det);

    if (isElectron) {

      if (pt < 0.0) {
	sectorEleMinus[electronMinus] = sec;
	ptEleMinus[electronMinus]     = pt;
	electronMinus++;
      } else {
	sectorElePlus[electronPlus] = sec;
	ptElePlus[electronPlus]     = pt;
	electronPlus++;
      }

    } else {

      if (TMath::Abs(pt) < highPt) {
	hadronLowPt++;
      } else {
	hadronHighPt++;
      }

    }

  }

  loader->UnloadTracks();

  // hadrons

  if (hadronLowPt)  SetInput("TRD_Hadr_LPt_L1");
  if (hadronHighPt) SetInput("TRD_Hadr_HPt_L1");

  // electron-positron pairs (open angle > 80 deg)

  Int_t  secPlus, secMinus, secDiff;
  Bool_t electronUnlikePair    = kFALSE;
  Bool_t electronUnlikePairHPt = kFALSE;

  if (electronMinus > 0 && electronPlus > 0) {
    for (Int_t iPlus = 0; iPlus < electronPlus; iPlus++) {
      secPlus = sectorElePlus[iPlus];
      for (Int_t iMinus = 0; iMinus < electronMinus; iMinus++) {
	secMinus = sectorEleMinus[iMinus];
	secDiff = TMath::Abs(secPlus-secMinus);
	if (secDiff >  9) secDiff = 18 - secDiff;
	if (secDiff >= 5) {
	  electronUnlikePair = kTRUE;
	  if (TMath::Abs(ptElePlus[iPlus]) > highPt && TMath::Abs(ptEleMinus[iMinus]) > highPt) {
	    electronUnlikePairHPt = kTRUE;
	  }
	}
      }
    }
  }

  if (electronUnlikePair)    SetInput("TRD_Unlike_EPair_L1");
  if (electronUnlikePairHPt) SetInput("TRD_Unlike_EPair_HPt_L1");

  // like electron/positron pairs

  Bool_t ele1, ele1HPt;
  Bool_t ele2, ele2HPt;

  // positive

  ele1    = kFALSE;
  ele2    = kFALSE;
  ele1HPt = kFALSE;
  ele2HPt = kFALSE;
  if (electronPlus > 1) {
    for (Int_t iPlus = 0; iPlus < electronPlus; iPlus++) {
      if (!ele1) {
	ele1 = kTRUE;
      } else if (!ele2) {
	ele2 = kTRUE;
      }
      if (TMath::Abs(ptElePlus[iPlus]) > highPt) {
	if (!ele1HPt) {
	  ele1HPt = kTRUE;
	} else if (!ele2HPt) {
	  ele2HPt = kTRUE;
	}
      }
    }
  }

  if (ele1    && ele2   ) SetInput("TRD_Like_EPair_L1");
  if (ele1HPt && ele2HPt) SetInput("TRD_Like_EPair_HPt_L1");
  
  // negative

  ele1    = kFALSE;
  ele2    = kFALSE;
  ele1HPt = kFALSE;
  ele2HPt = kFALSE;
  if (electronMinus > 1) {
    for (Int_t iMinus = 0; iMinus < electronMinus; iMinus++) {
      if (!ele1) {
	ele1 = kTRUE;
      } else if (!ele2) {
	ele2 = kTRUE;
      }
      if (TMath::Abs(ptEleMinus[iMinus]) > highPt) {
	if (!ele1HPt) {
	  ele1HPt = kTRUE;
	} else if (!ele2HPt) {
	  ele2HPt = kTRUE;
	}
      }
    }
  }

  if (ele1    && ele2   ) SetInput("TRD_Like_EPair_L1");
  if (ele1HPt && ele2HPt) SetInput("TRD_Like_EPair_HPt_L1");
  
  // single electron/positron

  if (electronPlus > 0 || electronMinus > 0) {
    SetInput("TRD_Electron_L1");
    for (Int_t iPlus = 0; iPlus < electronPlus; iPlus++) {
      if (TMath::Abs(ptElePlus[iPlus]) > highPt) SetInput("TRD_Electron_HPt_L1");
      break;
    }
    for (Int_t iMinus = 0; iMinus < electronMinus; iMinus++) {
      if (TMath::Abs(ptEleMinus[iMinus]) > highPt) SetInput("TRD_Electron_HPt_L1");
      break;
    }
  }

}
Commit	Line	Data
e3b2b5e5	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, 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	///////////////////////////////////////////////////////
	17	// //
	18	// //
	19	// TRD main trigger class for L1 //
	20	// //
	21	// //
	22	///////////////////////////////////////////////////////
	23
	24	#include <TMath.h>
	25
	26	#include "AliRun.h"
	27	#include "AliTriggerInput.h"
	28
	29	#include "AliTRDTriggerL1.h"
	30	#include "AliTRDtrigParam.h"
	31	#include "AliTRDtrigger.h"
	32	#include "AliTRDgtuTrack.h"
	33	#include "AliTRDgeometry.h"
	34
	35	ClassImp(AliTRDTriggerL1)
	36
	37	//_____________________________________________________________________________
	38	AliTRDTriggerL1::AliTRDTriggerL1():AliTriggerDetector()
	39	{
	40
	41	SetName("TRD");
	42
	43	}
	44
	45	//_____________________________________________________________________________
	46	void AliTRDTriggerL1::CreateInputs()
	47	{
	48
	49	fInputs.AddLast(new AliTriggerInput( "TRD_HadrLPt_L1", "Single hadron low pt ", 0x01 ));
	50	fInputs.AddLast(new AliTriggerInput( "TRD_HadrHPt_L1", "Single hadron high pt", 0x02 ));
	51	fInputs.AddLast(new AliTriggerInput( "TRD_Unlike_EPair_L1", "Unlike electron pair", 0x04 ));
	52	fInputs.AddLast(new AliTriggerInput( "TRD_Unlike_EPair_HPt_L1", "Unlike electron pair high pt", 0x08 ));
	53	fInputs.AddLast(new AliTriggerInput( "TRD_Like_EPair_L1", "Like electron pair", 0x10 ));
	54	fInputs.AddLast(new AliTriggerInput( "TRD_Like_EPair_HPt_L1", "Like electron pair high pt", 0x20 ));
	55	fInputs.AddLast(new AliTriggerInput( "TRD_Electron_L1", "Single electron", 0x40 ));
	56	fInputs.AddLast(new AliTriggerInput( "TRD_Electron_HPt_L1", "Single electron high pt", 0x80 ));
	57
	58	}
	59
	60	//_____________________________________________________________________________
	61	void AliTRDTriggerL1::Trigger()
	62	{
	63
	64	AliRunLoader* runLoader = gAlice->GetRunLoader();
65
66	AliLoader *loader=runLoader->GetLoader("TRDLoader");
67
68	Int_t nEvents = runLoader->GetNumberOfEvents();
69
70	// Trigger (tracklets, LTU)
71
72	AliTRDgeometry *geo = AliTRDgeometry::GetGeometry(runLoader);
73
74	AliTRDtrigger trdTrigger("Trigger","Trigger class");
75
76	AliTRDtrigParam *trigp = new AliTRDtrigParam("TRDtrigParam","TRD Trigger parameters");
77
78	gAlice = runLoader->GetAliRun();
79	Double_t x[3] = { 0.0, 0.0, 0.0 };
80	Double_t b[3];
81	gAlice->Field(x,b); // b[] is in kilo Gauss
82	Float_t field = b[2] * 0.1; // Tesla
83	Info("Trigger","Trigger set for magnetic field = %f Tesla \n",field);
84
85	trigp->SetField(field);
86	trigp->Init();
87
88	trdTrigger.SetParameter(trigp);
89	trdTrigger.SetRunLoader(runLoader);
90	trdTrigger.Init();
91
92	for (Int_t iEvent = 0; iEvent < nEvents; iEvent++) {
93
94	trdTrigger.Open(runLoader->GetFileName(), iEvent);
95	trdTrigger.ReadDigits();
96	trdTrigger.MakeTracklets(kTRUE);
97	trdTrigger.WriteTracklets(-1);
98
99	}
100
101	// Trigger (tracks, GTU)
102
103	Float_t highPt = trigp->GetHighPt();
104
105	Float_t pid, pt;
106	Int_t det, sec;
107	Bool_t isElectron;
108
109	const Int_t maxEle = 1000;
110
111	Int_t electronPlus, electronMinus;
112	Int_t sectorElePlus[maxEle], sectorEleMinus[maxEle];
113	Float_t ptElePlus[maxEle], ptEleMinus[maxEle];
3164b03b	114	Int_t hadronLowPt=0, hadronHighPt=0;
e3b2b5e5	115
	116	electronPlus = 0;
	117	electronMinus = 0;
	118
	119	AliTRDgtuTrack *gtuTrack;
	120	Int_t nTracks = trdTrigger.GetNumberOfTracks();
	121	for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
	122
	123	gtuTrack = trdTrigger.GetTrack(iTrack);
	124
	125	pid = gtuTrack->GetPID();
	126	isElectron = gtuTrack->IsElectron();
	127	pt = gtuTrack->GetPt();
	128	det = gtuTrack->GetDetector();
	129
	130	sec = geo->GetSector(det);
	131
	132	if (isElectron) {
	133
	134	if (pt < 0.0) {
	135	sectorEleMinus[electronMinus] = sec;
	136	ptEleMinus[electronMinus] = pt;
	137	electronMinus++;
	138	} else {
	139	sectorElePlus[electronPlus] = sec;
	140	ptElePlus[electronPlus] = pt;
	141	electronPlus++;
	142	}
	143
	144	} else {
	145
	146	if (TMath::Abs(pt) < highPt) {
	147	hadronLowPt++;
	148	} else {
	149	hadronHighPt++;
	150	}
	151
	152	}
	153
	154	}
	155
	156	loader->UnloadTracks();
	157
	158	// hadrons
	159
	160	if (hadronLowPt) SetInput("TRD_Hadr_LPt_L1");
	161	if (hadronHighPt) SetInput("TRD_Hadr_HPt_L1");
	162
	163	// electron-positron pairs (open angle > 80 deg)
	164
	165	Int_t secPlus, secMinus, secDiff;
	166	Bool_t electronUnlikePair = kFALSE;
	167	Bool_t electronUnlikePairHPt = kFALSE;
	168
	169	if (electronMinus > 0 && electronPlus > 0) {
	170	for (Int_t iPlus = 0; iPlus < electronPlus; iPlus++) {
	171	secPlus = sectorElePlus[iPlus];
	172	for (Int_t iMinus = 0; iMinus < electronMinus; iMinus++) {
	173	secMinus = sectorEleMinus[iMinus];
	174	secDiff = TMath::Abs(secPlus-secMinus);
	175	if (secDiff > 9) secDiff = 18 - secDiff;
	176	if (secDiff >= 5) {
	177	electronUnlikePair = kTRUE;
	178	if (TMath::Abs(ptElePlus[iPlus]) > highPt && TMath::Abs(ptEleMinus[iMinus]) > highPt) {
179	electronUnlikePairHPt = kTRUE;
180	}
181	}
182	}
183	}
184	}
185
186	if (electronUnlikePair) SetInput("TRD_Unlike_EPair_L1");
187	if (electronUnlikePairHPt) SetInput("TRD_Unlike_EPair_HPt_L1");
188
189	// like electron/positron pairs
190
191	Bool_t ele1, ele1HPt;
192	Bool_t ele2, ele2HPt;
193
194	// positive
195
196	ele1 = kFALSE;
197	ele2 = kFALSE;
198	ele1HPt = kFALSE;
199	ele2HPt = kFALSE;
200	if (electronPlus > 1) {
201	for (Int_t iPlus = 0; iPlus < electronPlus; iPlus++) {
202	if (!ele1) {
203	ele1 = kTRUE;
204	} else if (!ele2) {
205	ele2 = kTRUE;
206	}
207	if (TMath::Abs(ptElePlus[iPlus]) > highPt) {
208	if (!ele1HPt) {
209	ele1HPt = kTRUE;
210	} else if (!ele2HPt) {
211	ele2HPt = kTRUE;
212	}
213	}
214	}
215	}
216
217	if (ele1 && ele2 ) SetInput("TRD_Like_EPair_L1");
218	if (ele1HPt && ele2HPt) SetInput("TRD_Like_EPair_HPt_L1");
219
220	// negative
221
222	ele1 = kFALSE;
223	ele2 = kFALSE;
224	ele1HPt = kFALSE;
225	ele2HPt = kFALSE;
226	if (electronMinus > 1) {
227	for (Int_t iMinus = 0; iMinus < electronMinus; iMinus++) {
228	if (!ele1) {
229	ele1 = kTRUE;
230	} else if (!ele2) {
231	ele2 = kTRUE;
232	}
233	if (TMath::Abs(ptEleMinus[iMinus]) > highPt) {
234	if (!ele1HPt) {
235	ele1HPt = kTRUE;
236	} else if (!ele2HPt) {
237	ele2HPt = kTRUE;
238	}
239	}
240	}
241	}
242
243	if (ele1 && ele2 ) SetInput("TRD_Like_EPair_L1");
244	if (ele1HPt && ele2HPt) SetInput("TRD_Like_EPair_HPt_L1");
245
246	// single electron/positron
247
248	if (electronPlus > 0 \|\| electronMinus > 0) {
249	SetInput("TRD_Electron_L1");
250	for (Int_t iPlus = 0; iPlus < electronPlus; iPlus++) {
251	if (TMath::Abs(ptElePlus[iPlus]) > highPt) SetInput("TRD_Electron_HPt_L1");
252	break;
253	}
254	for (Int_t iMinus = 0; iMinus < electronMinus; iMinus++) {
255	if (TMath::Abs(ptEleMinus[iMinus]) > highPt) SetInput("TRD_Electron_HPt_L1");
256	break;
257	}
258	}
259
260	}
261