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   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];
 114   Int_t   hadronLowPt, hadronHighPt;
 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