//--------------------------------------------------------------------------
// File and Version Information:
//
// Description:
//	Class PndEmcClusterEnergySums
//
// Environment:
//	Software developed for the BaBar Detector at the SLAC B-Factory.
//
// Author List:
//	Stephen J. Gowdy	Originator
//	Helmut Marsiske
//
// Copyright Information:
//	Copyright (C) 1998	University of Edinburgh
//
// Dima Melnichuk, adaption for pandaroot
//------------------------------------------------------------------------
#include "PndEmcClusterEnergySums.h"
#include "PndEmcCluster.h"
#include "PndEmcDigi.h"
#include "TClonesArray.h"

#include <iostream>



using std::endl;
using std::ostream;

PndEmcClusterEnergySums::PndEmcClusterEnergySums(const PndEmcCluster &toUse, const TClonesArray *digiArray):
	PndEmcAbsClusterProperty( toUse, digiArray )
{
}

PndEmcClusterEnergySums::PndEmcClusterEnergySums(const PndEmcClusterEnergySums& other):
	PndEmcAbsClusterProperty( other )		
{}

//--------------
// Destructor --
//--------------

PndEmcClusterEnergySums::~PndEmcClusterEnergySums()
{}

//-------------
// Methods   --
//-------------

Double_t
PndEmcClusterEnergySums::energy( Int_t n ) const 
{
	Double_t sum = 0;
	
  // If asked for too many digis summed return the whole energy
	if ( n > MyCluster().NumberOfDigis() ) return ( MyCluster().energy() );
	
	std::vector<Int_t>::const_iterator digi_iter;
	std::vector<Int_t> digiList = MyCluster().DigiList();
	for (Int_t i=0; i<n; n++)
	{
		PndEmcDigi *digi = (PndEmcDigi *) DigiArray()->At(digiList[i]);
		sum += digi->GetEnergy();
	} 

	return( sum );
}

Double_t
PndEmcClusterEnergySums::energy( Double_t distance ) const 
{
	Double_t sum = 0;
	std::vector<Int_t>::const_iterator digi_iter;
	std::vector<Int_t> digiList = MyCluster().DigiList();
	for (digi_iter=digiList.begin();digi_iter!=digiList.end();++digi_iter)
	{
		PndEmcDigi *digi = (PndEmcDigi *) DigiArray()->At(*digi_iter); 
		if ( MyCluster().DistanceToCentre( digi) < distance )
			sum += digi->GetEnergy();
	}
 
	return( sum );
}

Double_t
PndEmcClusterEnergySums::E1() const
{
  const PndEmcDigi* current = MyCluster().Maxima(DigiArray());
  return( current->GetEnergy() );
}

Double_t
PndEmcClusterEnergySums::E9() const
{
	PndEmcDigi* maxDigi = const_cast<PndEmcDigi*> (MyCluster().Maxima(DigiArray()));
	
	Double_t sum = maxDigi->GetEnergy();

	std::vector<Int_t>::const_iterator digi_iter;
	std::vector<Int_t> digiList = MyCluster().DigiList();
	for (digi_iter=digiList.begin();digi_iter!=digiList.end();++digi_iter)
	{
		PndEmcDigi *digi = (PndEmcDigi *) DigiArray()->At(*digi_iter);
		if (digi==maxDigi) continue; 
      if ( digi->isNeighbour(maxDigi))
		{
			sum += digi->GetEnergy();
		}
	}  
	return sum;
}

Double_t
PndEmcClusterEnergySums::E25() const
{
	const PndEmcDigi* maxDigi = MyCluster().Maxima(DigiArray());
	Double_t sum = E9();
	std::vector<Int_t> tmpDigiList;
	
	std::vector<Int_t>::const_iterator current_i, current_j;
	std::vector<Int_t> digiList = MyCluster().DigiList();
	
	for (current_i=digiList.begin();current_i!=digiList.end();++current_i)
	{
		PndEmcDigi *digi_i = (PndEmcDigi *) DigiArray()->At(*current_i);
		if (digi_i == maxDigi) continue;
      if (digi_i->isNeighbour(maxDigi))
		{
			for (current_j=digiList.begin();current_j!=digiList.end();++current_j){
				PndEmcDigi *digi_j = (PndEmcDigi *) DigiArray()->At(*current_j);
				if ( (digi_j == maxDigi) || (digi_j->isNeighbour(maxDigi) ) ) continue; 
				if ( digi_j->isNeighbour(digi_i) ) {
					std::vector<Int_t>::iterator iter;
					iter = std::find(tmpDigiList.begin(), tmpDigiList.end(), *current_j);
					if (iter == tmpDigiList.end()) {
						sum += digi_j->GetEnergy();
						tmpDigiList.push_back(*current_j);
					}
				}
			}
		}	
	}	
	
	return sum;
}

Double_t PndEmcClusterEnergySums::E1E9() const
{
  Double_t e9 = E9();
  //Double_t e1e9 = ( e9 != 0. )? e1e9 = E1()/e9 : -1.;
   /*
   Double_t e1e9 = -1;
   if( e9 != 0.0){
   	e1e9 = E1()/e9;
   	}
  return( e1e9 );
  */
  return ( e9 != 0. )? E1()/e9 : -1.;
}

Double_t PndEmcClusterEnergySums::E9E25() const
{
  Double_t e25 = E25();
  //Double_t e9e25 = ( e25 != 0. )? e9e25 = E9()/e25 : -1.;
  /*
  Double_t e9e25 = -1;
  if( e25 != 0.0){
  	e9e25 = E9()/e25;
  	}
  return( e9e25 );
  */
  return ( e25 != 0. )? E9()/e25 : -1.;
}

void
PndEmcClusterEnergySums::Print(const Option_t* opt) const
{
  std::cout << " E1=" << E1() << ", E9=" << E9() << ", E25=" << E25();
  std::cout << ", E1/E9=" << E1E9() << ", E9/E25=" << E9E25();
  std::cout << endl;
}

ClassImp(PndEmcClusterEnergySums)