Update on the trigger, new OCDB DCS trigger information, use ESDVZERO (Rachid)
authorgconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 May 2010 15:57:19 +0000 (15:57 +0000)
committergconesab <gconesab@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 May 2010 15:57:19 +0000 (15:57 +0000)
22 files changed:
EMCAL/AliEMCALReconstructor.cxx
EMCAL/AliEMCALTriggerBoard.cxx
EMCAL/AliEMCALTriggerBoard.h
EMCAL/AliEMCALTriggerDCSConfig.cxx [new file with mode: 0644]
EMCAL/AliEMCALTriggerDCSConfig.h [new file with mode: 0644]
EMCAL/AliEMCALTriggerDCSConfigDB.cxx [new file with mode: 0644]
EMCAL/AliEMCALTriggerDCSConfigDB.h [new file with mode: 0644]
EMCAL/AliEMCALTriggerData.cxx
EMCAL/AliEMCALTriggerData.h
EMCAL/AliEMCALTriggerElectronics.cxx
EMCAL/AliEMCALTriggerElectronics.h
EMCAL/AliEMCALTriggerSTU.cxx
EMCAL/AliEMCALTriggerSTU.h
EMCAL/AliEMCALTriggerSTUDCSConfig.cxx [new file with mode: 0644]
EMCAL/AliEMCALTriggerSTUDCSConfig.h [new file with mode: 0644]
EMCAL/AliEMCALTriggerSTURawStream.cxx
EMCAL/AliEMCALTriggerTRU.cxx
EMCAL/AliEMCALTriggerTRU.h
EMCAL/AliEMCALTriggerTRUDCSConfig.cxx [new file with mode: 0644]
EMCAL/AliEMCALTriggerTRUDCSConfig.h [new file with mode: 0644]
EMCAL/EMCALbaseLinkDef.h
EMCAL/libEMCALbase.pkg

index 8125ea7..4a0e894 100644 (file)
@@ -59,7 +59,8 @@
 #include "AliRun.h"
 #include "AliEMCALTriggerData.h"
 #include "AliEMCALTriggerElectronics.h"
-//#include "AliVZEROLoader.h"
+#include "AliEMCALTriggerDCSConfigDB.h"
+#include "AliEMCALTriggerDCSConfig.h"
 
 ClassImp(AliEMCALReconstructor) 
 
@@ -114,7 +115,12 @@ AliEMCALReconstructor::AliEMCALReconstructor()
        
   if(!fGeom) AliFatal(Form("Could not get geometry!"));
 
-  fgTriggerProcessor = new AliEMCALTriggerElectronics();
+  AliEMCALTriggerDCSConfigDB* dcsConfigDB = AliEMCALTriggerDCSConfigDB::Instance();
+
+  const AliEMCALTriggerDCSConfig* dcsConfig = dcsConfigDB->GetTriggerDCSConfig();
+
+  if (!dcsConfig) AliFatal("No Trigger DCS Configuration from OCDB!");
+  fgTriggerProcessor = new AliEMCALTriggerElectronics( dcsConfig );
 } 
 
 //____________________________________________________________________________
@@ -160,16 +166,6 @@ void AliEMCALReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree)
   else
          clustersTree->Branch("EMTRG","AliEMCALTriggerData",&trgData,bufferSize);
 
-//  AliVZEROLoader* vzeroLoader = dynamic_cast<AliVZEROLoader*>(AliRunLoader::Instance()->GetDetectorLoader("VZERO"));
-//  
-//  TTree* treeV0 = 0x0;
-//     
-//  if (vzeroLoader) 
-//  {
-//       vzeroLoader->LoadDigits("READ");
-//      treeV0 = vzeroLoader->TreeD();
-//  }
-//
   TClonesArray *trgDigits = new TClonesArray("AliEMCALRawDigit",1000);
   TBranch *branchdig = digitsTree->GetBranch("EMTRG");
   if (!branchdig) 
@@ -181,10 +177,11 @@ void AliEMCALReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree)
   branchdig->SetAddress(&trgDigits);
   branchdig->GetEntry(0);
 
-  fgTriggerProcessor->Digits2Trigger(trgDigits, NULL, trgData);
+  Int_t v0M[2] = {0,0};
+  fgTriggerProcessor->Digits2Trigger(trgDigits, v0M, trgData);
        
   trgDigits->Delete();
-  delete       trgDigits;
+  delete trgDigits; trgDigits = 0x0;
 
   if(fgDigitsArr && fgDigitsArr->GetEntries()) {
 
@@ -199,14 +196,9 @@ void AliEMCALReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree)
 
   }
 
-//  if (vzeroLoader) 
-//  {
-//       vzeroLoader->UnloadDigits();
-//  }
-//
   clustersTree->Fill();        
 
-  delete trgData;
+  delete trgData; trgData = 0x0;
 }
 
 //____________________________________________________________________________
@@ -261,89 +253,6 @@ void AliEMCALReconstructor::FillESD(TTree* digitsTree, TTree* clustersTree,
   //  printf(" ## AliEMCALReconstructor::FillESD() is started ### \n ");
   //return;
 
-  //######################################################
-  //#########Calculate trigger and set trigger info###########
-  //######################################################
-  // Obsolete, to be changed with new trigger emulator when consensus is achieved about what is stored in ESDs.
-  AliEMCALTrigger tr;
-  //   tr.SetPatchSize(1);  // create 4x4 patches
-  tr.SetSimulation(kFALSE); // Reconstruction mode
-  tr.SetDigitsList(fgDigitsArr);
-  // Get VZERO total multiplicity for jet trigger simulation 
-  // The simulation of jey trigger will be incorrect if no VZERO data 
-  // at ESD
-  AliESDVZERO* vZero = esd->GetVZEROData();
-  if(vZero) {
-    tr.SetVZER0Multiplicity(vZero->GetMTotV0A() + vZero->GetMTotV0C());
-  }
-  //
-  tr.Trigger();
-
-  Float_t maxAmp2x2  = tr.Get2x2MaxAmplitude();
-  Float_t maxAmpnxn  = tr.GetnxnMaxAmplitude();
-  Float_t ampOutOfPatch2x2  = tr.Get2x2AmpOutOfPatch() ;
-  Float_t ampOutOfPatchnxn  = tr.GetnxnAmpOutOfPatch() ;
-
-  Int_t iSM2x2      = tr.Get2x2SuperModule();
-  Int_t iSMnxn      = tr.GetnxnSuperModule();
-  Int_t iModulePhi2x2 = tr.Get2x2ModulePhi();
-  Int_t iModulePhinxn = tr.GetnxnModulePhi();
-  Int_t iModuleEta2x2 = tr.Get2x2ModuleEta();
-  Int_t iModuleEtanxn = tr.GetnxnModuleEta();
-
-  AliDebug(2, Form("Trigger 2x2 max amp %f, out amp %f, SM %d, iphi %d ieta %d",  maxAmp2x2, ampOutOfPatch2x2, iSM2x2,iModulePhi2x2, iModuleEta2x2));
-  AliDebug(2, Form("Trigger 4x4 max amp %f , out amp %f, SM %d, iphi %d, ieta %d",  maxAmpnxn, ampOutOfPatchnxn, iSMnxn,iModulePhinxn, iModuleEtanxn));
-
-  TVector3    pos2x2(-1,-1,-1);
-  TVector3    posnxn(-1,-1,-1);
-
-  Int_t iAbsId2x2 = fGeom->GetAbsCellIdFromCellIndexes( iSM2x2, iModulePhi2x2, iModuleEta2x2) ; // should be changed to Module
-  Int_t iAbsIdnxn = fGeom->GetAbsCellIdFromCellIndexes( iSMnxn, iModulePhinxn, iModuleEtanxn) ;
-  fGeom->GetGlobal(iAbsId2x2, pos2x2);
-  fGeom->GetGlobal(iAbsIdnxn, posnxn);
-  //printf(" iAbsId2x2 %i iAbsIdnxn %i \n", iAbsId2x2, iAbsIdnxn);
-  
-  TArrayF triggerPosition(6);
-  triggerPosition[0] = pos2x2(0) ;   
-  triggerPosition[1] = pos2x2(1) ;   
-  triggerPosition[2] = pos2x2(2) ;  
-  triggerPosition[3] = posnxn(0) ;   
-  triggerPosition[4] = posnxn(1) ;   
-  triggerPosition[5] = posnxn(2) ;
-  //printf(" triggerPosition ");
-  //for(int i=0; i<6; i++) printf(" %i %f : ", i, triggerPosition[i]);
-
-  TArrayF triggerAmplitudes(4);
-  triggerAmplitudes[0] = maxAmp2x2 ;   
-  triggerAmplitudes[1] = ampOutOfPatch2x2 ;    
-  triggerAmplitudes[2] = maxAmpnxn ;   
-  triggerAmplitudes[3] = ampOutOfPatchnxn ;   
-  //printf("\n triggerAmplitudes ");
-  //for(int i=0; i<4; i++) printf(" %i %f : ", i, triggerAmplitudes[i]);
-  //printf("\n");
-  //tr.Print("");
-  //
-  // Trigger jet staff
-  //
-  if(tr.GetNJetThreshold()>0) {
-    // Jet phi/eta
-    Int_t n0 = triggerPosition.GetSize();
-    const TH2F *hpatch = tr.GetJetMatrixE();
-    triggerPosition.Set(n0 + 2);
-    for(Int_t i=0; i<2; i++) triggerPosition[n0+i] = hpatch->GetMean(i+1);   
-    // Add jet ampitudes
-    n0 = triggerAmplitudes.GetSize();
-    triggerAmplitudes.Set(n0 + tr.GetNJetThreshold());
-    Double_t *ampJet = tr.GetL1JetThresholds();
-    for(Int_t i=0; i<tr.GetNJetThreshold(); i++){
-      triggerAmplitudes[n0 + i] = Float_t(ampJet[i]);
-    }
-  }
-  esd->AddEMCALTriggerPosition(triggerPosition);
-  esd->AddEMCALTriggerAmplitudes(triggerAmplitudes);
-  // Fill trigger hists
-  //  AliEMCALHistoUtilities::FillTriggersListOfHists(fList,&triggerPosition,&triggerAmplitudes);
-
   //########################################
   //##############Fill CaloCells###############
   //########################################
index 246f305..2eb739e 100644 (file)
@@ -46,7 +46,7 @@ fPatches( new TClonesArray("AliEMCALTriggerPatch",10) )
 }      
 
 //_______________
