#ifndef _CALIB_HH_
#define _CALIB_HH_
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Component: Calib.hh
// Purpose: This class contains the offline calorimeter calibration
//                constants.  The loadCalibConsts loads the constants from
//                the database
//          
// Created: 1998   Jodi Lamoureux
// History:  
//          30/06/03  Willis Sakumoto: standardize LER data members; add
//                    PEM,PHA bad channels
//          29/10/03   Angela Wyatt: Add CEM, CHA, WHA BadChannels use in preference to DeadChannels. 
//          15/12/04   Else Lytken: Add CP2, CCR offline LER's.
//                     
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <iostream>
// #include "CalorCalibDBTables/CALDigiToGeV.Defs.hh"
// #include "CalorCalibDBTables/CALDigiToGeV2.Defs.hh"
#include "CalorCalibDBTables/CALDigiToGeV3.Defs.hh"
#include "CalorCalibDBTables/CALL1Peds3.Defs.hh"
#include "CalorCalibDBTables/CHASlewing.Defs.hh"
#include "CalorCalibDBTables/PHASlewing.Defs.hh"
#include "CalorCalibDBTables/WHASlewing.Defs.hh"
#include "CalorCalibDBTables/CHAEfficiency.Defs.hh"
#include "CalorCalibDBTables/PHAEfficiency.Defs.hh"
#include "CalorCalibDBTables/WHAEfficiency.Defs.hh"
#include "CalorCalibDBTables/PPRLinEResponse.Defs.hh"
#include "CalorCalibDBTables/CEMOffLER.Defs.hh"
#include "CalorCalibDBTables/CHAOffLER.Defs.hh"
#include "CalorCalibDBTables/PEMOffLER.Defs.hh"
#include "CalorCalibDBTables/PHAOffLER.Defs.hh"
#include "CalorCalibDBTables/WHAOffLER.Defs.hh"
#include "CalorCalibDBTables/OffSCL.Defs.hh"
#include "CalorCalibDBTables/CEMPMTDeadChannels.Defs.hh"
#include "CalorCalibDBTables/CHAPMTDeadChannels.Defs.hh"
#include "CalorCalibDBTables/WHAPMTDeadChannels.Defs.hh"
#include "CalorCalibDBTables/CEMBadChannels.Defs.hh"
#include "CalorCalibDBTables/CHABadChannels.Defs.hh"
#include "CalorCalibDBTables/WHABadChannels.Defs.hh"
#include "CalorCalibDBTables/PEMBadChannels.Defs.hh"
#include "CalorCalibDBTables/PHABadChannels.Defs.hh"
#include "ShMaxCalibDBTables/CP2OffLER.Defs.hh"
#include "ShMaxCalibDBTables/CCROffLER.Defs.hh"
//#include "FwdDetCalibDBTables/FWDDigiToGeV3.Defs.hh"
//#include "FwdDetCalibDBTables/FWDL1Peds3.Defs.hh"
#include "FwdDetCalibDBTables/MPAOffLumiCalib.Defs.hh"
#include "CalorGeometry/CalConstants.hh"
#include "CalorGeometry/CalParameters.hh"
#include "Trybos/TRY_Fixed_Size_Types.hh"
#include "EdmUtilities/BitMask.hh"

class CalDataCalib;

// namespace calor{

class Calib{
  
public:
  
  Calib();                  
  ~Calib();                 
  
  // initialize database connection
  bool initializeDB();
  // read the calib constants from the data base
  bool loadCalibConsts();
  bool loadCalibConsts(bool applyOffScl);
  // load MC constants
  bool loadMCConsts();

  // load fake constants
  bool loadFakeConsts();

  // load constants using those of old Calibration
  bool loadConsts(CalDataCalib* Calibrations);
  
  float detCem() const; 
  float detCha() const; 
  float detWha() const; 
  float detPem() const; 
  float detPha() const; 
  float detPpr() const; 
  float detMpa() const; 
  
  uint2 pedCem() const; 
  uint2 pedCha() const; 
  uint2 pedWha() const; 
  uint2 pedPem() const; 
  uint2 pedPha() const; 
  uint2 pedPpr() const; 
  uint2 pedMpa() const; 
  
  float detCpr() const;
  float detCesStrip() const;
  float detCesWire() const;
  
  uint2 pedCpr() const;
  uint2 pedCes() const;
  
  // slewing corrections and T0 values for each TDC channel

