//----------------------------------------------------------------------
// File and Version Information:
//      $Id: //
// Description:
//      Class PndEmcMakeDigi. This class takes array of EmcHit's and produce
// an array of EmcDigis.
// It is convenient to study reconstruction algoritms without
// disturbance from digitization
//----------------------------------------------------------------------

#include "PndEmcMakeDigi.h"		

#include "PndEmcDigi.h"
#include "PndEmcDigiPar.h"		
#include "PndEmcMapper.h"
#include "PndEmcStructure.h"

#include "CbmRootManager.h"
#include "CbmRunAna.h"
#include "CbmRuntimeDb.h"

#include "TClonesArray.h"
#include "TROOT.h"

#include <iostream>
#include <map>

using std::cout;
using std::endl;
using std::fstream;

PndEmcMakeDigi::PndEmcMakeDigi()
{
	fDigiPosMethod="depth";// "surface" or "depth"
	fEmcDigiRescaleFactor=1.08;
	fEmcDigiPositionDepth=6.2;
}

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

PndEmcMakeDigi::~PndEmcMakeDigi()
{
}


InitStatus PndEmcMakeDigi::Init()
{
	// Get RootManager
	CbmRootManager* ioman = CbmRootManager::Instance();
	if ( ! ioman )
	{
		cout << "-E- PndEmcMakeDigi::Init: "
		<< "RootManager not instantiated!" << endl;
		return kFATAL;
	}
	
	// Get input array
	fHitArray = (TClonesArray*) ioman->GetObject("EmcHit");
	if ( ! fHitArray ) {
		cout << "-W- PndEmcMakeDigi::Init: "
		<< "No EmcHit array!" << endl;
		return kERROR;
	}
	
	// Create and register output array
	fDigiArray = new TClonesArray("PndEmcDigi");

	ioman->Register("EmcDigi","Emc",fDigiArray,kTRUE);
	
	// Geometry loading
//	TFile *infile = ioman->GetInFile();
//	TGeoManager *geoMan = (TGeoManager*) infile->Get("CBMGeom");
	TGeoManager *geoMan = (TGeoManager*) gROOT->FindObject("CBMGeom");
	
	fThreshold=fDigiPar->GetEnergyDigiThreshold();

	
	if (!fDigiPosMethod.compare("surface"))
	{
		PndEmcDigi::selectDigiPositionMethod( PndEmcDigi::surface, 1., 0. );
	}
	else if (!fDigiPosMethod.compare("depth"))
	{
	   PndEmcDigi::selectDigiPositionMethod( PndEmcDigi::depth, 
			 fEmcDigiRescaleFactor, fEmcDigiPositionDepth);
	}
	else 
	{
		cout << "-W- PndEmcMakeDigi::Init: "
		<< "Unknown digi position method!" << endl;
		return kERROR;
	}
	
	fMapVersion=fDigiPar->GetMapperVersion();  
	PndEmcMapper::Instance(fMapVersion);
	PndEmcStructure::Instance(geoMan);

	cout << "-I- PndEmcMakeDigi: Intialization successfull" << endl;
	
	return kSUCCESS;
}

void PndEmcMakeDigi::Exec(Option_t* opt)
{
	// Reset output array
	if ( ! fDigiArray ) Fatal("Exec", "No Digi Array");
	fDigiArray->Delete();
  
	// Variable declaration
	PndEmcHit* theHit = NULL;

	// Loop over PndEmcHits to add them to correspondent wavefoorms
	Int_t nHits = fHitArray->GetEntriesFast();
	Int_t i_digi=0;
	// there are 2  different indexes i_digi and iHit since not for each Hit there is digi
	
	std::vector<PndEmcHit*> hitList;
	cout<<"Hit array contains "<<nHits<< " hits"<<endl;
	for (Int_t iHit=0; iHit<nHits; iHit++) {
		theHit = (PndEmcHit*) fHitArray->At(iHit);
		// hitList contains only 1 hit
		hitList.push_back(theHit);
		int detId=theHit->GetDetectorId();
		Double_t energy=theHit->GetEnergy();
		
		// Both endcaps are already implemented in PndEmcMapper (21.05.07)
		int module = detId/100000000;
		
		if (energy>fThreshold)
		{
			Int_t trackId=theHit->GetTrackId();

			Double_t time=theHit->GetTime();
			
			new((*fDigiArray)[i_digi]) PndEmcDigi(trackId,detId, energy, time,hitList);
			i_digi++;
		}
		hitList.clear();
	}

}

void PndEmcMakeDigi::SetParContainers() {

  // Get run and runtime database
  CbmRunAna* run = CbmRunAna::Instance();
  if ( ! run ) Fatal("SetParContainers", "No analysis run");

  CbmRuntimeDb* db = run->GetRuntimeDb();
  if ( ! db ) Fatal("SetParContainers", "No runtime database");

  // Get Emc digitisation parameter container
  fDigiPar = (PndEmcDigiPar*) db->getContainer("PndEmcDigiPar");
 
}

ClassImp(PndEmcMakeDigi)