-AliEMCALTriggerBoard::AliEMCALTriggerBoard(const AliEMCALCalibData */*calibData*/, const TVector2& RS) : TObject(),
+AliEMCALTriggerBoard::AliEMCALTriggerBoard(const TVector2& RS) : TObject(),
 fRegion(0x0),
 fMap(0x0),
 fRegionSize(    new TVector2( RS ) ),
index 3b5921e..f945cc7 100644 (file)
@@ -12,7 +12,6 @@ Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
 #include "TVector2.h"
 
 class TClonesArray;
-class AliEMCALCalibData;
 
 typedef enum { kGamma, kJet } L1TriggerType_t;
 
@@ -21,7 +20,7 @@ class AliEMCALTriggerBoard : public TObject
        
 public:
                 AliEMCALTriggerBoard();
-                AliEMCALTriggerBoard(const AliEMCALCalibData *calibData, const TVector2& RegionSize);
+                AliEMCALTriggerBoard(const TVector2& RegionSize);
        virtual ~AliEMCALTriggerBoard();
        
        virtual void SlidingWindow(L1TriggerType_t type, Int_t Threshold);
diff --git a/EMCAL/AliEMCALTriggerDCSConfig.cxx b/EMCAL/AliEMCALTriggerDCSConfig.cxx
new file mode 100644 (file)
index 0000000..1fc4404
--- /dev/null
@@ -0,0 +1,49 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/*
+
+
+
+Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
+*/
+
+#include "AliEMCALTriggerDCSConfig.h"
+#include "AliEMCALTriggerSTUDCSConfig.h"
+#include "AliEMCALTriggerTRUDCSConfig.h"
+
+ClassImp(AliEMCALTriggerDCSConfig)
+
+//_____________________________________________________________________________
+AliEMCALTriggerDCSConfig::AliEMCALTriggerDCSConfig() : TObject()
+,fTRUArr(new TClonesArray("AliEMCALTriggerTRUDCSConfig",32))
+,fSTUObj(new AliEMCALTriggerSTUDCSConfig())
+{
+       //
+       // AliEMCALTriggerDCSConfig default constructor
+       //
+}
+
+//_____________________________________________________________________________
+AliEMCALTriggerDCSConfig::~AliEMCALTriggerDCSConfig()
+{
+       //
+       //
+       //
+       delete fTRUArr; fTRUArr = 0x0;
+       delete fSTUObj; fSTUObj = 0x0;
+}
diff --git a/EMCAL/AliEMCALTriggerDCSConfig.h b/EMCAL/AliEMCALTriggerDCSConfig.h
new file mode 100644 (file)
index 0000000..837fb02
--- /dev/null
@@ -0,0 +1,45 @@
+#ifndef ALIEMCALTRIGGERDCSCONFIG_H
+#define ALIEMCALTRIGGERDCSCONFIG_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/*
+
+
+
+Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
+*/
+
+#include "TObject.h"
+#include "TClonesArray.h"
+
+class AliEMCALTriggerSTUDCSConfig;
+class AliEMCALTriggerTRUDCSConfig;
+
+class AliEMCALTriggerDCSConfig : public TObject 
+{
+public:
+       
+                AliEMCALTriggerDCSConfig();
+       virtual ~AliEMCALTriggerDCSConfig();
+       
+       void                         SetTRUArr(TClonesArray* const ta)             { fTRUArr    = ta; }
+       void                         SetSTUObj(AliEMCALTriggerSTUDCSConfig* so)    { fSTUObj    = so; }
+  
+       TClonesArray*                GetTRUArr()                 const             { return fTRUArr;  }
+       AliEMCALTriggerSTUDCSConfig* GetSTUDCSConfig(          ) const             { return (AliEMCALTriggerSTUDCSConfig*)fSTUObj;           }
+       AliEMCALTriggerTRUDCSConfig* GetTRUDCSConfig(Int_t iTRU) const             { return (AliEMCALTriggerTRUDCSConfig*)fTRUArr->At(iTRU); }
+       
+private:
+
+       AliEMCALTriggerDCSConfig(const AliEMCALTriggerDCSConfig &cd);            // Not implemented
+       AliEMCALTriggerDCSConfig &operator=(const AliEMCALTriggerDCSConfig &cd); // Not implemented
+
+       TClonesArray*                fTRUArr; //
+       AliEMCALTriggerSTUDCSConfig* fSTUObj; //
+
+       ClassDef(AliEMCALTriggerDCSConfig,1)  //
+};
+#endif
+
diff --git a/EMCAL/AliEMCALTriggerDCSConfigDB.cxx b/EMCAL/AliEMCALTriggerDCSConfigDB.cxx
new file mode 100644 (file)
index 0000000..f2c2675
--- /dev/null
@@ -0,0 +1,292 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+#include <TClonesArray.h>
+#include <TObjArray.h>
+
+#include "AliCDBManager.h"
+#include "AliCDBEntry.h"
+#include "AliLog.h"
+
+#include "AliEMCALTriggerDCSConfigDB.h"
+#include "AliEMCALTriggerDCSConfig.h"
+#include "AliEMCALTriggerSTUDCSConfig.h"
+#include "AliEMCALTriggerTRUDCSConfig.h"
+
+ClassImp(AliEMCALTriggerDCSConfigDB)
+
+AliEMCALTriggerDCSConfigDB* AliEMCALTriggerDCSConfigDB::fgInstance   = 0;
+Bool_t                      AliEMCALTriggerDCSConfigDB::fgTerminated = kFALSE;
+
+//_____________________________________________________________________________
+AliEMCALTriggerDCSConfigDB* AliEMCALTriggerDCSConfigDB::Instance()
+{
+       //
+       // Singleton implementation
+       // Returns an instance of this class, it is created if neccessary
+       //
+  
+       if (fgTerminated != kFALSE) 
+       {
+               return 0;
+       }
+
+       if (fgInstance == 0) 
+       {
+               fgInstance = new AliEMCALTriggerDCSConfigDB();
+       }
+
+       return fgInstance;
+}
+
+//_____________________________________________________________________________
+void AliEMCALTriggerDCSConfigDB::Terminate()
+{
+       //
+       // Singleton implementation
+       // Deletes the instance of this class and sets the terminated flag,
+       // instances cannot be requested anymore
+       // This function can be called several times.
+       //
+  
+       fgTerminated = kTRUE;
+  
+       if (fgInstance != 0) 
+       {
+               delete fgInstance;
+               fgInstance = 0;
+       }
+}
+
+//_____________________________________________________________________________
+AliEMCALTriggerDCSConfigDB::AliEMCALTriggerDCSConfigDB() : TObject()
+,fRun(-1)
+{
+       //
+       // Default constructor
+       //
+       // TODO Default runnumber is set to 0, this should be changed later
+       //      to an invalid value (e.g. -1) to prevent
+       // TODO invalid calibration data to be used.
+       //
+
+       for (Int_t i = 0; i < kCDBCacheSize; ++i) 
+       {
+               fCDBCache[i]   = 0;
+               fCDBEntries[i] = 0;
+       }
+}
+
+//_____________________________________________________________________________
+AliEMCALTriggerDCSConfigDB::AliEMCALTriggerDCSConfigDB(const AliEMCALTriggerDCSConfigDB &c) : TObject(c)
+,fRun(-1)
+{
+       //
+       // Copy constructor (not that it make any sense for a singleton...)
+       //
+
+       for (Int_t i = 0; i < kCDBCacheSize; ++i) 
+       {
+               fCDBCache[i]   = 0;
+               fCDBEntries[i] = 0;
+       }
+}
+
+//_____________________________________________________________________________
+AliEMCALTriggerDCSConfigDB &AliEMCALTriggerDCSConfigDB::operator=(const AliEMCALTriggerDCSConfigDB &c) 
+{
+       //
+       // Assignment operator (same as above ...)
+       //
+       if (this != &c) 
+       {
+               AliFatal("No assignment operator defined");
+       }
+
+       return *this;
+}
+
+//_____________________________________________________________________________
+AliEMCALTriggerDCSConfigDB::~AliEMCALTriggerDCSConfigDB() 
+{
+       //
+       // destructor
+       //
+       Invalidate();
+}
+
+//_____________________________________________________________________________
+const TObject *AliEMCALTriggerDCSConfigDB::GetCachedCDBObject(Int_t id)
+{
+       //
+       // Retrieves a cdb object with the given id. The objects are cached as
+       // long as the run number is not changed.
+       //
+       // Put together the available objects here by using the lines
+       //   a) For usual calibration objects:
+       //      case kID<Name> : 
+       //        return CacheCDBEntry(kID<Name>,"TRD/Calib/<Path>"); 
+       //        break;
+       //      See function CacheCDBEntry for details.
+       //   and
+       //   b) For calibration data which depends on two objects: One containing 
+       //      a value per detector and one the local fluctuations per pad:
+       //      case kID<Name> :
+       //        return CacheMergeCDBEntry(kID<Name>,"TRD/Calib/<padPath>","TRD/Calib/<chamberPath>"); 
+       //        break;
+       //      See function CacheMergeCDBEntry for details.
+       //
+    
+       switch (id) 
+       {
+               // Parameters defined per pad and chamber
+               case kIDTriggerConfig : 
+                       return CacheCDBEntry(kIDTriggerConfig, "EMCAL/Config/Trigger"); 
+                       break;
+               default:                        
+                       AliError("Object not found!");
+                       break;
+       }
+
+       return 0x0;
+}
+
+//_____________________________________________________________________________
+AliCDBEntry* AliEMCALTriggerDCSConfigDB::GetCDBEntry(const char *cdbPath)
+{
+       // 
+       // Retrieves an entry with path <cdbPath> from the CDB.
+       //
+       AliCDBEntry *entry = AliCDBManager::Instance()->Get(cdbPath,fRun);
+       
+       if (!entry) 
+       { 
+               AliError(Form("Failed to get entry: %s",cdbPath));
+               return 0; 
+       }
+  
+       return entry;
+}
+
+//_____________________________________________________________________________
+const TObject *AliEMCALTriggerDCSConfigDB::CacheCDBEntry(Int_t id, const char *cdbPath)
+{
+       //
+       // Caches the entry <id> with cdb path <cdbPath>
+       //
+  
+       if (!fCDBCache[id]) 
+       {
+               fCDBEntries[id] = GetCDBEntry(cdbPath);
+               
+               if (fCDBEntries[id]) fCDBCache[id] = fCDBEntries[id]->GetObject();
+       }
+
+       return fCDBCache[id];
+}
+
+//_____________________________________________________________________________
+void AliEMCALTriggerDCSConfigDB::SetRun(Long64_t run)
+{
+  //
+  // Sets current run number. Calibration data is read from the corresponding file.
+  // When the run number changes the caching is invalidated.
+  //
+
+  if (fRun == run) return;
+
+  fRun = run;
+
+  Invalidate();
+}
+
+//_____________________________________________________________________________
+void AliEMCALTriggerDCSConfigDB::Invalidate()
+{
+       //
+       // Invalidates cache (when run number is changed).
+       //
+       for (Int_t i = 0; i < kCDBCacheSize; ++i) 
+       {
+               if (fCDBEntries[i]) 
+               {
+                       if (AliCDBManager::Instance()->GetCacheFlag() == kFALSE) 
+                       {
+                               if ((fCDBEntries[i]->IsOwner() == kFALSE) && (fCDBCache[i])) delete fCDBCache[i];
+                               
+                               delete fCDBEntries[i];
+                       }
+                       
+                       fCDBEntries[i] = 0;
+                       fCDBCache[i]   = 0;
+               }
+       }
+}
+
+//_____________________________________________________________________________
+const AliEMCALTriggerDCSConfig* AliEMCALTriggerDCSConfigDB::GetTriggerDCSConfig()
+{
+       //
+       //
+       //
+       const AliEMCALTriggerDCSConfig* dcsConf = dynamic_cast<const AliEMCALTriggerDCSConfig*>(GetCachedCDBObject(kIDTriggerConfig));
+       
+       if (!dcsConf) 
+       {
+               AliError("Trigger DCS configuration not found!");
+               return 0x0;
+       }
+       else
+               return dcsConf;
+}
+
+//_____________________________________________________________________________
+void AliEMCALTriggerDCSConfigDB::GetSTUSegmentation(Int_t ss[], Int_t sp[])
+{
+       //
+       //
+       //
+       const AliEMCALTriggerDCSConfig* dcsConf = dynamic_cast<const AliEMCALTriggerDCSConfig*>(GetCachedCDBObject(kIDTriggerConfig));
+
+       AliEMCALTriggerSTUDCSConfig* stuConf = dcsConf->GetSTUDCSConfig();
+       
+       Int_t fw = stuConf->GetFw();
+       
+       switch ( fw )
+       {
+               case 2223:
+                       ss[0] = 4;
+                       ss[1] = 4;
+                       sp[0] = 2;
+                       sp[1] = 2;
+                       break;
+               default:
+                       AliError("Firmware version do not match!");
+                       break;
+       }
+}
+
+//_____________________________________________________________________________
+Int_t AliEMCALTriggerDCSConfigDB::GetTRUGTHRL0(Int_t iTRU)
+{
+       //
+       //
+       //
+       const AliEMCALTriggerDCSConfig* dcsConf = dynamic_cast<const AliEMCALTriggerDCSConfig*>(GetCachedCDBObject(kIDTriggerConfig));
+       
+       AliEMCALTriggerTRUDCSConfig* truConf = dcsConf->GetTRUDCSConfig(iTRU);
+       
+       return truConf->GetGTHRL0();
+}
diff --git a/EMCAL/AliEMCALTriggerDCSConfigDB.h b/EMCAL/AliEMCALTriggerDCSConfigDB.h
new file mode 100644 (file)
index 0000000..251889d
--- /dev/null
@@ -0,0 +1,64 @@
+#ifndef ALIEMCALTRIGGERDCSCONFIGDB_H
+#define ALIEMCALTRIGGERDCSCONFIGDB_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/*
+ adapted from TRD: thanks!
+*/
+
+#ifndef ROOT_TObject
+#include "TObject.h"
+#endif
+
+class AliCDBEntry;
+
+class AliEMCALTriggerDCSConfig;
+
+class AliEMCALTriggerDCSConfigDB : public TObject 
+{
+public:
+       
+       static AliEMCALTriggerDCSConfigDB*  Instance();
+       static void                         Terminate();
+
+       void                                SetRun(Long64_t run);
+       Long64_t                            GetRun() const { return fRun; }
+       const AliEMCALTriggerDCSConfig*     GetTriggerDCSConfig();
+       void                                GetSTUSegmentation(Int_t ss[], Int_t sp[]);
+       Int_t                               GetTRUGTHRL0(Int_t iTRU);   
+       
+protected:
+
+       // For caching see also implentation of GetCachedCDBObject in the .cxx file
+       // For now, only one cached object but let the possibility to have more
+       enum { kCDBCacheSize = 1    };   // Number of cached objects
+       enum { kIDTriggerConfig = 0 };   // IDs of cached objects
+
+       const TObject *GetCachedCDBObject(Int_t id);
+  
+       void           Invalidate();
+    
+       AliCDBEntry   *GetCDBEntry(const Char_t *cdbPath);
+       const TObject *CacheCDBEntry(Int_t id, const Char_t *cdbPath);
+
+       static AliEMCALTriggerDCSConfigDB* fgInstance;                 //  Instance of this class (singleton implementation)
+       static Bool_t                      fgTerminated;               //  Defines if this class has already been terminated
+
+       AliCDBEntry*                       fCDBEntries[kCDBCacheSize]; //  Cache for CDB entries
+       TObject*                           fCDBCache[kCDBCacheSize];   //  Cache for calibration objects.
+
+       Long64_t                           fRun;                       //  Run Number
+  
+ private:
+
+       AliEMCALTriggerDCSConfigDB();                                  //  This is a singleton, constructor is private!  
+       AliEMCALTriggerDCSConfigDB(const AliEMCALTriggerDCSConfigDB &c);   
+       AliEMCALTriggerDCSConfigDB &operator=(const AliEMCALTriggerDCSConfigDB &c); 
+       virtual ~AliEMCALTriggerDCSConfigDB();
+
+       ClassDef(AliEMCALTriggerDCSConfigDB, 1)                         //  Provides central access to the CDB
+};
+
+#endif
+
index 17adddd..21c4ffe 100644 (file)
@@ -33,7 +33,6 @@ fL0NPatches(),
 fL0RegionSize(0,0),
 fL0SubRegionSize(0,0),
 fL0PatchSize(0,0),