  float slewTdcCHA(int ieta, int iphi) const;
  float slewTdcWHA(int ieta, int iphi) const;
  float slewTdcPHA(int ieta, int iphi) const;
  float t0TdcCHA(int ieta, int iphi) const;
  float t0TdcWHA(int ieta, int iphi) const;
  float t0TdcPHA(int ieta, int iphi) const;
  float efficTdcCHA(int ieta, int iphi) const;
  float efficTdcWHA(int ieta, int iphi) const;
  float efficTdcPHA(int ieta, int iphi) const;

  // LERs for each tower

  float pprLer(int ieta,int iphi) const;
  float cemLer(int ieta,int iphi) const;
  float chaLer(int ieta,int iphi) const;
  float pemLer(int ieta,int iphi) const;
  float phaLer(int ieta,int iphi) const;
  float whaLer(int ieta,int iphi) const;
  float cp2Ler(int side, int module, int pad) const;
  float ccrLer(int side, int module, int cell) const;

  // overall scale (SCL) for each calorimeter
  float cemScl() const;
  float chaScl() const;
  float whaScl() const;
  float pemScl() const;
  float phaScl() const;

  // bad tower bits
  long  badChannelsCEM(int ieta, int iphi) const;
  long  badChannelsCHA(int ieta, int iphi) const;
  long  badChannelsWHA(int ieta, int iphi) const;
  long  badChannelsPEM(int ieta, int iphi) const;
  long  badChannelsPHA(int ieta, int iphi) const;

  // MP calibs
  float mpaOffset(int iside, int itower) const;
  float mpaSlope(int iside, int itower)  const;
  void setDetMpa(float value);
  //
  // Printing
  //
  void print(std::ostream& os) const;
  void printLers(std::ostream& os) const;
  void printEffic(std::ostream& os) const;
  void printBadTowers(std::ostream& os) const;
  friend std::ostream& operator<<(std::ostream& os, const Calib& ctd);
  
private:
  
  CALDigiToGeV3_mgr calDB_mgr;
  CALDigiToGeV3Container_ptr calDB_data ;

  CALL1Peds3_mgr pedDB_mgr;
  CALL1Peds3Container_ptr pedDB_data ;

  CHASlewing_mgr chaSlDB_mgr;
  CHASlewingContainer_ptr chaSlDB_data ;

  PHASlewing_mgr phaSlDB_mgr;
  PHASlewingContainer_ptr phaSlDB_data ;

  WHASlewing_mgr whaSlDB_mgr;
  WHASlewingContainer_ptr whaSlDB_data ;

  CHAEfficiency_mgr chaEfDB_mgr;
  CHAEfficiencyContainer_ptr chaEfDB_data ;

  PHAEfficiency_mgr phaEfDB_mgr;
  PHAEfficiencyContainer_ptr phaEfDB_data ;

  WHAEfficiency_mgr whaEfDB_mgr;
  WHAEfficiencyContainer_ptr whaEfDB_data ;
  
  PPRLinEResponse_mgr pprLER_mgr;
  PPRLinEResponseContainer_ptr pprLER_data ;

  CEMOffLER_mgr cemLER_mgr;
  CEMOffLERContainer_ptr cemLER_data;

  CHAOffLER_mgr chaLER_mgr;
  CHAOffLERContainer_ptr chaLER_data;

  PEMOffLER_mgr pemLER_mgr;
  PEMOffLERContainer_ptr pemLER_data;

  PHAOffLER_mgr phaLER_mgr;
  PHAOffLERContainer_ptr phaLER_data;

  WHAOffLER_mgr whaLER_mgr;
  WHAOffLERContainer_ptr whaLER_data;

  CP2OffLER_mgr cp2LER_mgr;
  CP2OffLERContainer_ptr cp2LER_data;

  CCROffLER_mgr ccrLER_mgr;
  CCROffLERContainer_ptr ccrLER_data;

  OffSCL_mgr offScl_mgr;
  OffSCLContainer_ptr offScl_data;

  CEMPMTDeadChannels_mgr cemDeadDB_mgr;
  CEMPMTDeadChannelsContainer_ptr cemDeadDB_data;

  CHAPMTDeadChannels_mgr chaDeadDB_mgr;
  CHAPMTDeadChannelsContainer_ptr chaDeadDB_data;

  WHAPMTDeadChannels_mgr whaDeadDB_mgr;
  WHAPMTDeadChannelsContainer_ptr whaDeadDB_data;
  
  CEMBadChannels_mgr cemBadDB_mgr;
  CEMBadChannelsContainer_ptr cemBadDB_data;

  CHABadChannels_mgr chaBadDB_mgr;
  CHABadChannelsContainer_ptr chaBadDB_data;

  WHABadChannels_mgr whaBadDB_mgr;
  WHABadChannelsContainer_ptr whaBadDB_data;

