TRD/AliTRDTriggerL1.cxx

   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   // Default constructor
  42   //
  43
  44   SetName("TRD");
  45
  46 }
  47
  48 //_____________________________________________________________________________
  49 void AliTRDTriggerL1::CreateInputs()
  50 {
  51
  52   //
  53   // See TRIGGER/DAQ/HLT/DCS Techical Design Report, p. 58, Table 4.1 for the proposed inputs
  54   //
  55
  56   fInputs.AddLast(new AliTriggerInput( "TRD_Unlike_EPair_L1",     "Unlike electron pair",         0x01 ));
  57   fInputs.AddLast(new AliTriggerInput( "TRD_Like_EPair_L1",       "Like electron pair",           0x02 ));
  58   fInputs.AddLast(new AliTriggerInput( "TRD_Jet_LPt_L1",          "Jet low pt",                   0x04 ));
  59   fInputs.AddLast(new AliTriggerInput( "TRD_Jet_HPt_L1",          "Jet high pt",                  0x08 ));
  60   fInputs.AddLast(new AliTriggerInput( "TRD_Electron_L1",         "Single electron",              0x10 ));
  61   fInputs.AddLast(new AliTriggerInput( "TRD_HadrLPt_L1",          "Single hadron low pt ",        0x20 ));
  62   fInputs.AddLast(new AliTriggerInput( "TRD_HadrHPt_L1",          "Single hadron high pt",        0x40 ));
  63
  64
  65 }
  66
  67 //_____________________________________________________________________________
  68 void AliTRDTriggerL1::Trigger()
  69 {
  70   //
  71   // Run the online tracking and trigger
  72   //
  73
  74   AliRunLoader* runLoader = gAlice->GetRunLoader();
  75
  76   AliLoader *loader=runLoader->GetLoader("TRDLoader");
  77
  78   // Trigger (tracklets, LTU)
  79
  80   AliTRDgeometry *geo = AliTRDgeometry::GetGeometry(runLoader);
  81
  82   AliTRDtrigger trdTrigger("Trigger","Trigger class");
  83
  84   AliTRDtrigParam *trigp = new AliTRDtrigParam("TRDtrigParam","TRD Trigger parameters");
  85
  86   Double_t x[3] = { 0.0, 0.0, 0.0 };
  87   Double_t b[3];
  88   gAlice->Field(x,b);  // b[] is in kilo Gauss
  89   Float_t field = b[2] * 0.1; // Tesla
  90   Info("Trigger","Trigger set for magnetic field = %f Tesla \n",field);
  91
  92   trigp->SetField(field);
  93   trigp->Init();
  94
  95   trdTrigger.SetParameter(trigp);
  96   trdTrigger.SetRunLoader(runLoader);
  97   trdTrigger.Init();
  98
  99   trdTrigger.Open(runLoader->GetFileName(), runLoader->GetEventNumber());
 100   trdTrigger.ReadDigits();
 101   trdTrigger.MakeTracklets(kTRUE);
 102   trdTrigger.WriteTracklets(-1);
 103
 104   // Trigger (tracks, GTU)
 105
 106   Float_t highPt = trigp->GetHighPt();
 107   Float_t jetLowPt  = trigp->GetJetLowPt();
 108   Float_t jetHighPt = trigp->GetJetHighPt();
 109
 110   Float_t pid, pt;
 111   Int_t   det, sec;
 112   Bool_t  isElectron;
 113
 114   const Int_t maxEle = 1000;
 115
 116   Int_t   electronPlus,          electronMinus;
 117   Int_t   sectorElePlus[maxEle], sectorEleMinus[maxEle];
 118   Float_t ptElePlus[maxEle],     ptEleMinus[maxEle];
 119   Int_t   hadronLowPt, hadronHighPt;
 120   Int_t   hadronJetLowPt, hadronJetHighPt;
 121
 122   hadronJetLowPt  = 0;
 123   hadronJetHighPt = 0;
 124
 125   hadronLowPt  = 0;
 126   hadronHighPt = 0;
 127
 128   electronPlus  = 0;
 129   electronMinus = 0;
 130
 131   AliTRDgtuTrack *gtuTrack;
 132   Int_t nTracks = trdTrigger.GetNumberOfTracks();
 133   for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
 134
 135     gtuTrack = trdTrigger.GetTrack(iTrack);
 136
 137     pid        = gtuTrack->GetPID();
 138     isElectron = gtuTrack->IsElectron();
 139     pt         = gtuTrack->GetPt();
 140     det        = gtuTrack->GetDetector();
 141
 142     sec        = geo->GetSector(det);
 143
 144     if (isElectron) {
 145
 146       if (pt < 0.0) {
 147         sectorEleMinus[electronMinus] = sec;
 148         ptEleMinus[electronMinus]     = pt;
 149         electronMinus++;
 150       } else {
 151         sectorElePlus[electronPlus] = sec;
 152         ptElePlus[electronPlus]     = pt;
 153         electronPlus++;
 154       }
 155
 156     } else {
 157
 158       if (TMath::Abs(pt) < highPt) {
 159         hadronLowPt++;
 160       } else {
 161         hadronHighPt++;
 162       }
 163
 164       if (TMath::Abs(pt) > jetLowPt ) hadronJetLowPt++;
 165       if (TMath::Abs(pt) > jetHighPt) hadronJetHighPt++;
 166
 167     }
 168
 169   }
 170
 171   loader->UnloadTracks();
 172
 173   // hadrons
 174
 175   if (hadronLowPt)  SetInput("TRD_Hadr_LPt_L1");
 176   if (hadronHighPt) SetInput("TRD_Hadr_HPt_L1");
 177
 178   // hadrons from jets
 179
 180   if (hadronJetLowPt  >= trigp->GetNPartJetLow() )  SetInput("TRD_Jet_LPt_L1");
 181   if (hadronJetHighPt >= trigp->GetNPartJetHigh())  SetInput("TRD_Jet_HPt_L1");
 182
 183   // electron-positron pairs (open angle > 80 deg)
 184
 185   Int_t  secPlus, secMinus, secDiff;
 186   Bool_t electronUnlikePair    = kFALSE;
 187   Bool_t electronUnlikePairHPt = kFALSE;
 188
 189   if (electronMinus > 0 && electronPlus > 0) {
 190     for (Int_t iPlus = 0; iPlus < electronPlus; iPlus++) {
 191       secPlus = sectorElePlus[iPlus];
 192       for (Int_t iMinus = 0; iMinus < electronMinus; iMinus++) {
 193         secMinus = sectorEleMinus[iMinus];
 194         secDiff = TMath::Abs(secPlus-secMinus);
 195         if (secDiff >  9) secDiff = 18 - secDiff;
 196         if (secDiff >= 5) {
 197           electronUnlikePair = kTRUE;
 198           if (TMath::Abs(ptElePlus[iPlus]) > highPt && TMath::Abs(ptEleMinus[iMinus]) > highPt) {
 199             electronUnlikePairHPt = kTRUE;
 200           }
 201         }
 202       }
 203     }
 204   }
 205
 206   if (electronUnlikePair)    SetInput("TRD_Unlike_EPair_L1");
 207   //if (electronUnlikePairHPt) SetInput("TRD_Unlike_EPair_HPt_L1");
 208
 209   // like electron/positron pairs
 210
 211   Bool_t ele1, ele1HPt;
 212   Bool_t ele2, ele2HPt;
 213
 214   // positive
 215
 216   ele1    = kFALSE;
 217   ele2    = kFALSE;
 218   ele1HPt = kFALSE;
 219   ele2HPt = kFALSE;
 220   if (electronPlus > 1) {
 221     for (Int_t iPlus = 0; iPlus < electronPlus; iPlus++) {
 222       if (!ele1) {
 223         ele1 = kTRUE;
 224       } else if (!ele2) {
 225         ele2 = kTRUE;
 226       }
 227       if (TMath::Abs(ptElePlus[iPlus]) > highPt) {
 228         if (!ele1HPt) {
 229           ele1HPt = kTRUE;
 230         } else if (!ele2HPt) {
 231           ele2HPt = kTRUE;
 232         }
 233       }
 234     }
 235   }
 236
 237   if (ele1    && ele2   ) SetInput("TRD_Like_EPair_L1");
 238   //if (ele1HPt && ele2HPt) SetInput("TRD_Like_EPair_HPt_L1");
 239
 240   // negative
 241
 242   ele1    = kFALSE;
 243   ele2    = kFALSE;
 244   ele1HPt = kFALSE;
 245   ele2HPt = kFALSE;
 246   if (electronMinus > 1) {
 247     for (Int_t iMinus = 0; iMinus < electronMinus; iMinus++) {
 248       if (!ele1) {
 249         ele1 = kTRUE;
 250       } else if (!ele2) {
 251         ele2 = kTRUE;
 252       }
 253       if (TMath::Abs(ptEleMinus[iMinus]) > highPt) {
 254         if (!ele1HPt) {
 255           ele1HPt = kTRUE;
 256         } else if (!ele2HPt) {
 257           ele2HPt = kTRUE;
 258         }
 259       }
 260     }
 261   }
 262
 263   if (ele1    && ele2   ) SetInput("TRD_Like_EPair_L1");
 264   //if (ele1HPt && ele2HPt) SetInput("TRD_Like_EPair_HPt_L1");
 265
 266   // single electron/positron
 267
 268   if (electronPlus > 0 || electronMinus > 0) {
 269     SetInput("TRD_Electron_L1");
 270     /*
 271     for (Int_t iPlus = 0; iPlus < electronPlus; iPlus++) {
 272       if (TMath::Abs(ptElePlus[iPlus]) > highPt) SetInput("TRD_Electron_HPt_L1");
 273       break;
 274     }
 275     for (Int_t iMinus = 0; iMinus < electronMinus; iMinus++) {
 276       if (TMath::Abs(ptEleMinus[iMinus]) > highPt) SetInput("TRD_Electron_HPt_L1");
 277       break;
 278     }
 279     */
 280   }
 281
 282 }
 283