-fL0Peaks(),
 fL1GammaPatches( new TClonesArray("AliEMCALTriggerPatch") ),
 fL1JetPatches( new TClonesArray("AliEMCALTriggerPatch") ),
 fL1RegionSize(0,0),
index 8fd1628..5b881fe 100644 (file)
@@ -28,7 +28,6 @@ public:
        virtual void SetL0RegionSize(       TVector2 size ) {    fL0RegionSize = size; }
        virtual void SetL0SubRegionSize(    TVector2 size ) { fL0SubRegionSize = size; }
        virtual void SetL0PatchSize(        TVector2 size ) {     fL0PatchSize = size; }
-       virtual void SetL0Peaks(Int_t v, Int_t arr[96][2] ) { for (Int_t i=0;i<96;i++) for (Int_t j=0;j<2;j++) fL0Peaks[v][i][j] = arr[i][j]; }
        
        virtual void SetL1GammaPatches(const TClonesArray& patches);
        virtual void SetL1JetPatches(const TClonesArray& patches);
@@ -51,8 +50,6 @@ public:
        virtual void          L0SubRegionSize(     TVector2 size     ) const { size =      fL0SubRegionSize;      }
        virtual TVector2      L0SubRegionSize(                       ) const {     return  fL0SubRegionSize;      }
        virtual void          L0NPatches( Int_t arr[32]              ) const { for (Int_t i=0;i<32;i++) arr[i] = fL0NPatches[i]; }
