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