[u/mrichter/AliRoot.git] / TOF / AliTOFTrigger.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.                  *
 **************************************************************************/

/* $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 <TClonesArray.h>

#include "AliLoader.h"
#include "AliLog.h"
#include "AliRunLoader.h"
#include "AliRun.h"
#include "AliTriggerInput.h"

#include "AliTOFdigit.h"
#include "AliTOFTrigger.h"

extern AliRun* gAlice;

//-------------------------------------------------------------------------
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(),   
  fHighMultTh(HighMultTh),
  fppMBTh(ppMBTh),
  fMultiMuonTh(MultiMuonTh),
  fUPTh(UPTh),
  fdeltaminpsi(deltaminpsi),
  fdeltamaxpsi(deltamaxpsi),
  fdeltaminro(deltaminro),
  fdeltamaxro(deltamaxro),
  fstripWindow(stripWindow)

{
  //ctor with thresholds for triggers
  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(tr),
  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)
{
  //copy ctor
  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","TOF",0));
   fInputs.AddLast(new AliTriggerInput("0OIN","TOF",0)); // was "TOF_pp_MB_L0"
   fInputs.AddLast(new AliTriggerInput("0OX1","TOF",0)); // was "TOF_UltraPer_Coll_L0"

   fInputs.AddLast(new AliTriggerInput("0OHM","TOF",0)); // was "TOF_High_Mult_L0"
   fInputs.AddLast(new AliTriggerInput("TOF_Jet_L1","TOF",0));
}

//----------------------------------------------------------------------
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("0OIN");
  }

  //High Multiplicity Trigger
  if (nchonTot >= fHighMultTh) {
    SetInput("0OHM");
  }

  
  //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("0OX1");
		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("0OX1");
		  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("0OX1");
		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("0OX1");
		  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 = AliRunLoader::Instance();
  
  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;
  }

  tofLoader->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*2;
    }
    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!!!");
    }
  }
}
Commit	Line	Data
cd82ed2f	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	/* $Id$ */
	17
	18	/////////////////////////////////////////////////////////////////////
	19	//
	20	// Class performing TOF Trigger
	21	// Cosmic_Multi_muon: Cosmic Multi-Muonic Event Trigger (L0)
	22	// ppMB: p-p Minimum Bias Event Trigger (L0)
	23	// UltraPer_Coll: Ultra-Peripheral Collision Event Trigger (L0)
	24	// High_Mult: High Multiplicity Event Trigger (L0)
	25	// Jet: Events with Jet Topology Trigger (L1)
	26	//
	27	/////////////////////////////////////////////////////////////////////
	28
7ca4655f	29	#include <TClonesArray.h>
7ca4655f	30
cd82ed2f	31	#include "AliLoader.h"
0e46b9ae	32	#include "AliLog.h"
cd82ed2f	33	#include "AliRunLoader.h"
0e46b9ae	34	#include "AliRun.h"
cd82ed2f	35	#include "AliTriggerInput.h"
0e46b9ae	36
cd82ed2f	37	#include "AliTOFdigit.h"
0e46b9ae	38	#include "AliTOFTrigger.h"
cd82ed2f	39
0e46b9ae	40	extern AliRun* gAlice;
cd82ed2f	41
	42	//-------------------------------------------------------------------------
	43	ClassImp(AliTOFTrigger)
	44
	45	//----------------------------------------------------------------------
	46	AliTOFTrigger::AliTOFTrigger() :
	47	AliTriggerDetector(),
	48	fHighMultTh(1000),
	49	fppMBTh(4),
	50	fMultiMuonTh(2),
	51	fUPTh(2),
	52	fdeltaminpsi(150),
	53	fdeltamaxpsi(170),
	54	fdeltaminro(70),
	55	fdeltamaxro(110),
	56	fstripWindow(2)
	57	{
	58	//main ctor
	59	for (Int_t i=0;i<kNLTM;i++){
	60	for (Int_t j=0;j<kNLTMchannels;j++){
	61	fLTMmatrix[i][j]=kFALSE;
	62	}
	63	if (i<kNCTTM){
	64	for (Int_t j=0;j<kNCTTMchannels;j++){
	65	fCTTMmatrixFront[i][j]=kFALSE;
	66	fCTTMmatrixBack[i][j]=kFALSE;
	67	}
	68	}
	69	}
	70	SetName("TOF");
	71	CreateInputs();
	72	}
	73	//----------------------------------------------------------------------
