#ifdef USE_CDFEDM2
//////////////////////////////////////////////////////////////////////////
//
// Component: MiniplugDataMaker.cc
// Purpose: Implementation of MiniplugDataMaker class. 
//
//////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <ctime>
#include <math.h>
#include "inc/bcs.h"
#include "BaBar/Cdf.hh"


// Calorimeter D bank headers
#include "RawDataBanks/RawQieStorableBank.hh"
#include "RawDataBanks/MPAD_StorableBank.hh"

// Geometry headers
//#include "GeometryBase/CdfDetector.hh"
// Calorimetry class headers

#include "Calor/MiniplugDataMaker.hh"
#include "Calor/MiniplugConst.hh"

#include "Trybos/TRY_Bank_Number.hh"

using namespace std;

// namespace calor {

  //
  // Memory management
  //

MiniplugDataMaker::MiniplugDataMaker(){
    
}

//-------------------------------------------------------------------
//  Destructor
//-------------------------------------------------------------------
MiniplugDataMaker::~MiniplugDataMaker() {
  
}

void MiniplugDataMaker::initJob() {
  
  _dbInitialized = false;  
  bool result = true; // = _calib.initializeDB();
  if(result) _dbInitialized = true;  
}

void MiniplugDataMaker::initRun(bool verbose) {
  if(_dbInitialized){
    //    bool result = true; // = _calib.loadCalibConsts();
  }
  //  if(verbose) _calib.print(std::cout);
}

void MiniplugDataMaker::initEvent(AbsEvent* anEvent) {
  
  // make a MiniplugData object
  // MiniplugData(anEvent);
  _miniplugData  =  new MiniplugData();
  
}

void MiniplugDataMaker::endEvent(AbsEvent* anEvent, bool verbose){
  
  _miniplugData->cleanup();
  
  if (verbose) {
    
      _miniplugData->print(std::cout);
    
  }
  
  GenericConstHandle writeHandle(anEvent->append(_miniplugData));
  
}

int MiniplugDataMaker::makeDBank(AbsEvent* anEvent,bool verbose) {

  MiniplugData_ch miniplugdata;

  if(_miniplugData.is_null()){
    //  get MiniplugData from the event. 
    MiniplugData::Error result = MiniplugData::find(miniplugdata);
  
    if(result != MiniplugData::OK){
      std::cout << "could not find MiniplugData in the event" << std::endl;
      return 0 ;
    }
  }
  else{
    miniplugdata.assign(&(*_miniplugData));
  }

  //
  // Create a the D Bank class:
  Handle<MPAD_StorableBank> mpad(new MPAD_StorableBank) ;
  int mpadChanCount = 0;
   
   int4 n_blk = 4;   
   size_t ndat  = n_blk+2;
   int4 i_blk = 0;

   int type = 0; // it is tower
   
   // Create a buffers to hold the blocks of data
   
   int max_size = TOWER_NUMBER*2 + SUMTOWER_NUMBER*2;
   uint2 *buf  = new uint2[max_size+6];
   
   // Total number of blocks
   buf[i_blk++]  = n_blk;

				// west sum; east sum
     
  for (int we=0; we < 2; we++ ) {
      for (int tower=0; tower < SUMTOWER_NUMBER; tower++ ) {
	float data = _miniplugData->getSumEnergy(we, tower);
	if(data > 0){
	  // add the channel id and data to bank
	  data = data / MP_COUNT_CONST; // "calibration"
	  uint2 chid = 0;
	  chid += ( (we & MPAD_StorableBank::we_mask) 
		    << MPAD_StorableBank::we_shift) ;
	  chid += ( (type   &  MPAD_StorableBank::type_mask)
		    << MPAD_StorableBank::type_shift) ;   
	  chid += ( (tower     &  MPAD_StorableBank::sum_or_tower_mask)
		    << MPAD_StorableBank::sum_or_tower_shift) ;		
	  buf[ndat++] = chid;
	  buf[ndat++] = (uint2)data;	}
      }
  }
				// west tower; east tower
  
  for (int we=0; we < 2; we++ ) {
      for (int tower=0; tower < TOWER_NUMBER; tower++ ) {
	float data = _miniplugData->getEnergy(we, tower);
	if(data > 0){
	  // add the channel id and data to bank
	  data = data / MP_COUNT_CONST; // "calibration"
	  uint2 chid = 0;
	  chid += ( (we & MPAD_StorableBank::we_mask) 
		    << MPAD_StorableBank::we_shift) ;
	  chid += ( (type   &  MPAD_StorableBank::type_mask)
		    << MPAD_StorableBank::type_shift) ;   
	  chid += ( (tower     &  MPAD_StorableBank::sum_or_tower_mask)
		    << MPAD_StorableBank::sum_or_tower_shift) ;		
	  buf[ndat++] = chid;
	  buf[ndat++] = (uint2)data;	}
      }
  }
  // transfer data buffer to the bank:

  if (mpadChanCount>0){ 
    mpad->set_bank_number(TRY_Bank_Number(1)) ;
    mpad->set_bank_data(ndat, buf) ;
    anEvent->append(mpad);
  }

  if (verbose) {
    mpad->print();
  }
 

  delete [] buf;
  return 1;

}
 
int MiniplugDataMaker::makeMiniplugData(AbsEvent* anEvent,bool verbose) {

  int we;
  int type;
  int chanNumber;

  EventRecord::ConstIterator p_mpadBank( anEvent,  "MPAD_StorableBank" );
  if(p_mpadBank.is_valid()){ 
 
    ConstHandle<MPAD_StorableBank> bank_handle(p_mpadBank) ;
    
    for(ConstGrandBankIterI2s1<MPAD_StorableBank> data_iter(bank_handle); 
	data_iter.is_valid(); ++data_iter) {

      //      uint2 chid = bank_handle->get_chid( data_iter );
      we  = bank_handle->get_we( data_iter );
      type = bank_handle->get_type( data_iter );
      chanNumber = bank_handle->get_sum_or_tower( data_iter );
      
      //  Convert digits to energy
      
      float energy = bank_handle->get_data(data_iter) * MP_COUNT_CONST; 
      
      // Put the energy into MiniplugData:

      if ( type == 1 ) {
	_miniplugData->addTowerEn(we,chanNumber,energy);
      } else {
	// sum tower part - do nothing
      }
    }
  }

return 1;

}     
		      
		      

int MiniplugDataMaker::writeMiniplugData(AbsEvent* anEvent,bool verbose) {

  GenericConstHandle writeHandle(anEvent->append(_miniplugData));
  _miniplugData = 0;
  return 1;

}

//-------------------------------------------------------------------
//   AddSimEnergy:
//   add simulation energy in a tower 
//
//-------------------------------------------------------------------

void MiniplugDataMaker::addSimEnergy(AbsEvent* anEvent, 
				     int we,
				     int tower, 
				     float energy    ) {		
    _miniplugData->addTowerEn(we, tower, energy);
}
 
 
float  MiniplugDataMaker::getEnergy(AbsEvent* anEvent, 
				    int we, 
				    int tower) {		
    return _miniplugData->getEnergy(we, tower);
}
 
 
#endif  // USE_CDFEDM2