  PEMBadChannels_mgr pemBadDB_mgr;
  PEMBadChannelsContainer_ptr pemBadDB_data;

  PHABadChannels_mgr phaBadDB_mgr;
  PHABadChannelsContainer_ptr phaBadDB_data;


//   FWDDigiToGeV3_mgr fwdDB_mgr;
//   FWDDigiToGeV3Container_ptr fwdDB_data ;

//   FWDL1Peds3_mgr fwdpedDB_mgr;
//   FWDL1Peds3Container_ptr fwdpedDB_data ;

  MPAOffLumiCalib_mgr mpaCalDB_mgr;
  MPAOffLumiCalibContainer_ptr mpaCalDB_data;


  //  Calibration constants:  take digitization counts into GeV
  float _calibCem;
  float _calibCha;
  float _calibWha;
  float _calibPem;
  float _calibPha;
  float _calibPpr;
  float _calibMpa; // if useMPALumiCalib this stores the events ilumi
  
  // pedestals (they are really offsets here)
  
  uint2 _pedCem;
  uint2 _pedCha;
  uint2 _pedWha;
  uint2 _pedPem;
  uint2 _pedPha;
  uint2 _pedPpr;
  uint2 _pedMpa;
  
  //  Calibration constants:  adc to charge conversions
  
  float _calibCpr;
  float _calibCesStrip;
  float _calibCesWire;
  
  // pedestals (they are really offsets here)
  
  uint2 _pedCpr;
  uint2 _pedCes;
  
  // slewing and T0 and efficiency for HTDC's
  float _slewTdcCHA [TENETA][TENPHI];
  float _t0TdcCHA   [TENETA][TENPHI];
  float _efficTdcCHA[TENETA][TENPHI];
  float _slewTdcWHA [TENETA][TENPHI];
  float _t0TdcWHA   [TENETA][TENPHI];
  float _efficTdcWHA[TENETA][TENPHI];
  float _slewTdcPHA [TENETA][TENPHI];
  float _t0TdcPHA   [TENETA][TENPHI];
  float _efficTdcPHA[TENETA][TENPHI];

  // LER's for PPR
  float _lerPPR[TENETA][TENPHI];
  float _lerCEM[TENETA][TENPHI];
  float _lerCHA[TENETA][TENPHI];
  float _lerPEM[TENETA][TENPHI];
  float _lerPHA[TENETA][TENPHI];
  float _lerWHA[TENETA][TENPHI];

  float _lerCP2[NCP2_SIDES][NCP2_WEDGES][NCP2_PADS];
  float _lerCCR[NCP2_SIDES][NCP2_WEDGES][NCCR_CELLS];

  // Convert the hardware geomID to  _ler*** indices

  void getLERindices( int geomID, int& leta, int& lphi )
  {
    int     side( (geomID & 0x00000800) >> 11 );
    int    wedge( (geomID & 0x000007C0) >>  6 );
    int rapidity( (geomID & 0x0000003E) >>  1 );
    int      pmt( (geomID & 0x00000001)       );

    leta = (side == 0) ? 25 - rapidity : 26 + rapidity;
    lphi = 2*wedge + pmt;
  }

  // for CP2 and CCR
  void getCP2LERindices( int geomID, int& lside, int& lmodule, int& lpad )
  {
    lpad    = ( (geomID     ) &  BitMask::nbits06 ) ;
    lside   = ( (geomID >> 6) &  BitMask::nbits01 ) ;
    lmodule = ( (geomID >> 8) &  BitMask::nbits05 ) ;
  }

  void getCCRLERindices( int geomID, int& lside, int& lmodule, int& lpad )
  {
    lpad    = ( (geomID     ) &  BitMask::nbits04 ) ;
    lside   = ( (geomID >> 4) &  BitMask::nbits01 ) ;
    lmodule = ( (geomID >> 8) &  BitMask::nbits05 ) ;
  }

  float _sclCEM;
  float _sclCHA;
  float _sclWHA;
  float _sclPEM;
  float _sclPHA;

  // bad channels 
  long  _badChannelsCEM[TENETA][TENPHI];
  long  _badChannelsCHA[TENETA][TENPHI];
  long  _badChannelsWHA[TENETA][TENPHI];
  long  _badChannelsPEM[TENETA][TENPHI];
  long  _badChannelsPHA[TENETA][TENPHI];

  int numDeadDB;
  int numBadDB;

  //Mini-plug offline calibrations

  float _mpaOffset[2][84];
  float _mpaSlope[2][84];

};