655e379f	74	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) :
	75	AliTriggerDetector(),
	76	fHighMultTh(HighMultTh),
	77	fppMBTh(ppMBTh),
	78	fMultiMuonTh(MultiMuonTh),
	79	fUPTh(UPTh),
	80	fdeltaminpsi(deltaminpsi),
	81	fdeltamaxpsi(deltamaxpsi),
	82	fdeltaminro(deltaminro),
	83	fdeltamaxro(deltamaxro),
	84	fstripWindow(stripWindow)
	85
cd82ed2f	86	{
cd82ed2f	87	//ctor with thresholds for triggers
cd82ed2f	88	for (Int_t i=0;i<kNLTM;i++){
	89	for (Int_t j=0;j<kNLTMchannels;j++){
	90	fLTMmatrix[i][j]=kFALSE;
	91	}
	92	if (i<kNCTTM){
	93	for (Int_t j=0;j<kNCTTMchannels;j++){
	94	fCTTMmatrixFront[i][j]=kFALSE;
	95	fCTTMmatrixBack[i][j]=kFALSE;
	96	}
	97	}
	98	}
	99	SetName("TOF");
	100	CreateInputs();
	101	}
	102
	103	//____________________________________________________________________________
	104
655e379f	105	AliTOFTrigger::AliTOFTrigger(const AliTOFTrigger & tr):
8a190ba2	106	AliTriggerDetector(tr),
	107	fHighMultTh(tr.fHighMultTh),
	108	fppMBTh(tr.fppMBTh),
	109	fMultiMuonTh(tr.fMultiMuonTh),
	110	fUPTh(tr.fUPTh),
	111	fdeltaminpsi(tr.fdeltaminpsi),
	112	fdeltamaxpsi(tr.fdeltamaxpsi),
	113	fdeltaminro(tr.fdeltaminro),
	114	fdeltamaxro(tr.fdeltamaxro),
	115	fstripWindow(tr.fstripWindow)
