#ifdef USE_CDFEDM2
//////////////////////////////////////////////////////////////////////////
//
// Component: MiniplugData.cc
// Purpose: makes MiniplugData object
//
//////////////////////////////////////////////////////////////////////////
#include <cassert>
#include <iostream>

using namespace std;

#include "BaBar/Cdf.hh"
#include "AbsEnv/AbsEnv.hh"
#include "Edm/EventRecord.hh"
#include "CalorGeometry/MiniplugGeometry.hh"
#include "CalorObjects/MiniplugData.hh"
#include "EdmUtilities/CdfClassImp.hh"

  
  //
  // Memory management
  //
  
MiniplugData::MiniplugData():StorableObject(){

  for (int i=0; i<TOWER_NUMBER; i++) {
    _dataE[i] = 0.;     _dataW[i] = 0.;
  }

}

MiniplugData::~MiniplugData(){}

void MiniplugData::init() {
  for (int i=0; i<TOWER_NUMBER; i++) {
    _dataE[i] = 0.;     _dataW[i] = 0.;
  } 

}

void  MiniplugData::destroy(void)
{ MiniplugData::deallocate() ;  
  delete this ;
}

void  MiniplugData::deallocate(void)
{ StorableObject::deallocate() ;
}

std::string MiniplugData::class_name(void) const
{ return(MiniplugData::Class_Name()) ;
}

Version_t MiniplugData::class_version( void) const
{ return(MiniplugData::Class_Version()) ;
}

  //
  // IOstream
  //
    
void  MiniplugData::print(std::ostream& os) const
{
  StorableObject::print(os) ;
    os << "List of Miniplug calorimeter towers with energy: " << std::endl;
    os << "West: " << std::endl;
    for (int i=0; i<TOWER_NUMBER; i++) {
      if (_dataW[i] != 0.) { os << i << " - "<< _dataW[i] <<";"; }
    }
    os << std::endl;
    os << "East: " << std::endl;
    for (int i=0; i<TOWER_NUMBER; i++) {
      if (_dataE[i] != 0.) { os << i << " - "<< _dataE[i] <<";"; }
    }
    os << std::endl;
}

  //
  // EDM input/output
  //
 
bool MiniplugData::postread(EventRecord* p_record)
{ 
  bool status = StorableObject::postread(p_record) ;
  return(status) ;
}

bool MiniplugData::prewrite(EventRecord* p_record)
{ 
  bool status = StorableObject::prewrite(p_record) ;
  return(status) ;
}

bool MiniplugData::deactivate(EventRecord* p_record) 
{ 
  bool status = StorableObject::deactivate(p_record) ;
  return(status) ;
}

bool MiniplugData::activate(EventRecord* p_record) 
{ 
  bool status = StorableObject::activate(p_record) ;
  return(status) ;
}

void MiniplugData::Streamer(TBuffer& iobuffer){ 

  unsigned int start = 0 ;
  unsigned int byte_count = 0 ;

  if (iobuffer.IsReading()){ 
    Version_t original_version = iobuffer.ReadVersion(&start, &byte_count) ;

    if (original_version != 1){ 
      std::cerr << "MiniplugData::Streamer(IsReading): "
	"Unsupported MiniplugData class version cannot be treated.\n" ;
    }
    else{
      StorableObject::Streamer( iobuffer );

      float towerEn;

      for(int i = 0; i<TOWER_NUMBER; ++i)
	{       
	  towerEn = _dataE[i];
	  iobuffer >> towerEn;
	}
      for(int i = 0; i<TOWER_NUMBER; ++i)
	{       
	  towerEn = _dataW[i];
	  iobuffer >> towerEn;
	}
    } 

    iobuffer.CheckByteCount(start, byte_count, MiniplugData::IsA()) ;
  }
 else if (iobuffer.IsWriting())
   { 
     byte_count = iobuffer.WriteVersion(MiniplugData::IsA(), kTRUE) ;
     Version_t current_version = class_version() ;
     if (current_version != 1){ 
       std::cerr << "MiniplugData::Streamer(IsWriting): "
	 "Unsupported MiniplugData class version cannot be treated.\n" ;
     }
     else{
       StorableObject::Streamer( iobuffer );
       float towerEn;
       
       for(int i = 0; i<TOWER_NUMBER; ++i)
	 {       
	   iobuffer << towerEn;
	   _dataE[i] = towerEn;
	 }
       for(int i = 0; i<TOWER_NUMBER; ++i)
	 {       
	   iobuffer << towerEn;
	   _dataW[i] = towerEn;
	 }
     }
     
     iobuffer.SetByteCount(byte_count, kTRUE) ;
   }
  else
    { std::cerr << "MiniplugData::Streamer(<unknown action>): "
	"NOTHING DONE.\n" ;
    }
}

//
// Access and manipulation
//

int MiniplugData::size() const {
  int nTowers =0;
  for(int i = 0; i<TOWER_NUMBER; ++i)
    {       
      if ( _dataE[i] != 0. ) { nTowers++; }
      if ( _dataW[i] != 0. ) { nTowers++; }
    }
  return nTowers;
}

void MiniplugData::cleanup() {
  int nTowers =0;
  for(int i = 0; i<TOWER_NUMBER; ++i)
    {       
      if ( _dataE[i] != 0. ) { nTowers++; }
      if ( _dataW[i] != 0. ) { nTowers++; }
    }
  if ( nTowers == 0) std::cout << "warning: miniplug has no data" << std::endl;
}
/*
float MiniplugData::getSumEnergy(int we, int type) const {
  float energy = 0.;
  if (we == 0) {
    for (int tower=TOWER_TO_SUM[type][0];tower<TOWER_TO_SUM[type][1]+1;tower++){
      energy = energy + _dataW[tower];
    }
    return energy;
  } else {
    for (int tower=TOWER_TO_SUM[type][0];tower<TOWER_TO_SUM[type][1]+1;tower++){
      energy = energy + _dataE[tower];
    }
    return energy;
  }
}   
*/
MiniplugData::Error MiniplugData::find(MiniplugData_ch& theHandle){ 
  AbsEvent* theEvent = AbsEnv::theEvent();
  EventRecord::ConstIterator miniplugDataIter(theEvent,"MiniplugData" );
  if(miniplugDataIter.is_invalid()) return ERROR;
  theHandle = MiniplugData_ch(miniplugDataIter);
  return OK;
}

CdfClassImp(MiniplugData)
#endif  // USE_CDFEDM2