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 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:

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

 public:


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

  unsigned short getNumberOfHighTowers(){ return nRdosHT; }
  unsigned short getRdoOfHighTower(unsigned short i){ return mListOfRdosHT[i]; }
  unsigned short rdo2tower(unsigned short rdo){ return mRdo2tower[rdo]; }
  unsigned short tower2rdo(unsigned short tow){ return mTower2rdo[tow]; }
  
  unsigned short mListOfRdosHT[ MAX_TOWERS ]; /* list of rdos where HT exceeded specified threshold */
  unsigned short mListOfRdosTP[ MAX_TOWERS ]; /* list of rdos where 3x3 "cluster" exceeded specified threshold */
  unsigned short nRdosHT;                /* number of high towers */
  unsigned short nRdosTP;                /* number of clusters (patches) */
  float  mETofTP[ MAX_TOWERS ];       /* ET of clusters (patches) */
  unsigned short 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];

  unsigned short 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.
   ******************************************************************
   */


  unsigned short mPatchStat[MAX_TOWERS];
  unsigned short mPatchFail[MAX_TOWERS];

  unsigned short mTowerStat[MAX_TOWERS];
  unsigned short mTowerFail[MAX_TOWERS];

  unsigned short mRdo2tower[ MAX_TOWERS ];
  unsigned short mTower2rdo[ MAX_TOWERS ];

  unsigned short mNumPatch[ MAX_TOWERS ];
  unsigned short 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;

  unsigned short phibin( unsigned short sec, unsigned short sub ) { return mNumSubs * sec + sub; }
  unsigned short tower( unsigned short phi, unsigned short 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