-       virtual void          L0Peaks(    Int_t arr[32][96][2]       ) const { 
-               for (Int_t i=0;i<32;i++) for (Int_t j=0;j<96;j++) for (Int_t k=0;k<2;k++) arr[i][j][k] = fL0Peaks[i][j][k]; }
 
        virtual void          L1GammaPatches(  TClonesArray& patches ) const { patches =  *fL1GammaPatches;       }
        virtual TClonesArray* L1GammaPatches(                        ) const {     return  fL1GammaPatches;       }
@@ -85,7 +82,6 @@ private:
        TVector2       fL0RegionSize;         // region size in units of fast or
        TVector2       fL0SubRegionSize;      // subregion size in units of fast or
        TVector2       fL0PatchSize;          // patch size in units of subregion
-       Int_t          fL0Peaks[32][96][2];   // max & pos of the max for ADC channels
        
        TClonesArray*  fL1GammaPatches;       // array of patches  
        TClonesArray*  fL1JetPatches;         // array of patches  
index e78c6b0..6b9ddf0 100644 (file)
@@ -28,17 +28,16 @@ Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
 #include "AliRunLoader.h"
 #include "AliEMCAL.h" 
 #include "AliRun.h" 
+#include "AliEMCALTriggerDCSConfig.h"
 #include "AliEMCALTriggerData.h"
 #include "AliEMCALDigit.h"
 #include "AliCaloRawStreamV3.h"
-//#include "AliVZERORawStream.h"
 #include "AliEMCALTriggerSTURawStream.h"
 #include "AliEMCALDigit.h"
 #include "AliEMCALRawDigit.h"
 
 #include <TVector2.h>
 #include <TClonesArray.h>