cd82ed2f	116	{
cd82ed2f	117	//copy ctor
cd82ed2f	118	for (Int_t i=0;i<kNLTM;i++){
	119	for (Int_t j=0;j<kNLTMchannels;j++){
	120	fLTMmatrix[i][j]=tr.fLTMmatrix[i][j];
	121	}
	122	if (i<kNCTTM){
	123	for (Int_t j=0;j<kNCTTMchannels;j++){
	124	fCTTMmatrixFront[i][j]=tr.fCTTMmatrixFront[i][j];
	125	fCTTMmatrixBack[i][j]=tr.fCTTMmatrixBack[i][j];
	126	}
	127	}
	128	}
	129	SetName(tr.GetName());
	130	CreateInputs();
	131	//fInputs=&(tr.GetInputs());
	132	}
	133
	134	//----------------------------------------------------------------------
	135
	136	void AliTOFTrigger::CreateInputs()
	137	{
	138	// creating inputs
	139	// Do not create inputs again!!
	140	if( fInputs.GetEntriesFast() > 0 ) return;
	141
572b6f20	142	fInputs.AddLast(new AliTriggerInput("TOF_Cosmic_MultiMuon_L0","TOF",0));
c6eeb5c9	143	fInputs.AddLast(new AliTriggerInput("0OIN","TOF",0)); // was "TOF_pp_MB_L0"
c6eeb5c9	144	fInputs.AddLast(new AliTriggerInput("0OX1","TOF",0)); // was "TOF_UltraPer_Coll_L0"
cd82ed2f	145
c6eeb5c9	146	fInputs.AddLast(new AliTriggerInput("0OHM","TOF",0)); // was "TOF_High_Mult_L0"
572b6f20	147	fInputs.AddLast(new AliTriggerInput("TOF_Jet_L1","TOF",0));
cd82ed2f	148	}
	149
	150	//----------------------------------------------------------------------
	151	void AliTOFTrigger::Trigger(){
	152	//triggering method
c6eeb5c9	153
cd82ed2f	154	CreateLTMMatrix();
	155	Int_t nchonFront = 0;
	156	Int_t nchonBack = 0;
	157	Int_t nchonTot = 0;
	158	Int_t nchonFrontBack = 0;
	159	Int_t nchonFront1 = 0;
	160	Int_t nchonBack1 = 0;
	161	Int_t nchonFrontBack1 = 0;
	162	Int_t mindeltapsi = (Int_t)fdeltaminpsi/10;
	163	Int_t maxdeltapsi = (Int_t)fdeltamaxpsi/10;
	164	Int_t mindeltaro = (Int_t)fdeltaminro/10;
	165	Int_t maxdeltaro = (Int_t)fdeltamaxro/10;
	166	for (Int_t i=0;i<kNCTTM;i++){
	167	for (Int_t j=0;j<kNCTTMchannels;j++){
	168	fCTTMmatrixFront[i][j]=kFALSE;
	169	fCTTMmatrixBack[i][j]=kFALSE;
	170	}
	171	}
	172	for (Int_t i=0;i<kNCTTM;i++){
	173	for (Int_t j=0;j<kNCTTMchannels;j++){
	174	fCTTMmatrixFront[i][j] = (fLTMmatrix[i][j2] \|\| fLTMmatrix[i][j2+1]);
	175	if (fCTTMmatrixFront[i][j]) nchonFront++;
	176	}
	177	}
	178
	179	for (Int_t i=kNCTTM;i<(kNCTTM*2);i++){
	180	for (Int_t j=0;j<kNCTTMchannels;j++){
	181	fCTTMmatrixBack[i-kNCTTM][j] = (fLTMmatrix[i][j2] \|\| fLTMmatrix[i][j2+1]);
	182	if (fCTTMmatrixBack[i-kNCTTM][j]) nchonBack++;
	183	}
	184	}
	185
	186	nchonTot = nchonFront + nchonBack;
	187
	188	//pp Minimum Bias Trigger
	189	if (nchonTot >= fppMBTh) {
c6eeb5c9	190	SetInput("0OIN");
cd82ed2f	191	}
	192
	193	//High Multiplicity Trigger
	194	if (nchonTot >= fHighMultTh) {
c6eeb5c9	195	SetInput("0OHM");
cd82ed2f	196	}
	197
	198
	199	//MultiMuon Trigger
	200	nchonFront = 0;
	201	nchonBack = 0;
	202	nchonFrontBack = 0;
	203
	204	Bool_t boolCTTMor = kFALSE;
	205
	206	for (Int_t i=0;i<(kNCTTM/2);i++){
	207	Int_t iopp = i+kNCTTM/2;
	208	for (Int_t j=0;j<kNCTTMchannels;j++){
	209	if (fCTTMmatrixFront[i][j]){
	210	Int_t minj = j-fstripWindow;
	211	Int_t maxj = j+fstripWindow;
	212	if (minj<0) minj =0;
	213	if (maxj>=kNCTTMchannels) maxj = kNCTTMchannels-1;
	214	boolCTTMor = kFALSE;
	215	for (Int_t k = minj;k<=maxj;k++){
	216	boolCTTMor \|= fCTTMmatrixFront[iopp][k];
	217	}
	218	if (boolCTTMor) {
	219	nchonFront++;
	220	}
	221	}
	222
	223	if (fCTTMmatrixBack[i][j]){
	224	Int_t minj = j-fstripWindow;
	225	Int_t maxj = j+fstripWindow;
	226	if (minj<0) minj =0;
	227	if (maxj>=kNCTTMchannels) maxj =kNCTTMchannels-1;
	228	boolCTTMor = kFALSE;
	229	for (Int_t k = minj;k<=maxj;k++){
	230	boolCTTMor \|= fCTTMmatrixBack[iopp][k];
	231	}
	232	if (boolCTTMor) {
	233	nchonBack++;
	234	}
	235	}
	236	}
	237	}
	238
	239	nchonFrontBack = nchonFront+nchonBack;
	240
	241	nchonFront1 = 0;
	242	nchonBack1 = 0;
	243	nchonFrontBack1 = 0;
	244
	245	boolCTTMor = kFALSE;
	246	for (Int_t i=0;i<(kNCTTM/2);i++){
	247	Int_t i2max = (kNCTTM-1)-i+1;
	248	Int_t i2min = (kNCTTM-1)-i-1;
	249	if (i2max >=kNCTTM) i2max = kNCTTM-1;
	250	if (i2min==i) i2min = kNCTTM-1-i;
	251	for (Int_t j=0;j<kNCTTMchannels;j++){
	252	Int_t j2min = j-fstripWindow;
	253	Int_t j2max = j+fstripWindow;
	254	if (j2min<0) j2min =0;
	255	if (j2max>=kNCTTMchannels) j2max =kNCTTMchannels-1;
	256	if (fCTTMmatrixFront[i][j]){
	257	boolCTTMor = kFALSE;
	258	for (Int_t i2=i2min;i2<=i2max;i2++){
	259	for (Int_t j2 = j2min;j2<=j2max;j2++){
260	boolCTTMor \|= fCTTMmatrixFront[i2][j2];
261	}
262	if (boolCTTMor) {
263	nchonFront++;
264	}
265	}
266	}
267	if (fCTTMmatrixBack[i][j]){
268	boolCTTMor = kFALSE;
269	for (Int_t i2=i2min;i2<=i2max;i2++){
270	for (Int_t j2 = j2min;j2<=j2max;j2++){
271	boolCTTMor \|= fCTTMmatrixBack[i2][j2];
272	}
273	}
274	if (boolCTTMor) {
275	nchonBack++;
276	}
277	}
278	}
279	}
280
281	nchonFrontBack1 = nchonFront1+nchonBack1;
282
283	if (nchonFrontBack >= fMultiMuonTh \|\| nchonFrontBack1 >= fMultiMuonTh) {
284	SetInput("TOF_Cosmic_MultiMuon_L0");
285	}
286
287	//Ultra-Peripheral collision Trigger
288	Bool_t boolpsi = kFALSE;
289	Bool_t boolro = kFALSE;
290	if (nchonTot == fUPTh){
291	for (Int_t i=0;i<kNCTTM;i++){
292	for (Int_t j=0;j<kNCTTMchannels;j++){
293	Int_t minipsi = i+mindeltapsi;
294	Int_t maxipsi = i+maxdeltapsi;
295	if (minipsi>=kNCTTM) minipsi = mindeltapsi-((kNCTTM-1)-i)-1;
296	if (maxipsi>=kNCTTM) maxipsi = maxdeltapsi-((kNCTTM-1)-i)-1;
297	Int_t miniro = i+mindeltaro;
298	Int_t maxiro = i+maxdeltaro;
299	if (miniro>=kNCTTM) miniro = mindeltaro-((kNCTTM-1)-i)-1;
300	if (maxiro>=kNCTTM) maxiro = maxdeltaro-((kNCTTM-1)-i)-1;
301	Int_t j2min = j-fstripWindow;
302	Int_t j2max = j+fstripWindow;
303	if (j2min<0) j2min =0;
304	if (j2max>=kNCTTMchannels) j2max =kNCTTMchannels-1;
305	if (fCTTMmatrixFront[i][j]){
306	for (Int_t i2=minipsi;i2<=maxipsi;i2++){
307	for (Int_t j2 = j2min;j2<=j2max;j2++){
308	if (fCTTMmatrixFront[i2][j2]) {
c6eeb5c9	309	SetInput("0OX1");
cd82ed2f	310	boolpsi = kTRUE;
	311	//exiting loops
	312	j2 = j2max+1;
	313	i2 = maxipsi+1;
	314	j=kNCTTMchannels;
	315	i=kNCTTM;
	316	}
	317	}
	318	}
	319	if (!boolpsi){
	320	for (Int_t i2=miniro;i2<=maxiro;i2++){
	321	for (Int_t j2 = j2min;j2<=j2max;j2++){
	322	if (fCTTMmatrixFront[i2][j2]) {
c6eeb5c9	323	SetInput("0OX1");
cd82ed2f	324	boolro = kTRUE;
	325	//exiting loops
	326	j2 = j2max+1;
	327	i2 = maxiro+1;
	328	j=kNCTTMchannels;
	329	i=kNCTTM;
	330	}
	331	}
	332	}
	333	}
	334	}
	335
	336	else if (fCTTMmatrixBack[i][j]){
	337	for (Int_t i2=minipsi;i2<=maxipsi;i2++){
	338	for (Int_t j2 = j2min;j2<=j2max;j2++){
	339	if (fCTTMmatrixBack[i2][j2]) {
c6eeb5c9	340	SetInput("0OX1");
cd82ed2f	341	boolpsi = kTRUE;
	342	//exiting loops
	343	j2 = j2max+1;
	344	i2 = maxipsi+1;
	345	j=kNCTTMchannels;
	346	i=kNCTTM;
	347	}
	348	}
	349	}
	350	if (!boolpsi){
	351	for (Int_t i2=miniro;i2<=maxiro;i2++){
	352	for (Int_t j2 = j2min;j2<=j2max;j2++){
	353	if (fCTTMmatrixBack[i2][j2]) {
c6eeb5c9	354	SetInput("0OX1");
cd82ed2f	355	boolro = kTRUE;
	356	//exiting loops
	357	j2 = j2max+1;
	358	i2 = maxiro+1;
	359	j=kNCTTMchannels;
	360	i=kNCTTM;
	361	}
	362	}
	363	}
	364	}
	365	}
	366	}
	367	}
	368	}
	369	}
	370	//-----------------------------------------------------------------------------
	371	void AliTOFTrigger::CreateLTMMatrix(){
	372	//creating LTMMatrix
	373	//initialization
	374	for (Int_t i=0;i<kNLTM;i++){
	375	for (Int_t j=0;j<kNLTMchannels;j++){
	376	fLTMmatrix[i][j]=kFALSE;
	377	}
	378	}
	379	AliRunLoader *rl;
33c3c91a	380	rl = AliRunLoader::Instance();
cd82ed2f	381
	382	Int_t ncurrevent = rl->GetEventNumber();
	383	rl->GetEvent(ncurrevent);
	384
	385	AliLoader * tofLoader = rl->GetLoader("TOFLoader");
	386
	387	tofLoader->LoadDigits("read");
	388	TTree *treeD = tofLoader->TreeD();
	389	if (treeD == 0x0)
	390	{
	391	AliFatal("AliTOFTrigger: Can not get TreeD");
	392	}
	393
	394	TBranch *branch = treeD->GetBranch("TOF");
	395	if (!branch) {
	396	AliError("can't get the branch with the TOF digits !");
	397	return;
	398	}
	399	TClonesArray *tofDigits =new TClonesArray("AliTOFdigit", 1000);
	400	branch->SetAddress(&tofDigits);
	401	treeD->GetEvent(0);
	402	Int_t ndigits = tofDigits->GetEntriesFast();
	403	Int_t detind[5]; //detector indexes: 0 -> sector
	404	// 1 -> plate
	405	// 2 -> strip
	406	// 3 -> padz
	407	// 4 -> padx
	408
	409	for (Int_t i=0;i<ndigits;i++){
	410	AliTOFdigit * digit = (AliTOFdigit*)tofDigits->UncheckedAt(i);
	411	detind[0] = digit->GetSector();
	412	detind[1] = digit->GetPlate();
	413	detind[2] = digit->GetStrip();
	414	detind[3] = digit->GetPadz();
	415	detind[4] = digit->GetPadx();
	416
	417	Int_t indexLTM[2] = {-1,-1};
	418	GetLTMIndex(detind,indexLTM);
	419
	420	fLTMmatrix[indexLTM[0]][indexLTM[1]] = kTRUE;
	421	}
	422
28751b82	423	tofLoader->UnloadDigits();
169674cd	424	// rl->UnloadgAlice();
cd82ed2f	425	}
	426	//-----------------------------------------------------------------------------
	427	void AliTOFTrigger::GetLTMIndex(Int_t detind, Int_t indexLTM){
	428	//getting LTMmatrix indexes for current digit
	429	if (detind[1]==0 \|\| detind[1]==1 \|\| (detind[1]==2 && detind[2]<=7)) {
	430	if (detind[4]<24){
	431	indexLTM[0] = detind[0]*2;
	432	}
	433	else {
	434	indexLTM[0] = detind[0]*2+1;
	435	}
	436	}
	437	else {
	438	if (detind[4]<24){
	439	indexLTM[0] = detind[0]*2+36;
	440	}
	441	else {
	442	indexLTM[0] = (detind[0]*2+1)+36;
	443	}
	444	}
	445
	446	if (indexLTM[0]<36){
	447	if (detind[1] ==0){
	448	indexLTM[1] = detind[2];
	449	}
	450	else if (detind[1] ==1){
	451	indexLTM[1] = detind[2]+19;
	452	}
	453	else if (detind[1] ==2){
2901911a	454	indexLTM[1] = detind[2]+19*2;
cd82ed2f	455	}
	456	else{
	457	AliError("Smth Wrong!!!");
	458	}
	459	}
	460	else {
	461	if (detind[1] ==2){
	462	indexLTM[1] = detind[2]-8;
	463	}
	464	else if (detind[1] ==3){
	465	indexLTM[1] = detind[2]+7;
	466	}
	467	else if (detind[1] ==4){
	468	indexLTM[1] = detind[2]+26;
	469	}
	470	else{
	471	AliError("Smth Wrong!!!");
	472	}
	473	}
	474	}
	475