StTriggerUtilities/L2Emulator/L2gammaAlgo/L2gammaAlgo.h

#ifndef __L2gammaAlgo_h__
#define __L2gammaAlgo_h__

#ifdef IS_REAL_L2  //in l2-ana  environment
  #include "L2VirtualAlgo.h"
  #include "L2Histo.h"
  #include "L2EmcDb.h"

#else
  #include "StTriggerUtilities/L2Emulator/L2algoUtil/L2VirtualAlgo.h"
  #include "StTriggerUtilities/L2Emulator/L2algoUtil/L2EmcDb.h"
  #include "StTriggerUtilities/L2Emulator/L2algoUtil/L2Histo.h"

#endif



/* CHANGE THIS WITH EVERY COMPILATION ON L2 MACHINE DURING RUN */
#define LEVEL2_GAMMA_ALGORITHM_VERSION 0x1 

//#define ushort unsigned short
typedef unsigned short ushort;

#define MAX_TOWERS 4800


#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <assert.h> /* tmp */
#include <time.h>
#include <string>




class L2gammaAlgo;

class L2gammaAlgo : public L2VirtualAlgo
{

 public:
  enum { kBEmcAlgo=0, kEEmcAlgo };
  enum { kThresh1=0, kThresh2 };

 private:
 protected:

  ushort  mEEmc;
  ushort  mBEmc;
  ushort  mThresholdLevel;
  ushort  mNumEtas;
  ushort  mNumPhis;
  ushort  mNumSubs;
  ushort  mNumSecs;
  ushort  mNumTower;
  ushort  mNumClust;
  ushort  mNumRdo;
  const float *mEtaBins; /* points to preexisting array, no "new" allocation */
  ushort  mMaxADC;
  float   mMaxET;
  float   mIdealGainT;
  int     mHistogramBase;
  ushort  mHistogramPres;
  ushort  mIdThreshold; // 0=low threshold, 1=high threshold

 public:


  /*
   * The following are made publicly available for the possible
   * use of other algorithms.
   */

  ushort getNumberOfHighTowers(){ return nRdosHT; }
  ushort getRdoOfHighTower(ushort i){ return mListOfRdosHT[i]; }
  ushort rdo2tower(ushort rdo){ return mRdo2tower[rdo]; }
  ushort tower2rdo(ushort tow){ return mTower2rdo[tow]; }
  
  ushort mListOfRdosHT[ MAX_TOWERS ]; /* list of rdos where HT exceeded specified threshold */
  ushort mListOfRdosTP[ MAX_TOWERS ]; /* list of rdos where 3x3 "cluster" exceeded specified threshold */
  ushort nRdosHT;                /* number of high towers */
  ushort nRdosTP;                /* number of clusters (patches) */
  float  mETofTP[ MAX_TOWERS ];       /* ET of clusters (patches) */
  ushort mADCofHT[ MAX_TOWERS ];      /* raw ADC of high tower */

  /*
   * Algorithm parameters, may be set in constructor 
   * using I_par[5] and F_par[5]  
   */

  void setTowerThreshold( float pt );
  void setPatchThreshold( float pt );

  float getTowerThreshold(){ return mTowerThreshold; }
  float getPatchThreshold(){ return mPatchThreshold; }

  void setUseOfflineGains();
  
  
  L2gammaAlgo(const char* name, L2EmcDb* db, char* outDir, int resOff);
  ~L2gammaAlgo(){ /* nada */ };

  void init(int run, int I_par[5], float F_par[5]);

  int  initRun( int run );  
  int  initRun( int run, int I_par[5], float F_par[5] );

  int  initRun( char *myname, int run, int I_par[5], float F_par[5] );

  bool  doEvent(int inpEveId, TrgDataType* trgData, int emcIn, unsigned short *emcData ); 


  bool  doEvent( int L0trigger, int inuptEventID, TrgDataType* trgData,
                 int bemcIn, unsigned short *bemcData,
                 int eemcIn, unsigned short *eemcData );