-//#include <Riostream.h>
 
 namespace
 {
@@ -48,7 +47,7 @@ namespace
 ClassImp(AliEMCALTriggerElectronics)
 
 //__________________
-AliEMCALTriggerElectronics::AliEMCALTriggerElectronics(AliEMCALCalibData *calibData) : TObject(),
+AliEMCALTriggerElectronics::AliEMCALTriggerElectronics(const AliEMCALTriggerDCSConfig *dcsConf) : TObject(),
 fTRU(new TClonesArray("AliEMCALTriggerTRU",32)),
 fSTU(0x0)
 {
@@ -57,12 +56,17 @@ fSTU(0x0)
        rSize.Set( 24.,  4. );
 
        // 32 TRUs
-       for (Int_t i=0;i<kNTRU;i++) new ((*fTRU)[i]) AliEMCALTriggerTRU(calibData, rSize, int(i/3) % 2);
-   
+       for (Int_t i=0;i<kNTRU;i++) 
+       {
+               AliEMCALTriggerTRUDCSConfig* truConf = dcsConf->GetTRUDCSConfig(i);
+               new ((*fTRU)[i]) AliEMCALTriggerTRU(truConf, rSize, int(i/3) % 2);
+       }
+       
        rSize.Set( 48., 64. );
        
        // 1 STU
-       fSTU = new AliEMCALTriggerSTU(calibData, rSize);
+       AliEMCALTriggerSTUDCSConfig* stuConf = dcsConf->GetSTUDCSConfig();
+       fSTU = new AliEMCALTriggerSTU(stuConf, rSize);
        
        for (Int_t i=0;i<kNTRU;i++) fSTU->BuildMap( i, 
                                                                                          (static_cast<AliEMCALTriggerTRU*>(fTRU->At(i)))->Map(), 
@@ -79,7 +83,7 @@ AliEMCALTriggerElectronics::~AliEMCALTriggerElectronics()
 }
 
 //__________________
-void AliEMCALTriggerElectronics::Digits2Trigger(const TClonesArray* digits, const TTree* treeV0, AliEMCALTriggerData* data)
+void AliEMCALTriggerElectronics::Digits2Trigger(const TClonesArray* digits, const Int_t V0M[], AliEMCALTriggerData* data)
 {
        //
        AliEMCALGeometry* geom = 0x0;
@@ -132,12 +136,12 @@ void AliEMCALTriggerElectronics::Digits2Trigger(const TClonesArray* digits, cons
                
                AliEMCALTriggerTRU *iTRU = static_cast<AliEMCALTriggerTRU*>(fTRU->At(i));
 
-               iL0 += iTRU->L0v1();
+               iL0 += iTRU->L0();
 
-               Int_t vL0Peaks[96][2]; iTRU->Peaks( vL0Peaks );
+//             Int_t vL0Peaks[96][2]; iTRU->Peaks( vL0Peaks );
                        
                data->SetL0Patches( i , iTRU->Patches() );                      
-               data->SetL0Peaks(   i , vL0Peaks );
+//             data->SetL0Peaks(   i , vL0Peaks );
 
                if ( !i ) // do it once since identical for all TRU 
                {
@@ -166,11 +170,8 @@ void AliEMCALTriggerElectronics::Digits2Trigger(const TClonesArray* digits, cons
                                                                                                    (static_cast<AliEMCALTriggerTRU*>(fTRU->At(i)))->Region(), 
                                                                                                    (static_cast<AliEMCALTriggerTRU*>(fTRU->At(i)))->RegionSize() 
                                                                                                    );
-
-//             fSTU->Scan();
                
-               TTree* tr = const_cast<TTree*>(treeV0);
-               if ( tr ) fSTU->V0Multiplicity( *tr );
+               fSTU->SetV0Multiplicity( V0M , 2 ); // C/A
 
                TVector2 size;
 
index 445f04a..d382df1 100644 (file)
@@ -15,7 +15,7 @@ Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
 #include "TClonesArray.h"
 
 class AliRawReader;
-class AliEMCALCalibData;
+class AliEMCALTriggerDCSConfig;
 class TTree;
 class AliEMCALTriggerData;
 class AliEMCALTriggerSTU;
@@ -25,14 +25,14 @@ class AliEMCALTriggerTRU;
 class AliEMCALTriggerElectronics : public TObject 
 {
 public:
-                              AliEMCALTriggerElectronics(AliEMCALCalibData* calibData = 0x0); // ctor
+                              AliEMCALTriggerElectronics(const AliEMCALTriggerDCSConfig* dcsConfig = 0x0); // ctor
        virtual       ~AliEMCALTriggerElectronics();                                   // dtor
        
-       virtual void   Digits2Trigger(const TClonesArray* digits, const TTree* treeV0, AliEMCALTriggerData* data);      
+       virtual void   Digits2Trigger(const TClonesArray* digits, const Int_t V0M[], AliEMCALTriggerData* data);        
        virtual void   Reset();  
        
        virtual AliEMCALTriggerTRU* GetTRU( Int_t iTRU ) {return (AliEMCALTriggerTRU*)fTRU->At(iTRU);}
-       virtual AliEMCALTriggerSTU* GetSTU(            ) {return                      fSTU;}
+       virtual AliEMCALTriggerSTU* GetSTU(            ) {return                      fSTU;          }
        
 private:
 
index c1c6368..e9f0cb4 100644 (file)
@@ -24,7 +24,7 @@ Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
 #include "AliEMCALTriggerSTU.h"
 #include "AliCDBManager.h"
 #include "AliCDBEntry.h"
-#include "AliEMCALCalibData.h"
+#include "AliEMCALTriggerSTUDCSConfig.h"
 #include "AliVZEROCalibData.h"
 #include "AliVZEROdigit.h"
 #include "AliEMCALTriggerPatch.h"
@@ -45,14 +45,19 @@ ClassImp(AliEMCALTriggerSTU)
 
 //_______________
 AliEMCALTriggerSTU::AliEMCALTriggerSTU() : AliEMCALTriggerBoard()
+,fGammaTh(0)
+,fJetTh(0)
+,fDCSConfig(0x0)
 {
        //
        fV0M[0] = fV0M[1] = 0;
 }
 
 //_______________
-AliEMCALTriggerSTU::AliEMCALTriggerSTU(AliEMCALCalibData *calibData, const TVector2& RS) : 
-AliEMCALTriggerBoard(calibData, RS)
+AliEMCALTriggerSTU::AliEMCALTriggerSTU(AliEMCALTriggerSTUDCSConfig *dcsConf, const TVector2& RS) : AliEMCALTriggerBoard(RS)
+,fGammaTh(0)
+,fJetTh(0)
+,fDCSConfig(dcsConf)
 {
        //
        fV0M[0] = fV0M[1] = 0;
@@ -92,7 +97,7 @@ void AliEMCALTriggerSTU::BuildMap( Int_t iTRU, Int_t** M, const TVector2* rSize
 void AliEMCALTriggerSTU::L1( L1TriggerType_t type )
 {
        //
-       SlidingWindow( type, int(ThresholdFromV0( type )) );    
+       SlidingWindow( type, GetThreshold( type ) );    
 }
 
 //________________
@@ -177,53 +182,6 @@ void AliEMCALTriggerSTU::PrintADC( L1TriggerType_t type, TVector2& pos, TVector2
 }
 
 //________________
-void AliEMCALTriggerSTU::V0Multiplicity( TTree& treeV0 )
-{  
-       //
-    AliCDBManager *man = AliCDBManager::Instance();
-    AliCDBEntry *entry = man->Get("VZERO/Calib/Data");
-    AliVZEROCalibData *calibdata = (AliVZEROCalibData*)entry->GetObject();
-       
-    TClonesArray* digitsArray = 0x0;
-    treeV0.SetBranchAddress("VZERODigit",&digitsArray);
-
-       Float_t mult[64];
-       Short_t  adc[64];
-   
-       for (Int_t i=0; i<64; i++)
-       {
-               adc[i]    = 0;
-               mult[i]   = 0.0;
-       }
-
-       Int_t nEntries = (Int_t)treeV0.GetEntries();
-
-       for (Int_t e=0; e<nEntries; e++) 
-       {
-               treeV0.GetEvent(e);
-
-               Int_t nDigits = digitsArray->GetEntriesFast();
-          
-               for (Int_t d=0; d<nDigits; d++) 
-               {    
-                       AliVZEROdigit* digit = (AliVZEROdigit*)digitsArray->At(d);      
-                       Int_t  pmNumber      = digit->PMNumber();
-                       
-                       if (adc[pmNumber] > (int(1.0/calibdata->GetMIPperADC(pmNumber)) /2) ) 
-                               mult[pmNumber] += float(adc[pmNumber])*calibdata->GetMIPperADC(pmNumber);
-               }
-       }
-  
-       //  0..31 V0C 
-       // 32..63 V0A
-       for (Int_t j=0; j<32; j++) 
-       {
-               fV0M[0] += short(mult[j   ]+0.5); 
-               fV0M[1] += short(mult[j+32]+0.5); 
-       }
-}
-
-//________________
 void AliEMCALTriggerSTU::FetchFOR( Int_t iTRU, Int_t **R, const TVector2* rSize )
 {
        // L1 triggers run over the whole EMCal surface
@@ -322,7 +280,22 @@ void AliEMCALTriggerSTU::PatchGenerator(const TClonesArray* lpos, Int_t val)
 }
 
 //___________
-Float_t AliEMCALTriggerSTU::ThresholdFromV0( L1TriggerType_t type )
+void AliEMCALTriggerSTU::SetV0Multiplicity(const Int_t M[], Int_t n)
+{
+       //
+       for (Int_t i=0;i<n;i++) fV0M[i] = M[i]; 
+
+       Int_t sumV0 = fV0M[0] + fV0M[1];
+       
+       if (!sumV0) AliWarning("V0A + V0C is null!");
+       
+       fGammaTh = fDCSConfig->GetGA()*sumV0*sumV0+fDCSConfig->GetGB()*sumV0+fDCSConfig->GetGC();
+       
+       fJetTh   = fDCSConfig->GetJA()*sumV0*sumV0+fDCSConfig->GetJB()*sumV0+fDCSConfig->GetJC();
+}
+
+//___________
+Int_t AliEMCALTriggerSTU::GetThreshold( L1TriggerType_t type )
 {      
        // Compute threshold FIXME: need an access to the OCDB
        // to get f(V0) parameters depending on trigger type
@@ -330,15 +303,16 @@ Float_t AliEMCALTriggerSTU::ThresholdFromV0( L1TriggerType_t type )
        switch ( type )
        {
                case kGamma:
+                       return fGammaTh;
                        break;
                case kJet:
-//                     return 15.;
+                       return fJetTh;          
                        break;
                default:
-                       AliError("AliEMCALTriggerSTU::ThresholdFromV0(): Undefined trigger type, pls check!");
+                       AliError("AliEMCALTriggerSTU::GetThreshold(): Undefined trigger type, pls check!");
        }
        
-       return 0.;
+       return 0;
 }
 
 //__________
index ea1f10a..a839ca5 100644 (file)
@@ -12,13 +12,14 @@ Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
 #include <AliEMCALTriggerBoard.h>
 
 class TTree;
+class AliEMCALTriggerSTUDCSConfig;
 
 class AliEMCALTriggerSTU : public AliEMCALTriggerBoard 
 {
 public:
        
                      AliEMCALTriggerSTU();
-                     AliEMCALTriggerSTU(AliEMCALCalibData *calibData, const TVector2& rsize);
+                     AliEMCALTriggerSTU(AliEMCALTriggerSTUDCSConfig *dcsConf, const TVector2& rsize);
        virtual      ~AliEMCALTriggerSTU();
        
        virtual void  FetchFOR(Int_t i, Int_t** Region, const TVector2* rSize);
@@ -27,9 +28,9 @@ public:
        virtual void  L1(L1TriggerType_t type);//, TTree& treeV0);
        virtual void  PatchGenerator(const TClonesArray* lpos, Int_t val);
        virtual const Int_t* V0() const {return fV0M;}
-       virtual void  SetV0Multiplicity(Int_t M[], Int_t n) { for (Int_t i=0;i<n;i++) fV0M[i] = M[i]; } // for raw data rec
-       virtual void  V0Multiplicity(TTree& treeV0);
+       virtual void  SetV0Multiplicity(const Int_t M[], Int_t n);
        virtual void  Reset();
+       virtual Int_t GetThreshold(L1TriggerType_t type);
        
 protected:
                            AliEMCALTriggerSTU(const AliEMCALTriggerSTU& rhs);
@@ -37,9 +38,11 @@ protected:
 
 private:
        
-       virtual Float_t ThresholdFromV0(L1TriggerType_t type);
-       
                Int_t   fV0M[2]; //! 0/1: V0C/V0A
+                 Int_t   fGammaTh;
+                 Int_t   fJetTh;
+       
+       AliEMCALTriggerSTUDCSConfig* fDCSConfig;
 
        ClassDef(AliEMCALTriggerSTU,1)
 };
diff --git a/EMCAL/AliEMCALTriggerSTUDCSConfig.cxx b/EMCAL/AliEMCALTriggerSTUDCSConfig.cxx
new file mode 100644 (file)
index 0000000..f6e25d9
--- /dev/null
@@ -0,0 +1,46 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/*
+Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
+*/
+
+#include "AliEMCALTriggerSTUDCSConfig.h"
+
+ClassImp(AliEMCALTriggerSTUDCSConfig)
+  
+//_____________________________________________________________________________
+AliEMCALTriggerSTUDCSConfig::AliEMCALTriggerSTUDCSConfig() : TObject()
+  ,fGA(0)
+  ,fGB(1)
+  ,fGC(0)
+  ,fJA(0)
+  ,fJB(1)
+  ,fJC(0)
+  ,fGetRawData(0)
+  ,fRegion(0xFFFFFFFF)
+  ,fFw(2223)
+{
+  //
+  // AliEMCALTriggerSTUDCSConfig default constructor
+  //
+}
+
+
diff --git a/EMCAL/AliEMCALTriggerSTUDCSConfig.h b/EMCAL/AliEMCALTriggerSTUDCSConfig.h
new file mode 100644 (file)
index 0000000..6967c74
--- /dev/null
@@ -0,0 +1,62 @@
+#ifndef ALIEMCALTRIGGERSTUDCSCONFIG_H
+#define ALIEMCALTRIGGERSTUDCSCONFIG_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/*
+
+
+EMCAL STU DCS parameters to be stored in OCDB
+Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
+*/
+
+#include "TObject.h"
+
+class AliEMCALTriggerSTUDCSConfig : public TObject 
+{
+ public:
+
+  AliEMCALTriggerSTUDCSConfig();
+  virtual ~AliEMCALTriggerSTUDCSConfig() {};
+         
+  void    SetGA(Int_t ga)        { fGA         = ga; }
+  void    SetGB(Int_t gb)        { fGB         = gb; }
+  void    SetGC(Int_t gc)        { fGC         = gc; }
+  void    SetJA(Int_t ja)        { fJA         = ja; }
+  void    SetJB(Int_t jb)        { fJB         = jb; }
+  void    SetJC(Int_t jc)        { fJC         = jc; }
+  void    SetRawData(Int_t rd)   { fGetRawData = rd; }
+  void    SetRegion(Int_t rg)    { fRegion     = rg; }
+  void    SetFw(Int_t fv)        { fFw         = fv; }
+       
+  Int_t   GetGA()        const { return fGA;         }
+  Int_t   GetGB()        const { return fGB;         }
+  Int_t   GetGC()        const { return fGC;         }
+  Int_t   GetJA()        const { return fJA;         }
+  Int_t   GetJB()        const { return fJB;         }
+  Int_t   GetJC()        const { return fJC;         }
+  Int_t   GetRawData()   const { return fGetRawData; }
+  Int_t   GetRegion()    const { return fRegion;     }
+  Int_t   GetFw()        const { return fFw;         }
+       
+protected:
+
+       AliEMCALTriggerSTUDCSConfig(const AliEMCALTriggerSTUDCSConfig &cd);
+       AliEMCALTriggerSTUDCSConfig &operator=(const AliEMCALTriggerSTUDCSConfig &cd);
+
+private:
+       
+  Int_t   fGA;         //
+  Int_t   fGB;         //
+  Int_t   fGC;         //
+  Int_t   fJA;         //
+  Int_t   fJB;         //
+  Int_t   fJC;         //
+  Int_t   fGetRawData; //
+  Int_t   fRegion;     //
+  Int_t   fFw;         //
+  
+  ClassDef(AliEMCALTriggerSTUDCSConfig,1) //
+};
+#endif
+
index dcdf0d3..38b96e0 100644 (file)
@@ -82,6 +82,14 @@ void AliEMCALTriggerSTURawStream::Reset()
 {
        //
        if (fRawReader) fRawReader->Reset();
+
+       fNL0GammaPatch = 0;
+       fNL1GammaPatch = 0;
+       fNL1JetPatch   = 0;     
+       
+       delete fL0GammaPatchIndex; fL0GammaPatchIndex = 0x0;
+       delete fL1GammaPatchIndex; fL1GammaPatchIndex = 0x0;
+       delete fL1JetPatchIndex;   fL1JetPatchIndex   = 0x0;    
 }
 
 //_____________________________________________________________________________
@@ -94,6 +102,14 @@ Bool_t AliEMCALTriggerSTURawStream::ReadPayLoad()
 
        Int_t iword = 0;
        
+       fNL0GammaPatch = 0;
+       fNL1GammaPatch = 0;
+       fNL1JetPatch   = 0;
+       
+       delete fL0GammaPatchIndex; fL0GammaPatchIndex = 0x0;
+       delete fL1GammaPatchIndex; fL1GammaPatchIndex = 0x0;
+       delete fL1JetPatchIndex;   fL1JetPatchIndex   = 0x0;
+       
        UInt_t w32;
        while (fRawReader->ReadNextInt(w32)) word32[iword++] = w32;
        
index 666cea7..59b0418 100644 (file)
@@ -24,20 +24,16 @@ Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
 
 #include "AliEMCALTriggerTRU.h"
 #include "AliEMCALTriggerPatch.h"
-#include "AliEMCALDigit.h"
-#include "AliEMCALTriggerSTU.h"
-#include "AliEMCALCalibData.h"
+#include "AliEMCALTriggerTRUDCSConfig.h"
 #include "AliLog.h"
 
-#include <TF1.h>
-#include <TMath.h>
 #include <TClonesArray.h>
 #include <TSystem.h>
 #include <Riostream.h>
   
 namespace
 {
-       const Int_t kTimeBins       = 64; // number of sampling bins of the FastOR signal
+       const Int_t kTimeBins       = 16; // number of sampling bins of the FastOR signal
        const Int_t kTimeWindowSize =  4; // 
        const Int_t kNup            =  2; // 
        const Int_t kNdown          =  1; // 
@@ -46,16 +42,17 @@ namespace
 ClassImp(AliEMCALTriggerTRU)
 
 //________________
-AliEMCALTriggerTRU::AliEMCALTriggerTRU() : AliEMCALTriggerBoard()//,
-//fDigits(    0x0 )
+AliEMCALTriggerTRU::AliEMCALTriggerTRU() : AliEMCALTriggerBoard()
+,fDCSConfig(0x0)
 {
        //
        for (Int_t i=0;i<96;i++) for (Int_t j=0;j<256;j++) fADC[i][j] = 0;
 }
 
 //________________
-AliEMCALTriggerTRU::AliEMCALTriggerTRU(AliEMCALCalibData *calibData, const TVector2& rSize, Int_t mapType) : 
-AliEMCALTriggerBoard(calibData, rSize)
+AliEMCALTriggerTRU::AliEMCALTriggerTRU(AliEMCALTriggerTRUDCSConfig* dcsConf, const TVector2& rSize, Int_t mapType) : 
+AliEMCALTriggerBoard(rSize)
+,fDCSConfig(dcsConf)
 {
        //
        for (Int_t i=0;i<96;i++) for (Int_t j=0;j<256;j++) fADC[i][j] = 0;
@@ -91,29 +88,6 @@ AliEMCALTriggerTRU::~AliEMCALTriggerTRU()
 }
 
 //________________
-void AliEMCALTriggerTRU::Peaks(Int_t arr[96][2])
-{
-       // Return max time bin & max value for all channels
-       for (Int_t i=0;i<96;i++)
-       {
-               arr[i][0] = arr[i][1] = 0;
-               
-               Int_t max = 0, pos = 0;
-               for (Int_t j=0;j<256;j++)
-               {
-                       if (fADC[i][j]>max) 
-                       {
-                               max = fADC[i][j];
-                               pos = j;
-                       }
-               }
-               
-               arr[i][0] = max;
-               arr[i][1] = pos;
-       }
-}
-
-//________________
 void AliEMCALTriggerTRU::ShowFastOR(Int_t iTimeWindow, Int_t iChannel)
 {
        //
@@ -144,7 +118,7 @@ void AliEMCALTriggerTRU::ShowFastOR(Int_t iTimeWindow, Int_t iChannel)
 }
 
 //________________
-Int_t AliEMCALTriggerTRU::L0v0()
+Int_t AliEMCALTriggerTRU::L0()
 {
        // Mimick the TRU L0 'virtual' since not yet released algo
        
@@ -152,115 +126,107 @@ Int_t AliEMCALTriggerTRU::L0v0()
        // fill a matrix to support sliding window
        // compute the time sum for all the FastOR of a given TRU
        // and then move the space window
+
+       AliDebug(1,"=== Running TRU L0 algorithm ===");
        
-       Int_t sum[96][3] ;//= { 0 };
-       for(Int_t i = 0; i < 96 ; i++)
-               for(Int_t j = 0; j < 3 ; j++) sum[i][j] = 0;
+       Int_t buffer[int(fRegionSize->X())][int(fRegionSize->X())][kNup+kNdown];
        
-       // Sliding window algorithm
+       for (Int_t i=0; i<fRegionSize->X(); i++) for (Int_t j=0; j<fRegionSize->Y(); j++) 
+               for (Int_t k=0; k<kNup+kNdown; k++)     buffer[i][j][k] = 0;
+               
+       // Time sliding window algorithm
        for (Int_t i=0; i<=(kTimeBins-kTimeWindowSize); i++) 
        {
-               for(Int_t j=0; j<fRegionSize->X(); j++)
+               AliDebug(1,Form("----------- Time window: %d\n",i));
+               
+               for (Int_t j=0; j<fRegionSize->X(); j++)
                {               
                        for (Int_t k=0; k<fRegionSize->Y(); k++)
                        {
                                for (Int_t l=i; l<i+kTimeWindowSize; l++) 
                                {
+//                                     printf("fRegion[%2d][%2d]: %d += fADC[%2d][%2d]: %d\n",j,k,fRegion[j][k],fMap[j][k],l,fADC[fMap[j][k]][l]);
                                        // [eta][phi][time]
-                                       fRegion[j][k] += fADC[fMap[j][k]][l];
+                                       fRegion[j][k] += fADC[fMap[j][k]][l];   
                                }
                                
-//                             fRegion[j][k] = fRegion[j][k]>>2; // truncate time sum
-                       }
-               }
+                               buffer[j][k][i%(kNup + kNdown)] = fRegion[j][k];
                                
-               // Threshold 
-               // FIXME: for now consider just one threshold for all patches, should consider one per patch?
-               // return the list of patches above threshold
-               // Should probably be checked out from OCDB
-               
-               Int_t vL0Threshold = 0;
-               
-               SlidingWindow( kGamma, vL0Threshold );
-               
-               Int_t nP = 0;
-               
-               for (Int_t j=0; j<fPatches->GetEntriesFast(); j++)
-               {
-                       AliEMCALTriggerPatch *p = (AliEMCALTriggerPatch*)fPatches->At( j );
+                               if ( i > kNup + kNdown - 1 ) 
+                               {       
+                                       for (Int_t v = 0; v < kNup + kNdown - 1; v++) buffer[j][k][v] =  buffer[j][k][v+1];
+       
+                                       buffer[j][k][kNup + kNdown - 1] = fRegion[j][k];
+                               }
+                               else
+                               {
+                                       buffer[j][k][i] = fRegion[j][k];
+                               }
 
-                       TVector2 v;
-                       p->Position(v);
-                       
-                       Int_t idx = fMap[int(v.X())][int(v.Y())];
-                       
-                       if ( i>2 ) 
-                       {                               
-                               // Now check the '2 up/1 down' on each patch
-                               if ( sum[idx][1]>sum[idx][0] && sum[idx][2]<=sum[idx][1] ) nP++;
+/*
+                               for (Int_t v = 0; v<kNup + kNdown; v++) 
+                                       printf("buffer[%2d][%2d][%2d]: %d\n",j,k,v,buffer[j][k][v]);
+*/
                                
-                               sum[idx][0] = sum[idx][1];
-                               sum[idx][1] = sum[idx][2];
-                               sum[idx][2] = p->Sum();
-                       }
-                       else
-                       {
-                               sum[idx][i] = p->Sum();
+//                             if (kTimeWindowSize > 4) fRegion[j][k] = fRegion[j][k] >> 1; // truncate time sum to fit 14b
                        }
                }
                
-               if ( !nP ) 
-                       fPatches->Delete();
-               else
-                       break;     // Stop the algo when at least one patch is found ( thres & max )
+               // Don't start to evaluate space sum if a peak can't be findable
+               if (i < kNup + kNdown - 1) 
+               {
+                       ZeroRegion();
+                       continue; 
+               }
                
-               ZeroRegion();  // Clear fRegion for this time window before computing the next one
+               Int_t peaks[int(fRegionSize->X())][int(fRegionSize->X())];
                
-       }
-       
-       return fPatches->GetEntriesFast();
-}
-
-//________________
-Int_t AliEMCALTriggerTRU::L0v1()
-{
-       // Mimick the TRU L0 'virtual' since not yet released algo
-       
-       // L0 issuing condition is: (2 up & 1 down) AND (time sum > thres)
-       // fill a matrix to support sliding window
-       // compute the time sum for all the FastOR of a given TRU
-       // and then move the space window
-
-       AliDebug(1,"=== Running TRU L0 v1 version ===");
-       
-       // Time sliding window algorithm
-       for (Int_t i=0; i<=(kTimeBins-kTimeWindowSize); i++) 
-       {
-               AliDebug(1,Form("----------- Time window: %d\n",i));
+               for (Int_t j=0; j<fRegionSize->X(); j++) for (Int_t k=0; k<fRegionSize->Y(); k++) peaks[j][k] = 0;
+               
+               Int_t nPeaks = 0;
                
                for (Int_t j=0; j<fRegionSize->X(); j++)
                {               
                        for (Int_t k=0; k<fRegionSize->Y(); k++)
                        {
-                               for (Int_t l=i; l<i+kTimeWindowSize; l++) 
+                               Int_t foundU = 0;
+                               
+                               Int_t foundD = 0;
+               
+                               for (Int_t l=   1;l<kNup       ;l++) foundU = ( buffer[j][k][l]> buffer[j][k][l-1] && buffer[j][k][l-1] ) ? 1 : 0;
+                               
+                               for (Int_t l=kNup;l<kNup+kNdown;l++) foundD = ( buffer[j][k][l]<=buffer[j][k][l-1] && buffer[j][k][l  ] ) ? 1 : 0; 
+               
+                               if ( foundU && foundD ) 
                                {
-                                       // [eta][phi][time]
-                                       fRegion[j][k] += fADC[fMap[j][k]][l];
+                                       peaks[j][k] = 1;
+                                       nPeaks++;
                                }
-                               
-//                             if (kTimeWindowSize > 4) fRegion[j][k] = fRegion[j][k] >> 1; // truncate time sum to fit 14b
                        }
                }
+
+/*             
+               for (Int_t j=0; j<fRegionSize->X(); j++)
+               {               
+                       for (Int_t k=0; k<fRegionSize->Y(); k++)
+                       {
+                               printf("peaks[%2d][%2d]: %d\n",j,k,peaks[j][k]);
+                       }
+               }
+*/             
+               if ( !nPeaks )
+               {
+                       ZeroRegion();
+                       continue;
+               }
                
                // Threshold 
                // FIXME: for now consider just one threshold for all patches, should consider one per patch?
                // ANSWE: both solutions will be implemented in the TRU
                // return the list of patches above threshold
-               // Should probably be checked out from OCDB
-               
-               Int_t vL0Threshold = 0;
+               // Theshold checked out from OCDB
                
-               SlidingWindow( kGamma, vL0Threshold );
+               SlidingWindow( kGamma, fDCSConfig->GetGTHRL0() );
                
 //             for(Int_t j=0; j<fRegionSize->X(); j++)
 //                     for (Int_t k=0; k<fRegionSize->Y(); k++) fRegion[j][k] = fRegion[j][k]>>2; // go to 12b before shipping to STU
@@ -273,101 +239,53 @@ Int_t AliEMCALTriggerTRU::L0v1()
 
                        if ( AliDebugLevel() ) p->Print("");
 
-                       TVector2 v;
-                       p->Position(v);
+                       TVector2 v; p->Position(v);
                        
                        Int_t sizeX = (Int_t)(fPatchSize->X() * fSubRegionSize->X());
+                       
                        Int_t sizeY = (Int_t)(fPatchSize->Y() * fSubRegionSize->Y());
                        
                        const Int_t psize =  sizeX * sizeY; // Number of FastOR in the patch
                        
-                       Int_t *idx= new Int_t[psize];
-                       
-                       Int_t aPeaks = 0;
+                       Int_t* idx = new Int_t[psize];
                        
                        for (Int_t xx=0;xx<sizeX;xx++) 
                        {
                                for (Int_t yy=0;yy<sizeY;yy++) 
                                {   
-                                       idx[xx*sizeY+yy] = fMap[int(v.X()*fSubRegionSize->X())+xx][int(v.Y()*fSubRegionSize->Y())+yy]; // Get current patch FastOR ADC channels 
+                                       Int_t index = xx*sizeY+yy;
                                        
-                                       if (fRegion[int(v.X()*fSubRegionSize->X())+xx][int(v.Y()*fSubRegionSize->Y())+yy]) aPeaks++;
+                                       idx[index] = fMap[int(v.X()*fSubRegionSize->X())+xx][int(v.Y()*fSubRegionSize->Y())+yy]; // Get current patch FastOR ADC channels 
                                        
-                                       if ( AliDebugLevel() ) ShowFastOR(i,idx[xx*sizeY+yy]);
+                                       if (peaks[int(v.X()*fSubRegionSize->X())+xx][int(v.Y()*fSubRegionSize->Y())+yy]) nP++;
+                                       
+                                       if ( AliDebugLevel() ) ShowFastOR(i,idx[index]);
                                }
                        }
-
-                       Int_t nPeaks = 0;
-                       
-                       for (Int_t k=i;k<=i+kTimeWindowSize-(kNup+kNdown);k++)
-                       {                               
-                               // Now check the 'kNup up / kNdown down' on each FastOR of the patch
-                               PeakFinder( idx , psize , k , kNup , kNdown , nPeaks );
-                       }
                        
-                       if (nPeaks == aPeaks) 
+                       if ( nP ) 
                        {
-                               if ( AliDebugLevel() ) 
-                               {
-                                       printf("\t----- Valid patch (all FastOR have crossed a maximum)\n");
-                                 for (Int_t xx=0;xx<sizeX;xx++) {
-                                   for (Int_t yy=0;yy<sizeY;yy++) {
-                                     Int_t index = xx*sizeY+yy;
-                                     ShowFastOR(i,idx[index]); 
-                                   }
-                                 }
-                               }
-                               
-                               nP++; // all FOR in the patch must have seen a max
+//                             cout << "break patch loop" << endl;
+                               break;
                        }
-                       
-                       delete [] idx;
                }
                
                if ( !nP ) 
                        fPatches->Delete();
                else
                {
-                       AliDebug(1,Form("==========[ Found %4d valid patches out of %4d ]==========\n",nP,fPatches->GetEntriesFast()));
+//                     cout << "break time loop" << endl;
                        break;     // Stop the algo when at least one patch is found ( thres & max )
                }
-
+               
                ZeroRegion();  // Clear fRegion for this time window before computing the next one              
        }
        
-       return fPatches->GetEntriesFast();
-}
-
-
-//________________
-Int_t AliEMCALTriggerTRU::L0v2()
-{
-       // Activity trigger
-
-       // Sliding window algorithm
-
-       for(Int_t j=0; j<fRegionSize->X(); j++)
-       {               
-               for (Int_t k=0; k<fRegionSize->Y(); k++)
-               {
-                       Int_t max = 0;
-                       for (Int_t l=0; l<kTimeBins; l++) 
-                       {
-                               if (fADC[fMap[j][k]][l] > max) max = fADC[fMap[j][k]][l];
-                       }       
-                       
-                       if (max>4) fRegion[j][k] = max;
-               }
-       }
-               
-       Int_t vL0Threshold = 0;
-               
-       SlidingWindow( kGamma, vL0Threshold );
+//     cout << "Nof patches: " << fPatches->GetEntriesFast() << endl;
        
        return fPatches->GetEntriesFast();
 }
 
-
 //________________
 void AliEMCALTriggerTRU::SetADC( Int_t channel, Int_t bin, Int_t sig )
 {
@@ -377,22 +295,6 @@ void AliEMCALTriggerTRU::SetADC( Int_t channel, Int_t bin, Int_t sig )
 }
 
 //________________
-void AliEMCALTriggerTRU::PeakFinder( const Int_t idx[], Int_t nfastor, Int_t start, Int_t nup, Int_t ndown, Int_t& nPeaks ) 
-{
-       //
-       for (Int_t i=0;i<nfastor;i++)
-       { 
-               Int_t foundU = 0;
-               Int_t foundD = 0;
-               
-               for (Int_t j=start+  1;j<start+nup      ;j++) foundU = ( fADC[idx[i]][j]> fADC[idx[i]][j-1] && fADC[idx[i]][j-1] ) ? 1 : 0;
-               for (Int_t j=start+nup;j<start+nup+ndown;j++) foundD = ( fADC[idx[i]][j]<=fADC[idx[i]][j-1] && fADC[idx[i]][j  ] ) ? 1 : 0; 
-               
-               if ( foundU && foundD ) nPeaks++;
-       }
-}
-
-//________________
 void AliEMCALTriggerTRU::SaveRegionADC(Int_t iTRU, Int_t iEvent)
 {
        // O for STU Hw
@@ -413,21 +315,6 @@ void AliEMCALTriggerTRU::SaveRegionADC(Int_t iTRU, Int_t iEvent)
        outfile.close();
 }
 
-/*
-//________________
-void AliEMCALTriggerTRU::Scan()
-{
-       //
-       for (Int_t i=0;i<96;i++) 
-       {
-               Int_t ietam = 23 - i/4;
-               
-               Int_t iphim =  3 - i%4;
-               
-               printf("ADC: %2d fRegion[%2d][%2d]: %4d\n",i,ietam,iphim,fRegion[ietam][iphim]);
-       }       
-}      
-*/
 //________________
 void AliEMCALTriggerTRU::Reset()
 {
index 71600cd..4ccb340 100644 (file)
@@ -13,33 +13,28 @@ Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
 
 class AliEMCALTriggerSTU;
 class AliEMCALDigit;
-class AliEMCALCalibData;
+class AliEMCALTriggerTRUDCSConfig;
 
 class AliEMCALTriggerTRU : public AliEMCALTriggerBoard 
 {
 public:
        
                       AliEMCALTriggerTRU();
-                      AliEMCALTriggerTRU(AliEMCALCalibData *calibData, const TVector2& rSize, Int_t mapType);
+                      AliEMCALTriggerTRU(AliEMCALTriggerTRUDCSConfig* dcsConf, const TVector2& rSize, Int_t mapType);
        virtual       ~AliEMCALTriggerTRU();
        
-       virtual Int_t  L0v0(); // space sum has reached a max
-       virtual Int_t  L0v1(); // one of the 4 FastOR in the patch has reached a max
-       virtual Int_t  L0v2(); // activity trigger
-       
-       virtual void   PeakFinder(const Int_t idx[], Int_t nfastor, Int_t start, Int_t nup, Int_t ndown, Int_t& npeaks); 
+       virtual Int_t  L0();
        virtual void   SetADC(Int_t channel, Int_t bin, Int_t sig );
-       
        virtual void   SaveRegionADC(Int_t iTRU, Int_t iEvent);
-//     virtual void   Scan();
        virtual void   Reset();
-       virtual void   Peaks(Int_t arr[96][2]);
        virtual void   ShowFastOR(Int_t timewindow, Int_t chan = -1);
        
 private:
                            AliEMCALTriggerTRU(const AliEMCALTriggerTRU& rhs);
                 AliEMCALTriggerTRU& operator=(const AliEMCALTriggerTRU& rhs);
        
+       AliEMCALTriggerTRUDCSConfig* fDCSConfig;
+
        Int_t         fADC[96][256]; //! FIXME: Check the maximum number of samples
        
        ClassDef(AliEMCALTriggerTRU,1)
diff --git a/EMCAL/AliEMCALTriggerTRUDCSConfig.cxx b/EMCAL/AliEMCALTriggerTRUDCSConfig.cxx
new file mode 100644 (file)
index 0000000..46635b5
--- /dev/null
@@ -0,0 +1,41 @@
+/**************************************************************************
+ * 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.                  *
+ **************************************************************************/
+
+/*
+ Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
+*/
+
+#include "AliEMCALTriggerTRUDCSConfig.h"
+
+ClassImp(AliEMCALTriggerTRUDCSConfig)
+  
+//_____________________________________________________________________________
+AliEMCALTriggerTRUDCSConfig::AliEMCALTriggerTRUDCSConfig() : TObject()
+,fSELPF(0)
+,fL0SEL(0)
+,fL0COSM(0)
+,fGTHRL0(0)
+{
+       //
+       // AliEMCALTriggerTRUDCSConfig default constructor
+       //
+       for (Int_t i=0;i<5;i++) fMaskReg[i] = 0;
+}
+
+
diff --git a/EMCAL/AliEMCALTriggerTRUDCSConfig.h b/EMCAL/AliEMCALTriggerTRUDCSConfig.h
new file mode 100644 (file)
index 0000000..e62079a
--- /dev/null
@@ -0,0 +1,50 @@
+#ifndef ALIEMCALTRIGGERTRUDCSCONFIG_H
+#define ALIEMCALTRIGGERTRUDCSCONFIG_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/*
+ Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
+*/
+
+#include "TObject.h"
+
+class AliEMCALTriggerTRUDCSConfig : public TObject 
+{
+public:
+
+       AliEMCALTriggerTRUDCSConfig();
+       virtual ~AliEMCALTriggerTRUDCSConfig() {}
+
+       void    SetSELPF( Int_t pf)              { fSELPF  = pf; }  
+       void    SetL0SEL( Int_t la)              { fL0SEL  = la; }  
+       void    SetL0COSM(Int_t lc)              { fL0COSM = lc; }
+       void    SetGTHRL0(Int_t lg)              { fGTHRL0 = lg; }
+       void    SetMaskReg(Int_t arr[], Int_t n) { for (Int_t i=0;i<n;i++) fMaskReg[i] = arr[i]; }
+
+       Int_t   GetSELPF()                       const { return fSELPF;  }
+       Int_t   GetL0SEL()                       const { return fL0SEL;  }
+       Int_t   GetL0COSM()                      const { return fL0COSM; }
+       Int_t   GetGTHRL0()                      const { return fGTHRL0; }
+       void    GetMaskReg(Int_t arr[], Int_t n) const { for (Int_t i=0;i<n;i++) arr[i] = fMaskReg[i]; }
+       
+protected:
+
+       AliEMCALTriggerTRUDCSConfig(const AliEMCALTriggerTRUDCSConfig &cd);
+       AliEMCALTriggerTRUDCSConfig &operator=(const AliEMCALTriggerTRUDCSConfig &cd);
+
+private:
+       
+       Int_t   fSELPF;                          // 
+       Int_t   fL0SEL;                          // 
+       Int_t   fL0COSM;                         // 
+       Int_t   fGTHRL0;                         // 
+       Int_t   fMaskReg[5];                     //
+       
+       ClassDef(AliEMCALTriggerTRUDCSConfig,1)  //
+};
+#endif
index 59aadfb..3a36a30 100644 (file)
 #pragma link C++ class AliEMCALRawUtils+;
 #pragma link C++ class AliCaloRawAnalyzerFastFit+;
 #pragma link C++ class AliEMCAL+;
+#pragma link C++ class AliEMCALTriggerDCSConfig+;
+#pragma link C++ class AliEMCALTriggerTRUDCSConfig+;
+#pragma link C++ class AliEMCALTriggerSTUDCSConfig+;
+#pragma link C++ class AliEMCALTriggerDCSConfigDB+;
 
 #endif
 
index 2494278..8f61818 100644 (file)
@@ -33,7 +33,11 @@ AliEMCALTrigger.cxx \
 AliEMCALTriggerSTURawStream.cxx \
 AliEMCAL.cxx \
 AliEMCALRawUtils.cxx \
-AliCaloRawAnalyzerFastFit.cxx
+AliCaloRawAnalyzerFastFit.cxx \
+AliEMCALTriggerDCSConfig.cxx \
+AliEMCALTriggerTRUDCSConfig.cxx \
+AliEMCALTriggerSTUDCSConfig.cxx \
+AliEMCALTriggerDCSConfigDB.cxx