#include "AliEMCALTrigger.h"
#include "AliEMCALGeometry.h"
#include "AliEMCALRawUtils.h"
+#include "AliLog.h"
+#include "AliCaloConstants.h"
+#include "AliEMCALRawResponse.h"
+
+using namespace CALO;
ClassImp(AliEMCALTrigger)
// cpy ctor
}
+//____________________________________________________________________________
AliEMCALTrigger::~AliEMCALTrigger() {
+
+ //dtor
+
if(GetTimeKey()) {
delete [] fADCValuesHighnxn;
delete [] fADCValuesLownxn;
fInputs.AddLast( new AliTriggerInput( det+"_GammaHPt_L1", det, 0x04 ) );
fInputs.AddLast( new AliTriggerInput( det+"_GammaMPt_L1", det, 0x08 ) );
fInputs.AddLast( new AliTriggerInput( det+"_GammaLPt_L1", det, 0x016 ) );
+ fInputs.AddLast( new AliTriggerInput( det+"_JetHPt_L1", det, 0x032 ) );
+ fInputs.AddLast( new AliTriggerInput( det+"_JetMPt_L1", det, 0x048 ) );
+ fInputs.AddLast( new AliTriggerInput( det+"_JetLPt_L1", det, 0x064 ) );
if(fNJetThreshold<=0) return;
// Jet Trigger(s)
UInt_t level = 0x032;
for(Int_t i=0; i<fNJetThreshold; i++ ) {
- TString name(Form("%s_Th_%2.2i",fgNameOfJetTriggers.Data(),i));
+ TString name(GetNameOfJetTrigger(i));
TString title("EMCAL Jet triger L1 :"); // unused now
// 0.0153 - hard coded now
title += Form("Th %i(%5.1f GeV) :", (Int_t)fL1JetThreshold[i], fL1JetThreshold[i] * 0.0153);
// 1 4x4 8x8
Bool_t b = kFALSE;
-
+ if(!ampmatrixes) return kFALSE;
+
// Get matrix of TRU or Module with maximum amplitude patch.
Int_t itru = mtru + iSM * fGeom->GetNTRU(); //number of tru, min 0 max 3*12=36.
TMatrixD * ampmatrix = 0x0;
Int_t colborder = 0;
Int_t rowborder = 0;
static int keyPrint = 0;
- if(keyPrint) printf(" IsPatchIsolated : iSM %i mtru %i itru %i maxphi %i maxeta %i \n", iSM, mtru, itru, maxphi, maxeta);
+ if(keyPrint) AliDebug(2,Form(" IsPatchIsolated : iSM %i mtru %i itru %i maxphi %i maxeta %i \n", iSM, mtru, itru, maxphi, maxeta));
if(fIsolateInSuperModule){ // ?
ampmatrix = dynamic_cast<TMatrixD *>(ampmatrixes->At(iSM)) ;
}
if(iSM>9) rowborder /= 2; // half size in phi
+ if(!ampmatrixes || !ampmatrix){
+ AliError("Could not recover the matrix with the amplitudes");
+ return kFALSE;
+ }
+
//Define patch modules - what is this ??
Int_t isolmodules = fIsolPatchSize*(1+iPatchType);
Int_t ipatchmodules = 2*(1+fPatchSize*iPatchType);
if(amp < fnxnAmpOutOfPatchThres) b=kTRUE;
}
- if(keyPrint) printf(" IsPatchIsolated - OUT \n");
+ if(keyPrint) AliDebug(2,Form(" IsPatchIsolated - OUT \n"));
return b;
*/
//____________________________________________________________________________
void AliEMCALTrigger::MakeSlidingTowers(const TClonesArray * amptrus, const TClonesArray * timeRtrus,
-const Int_t isupermod,TMatrixD &max2, TMatrixD &maxn){
+ const Int_t isupermod,TMatrixD &max2, TMatrixD &maxn){
// Output from module (2x2 cells from one module)
Int_t nModulesPhi = fGeom->GetNModulesInTRUPhi(); // now 4 modules (3 div in phi)
Int_t nModulesEta = fGeom->GetNModulesInTRUEta(); // now 24 modules (no division in eta)
Int_t nTRU = fGeom->GetNTRU();
static int keyPrint = 0;
- if(keyPrint) printf("MakeSlidingTowers : nTRU %i nModulesPhi %i nModulesEta %i ",
- nTRU, nModulesPhi, nModulesEta );
-
+ if(keyPrint) AliDebug(2,Form("MakeSlidingTowers : nTRU %i nModulesPhi %i nModulesEta %i ",
+ nTRU, nModulesPhi, nModulesEta ));
+
Float_t amp2 = 0 ;
Float_t ampn = 0 ;
for(Int_t i = 0; i < 4; i++){
ampmax2(i,j) = ampmaxn(i,j) = -1;
}
}
-
+
// Create matrix that will contain 2x2 amplitude sums
// used to calculate the nxn sums
TMatrixD tru2x2(nModulesPhi/2,nModulesEta/2);
-
+
// Loop over all TRUS in a supermodule
for(Int_t itru = 0 + isupermod * nTRU ; itru < (isupermod+1)*nTRU ; itru++) {
TMatrixD * amptru = dynamic_cast<TMatrixD *>(amptrus->At(itru)) ;
TMatrixD * timeRtru = dynamic_cast<TMatrixD *>(timeRtrus->At(itru)) ;
Int_t mtru = itru - isupermod*nTRU ; // Number of TRU in Supermodule !!
-
+
+ if(!amptru || !timeRtru){
+ AliError("Amplitude or Time TRU matrix not available");
+ return;
+ }
+
// Sliding 2x2, add 2x2 amplitudes (NOT OVERLAP)
for(Int_t irow = 0 ; irow < nModulesPhi; irow +=2){
for(Int_t icol = 0 ; icol < nModulesEta ; icol +=2){
- amp2 = (*amptru)(irow,icol) +(*amptru)(irow+1,icol)+
- (*amptru)(irow,icol+1)+(*amptru)(irow+1,icol+1);
-
- //Fill matrix with added 2x2 towers for use in nxn sums
- tru2x2(irow/2,icol/2) = amp2 ;
- //Select 2x2 maximum sums to select L0
- if(amp2 > ampmax2(0,mtru)){
- ampmax2(0,mtru) = amp2 ;
- ampmax2(1,mtru) = irow;
- ampmax2(2,mtru) = icol;
- }
+ amp2 = (*amptru)(irow,icol) +(*amptru)(irow+1,icol)+
+ (*amptru)(irow,icol+1)+(*amptru)(irow+1,icol+1);
+
+ //Fill matrix with added 2x2 towers for use in nxn sums
+ tru2x2(irow/2,icol/2) = amp2 ;
+ //Select 2x2 maximum sums to select L0
+ if(amp2 > ampmax2(0,mtru)){
+ ampmax2(0,mtru) = amp2 ;
+ ampmax2(1,mtru) = irow;
+ ampmax2(2,mtru) = icol;
+ }
}
}
ampmax2(3,mtru) = 0.;
if(GetTimeKey()) {
- // Find most recent time in the selected 2x2 towers
+ // Find most recent time in the selected 2x2 towers
Int_t row2 = static_cast <Int_t> (ampmax2(1,mtru));
Int_t col2 = static_cast <Int_t> (ampmax2(2,mtru));
for(Int_t i = 0; i<2; i++){
for(Int_t j = 0; j<2; j++){
- if((*amptru)(row2+i,col2+j) > 0 && (*timeRtru)(row2+i,col2+j)> 0){
- if((*timeRtru)(row2+i,col2+j) > ampmax2(3,mtru) )
- ampmax2(3,mtru) = (*timeRtru)(row2+i,col2+j); // max time
- }
+ if((*amptru)(row2+i,col2+j) > 0 && (*timeRtru)(row2+i,col2+j)> 0){
+ if((*timeRtru)(row2+i,col2+j) > ampmax2(3,mtru) )
+ ampmax2(3,mtru) = (*timeRtru)(row2+i,col2+j); // max time
+ }
}
}
}
-
+
//Sliding nxn, add nxn amplitudes (OVERLAP)
if(fPatchSize > 0){
for(Int_t irow = 0 ; irow < nModulesPhi/2; irow++){
- for(Int_t icol = 0 ; icol < nModulesEta/2; icol++){
- ampn = 0;
- if( (irow+fPatchSize) < nModulesPhi/2 && (icol+fPatchSize) < nModulesEta/2){ //Avoid exit the TRU
- for(Int_t i = 0 ; i <= fPatchSize ; i++)
- for(Int_t j = 0 ; j <= fPatchSize ; j++)
- ampn += tru2x2(irow+i,icol+j);
- //Select nxn maximum sums to select L1
- if(ampn > ampmaxn(0,mtru)){
- ampmaxn(0,mtru) = ampn ;
- ampmaxn(1,mtru) = irow;
- ampmaxn(2,mtru) = icol;
- }
- }
- }
+ for(Int_t icol = 0 ; icol < nModulesEta/2; icol++){
+ ampn = 0;
+ if( (irow+fPatchSize) < nModulesPhi/2 && (icol+fPatchSize) < nModulesEta/2){ //Avoid exit the TRU
+ for(Int_t i = 0 ; i <= fPatchSize ; i++)
+ for(Int_t j = 0 ; j <= fPatchSize ; j++)
+ ampn += tru2x2(irow+i,icol+j);
+ //Select nxn maximum sums to select L1
+ if(ampn > ampmaxn(0,mtru)){
+ ampmaxn(0,mtru) = ampn ;
+ ampmaxn(1,mtru) = irow;
+ ampmaxn(2,mtru) = icol;
+ }
+ }
+ }
}
ampmaxn(3,mtru) = 0.; // Was 1 , I don't know why
if(GetTimeKey()) {
- //Find most recent time in selected nxn cell
+ //Find most recent time in selected nxn cell
Int_t rown = static_cast <Int_t> (ampmaxn(1,mtru));
Int_t coln = static_cast <Int_t> (ampmaxn(2,mtru));
for(Int_t i = 0; i<4*fPatchSize; i++){
- for(Int_t j = 0; j<4*fPatchSize; j++){
- if( (rown+i) < nModulesPhi && (coln+j) < nModulesEta){//Avoid exit the TRU
- if((*amptru)(rown+i,coln+j) > 0 && (*timeRtru)(rown+i,coln+j)> 0){
- if((*timeRtru)(rown+i,coln+j) > ampmaxn(3,mtru) )
- ampmaxn(3,mtru) = (*timeRtru)(rown+i,coln+j); // max time
- }
- }
- }
+ for(Int_t j = 0; j<4*fPatchSize; j++){
+ if( (rown+i) < nModulesPhi && (coln+j) < nModulesEta){//Avoid exit the TRU
+ if((*amptru)(rown+i,coln+j) > 0 && (*timeRtru)(rown+i,coln+j)> 0){
+ if((*timeRtru)(rown+i,coln+j) > ampmaxn(3,mtru) )
+ ampmaxn(3,mtru) = (*timeRtru)(rown+i,coln+j); // max time
+ }
+ }
+ }
}
}
} else { // copy 2x2 to nxn
- ampmaxn(0,mtru) = ampmax2(0,mtru);
- ampmaxn(1,mtru) = ampmax2(1,mtru);
- ampmaxn(2,mtru) = ampmax2(2,mtru);
- ampmaxn(3,mtru) = ampmax2(3,mtru);
+ ampmaxn(0,mtru) = ampmax2(0,mtru);
+ ampmaxn(1,mtru) = ampmax2(1,mtru);
+ ampmaxn(2,mtru) = ampmax2(2,mtru);
+ ampmaxn(3,mtru) = ampmax2(3,mtru);
}
}
- if(keyPrint) printf(" : MakeSlidingTowers -OUt \n");
+ if(keyPrint) AliDebug(2,Form(" : MakeSlidingTowers -OUt \n"));
}
//____________________________________________________________________________
if(! opt)
return;
AliTriggerInput* in = 0x0 ;
- printf( " fSimulation %i (input option) : #digits %i\n", fSimulation, fDigitsList->GetEntries());
- printf( " fTimeKey %i \n ", fTimeKey);
-
- printf( " Maximum Amplitude after Sliding Cell, \n") ;
- printf( " -2x2 cells sum (not overlapped): %10.2f, in Super Module %d\n",
- f2x2MaxAmp,f2x2SM) ;
- printf( " -2x2 from row %d to row %d and from column %d to column %d\n", f2x2ModulePhi, f2x2ModulePhi+2, f2x2ModuleEta, f2x2ModuleEta+2) ;
- printf( " -2x2 Isolation Patch %d x %d, Amplitude out of 2x2 patch is %f, threshold %f, Isolated? %d \n",
- 2*fIsolPatchSize+2, 2*fIsolPatchSize+2, f2x2AmpOutOfPatch, f2x2AmpOutOfPatchThres,static_cast<Int_t> (fIs2x2Isol)) ;
+ AliInfo(Form(" fSimulation %i (input option) : #digits %i\n", fSimulation, fDigitsList->GetEntries()));
+ AliInfo(Form(" fTimeKey %i \n ", fTimeKey));
+
+ AliInfo(Form("\t Maximum Amplitude after Sliding Cell, \n")) ;
+ AliInfo(Form("\t -2x2 cells sum (not overlapped): %10.2f, in Super Module %d\n",
+ f2x2MaxAmp,f2x2SM)) ;
+ AliInfo(Form("\t -2x2 from row %d to row %d and from column %d to column %d\n", f2x2ModulePhi, f2x2ModulePhi+2, f2x2ModuleEta, f2x2ModuleEta+2));
+ AliInfo(Form("\t -2x2 Isolation Patch %d x %d, Amplitude out of 2x2 patch is %f, threshold %f, Isolated? %d \n", 2*fIsolPatchSize+2, 2*fIsolPatchSize+2, f2x2AmpOutOfPatch, f2x2AmpOutOfPatchThres,static_cast<Int_t> (fIs2x2Isol)));
if(fPatchSize > 0){
- printf( " Patch Size, n x n: %d x %d cells\n",2*(fPatchSize+1), 2*(fPatchSize+1));
- printf( " -nxn cells sum (overlapped) : %10.2f, in Super Module %d\n",
- fnxnMaxAmp,fnxnSM) ;
- printf( " -nxn from row %d to row %d and from column %d to column %d\n", fnxnModulePhi, fnxnModulePhi+4*fPatchSize, fnxnModuleEta, fnxnModuleEta+4*fPatchSize) ;
- printf( " -nxn Isolation Patch %d x %d, Amplitude out of nxn patch is %f, threshold %f, Isolated? %d \n",
- 4*fIsolPatchSize+2*(fPatchSize+1),4*fIsolPatchSize+2*(fPatchSize+1) , fnxnAmpOutOfPatch, fnxnAmpOutOfPatchThres,static_cast<Int_t> (fIsnxnIsol) ) ;
+ AliInfo(Form("\t Patch Size, n x n: %d x %d cells\n",2*(fPatchSize+1), 2*(fPatchSize+1)));
+ AliInfo(Form("\t -nxn cells sum (overlapped) : %10.2f, in Super Module %d\n", fnxnMaxAmp,fnxnSM));
+ AliInfo(Form("\t -nxn from row %d to row %d and from column %d to column %d\n", fnxnModulePhi, fnxnModulePhi+4*fPatchSize, fnxnModuleEta, fnxnModuleEta+4*fPatchSize)) ;
+ AliInfo(Form("\t -nxn Isolation Patch %d x %d, Amplitude out of nxn patch is %f, threshold %f, Isolated? %d \n", 4*fIsolPatchSize+2*(fPatchSize+1),4*fIsolPatchSize+2*(fPatchSize+1) , fnxnAmpOutOfPatch, fnxnAmpOutOfPatchThres,static_cast<Int_t> (fIsnxnIsol) ));
}
- printf( " Isolate in SuperModule? %d\n",
- fIsolateInSuperModule) ;
+ AliInfo(Form("\t Isolate in SuperModule? %d\n", fIsolateInSuperModule)) ;
+ AliInfo(Form("\t Threshold for LO %10.2f\n", fL0Threshold));
- printf( " Threshold for LO %10.2f\n",
- fL0Threshold) ;
in = (AliTriggerInput*)fInputs.FindObject( "EMCAL_L0" );
if(in->GetValue())
- printf( " *** EMCAL LO is set ***\n") ;
+ AliInfo(Form("\t *** EMCAL LO is set ***\n"));
- printf( " Gamma Low Pt Threshold for L1 %10.2f\n",
- fL1GammaLowPtThreshold) ;
+ AliInfo(Form("\t Gamma Low Pt Threshold for L1 %10.2f\n", fL1GammaLowPtThreshold));
in = (AliTriggerInput*)fInputs.FindObject( "EMCAL_GammaLPt_L1" );
if(in->GetValue())
- printf( " *** EMCAL Gamma Low Pt for L1 is set ***\n") ;
+ AliInfo(Form("\t *** EMCAL Gamma Low Pt for L1 is set ***\n"));
- printf( " Gamma Medium Pt Threshold for L1 %10.2f\n",
- fL1GammaMediumPtThreshold) ;
+ AliInfo(Form("\t Gamma Medium Pt Threshold for L1 %10.2f\n", fL1GammaMediumPtThreshold));
in = (AliTriggerInput*) fInputs.FindObject( "EMCAL_GammaMPt_L1" );
if(in->GetValue())
- printf( " *** EMCAL Gamma Medium Pt for L1 is set ***\n") ;
+ AliInfo(Form("\t *** EMCAL Gamma Medium Pt for L1 is set ***\n"));
- printf( " Gamma High Pt Threshold for L1 %10.2f\n",
- fL1GammaHighPtThreshold) ;
+ AliInfo(Form("\t Gamma High Pt Threshold for L1 %10.2f\n", fL1GammaHighPtThreshold));
in = (AliTriggerInput*) fInputs.FindObject( "EMCAL_GammaHPt_L1" );
if(in->GetValue())
- printf( " *** EMCAL Gamma High Pt for L1 is set ***\n") ;
+ AliInfo(Form("\t *** EMCAL Gamma High Pt for L1 is set ***\n")) ;
}
Float_t maxtimeR2 = -1 ;
Float_t maxtimeRn = -1 ;
static AliEMCALRawUtils rawUtil;
- Int_t nTimeBins = rawUtil.GetRawFormatTimeBins() ;
+ // Int_t nTimeBins = rawUtil.GetRawFormatTimeBins() ;
+ Int_t nTimeBins = TIMEBINS; //changed by PTH
//Set max of 2x2 amplitudes and select L0 trigger
if(max2[0] > f2x2MaxAmp ){
fADCValuesHigh2x2 = new Int_t[nTimeBins];
}
//printf(" maxtimeR2 %12.5e (1)\n", maxtimeR2);
- rawUtil.RawSampledResponse(maxtimeR2 * AliEMCALRawUtils::GetRawFormatTimeBin(),
- f2x2MaxAmp, fADCValuesHigh2x2, fADCValuesLow2x2) ;
-
+ // rawUtil.RawSampledResponse(maxtimeR2 * AliEMCALRawUtils::GetRawFormatTimeBin(),
+ // f2x2MaxAmp, fADCValuesHigh2x2, fADCValuesLow2x2) ;
+
+ // rawUtil.RawSampledResponse(maxtimeR2*TIMEBINMAX/TIMEBINS,
+ // f2x2MaxAmp, fADCValuesHigh2x2, fADCValuesLow2x2) ;
+
+ AliEMCALRawResponse::RawSampledResponse( maxtimeR2*TIMEBINMAX/TIMEBINS,
+ f2x2MaxAmp, fADCValuesHigh2x2, fADCValuesLow2x2) ;
+
// Set Trigger Inputs, compare ADC time bins until threshold is attained
// Set L0
for(Int_t i = 0 ; i < nTimeBins ; i++){
fADCValuesHighnxn = new Int_t[nTimeBins];
fADCValuesLownxn = new Int_t[nTimeBins];
}
- rawUtil.RawSampledResponse(maxtimeRn * AliEMCALRawUtils::GetRawFormatTimeBin(),
- fnxnMaxAmp, fADCValuesHighnxn, fADCValuesLownxn) ;
-
+ // rawUtil.RawSampledResponse(maxtimeRn * AliEMCALRawUtils::GetRawFormatTimeBin(),
+ // fnxnMaxAmp, fADCValuesHighnxn, fADCValuesLownxn) ;
+
+ //rawUtil.RawSampledResponse(maxtimeRn*TIMEBINMAX/TIMEBINS,
+ // fnxnMaxAmp, fADCValuesHighnxn, fADCValuesLownxn) ;
+
+ AliEMCALRawResponse::RawSampledResponse (maxtimeRn*TIMEBINMAX/TIMEBINS,
+ fnxnMaxAmp, fADCValuesHighnxn, fADCValuesLownxn) ;
+
//Set Trigger Inputs, compare ADC time bins until threshold is attained
//SetL1 Low
for(Int_t i = 0 ; i < nTimeBins ; i++){
for(Int_t idig = 0 ; idig < digits->GetEntriesFast() ; idig++){
dig = dynamic_cast<AliEMCALDigit *>(digits->At(idig)) ;
- amp = Float_t(dig->GetAmp()); // Energy of the digit (arbitrary units)
- id = dig->GetId() ; // Id label of the cell
- timeR = dig->GetTimeR() ; // Earliest time of the digit
- if(amp<=0.0) printf("<I> AliEMCALTrigger::FillTRU : id %i amp %f \n", id, amp);
- // printf(" FILLTRU : timeR %10.5e time %10.5e : amp %10.5e \n", timeR, dig->GetTime(), amp);
- // Get eta and phi cell position in supermodule
- Bool_t bCell = fGeom->GetCellIndex(id, iSupMod, nModule, nIphi, nIeta) ;
- if(!bCell)
- Error("FillTRU","%i Wrong cell id number %i ", idig, id) ;
-
- fGeom->GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
- // iphim, ietam - module indexes in SM
- fGeom->GetModuleIndexesFromCellIndexesInSModule(iSupMod,iphi,ieta, iphim, ietam, nModule);
- //if(iSupMod >9)
- //printf("iSupMod %i nModule %i iphi %i ieta %i iphim %i ietam %i \n",
- //iSupMod,nModule, iphi, ieta, iphim, ietam);
-
- // Check to which TRU in the supermodule belongs the cell.
- // Supermodules are divided in a TRU matrix of dimension
- // (fNTRUPhi,fNTRUEta).
- // Each TRU is a cell matrix of dimension (nModulesPhi,nModulesEta)
-
- // First calculate the row and column in the supermodule
- // of the TRU to which the cell belongs.
- Int_t row = iphim / nModulesPhi;
- Int_t col = ietam / nModulesEta;
- //Calculate label number of the TRU
- Int_t itru = fGeom->GetAbsTRUNumberFromNumberInSm(row, col, iSupMod);
-
- //Fill TRU matrix with cell values
- TMatrixD * amptrus = dynamic_cast<TMatrixD *>(ampmatrix->At(itru)) ;
- TMatrixD * timeRtrus = dynamic_cast<TMatrixD *>(timeRmatrix->At(itru)) ;
-
- //Calculate row and column of the module inside the TRU with number itru
- Int_t irow = iphim - row * nModulesPhi;
- if(iSupMod > 9)
- irow = iphim - row * nModulesPhi2; // size of matrix the same
- Int_t icol = ietam - col * nModulesEta;
-
- (*amptrus)(irow,icol) += amp ;
- if((*timeRtrus)(irow,icol) <0.0 || (*timeRtrus)(irow,icol) <= timeR){ // ??
- (*timeRtrus)(irow,icol) = timeR ;
+ if(dig){
+ amp = Float_t(dig->GetAmplitude()); // Energy of the digit (arbitrary units)
+ id = dig->GetId() ; // Id label of the cell
+ timeR = dig->GetTimeR() ; // Earliest time of the digit
+ if(amp<=0.0) AliDebug(1,Form(" id %i amp %f \n", id, amp));
+ // printf(" FILLTRU : timeR %10.5e time %10.5e : amp %10.5e \n", timeR, dig->GetTime(), amp);
+ // Get eta and phi cell position in supermodule
+ Bool_t bCell = fGeom->GetCellIndex(id, iSupMod, nModule, nIphi, nIeta) ;
+ if(!bCell)
+ AliError(Form("%i Wrong cell id number %i ", idig, id)) ;
+
+ fGeom->GetCellPhiEtaIndexInSModule(iSupMod,nModule,nIphi, nIeta,iphi,ieta);
+ // iphim, ietam - module indexes in SM
+ fGeom->GetModuleIndexesFromCellIndexesInSModule(iSupMod,iphi,ieta, iphim, ietam, nModule);
+ //if(iSupMod >9)
+ //printf("iSupMod %i nModule %i iphi %i ieta %i iphim %i ietam %i \n",
+ //iSupMod,nModule, iphi, ieta, iphim, ietam);
+
+ // Check to which TRU in the supermodule belongs the cell.
+ // Supermodules are divided in a TRU matrix of dimension
+ // (fNTRUPhi,fNTRUEta).
+ // Each TRU is a cell matrix of dimension (nModulesPhi,nModulesEta)
+
+ // First calculate the row and column in the supermodule
+ // of the TRU to which the cell belongs.
+ Int_t row = iphim / nModulesPhi;
+ Int_t col = ietam / nModulesEta;
+ //Calculate label number of the TRU
+ Int_t itru = fGeom->GetAbsTRUNumberFromNumberInSm(row, col, iSupMod);
+
+ //Fill TRU matrix with cell values
+ TMatrixD * amptrus = dynamic_cast<TMatrixD *>(ampmatrix->At(itru)) ;
+ TMatrixD * timeRtrus = dynamic_cast<TMatrixD *>(timeRmatrix->At(itru)) ;
+
+ if(!amptrus || !timeRtrus){
+ AliError("Could not recover the TRU matrix with amplitudes or times");
+ }
+ else{
+ //Calculate row and column of the module inside the TRU with number itru
+ Int_t irow = iphim - row * nModulesPhi;
+ if(iSupMod > 9)
+ irow = iphim - row * nModulesPhi2; // size of matrix the same
+ Int_t icol = ietam - col * nModulesEta;
+
+ (*amptrus)(irow,icol) += amp ;
+ if((*timeRtrus)(irow,icol) <0.0 || (*timeRtrus)(irow,icol) <= timeR){ // ??
+ (*timeRtrus)(irow,icol) = timeR ;
+ }
+ }
+ //printf(" ieta %i iphi %i iSM %i || col %i row %i : itru %i -> amp %f\n",
+ // ieta, iphi, iSupMod, col, row, itru, amp);
+ //####################SUPERMODULE MATRIX ##################
+ TMatrixD * ampsmods = dynamic_cast<TMatrixD *>(ampmatrixsmod->At(iSupMod)) ;
+ if(!ampsmods){
+ AliError("Could not recover the matrix per SM");
+ continue;
+ }
+ (*ampsmods)(iphim,ietam) += amp ;
+ // printf(" id %i iphim %i ietam %i SM %i : irow %i icol %i itru %i : amp %6.0f\n",
+ //id, iphim, ietam, iSupMod, irow, icol, itru, amp);
}
- //printf(" ieta %i iphi %i iSM %i || col %i row %i : itru %i -> amp %f\n",
- // ieta, iphi, iSupMod, col, row, itru, amp);
- //####################SUPERMODULE MATRIX ##################
- TMatrixD * ampsmods = dynamic_cast<TMatrixD *>(ampmatrixsmod->At(iSupMod)) ;
- (*ampsmods)(iphim,ietam) += amp ;
- // printf(" id %i iphim %i ietam %i SM %i : irow %i icol %i itru %i : amp %6.0f\n",
- //id, iphim, ietam, iSupMod, irow, icol, itru, amp);
+ else AliError("Could not recover the digit");
}
//assert(0);
//printf("<I> AliEMCALTrigger::FillTRU() is ended \n");
}
+
//____________________________________________________________________________
void AliEMCALTrigger::Trigger()
{
- TH1::AddDirectory(0);
//Main Method to select triggers.
- AliRunLoader *runLoader = AliRunLoader::GetRunLoader();
+ TH1::AddDirectory(0);
+
+ AliRunLoader *runLoader = AliRunLoader::Instance();
AliEMCALLoader *emcalLoader = 0;
if(runLoader) {
emcalLoader = dynamic_cast<AliEMCALLoader*>(runLoader->GetDetectorLoader("EMCAL"));
}
//Load EMCAL Geometry
- if (runLoader && runLoader->GetAliRun() && runLoader->GetAliRun()->GetDetector("EMCAL"))
- fGeom = dynamic_cast<AliEMCAL*>(runLoader->GetAliRun()->GetDetector("EMCAL"))->GetGeometry();
+ if (runLoader && runLoader->GetAliRun()){
+ AliEMCAL* emcal = dynamic_cast<AliEMCAL*>(runLoader->GetAliRun()->GetDetector("EMCAL"));
+ if(emcal)fGeom = emcal->GetGeometry();
+ }
+
+ if (!fGeom)
+ fGeom = AliEMCALGeometry::GetInstance(AliEMCALGeometry::GetDefaultGeometryName());
- if (fGeom==0)
+ if (!fGeom)
AliFatal("Did not get geometry from EMCALLoader");
//Define parameters
FillTRU(fDigitsList, fAmpTrus, fAmpSMods, fTimeRtrus);
- // Jet staff - only one case, no fredom here
+ // Jet stuff - only one case, no freedom here
if(fGeom->GetNEtaSubOfTRU() == 6) {
if(fAmpJetMatrix) {delete fAmpJetMatrix; fAmpJetMatrix=0;}
if(fJetMatrixE) {delete fJetMatrixE; fJetMatrixE=0;}
// fDigitsList = 0;
}
-void AliEMCALTrigger::GetTriggerInfo(TArrayF &triggerPosition, TArrayF &triggerAmplitudes)
+//____________________________________________________________________________
+void AliEMCALTrigger::GetTriggerInfo(TArrayF &triggerPosition, TArrayF &triggerAmplitudes) const
{
// Template - should be defined; Nov 5, 2007
triggerPosition[0] = 0.;
triggerAmplitudes[0] = 0.;
}
+//____________________________________________________________________________
void AliEMCALTrigger::FillJetMatrixFromSMs(TClonesArray *ampmatrixsmod, TMatrixD* jetMat, AliEMCALGeometry *g)
{
// Nov 5, 2007
Int_t nEtaModSum = g->GetNZ() / g->GetNEtaSubOfTRU(); // should be 4
Int_t nPhiModSum = g->GetNPhi() / g->GetNTRUPhi(); // should be 4
- if(keyPrint) printf("%s",Form(" AliEMCALTrigger::FillJetMatrixFromSMs | nEtaModSum %i : nPhiModSum %i \n",
- nEtaModSum, nPhiModSum));
+ if(keyPrint) AliDebug(2,Form("%s",Form(" AliEMCALTrigger::FillJetMatrixFromSMs | nEtaModSum %i : nPhiModSum %i \n", nEtaModSum, nPhiModSum)));
Int_t jrow=0, jcol=0; // indexes of jet matrix
Int_t nEtaSM=0, nPhiSM=0;
for(Int_t iSM=0; iSM<ampmatrixsmod->GetEntries(); iSM++) {
TMatrixD * ampsmods = dynamic_cast<TMatrixD *>(ampmatrixsmod->At(iSM));
+
+ if(!ampsmods) return;
+
Int_t nrow = ampsmods->GetNrows();
Int_t ncol = ampsmods->GetNcols();
//printf("%s",Form(" ######## SM %i : nrow %i : ncol %i ##### \n", iSM, nrow, ncol));
nPhiSM = iSM / 2;
nEtaSM = iSM % 2;
if (amp>0.0) {
- if(keyPrint) printf("%s",Form(" ** nPhiSm %i : nEtaSM %i : row %2.2i : col %2.2i -> ",
- nPhiSM, nEtaSM, row, col));
+ if(keyPrint) AliDebug(2,Form("%s",Form(" ** nPhiSm %i : nEtaSM %i : row %2.2i : col %2.2i -> ", nPhiSM, nEtaSM, row, col)));
if(nEtaSM == 0) { // positive Z
jrow = 3*nPhiSM + row/nPhiModSum;
jcol = 6 + col / nEtaModSum;
else jrow = 3*nPhiSM + 1 - row/nPhiModSum; // half size
jcol = 5 - col / nEtaModSum;
}
- if(keyPrint) printf("%s",Form(" jrow %2.2i : jcol %2.2i : amp %f (jetMat) \n", jrow, jcol, amp));
+ if(keyPrint) AliDebug(2,Form("%s",Form(" jrow %2.2i : jcol %2.2i : amp %f (jetMat) \n", jrow, jcol, amp)));
(*jetMat)(jrow,jcol) += amp;
ampSum += amp; // For controling
} else if(amp<0.0) {
- printf("%s",Form(" jrow %2.2i : jcol %2.2i : amp %f (jetMat: amp<0) \n", jrow, jcol, amp));
+ AliDebug(1,Form(" jrow %2.2i : jcol %2.2i : amp %f (jetMat: amp<0) \n", jrow, jcol, amp));
assert(0);
}
}
}
} // cycle on SM
- if(ampSum <= 0.0) Warning("FillJetMatrixFromSMs","ampSum %f (<=0.0) ", ampSum);
+ if(ampSum <= 0.0) AliDebug(1,Form("ampSum %f (<=0.0) ", ampSum));
}
+//____________________________________________________________________________
void AliEMCALTrigger::MakeSlidingPatch(const TMatrixD &jm, const Int_t nPatchSize, TMatrixD &JetMax)
{
// Sliding patch : nPatchSize x nPatchSize (OVERLAP)
static int keyPrint = 0;
- if(keyPrint) printf(" AliEMCALTrigger::MakeSlidingPatch() was started \n");
+ if(keyPrint) AliDebug(2,Form(" AliEMCALTrigger::MakeSlidingPatch() was started \n"));
Double_t ampCur = 0.0, e=0.0;
ampJetMax(0,0) = 0.0;
ampJetMax(3,0) = 0.0; // unused now
} // check on patch size
}
}
- if(keyPrint) printf(" ampJetMax %i row %2i->%2i col %2i->%2i \n",
- Int_t(ampJetMax(0,0)), Int_t(ampJetMax(1,0)), Int_t(ampJetMax(1,0))+nPatchSize-1,
- Int_t(ampJetMax(2,0)), Int_t(ampJetMax(2,0))+nPatchSize-1);
+ if(keyPrint) AliDebug(2,Form(" ampJetMax %i row %2i->%2i col %2i->%2i \n", Int_t(ampJetMax(0,0)), Int_t(ampJetMax(1,0)), Int_t(ampJetMax(1,0))+nPatchSize-1, Int_t(ampJetMax(2,0)), Int_t(ampJetMax(2,0))+nPatchSize-1));
Double_t eCorrJetMatrix=0.0;
if(fVZER0Mult > 0.0) {
ampJetMax(5,0) = meanAmpBG;
Double_t eCorr = ampJetMax(0,0) - meanAmpBG;
- printf(" ampJetMax(0,0) %f meanAmpBG %f eCorr %f : ampJetMax(4,0) %f \n",
- ampJetMax(0,0), meanAmpBG, eCorr, ampJetMax(5,0));
+ AliDebug(2,Form(" ampJetMax(0,0) %f meanAmpBG %f eCorr %f : ampJetMax(4,0) %f \n",
+ ampJetMax(0,0), meanAmpBG, eCorr, ampJetMax(5,0)));
ampJetMax(0,0) = eCorr;
// --
eCorrJetMatrix = GetMeanEmcalEnergy(Int_t(fVZER0Mult)) / 208.;
// Set the jet trigger(s), multiple threshold now, Nov 19,2007
for(Int_t i=0; i<fNJetThreshold; i++ ) {
if(ampJetMax(0,0) >= fL1JetThreshold[i]) {
- SetInput((Form("%s_Th%2i", fgNameOfJetTriggers.Data(),i)));
+ SetInput(GetNameOfJetTrigger(i));
}
}
}
+//____________________________________________________________________________
Double_t AliEMCALTrigger::GetEmcalSumAmp() const
{
// Return sum of amplidutes from EMCal
return fAmpJetMatrix >0 ?fAmpJetMatrix->Sum() :0.0;
}
-
+//____________________________________________________________________________
void AliEMCALTrigger::PrintJetMatrix() const
{
// fAmpJetMatrix : (17,12); // 17-phi(row), 12-eta(col)
if(fAmpJetMatrix == 0) return;
- printf("\n #### jetMatrix : (%i,%i) ##### \n ",
- fAmpJetMatrix->GetNrows(), fAmpJetMatrix->GetNcols());
+ AliInfo(Form("\n #### jetMatrix : (%i,%i) ##### \n ",
+ fAmpJetMatrix->GetNrows(), fAmpJetMatrix->GetNcols()));
PrintMatrix(*fAmpJetMatrix);
}
+//____________________________________________________________________________
void AliEMCALTrigger::PrintAmpTruMatrix(Int_t ind) const
{
+ // Print matrix with TRU patches
TMatrixD * tru = dynamic_cast<TMatrixD *>(fAmpTrus->At(ind));
if(tru == 0) return;
- printf("\n #### Amp TRU matrix(%i) : (%i,%i) ##### \n ",
- ind, tru->GetNrows(), tru->GetNcols());
+ AliInfo(Form("\n #### Amp TRU matrix(%i) : (%i,%i) ##### \n ",
+ ind, tru->GetNrows(), tru->GetNcols()));
PrintMatrix(*tru);
}
+//____________________________________________________________________________
void AliEMCALTrigger::PrintAmpSmMatrix(Int_t ind) const
{
- TMatrixD * sm = dynamic_cast<TMatrixD *>(fAmpSMods->At(ind));
+ // Print matrix with SM amplitudes
+ TMatrixD * sm = dynamic_cast<TMatrixD *>(fAmpSMods->At(ind));
if(sm == 0) return;
- printf("\n #### Amp SM matrix(%i) : (%i,%i) ##### \n ",
- ind, sm->GetNrows(), sm->GetNcols());
+ AliInfo(Form("\n #### Amp SM matrix(%i) : (%i,%i) ##### \n ",
+ ind, sm->GetNrows(), sm->GetNcols()));
PrintMatrix(*sm);
}
+//____________________________________________________________________________
void AliEMCALTrigger::PrintMatrix(const TMatrixD &mat) const
{
- for(Int_t col=0; col<mat.GetNcols(); col++) printf(" %3i ", col);
- printf("\n -- \n");
+ //Print matrix object
+ for(Int_t col=0; col<mat.GetNcols(); col++) AliInfo(Form(" %3i ", col));
+ AliInfo(Form("\n -- \n"));
for(Int_t row=0; row<mat.GetNrows(); row++) {
- printf(" row:%2i ", row);
+ AliInfo(Form(" row:%2i ", row));
for(Int_t col=0; col<mat.GetNcols(); col++) {
- printf(" %4i", (Int_t)mat(row,col));
+ AliInfo(Form(" %4i", (Int_t)mat(row,col)));
}
- printf("\n");
+ AliInfo("\n");
}
}
+//____________________________________________________________________________
Bool_t AliEMCALTrigger::CheckConsistentOfMatrixes(const Int_t pri)
{
+ // Check consitency of matrices
Double_t sumSM = 0.0, smCur=0.0;
Double_t sumTru=0.0, sumTruInSM = 0.0, truSum=0.0;
// Bool_t key = kTRUE;
sumTru += sumTruInSM;
if(sumTruInSM != smCur) {
- printf(" sm %i : smCur %f -> sumTruInSM %f \n", i, smCur, sumTruInSM);
+ AliDebug(1,Form(" sm %i : smCur %f -> sumTruInSM %f \n", i, smCur, sumTruInSM));
return kFALSE;
}
}
}
Double_t sumJetMat = fAmpJetMatrix->Sum();
- if(pri || sumSM != sumTru || sumSM != sumJetMat)
- printf(" sumSM %f : sumTru %f : sumJetMat %f \n", sumSM, sumTru, sumJetMat);
- if(sumSM != sumTru || sumSM != sumJetMat) return kFALSE;
+ if(pri || TMath::Abs(sumSM-sumTru)>0.0001 || TMath::Abs(sumSM-sumJetMat) > 0.0001)
+ AliDebug(1,Form(" sumSM %f : sumTru %f : sumJetMat %f \n", sumSM, sumTru, sumJetMat));
+ if(TMath::Abs(sumSM - sumTru)>0.0001 || TMath::Abs(sumSM-sumJetMat) > 0.0001) return kFALSE;
else return kTRUE;
}
-
+//____________________________________________________________________________
void AliEMCALTrigger::Browse(TBrowser* b)
{
+ //Browse.
if(&fInputs) b->Add(&fInputs);
if(fAmpTrus) b->Add(fAmpTrus);
if(fTimeRtrus) b->Add(fTimeRtrus);
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff