//-----------------------------------------------------------
// File and Version Information:
// $Id$
//
// Description:
//      Implementation of class TpcLaserTask
//      see TpcLaserTask.h for details
//
// Environment:
//      Software developed for the PANDA Detector at FAIR.
//
// Author List:
//      Felix Boehmer        TUM            (original author)
//
//
//-----------------------------------------------------------


// This Class' Header ---------------------------------------
#include "TpcLaserTask.h"
#include "TpcLaserGrid.h"

// Collaborating Class Headers --------
#include "FairRootManager.h"
#include "FairRunAna.h"
#include "FairRuntimeDb.h"
#include "TClonesArray.h"
#include "TpcPrimaryCluster.h"
#include "TpcLaser.h"
#include "TVector3.h"
#include "TError.h"
#include "TpcDigiPar.h"
#include "TpcDigiMapper.h"
#include <iostream>
#include <fstream>
#include <string>
#include <map>


TpcLaserTask::TpcLaserTask()
  : FairTask("TPC Laser"),
    addCounter(0),
    NEcount(0),
    fprimArray(NULL),
    flaserArray(NULL),
    fpersistence(false)
{
  ;
}

TpcLaserTask::~TpcLaserTask()
{
  ;
}

InitStatus
TpcLaserTask::Init()
{
  //Get ROOT Manager
  FairRootManager* ioman= FairRootManager::Instance();

  if(ioman==0)
    {
      Error("TpcLaserTask::Init","RootManager not instantiated!");
      return kERROR;
    }
  // Get input collection
  fprimArray=(TClonesArray*) ioman->GetObject("TpcPrimaryCluster");
  
  if(fprimArray==0)
    {
      Error("TpcLaserTask::Init","PrimaryElectron-array not found!");
      return kERROR;
    }

  //clear input array of any real "physical" hits
  fprimArray->Delete();

  flaserArray = new TClonesArray("TpcLaser");
  ioman->Register("TpcLaser","Tpc",flaserArray,fpersistence);

   
  //read in parameters
  fzMin = fpar->windowMin();
  fzMax = fpar->windowMax();
  frMin=fpar->getRMin();
  frMax=fpar->getRMax();
  
  return kSUCCESS;
}



void 
TpcLaserTask::SetParContainers() {

  std::cout<<"TpcLaserTask::SetParContainers"<<std::endl;
  std::cout.flush();

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

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

  // Get Tpc digitisation parameter container
  fpar= (TpcDigiPar*) db->getContainer("TpcDigiPar");
  if (! fpar ) Fatal("SetParContainers", "TpcDigiPar not found");
}


void
TpcLaserTask::Exec(Option_t* opt)
{
  // Reset output Array
  if(flaserArray==0) Fatal("TpcLaserTask::Exec()","No output array!");
  flaserArray->Delete();
  
  //get laser list from singleton:
  const std::map<unsigned int, TpcLaser*>* theMap = TpcLaserGrid::Instance()->GetLasers();
  std::map<unsigned int, TpcLaser*>::const_iterator it;
  unsigned int size = theMap->size();
  
  //loop over lasers in the grid
  for(it=theMap->begin(); it!=theMap->end(); it++)
  {
    TpcLaser* iLaser = it->second;
    unsigned int id = iLaser->getId();
    //store laser in the outout array.
    //ownership lies with the TpcLaserGrid singleton, which is deleted at the END of the macro
    //using id as TCA index assumes cont. running id from 0 to idMax!!!!
    iLaser = new ((*flaserArray)[id]) TpcLaser(*iLaser);
    
    TClonesArray* laserArray = iLaser->activate();    //the task takes ownership of this TCA
    if(iLaser->getNE()>0)
      NEcount++;
    Int_t nPrim = fprimArray->GetEntriesFast();
    Int_t nLaser = laserArray->GetEntriesFast();
    
    if(nLaser>0)
      addCounter++;
    
    for(Int_t j=0; j<nLaser; j++)
    { 
      TpcPrimaryCluster* cl=(TpcPrimaryCluster*) laserArray->At(j);
         
      if(cl!=NULL){
	TVector3 cl_pos = cl->pos();
	if(cl_pos.Perp()<frMin || cl_pos.Perp()>frMax)
	  continue;
	if(cl_pos.Z()<fzMin || cl_pos.Z()>fzMax)
	  continue;   
	new((*fprimArray)[fprimArray->GetEntriesFast()]) TpcPrimaryCluster(cl->t(),cl->q(),
									     cl->pos(),1,1);
      }
    }
    delete laserArray;
  }
  std::cout<<"\n***LaserList had "<<size<<" entries***"<<std::endl;
  std::cout.flush();
  std::cout<<NEcount<<" Lasers initialized with NEcount > 0"<<std::endl; 
  std::cout<<addCounter<<" Laser-Arrays have been added.\n"<<std::endl;
  std::cout.flush();
  
  return;
}

    
ClassImp(TpcLaserTask)