inline float Calib::detCem() const { return _calibCem; }
inline float Calib::detCha() const { return _calibCha; }
inline float Calib::detWha() const { return _calibWha; }
inline float Calib::detPem() const { return _calibPem; }
inline float Calib::detPha() const { return _calibPha; }
inline float Calib::detPpr() const { return _calibPpr; }

inline float Calib::detCpr() const { return _calibCpr; }
inline float Calib::detCesStrip() const { return _calibCesStrip; }
inline float Calib::detCesWire() const { return _calibCesWire; }


inline uint2 Calib::pedCem() const { return _pedCem; }
inline uint2 Calib::pedCha() const { return _pedCha; }
inline uint2 Calib::pedWha() const { return _pedWha; }
inline uint2 Calib::pedPem() const { return _pedPem; }
inline uint2 Calib::pedPha() const { return _pedPha; }
inline uint2 Calib::pedPpr() const { return _pedPpr; }
inline uint2 Calib::pedMpa() const { return _pedMpa; }

inline uint2 Calib::pedCpr() const { return _pedCpr; }
inline uint2 Calib::pedCes() const { return _pedCes; }


// return 0 for now
inline float Calib::detMpa() const { return _calibMpa; }
// hack to set MP calib to actually contain other info if necessary
inline void Calib::setDetMpa(float value) { _calibMpa = value;}

// slewing of TDCs
inline float Calib::slewTdcCHA(int ieta, int iphi) const { return _slewTdcCHA[ieta][iphi]; }
inline float Calib::slewTdcWHA(int ieta, int iphi) const { return _slewTdcWHA[ieta][iphi]; }
inline float Calib::slewTdcPHA(int ieta, int iphi) const { return _slewTdcPHA[ieta][iphi]; }
// t0 of TDCs
inline float Calib::t0TdcCHA(int ieta, int iphi) const   { return _t0TdcCHA[ieta][iphi]; }
inline float Calib::t0TdcWHA(int ieta, int iphi) const   { return _t0TdcWHA[ieta][iphi]; }
inline float Calib::t0TdcPHA(int ieta, int iphi) const   { return _t0TdcPHA[ieta][iphi]; }
// efficiency of TDCs
inline float Calib::efficTdcCHA(int ieta, int iphi) const   { return _efficTdcCHA[ieta][iphi]; }
inline float Calib::efficTdcWHA(int ieta, int iphi) const   { return _efficTdcWHA[ieta][iphi]; }
inline float Calib::efficTdcPHA(int ieta, int iphi) const   { return _efficTdcPHA[ieta][iphi]; }
// offline LERs
inline float Calib::pprLer(int ieta, int iphi)   const   { return _lerPPR[ieta][iphi]; }
inline float Calib::cemLer(int ieta, int iphi)   const   { return _lerCEM[ieta][iphi]; }
inline float Calib::chaLer(int ieta, int iphi)   const   { return _lerCHA[ieta][iphi]; }
inline float Calib::pemLer(int ieta, int iphi)   const   { return _lerPEM[ieta][iphi]; }
inline float Calib::phaLer(int ieta, int iphi)   const   { return _lerPHA[ieta][iphi]; }
inline float Calib::whaLer(int ieta, int iphi)   const   { return _lerWHA[ieta][iphi]; }

inline float Calib::cp2Ler(int side, int mod, int pad) const { return _lerCP2[side][mod][pad]; }
inline float Calib::ccrLer(int side, int mod, int pad) const { return _lerCCR[side][mod][pad]; }

// offline SCL
inline float Calib::cemScl() const {return _sclCEM;}
inline float Calib::chaScl() const {return _sclCHA;}
inline float Calib::whaScl() const {return _sclWHA;}
inline float Calib::pemScl() const {return _sclPEM;}
inline float Calib::phaScl() const {return _sclPHA;}

// bad channels
inline long Calib::badChannelsCEM (int ieta, int iphi) const { return  _badChannelsCEM[ieta][iphi]; }
inline long Calib::badChannelsCHA (int ieta, int iphi) const { return  _badChannelsCHA[ieta][iphi]; }
inline long Calib::badChannelsWHA (int ieta, int iphi) const { return  _badChannelsWHA[ieta][iphi]; }
inline long Calib::badChannelsPEM (int ieta, int iphi) const { return  _badChannelsPEM[ieta][iphi]; }
inline long Calib::badChannelsPHA (int ieta, int iphi) const { return  _badChannelsPHA[ieta][iphi]; }

//mp calibs
inline float Calib::mpaOffset(int iside, int itower)   const   { return _mpaOffset[iside][itower]; }
inline float Calib::mpaSlope(int iside, int itower)    const   { return _mpaSlope[iside][itower]; }

// }
#endif