Working version of the class for the TOF Trigger. For the time being,
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Apr 2006 07:16:14 +0000 (07:16 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Apr 2006 07:16:14 +0000 (07:16 +0000)
it includes the four TOF level zero triggers (pp Minimum Bias, Multi-Muon
cosmic trigger, High Multiplicity trigger and ultra-peripheral collision
trigger; the level 1 trigger for the jet topology is still missing)
Chiara and Silvia

TOF/AliTOF.h
TOF/AliTOFTrigger.cxx [new file with mode: 0644]
TOF/AliTOFTrigger.h [new file with mode: 0644]
TOF/TOFsimLinkDef.h
TOF/libTOFsim.pkg

index 386d12c2d2ca672504169f545489063144206004..844b9ea4b31e3df512ef2ef419112fa6f3e3e895 100644 (file)
@@ -30,6 +30,7 @@ class TFolder ;
 
 #include "AliTOFSDigitizer.h"
 #include "AliTOFGeometry.h"
+#include "AliTOFTrigger.h"
 
 class AliTOF : public AliDetector {
 public:
@@ -83,6 +84,10 @@ public:
   void CreateSDigitsArray();
   AliTOFGeometry *GetGeometry() const { return fTOFGeometry; }; 
 
+  // Trigger
+  virtual AliTriggerDetector* CreateTriggerDetector() const
+       {return new AliTOFTrigger();}
+
 protected:
   TFolder* fFGeom ;       //  Folder that holds the Geometry definition
   TTask*   fDTask ;       //  TOF Digitizer container
diff --git a/TOF/AliTOFTrigger.cxx b/TOF/AliTOFTrigger.cxx
new file mode 100644 (file)
index 0000000..19b4003
--- /dev/null
@@ -0,0 +1,467 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+/////////////////////////////////////////////////////////////////////
+// 
+//       Class performing TOF Trigger
+//       Cosmic_Multi_muon: Cosmic Multi-Muonic Event Trigger (L0)
+//       ppMB: p-p Minimum Bias Event Trigger (L0)
+//       UltraPer_Coll: Ultra-Peripheral Collision Event Trigger (L0)
+//       High_Mult: High Multiplicity Event Trigger (L0)
+//       Jet: Events with Jet Topology Trigger (L1)
+//
+/////////////////////////////////////////////////////////////////////
+
+#include "AliTOFTrigger.h"
+#include "AliLog.h"
+#include "AliRun.h"
+#include "AliLoader.h"
+#include "AliRunLoader.h"
+#include "AliTriggerInput.h"
+#include "AliTOFdigit.h"
+
+
+//-------------------------------------------------------------------------
+ClassImp(AliTOFTrigger)
+
+//----------------------------------------------------------------------
+  AliTOFTrigger::AliTOFTrigger() : 
+    AliTriggerDetector(), 
+    fHighMultTh(1000),
+    fppMBTh(4),
+    fMultiMuonTh(2),
+    fUPTh(2),
+    fdeltaminpsi(150),
+    fdeltamaxpsi(170),
+    fdeltaminro(70),
+    fdeltamaxro(110),
+    fstripWindow(2)
+{
+  //main ctor
+  for (Int_t i=0;i<kNLTM;i++){
+    for (Int_t j=0;j<kNLTMchannels;j++){
+      fLTMmatrix[i][j]=kFALSE;
+    }
+    if (i<kNCTTM){
+      for (Int_t j=0;j<kNCTTMchannels;j++){
+       fCTTMmatrixFront[i][j]=kFALSE;
+       fCTTMmatrixBack[i][j]=kFALSE;
+      }
+    }
+  }
+  SetName("TOF");
+  CreateInputs();
+}
+//----------------------------------------------------------------------
+AliTOFTrigger::AliTOFTrigger(Int_t HighMultTh, Int_t ppMBTh, Int_t MultiMuonTh, Int_t UPTh, Float_t deltaminpsi, Float_t deltamaxpsi, Float_t deltaminro, Float_t deltamaxro, Int_t stripWindow) : AliTriggerDetector() 
+{
+  //ctor with thresholds for triggers
+  fHighMultTh=HighMultTh;
+  fppMBTh=ppMBTh;
+  fMultiMuonTh=MultiMuonTh;
+  fUPTh=UPTh;
+  fdeltaminpsi = deltaminpsi;
+  fdeltamaxpsi = deltamaxpsi;
+  fdeltaminro = deltaminro;
+  fdeltamaxro = deltamaxro;
+  fstripWindow = stripWindow;
+  for (Int_t i=0;i<kNLTM;i++){
+    for (Int_t j=0;j<kNLTMchannels;j++){
+      fLTMmatrix[i][j]=kFALSE;
+    }
+    if (i<kNCTTM){
+      for (Int_t j=0;j<kNCTTMchannels;j++){
+       fCTTMmatrixFront[i][j]=kFALSE;
+       fCTTMmatrixBack[i][j]=kFALSE;
+      }
+    }
+  }
+  SetName("TOF");
+  CreateInputs();
+}
+
+//____________________________________________________________________________ 
+
+AliTOFTrigger::AliTOFTrigger(const AliTOFTrigger & tr):AliTriggerDetector()
+{
+  //copy ctor
+  fHighMultTh=tr.fHighMultTh;
+  fppMBTh=tr.fppMBTh;
+  fMultiMuonTh=tr.fMultiMuonTh;
+  fUPTh=tr.fUPTh;
+  fdeltaminpsi = tr.fdeltaminpsi;
+  fdeltamaxpsi = tr.fdeltamaxpsi;
+  fdeltaminro = tr.fdeltaminro;
+  fdeltamaxro = tr.fdeltamaxro;
+  fstripWindow = tr.fstripWindow;
+  for (Int_t i=0;i<kNLTM;i++){
+    for (Int_t j=0;j<kNLTMchannels;j++){
+      fLTMmatrix[i][j]=tr.fLTMmatrix[i][j];
+    }
+    if (i<kNCTTM){
+      for (Int_t j=0;j<kNCTTMchannels;j++){
+      fCTTMmatrixFront[i][j]=tr.fCTTMmatrixFront[i][j];
+      fCTTMmatrixBack[i][j]=tr.fCTTMmatrixBack[i][j];
+      }
+    }
+  }
+  SetName(tr.GetName());
+  CreateInputs();
+    //fInputs=&(tr.GetInputs());
+}
+
+//----------------------------------------------------------------------
+
+void AliTOFTrigger::CreateInputs()
+{
+  // creating inputs 
+  // Do not create inputs again!!
+   if( fInputs.GetEntriesFast() > 0 ) return;
+   
+   fInputs.AddLast(new AliTriggerInput("TOF_Cosmic_MultiMuon_L0","Cosmic Multimuon Topology",0x01));
+   fInputs.AddLast(new AliTriggerInput("TOF_pp_MB_L0","pp Minimum Bias",0x02));
+   fInputs.AddLast(new AliTriggerInput("TOF_UltraPer_Coll_L0","Ultra Peripheral Collisions",0x04));
+
+   fInputs.AddLast(new AliTriggerInput("TOF_High_Mult_L0","High Multiplicity",0x08));
+   fInputs.AddLast(new AliTriggerInput("TOF_Jet_L1","Jet Search",0x10));
+}
+
+//----------------------------------------------------------------------
+void AliTOFTrigger::Trigger(){
+  //triggering method
+  CreateLTMMatrix();
+  Int_t nchonFront = 0;
+  Int_t nchonBack = 0;
+  Int_t nchonTot = 0;
+  Int_t nchonFrontBack = 0;
+  Int_t nchonFront1 = 0;
+  Int_t nchonBack1 = 0;
+  Int_t nchonFrontBack1 = 0;
+  Int_t mindeltapsi = (Int_t)fdeltaminpsi/10;
+  Int_t maxdeltapsi = (Int_t)fdeltamaxpsi/10;
+  Int_t mindeltaro = (Int_t)fdeltaminro/10;
+  Int_t maxdeltaro = (Int_t)fdeltamaxro/10;
+  for (Int_t i=0;i<kNCTTM;i++){
+    for (Int_t j=0;j<kNCTTMchannels;j++){
+      fCTTMmatrixFront[i][j]=kFALSE;
+      fCTTMmatrixBack[i][j]=kFALSE;
+    }
+  }
+  for (Int_t i=0;i<kNCTTM;i++){
+    for (Int_t j=0;j<kNCTTMchannels;j++){
+      fCTTMmatrixFront[i][j] = (fLTMmatrix[i][j*2] || fLTMmatrix[i][j*2+1]);
+      if (fCTTMmatrixFront[i][j]) nchonFront++; 
+    }
+  }
+
+  for (Int_t i=kNCTTM;i<(kNCTTM*2);i++){
+    for (Int_t j=0;j<kNCTTMchannels;j++){
+      fCTTMmatrixBack[i-kNCTTM][j] = (fLTMmatrix[i][j*2] || fLTMmatrix[i][j*2+1]);
+      if (fCTTMmatrixBack[i-kNCTTM][j]) nchonBack++; 
+    }
+  }
+
+  nchonTot = nchonFront + nchonBack;
+
+  //pp Minimum Bias Trigger
+  if (nchonTot >= fppMBTh) {
+    SetInput("TOF_pp_MB_L0");
+  }
+
+  //High Multiplicity Trigger
+  if (nchonTot >= fHighMultTh) {
+    SetInput("TOF_High_Mult_L0");
+  }
+
+  
+  //MultiMuon Trigger
+  nchonFront = 0;
+  nchonBack = 0;
+  nchonFrontBack = 0;
+
+  Bool_t boolCTTMor = kFALSE;
+
+  for (Int_t i=0;i<(kNCTTM/2);i++){
+    Int_t iopp = i+kNCTTM/2;
+    for (Int_t j=0;j<kNCTTMchannels;j++){
+      if (fCTTMmatrixFront[i][j]){
+       Int_t minj = j-fstripWindow;
+       Int_t maxj = j+fstripWindow;
+       if (minj<0) minj =0;
+       if (maxj>=kNCTTMchannels) maxj = kNCTTMchannels-1;
+       boolCTTMor = kFALSE;
+       for (Int_t k = minj;k<=maxj;k++){
+         boolCTTMor |= fCTTMmatrixFront[iopp][k];
+       } 
+       if (boolCTTMor) {
+         nchonFront++;
+       }
+      }
+    
+      if (fCTTMmatrixBack[i][j]){
+       Int_t minj = j-fstripWindow;
+       Int_t maxj = j+fstripWindow;
+       if (minj<0) minj =0;
+       if (maxj>=kNCTTMchannels) maxj =kNCTTMchannels-1;
+       boolCTTMor = kFALSE;
+       for (Int_t k = minj;k<=maxj;k++){
+         boolCTTMor |= fCTTMmatrixBack[iopp][k];
+       }
+       if (boolCTTMor) {
+         nchonBack++;
+       }
+      }
+    }
+  }
+
+  nchonFrontBack = nchonFront+nchonBack;
+
+  nchonFront1 = 0;
+  nchonBack1 = 0;
+  nchonFrontBack1 = 0;
+
+  boolCTTMor = kFALSE;
+  for (Int_t i=0;i<(kNCTTM/2);i++){
+    Int_t i2max = (kNCTTM-1)-i+1;
+    Int_t i2min = (kNCTTM-1)-i-1;
+    if (i2max >=kNCTTM) i2max = kNCTTM-1;
+    if (i2min==i) i2min = kNCTTM-1-i;
+    for (Int_t j=0;j<kNCTTMchannels;j++){
+      Int_t j2min = j-fstripWindow;
+      Int_t j2max = j+fstripWindow;
+      if (j2min<0) j2min =0;
+      if (j2max>=kNCTTMchannels) j2max =kNCTTMchannels-1;
+      if (fCTTMmatrixFront[i][j]){
+       boolCTTMor = kFALSE;
+       for (Int_t i2=i2min;i2<=i2max;i2++){
+         for (Int_t j2 = j2min;j2<=j2max;j2++){
+           boolCTTMor |= fCTTMmatrixFront[i2][j2];
+         } 
+         if (boolCTTMor) {
+           nchonFront++;
+         }
+       }
+      }
+      if (fCTTMmatrixBack[i][j]){
+       boolCTTMor = kFALSE;
+       for (Int_t i2=i2min;i2<=i2max;i2++){
+         for (Int_t j2 = j2min;j2<=j2max;j2++){
+           boolCTTMor |= fCTTMmatrixBack[i2][j2];
+         }
+       }
+       if (boolCTTMor) {
+         nchonBack++;
+       }
+      }
+    }
+  }
+
+  nchonFrontBack1 = nchonFront1+nchonBack1;
+
+  if (nchonFrontBack >= fMultiMuonTh || nchonFrontBack1 >= fMultiMuonTh) {
+    SetInput("TOF_Cosmic_MultiMuon_L0");
+  }
+
+  //Ultra-Peripheral collision Trigger
+  Bool_t boolpsi = kFALSE;
+  Bool_t boolro = kFALSE;
+  if (nchonTot == fUPTh){
+    for (Int_t i=0;i<kNCTTM;i++){
+      for (Int_t j=0;j<kNCTTMchannels;j++){
+       Int_t minipsi = i+mindeltapsi;
+       Int_t maxipsi = i+maxdeltapsi;
+       if (minipsi>=kNCTTM) minipsi = mindeltapsi-((kNCTTM-1)-i)-1;
+       if (maxipsi>=kNCTTM) maxipsi = maxdeltapsi-((kNCTTM-1)-i)-1;
+       Int_t miniro = i+mindeltaro;
+       Int_t maxiro = i+maxdeltaro;
+       if (miniro>=kNCTTM) miniro = mindeltaro-((kNCTTM-1)-i)-1;
+       if (maxiro>=kNCTTM) maxiro = maxdeltaro-((kNCTTM-1)-i)-1;
+       Int_t j2min = j-fstripWindow;
+       Int_t j2max = j+fstripWindow;
+       if (j2min<0) j2min =0;
+       if (j2max>=kNCTTMchannels) j2max =kNCTTMchannels-1;
+       if (fCTTMmatrixFront[i][j]){
+         for (Int_t i2=minipsi;i2<=maxipsi;i2++){
+           for (Int_t j2 = j2min;j2<=j2max;j2++){
+             if (fCTTMmatrixFront[i2][j2]) {
+               SetInput("TOF_UltraPer_Coll_L0");
+               boolpsi = kTRUE;
+               //exiting loops
+               j2 = j2max+1;
+               i2 = maxipsi+1;
+               j=kNCTTMchannels;
+               i=kNCTTM;
+             }
+           }
+         }
+         if (!boolpsi){
+           for (Int_t i2=miniro;i2<=maxiro;i2++){
+             for (Int_t j2 = j2min;j2<=j2max;j2++){
+               if (fCTTMmatrixFront[i2][j2]) {
+                 SetInput("TOF_UltraPer_Coll_L0");
+                 boolro = kTRUE;
+                 //exiting loops
+                 j2 = j2max+1;
+                 i2 = maxiro+1;
+                 j=kNCTTMchannels;
+                 i=kNCTTM;
+               }
+             }
+           }
+         }
+       }
+         
+       else if (fCTTMmatrixBack[i][j]){
+         for (Int_t i2=minipsi;i2<=maxipsi;i2++){
+           for (Int_t j2 = j2min;j2<=j2max;j2++){
+             if (fCTTMmatrixBack[i2][j2]) {
+               SetInput("TOF_UltraPer_Coll_L0");
+               boolpsi = kTRUE;
+               //exiting loops
+               j2 = j2max+1;
+               i2 = maxipsi+1;
+               j=kNCTTMchannels;
+               i=kNCTTM;
+             }
+           }
+         }
+         if (!boolpsi){
+           for (Int_t i2=miniro;i2<=maxiro;i2++){
+             for (Int_t j2 = j2min;j2<=j2max;j2++){
+               if (fCTTMmatrixBack[i2][j2]) {
+                 SetInput("TOF_UltraPer_Coll_L0");
+                 boolro = kTRUE;
+                 //exiting loops
+                 j2 = j2max+1;
+                 i2 = maxiro+1;
+                 j=kNCTTMchannels;
+                 i=kNCTTM;
+               }
+             }
+           }
+         } 
+       }
+      }
+    }
+  }
+}
+//-----------------------------------------------------------------------------
+void AliTOFTrigger::CreateLTMMatrix(){
+  //creating LTMMatrix
+  //initialization
+  for (Int_t i=0;i<kNLTM;i++){
+    for (Int_t j=0;j<kNLTMchannels;j++){
+      fLTMmatrix[i][j]=kFALSE;
+    }
+  }
+  AliRunLoader *rl;
+  rl = gAlice->GetRunLoader();
+  
+  Int_t ncurrevent = rl->GetEventNumber();
+  rl->GetEvent(ncurrevent);
+  
+  AliLoader * tofLoader = rl->GetLoader("TOFLoader");
+  
+  tofLoader->LoadDigits("read");
+  TTree *treeD = tofLoader->TreeD();
+  if (treeD == 0x0)
+    {
+      AliFatal("AliTOFTrigger: Can not get TreeD");
+    }
+  
+  TBranch *branch = treeD->GetBranch("TOF");
+  if (!branch) { 
+    AliError("can't get the branch with the TOF digits !");
+    return;
+  }
+  TClonesArray *tofDigits =new TClonesArray("AliTOFdigit",  1000);
+  branch->SetAddress(&tofDigits);
+  treeD->GetEvent(0);
+  Int_t ndigits = tofDigits->GetEntriesFast();
+  Int_t detind[5]; //detector indexes: 0 -> sector
+  //                                   1 -> plate
+  //                                   2 -> strip
+  //                                   3 -> padz
+  //                                   4 -> padx
+  
+  for (Int_t i=0;i<ndigits;i++){
+    AliTOFdigit * digit = (AliTOFdigit*)tofDigits->UncheckedAt(i);
+    detind[0] = digit->GetSector();
+    detind[1] = digit->GetPlate();
+    detind[2] = digit->GetStrip();
+    detind[3] = digit->GetPadz();
+    detind[4] = digit->GetPadx();
+    
+    Int_t indexLTM[2] = {-1,-1};
+    GetLTMIndex(detind,indexLTM);
+
+    fLTMmatrix[indexLTM[0]][indexLTM[1]] = kTRUE;
+  }
+
+  rl->UnloadDigits();
+  rl->UnloadgAlice();
+}
+//-----------------------------------------------------------------------------
+void AliTOFTrigger::GetLTMIndex(Int_t *detind, Int_t *indexLTM){
+  //getting LTMmatrix indexes for current digit
+  if (detind[1]==0 || detind[1]==1 || (detind[1]==2 && detind[2]<=7)) {
+    if (detind[4]<24){
+      indexLTM[0] = detind[0]*2;
+    }
+    else {
+      indexLTM[0] = detind[0]*2+1;
+    }
+  }
+  else {
+    if (detind[4]<24){
+      indexLTM[0] = detind[0]*2+36;
+    }
+    else {
+      indexLTM[0] = (detind[0]*2+1)+36;
+    }
+  }
+
+  if (indexLTM[0]<36){ 
+    if (detind[1] ==0){
+      indexLTM[1] = detind[2];
+    }
+    else if (detind[1] ==1){
+      indexLTM[1] = detind[2]+19;
+    }
+    else if (detind[1] ==2){
+      indexLTM[1] = detind[2]+19;
+    }
+    else{
+      AliError("Smth Wrong!!!");
+    }
+  }
+  else {
+    if (detind[1] ==2){
+      indexLTM[1] = detind[2]-8;
+    }
+    else if (detind[1] ==3){
+      indexLTM[1] = detind[2]+7;
+    }
+    else if (detind[1] ==4){
+      indexLTM[1] = detind[2]+26;
+    }
+    else{
+      AliError("Smth Wrong!!!");
+    }
+  }
+}
+  
diff --git a/TOF/AliTOFTrigger.h b/TOF/AliTOFTrigger.h
new file mode 100644 (file)
index 0000000..0707022
--- /dev/null
@@ -0,0 +1,73 @@
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+
+#ifndef ALITOFTRIGGER_H
+#define ALITOFTRIGGER_H
+
+/////////////////////////////////////////////////
+//
+//      TOF Trigger Detector Class               
+//
+/////////////////////////////////////////////////
+
+#include "AliTriggerDetector.h"
+
+class AliTOFTrigger : public AliTriggerDetector
+{
+ public:
+  AliTOFTrigger();  // constructor
+  AliTOFTrigger(Int_t HighMultTh, Int_t ppMBTh, Int_t MultiMuonTh, Int_t UPTh, Float_t deltaminpsi, Float_t deltamaxpsi, Float_t deltaminro, Float_t deltamaxro, Int_t stripWindow); //constructor with parameters
+  AliTOFTrigger(const AliTOFTrigger & tr);
+  virtual ~AliTOFTrigger(){}  // destructor
+  virtual void    CreateInputs();
+  virtual void    Trigger();
+  Int_t   GetHighMultTh() const {return fHighMultTh;}
+  Int_t   GetppMBTh() const {return fppMBTh;}
+  Int_t   GetMultiMuonTh() const {return fMultiMuonTh;}
+  Int_t   GetUPTh() const {return fUPTh;}
+  Float_t Getdeltaminpsi() const {return fdeltaminpsi;}
+  Float_t Getdeltamaxpsi() const {return fdeltamaxpsi;}
+  Float_t Getdeltaminro() const {return fdeltaminro;}
+  Float_t Getdeltamaxro() const {return fdeltamaxro;}
+  Int_t  GetstripWindow() const {return fstripWindow;}
+
+  void   SetHighMultTh(Int_t HighMultTh){fHighMultTh = HighMultTh;}
+  void   SetppMBTh(Int_t ppMBTh){fppMBTh = ppMBTh;}
+  void   SetMultiMuonTh(Int_t MultiMuonTh){fMultiMuonTh = MultiMuonTh;}
+  void   SetUPTh(Int_t UPTh){fUPTh = UPTh;}
+  void   Setdeltaminpsi(Float_t deltaminpsi){fdeltaminpsi = deltaminpsi;}
+  void   Setdeltamaxpsi(Float_t deltamaxpsi){fdeltamaxpsi = deltamaxpsi;}
+  void   Setdeltaminro(Float_t deltaminro){fdeltaminro = deltaminro;}
+  void   Setdeltamaxro(Float_t deltamaxro){fdeltamaxro = deltamaxro;}
+  void   SetstripWindow(Int_t stripWindow){fstripWindow = stripWindow;}
+
+  void   CreateLTMMatrix();
+
+ private:
+
+  enum{
+    kNLTM = 72,          //Number of LTM
+    kNLTMchannels = 48,  //Number of channels in a LTM
+    kNCTTM = 36,         //Number of CTTM per TOF side
+    kNCTTMchannels = 24  //Number of channels in a CTTM
+  };
+
+  void    GetLTMIndex(Int_t *detind, Int_t *LTMIndex);
+  Bool_t  fLTMmatrix[kNLTM][kNLTMchannels];         //LTM matrix  
+  Bool_t  fCTTMmatrixFront[kNCTTM][kNCTTMchannels]; //CTTM matrix for LTM 0-35
+  Bool_t  fCTTMmatrixBack[kNCTTM][kNCTTMchannels];  //CTTM matrix for LTM 36-71
+  Int_t   fHighMultTh;             //threshold for High Multiplicity trigger
+  Int_t   fppMBTh;                 //threshold for pp Minimum Bias trigger
+  Int_t   fMultiMuonTh;            //threshold for Multi Muon trigger 
+  Int_t   fUPTh;                   //threshold for Ultra-Per coll trigger 
+  Float_t fdeltaminpsi;            //min delta phi for J/psi decay (UP trigger)
+  Float_t fdeltamaxpsi;            //max delta phi for J/psi decay (UP trigger)
+  Float_t fdeltaminro;             //min delta phi for ro decay (UP trigger)
+  Float_t fdeltamaxro;             //max delta phi for ro decay (UP trigger)
+  Int_t   fstripWindow;            //strip window for triggering
+
+  ClassDef(AliTOFTrigger,1)  // TOF Trigger Detector class
+};
+#endif
index ccd9c59b0567e22879a6b34ecfa2a3936ff51dee..27711097c14f4030b7cf98af2d1d128690ec33f1 100644 (file)
@@ -23,5 +23,6 @@
 #pragma link C++ class  AliTOFDDLRawData+;
 
 #pragma link C++ class  AliTOFT0+;
+#pragma link C++ class  AliTOFTrigger+;
 
 #endif
index 087bf09e45e32c44f93c7fa1d467560cf583bdd4..14755472784da9f9b06a2bcb3f88ab5440e8d0cd 100644 (file)
@@ -8,7 +8,7 @@ SRCS  = AliTOF.cxx  AliTOFv5T0.cxx  AliTOFv4T0.cxx  \
        AliTOFDigitizer.cxx  \
        AliTOFDigitMap.cxx  \
        AliTOFDDLRawData.cxx  \
-        AliTOFT0.cxx
+        AliTOFT0.cxx AliTOFTrigger.cxx
 
 HDRS:= $(SRCS:.cxx=.h)