  /*****
  //
  // There aren't supposed to be any "calorimeter specific" methods in the header file. 
  // These got slipped in while I wasn't looking.  I suspect l2main already uses them.
  // These disapeear at the end of the run. 
  //
  bool  doEventBtow( int inpEveId, TrgDataType* trgData, int bemcIn, unsigned short *bemcData ) 
        { return doEvent(inpEveId,trgData, bemcIn,bemcData);};// it allows to add soe security - if you want, JB
  bool  doEventEtow(int inpEveId, TrgDataType* trgData, int eemcIn, unsigned short *eemcData ) 
        { return doEvent(inpEveId,trgData, eemcIn,eemcData);};// it allows to add soe security - if you want, JB

  *****/


  void clear();

  void finishRun();

  void finish();


  void setLogFile( const char *fname = "./bsqueal.log" );//{ mLogFile=fopen(fname,"w"); }

  void setHistFile( const char *fname = "./bsqueal.dat" );//{ mHistFile=fopen(fname,"w"); }

#ifdef OPT_PREPROCESS
  void setL2input( L2gammaAlgo *in ){ mL2input=in; }
#endif

 private:
 protected:  


  L2gammaAlgo *mL2input;

  int mRunNumber;

  float mTowerThreshold;
  float mPatchThreshold;
  int mUseOfflineGains;
  int mUseBbc;

  int mDefaultI_par[5];
  float mDefaultF_par[5];

  int mNumberInput;
  int mNumberAcceptHT;
  int mNumberAcceptTP;
  int mPrescale;

  int mTowerFrequency[MAX_TOWERS]; 
  int mPatchFrequency[MAX_TOWERS];

  ushort mTowerAdcThreshold[MAX_TOWERS];

  float  mPatchAdcThreshold[MAX_TOWERS];

  /*
   ******************************************************************
   Thresholds on the high tower and associated 3x3 tower cluster
   (generically refered to as a "patch" throughout this code) will be
   initialzed at the start of the run and stored in the following
   lookup tables.  The LUTs have sufficient space to store the 4800
   values needed by the barrel.  The endcap's 720 towers will fit
   just fine within that space.
   ******************************************************************
   */


  ushort mPatchStat[MAX_TOWERS];
  ushort mPatchFail[MAX_TOWERS];

  ushort mTowerStat[MAX_TOWERS];
  ushort mTowerFail[MAX_TOWERS];

  ushort mRdo2tower[ MAX_TOWERS ];
  ushort mTower2rdo[ MAX_TOWERS ];

  ushort mNumPatch[ MAX_TOWERS ];
  ushort mRdoPatch[ MAX_TOWERS ][ 9 ];

  float mTowerPed[ MAX_TOWERS ];
  float mPatchPed[ MAX_TOWERS ];
  
  float mTowerGain[ MAX_TOWERS ];
  float mTowerGainIdeal[ MAX_TOWERS ];
  float mTowerAdcCorrection[ MAX_TOWERS ];



  void printPatchConfig( int rdo );



  int mNumberLive;                   /* number of unmasked towers in db */
  int mEvalTime;                     /* total time spent in eval in kTicks */
  
  L2Histo mHistos[19];
  void jbook(); 
  void jclear();

  // FILE *mLogFile;
  // FILE *mHistFile;

  ushort phibin( ushort sec, ushort sub ) { return mNumSubs * sec + sub; }
  ushort tower( ushort phi, ushort eta ) { return mNumEtas * phi + eta; }



};

inline void L2gammaAlgo::setTowerThreshold(float pt)
{
  mTowerThreshold=pt;
}
inline void L2gammaAlgo::setPatchThreshold(float pt)
{
  mPatchThreshold=pt;
}
inline void L2gammaAlgo::setUseOfflineGains()
{
  mUseOfflineGains=true;
}

// $Log: L2gammaAlgo.h,v $
// Revision 1.4  2007/11/14 03:58:11  balewski
// cleanup of common timing measurement
//
// Revision 1.3  2007/11/08 04:02:29  balewski
// run on l2ana as well
//
// Revision 1.2  2007/11/02 03:03:44  balewski
// modified L2VirtualAlgo
//
// Revision 1.1  2007/10/25 15:30:50  balewski
// added L2gamma, full
//
// Revision 1.1  2006/03/29 13:08:15  balewski
// ver 16c
//



#endif

---