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

// Panda Headers ----------------------

// This Class' Header ------------------
#include "TpcClusterFinderTask.h"

// C/C++ Headers ----------------------
#include <algorithm>
#include <iostream>

// Collaborating Class Headers --------
#include "FairRootManager.h"
#include "FairRunAna.h"
#include "FairRuntimeDb.h"
#include "TpcDigiPar.h"
#include "TClonesArray.h"
#include "TpcDigi.h"
#include "TpcDigiAge.h"
#include "TpcFrontend.h"
#include "TpcGas.h"
#include "TpcGem.h"
#include "TpcPadPlane.h"
#include "GFRecoHitFactory.h"
#include "TpcClusterFinder.h"
#include "TpcClusterFinderSimple.h"
#include "TStopwatch.h"

//#define PERFMON

// Class Member definitions -----------

TpcClusterFinderTask::TpcClusterFinderTask()
  : FairTask("TPC Cluster Finder", 0),
    fpersistence(kFALSE), fDigiPersistence(kFALSE), fSamplePersistence(kFALSE),
    ftrivial(kFALSE), fsimple(kTRUE), fsectorize(kTRUE),
    ftimeslice(7), fmode(0), fthres(1), fSDiClAmpCut(0), fClAmpCut(0),
    fDataMode(kFALSE), fDiffFactor(1.), fClusterTimeCut(5),
    fAdcSens(600.), fC(14.),frecalcDigiPos(kFALSE),fDoPRF(kFALSE)
{
  fdigiBranchName = "TpcDigi";
  fClusterOutName = "TpcCluster";
}
 

TpcClusterFinderTask::~TpcClusterFinderTask() {
}


void
TpcClusterFinderTask::SetParContainers() {

  if (fVerbose) {
    std::cout<<"TpcClusterFinderTask::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 TpcClusterFinderTask::SetSimpleClustering(Bool_t opt, Bool_t sectorize){
  fsimple=opt;
  fsectorize=sectorize;
  if(fsimple){
    std::cerr<<"TpcClusterFinderTask::SetSimpleClustering - using ClusterFinderSimple ";
    if (fsectorize) std::cerr<<"with sectorization"<<std::endl;
    else std::cerr<<"without sectorization"<<std::endl;
  }
  if(fsimple && !fDigiPersistence)
    std::cerr<<"\n TpcClusterFinderTask::SetSimpleClustering  \n \
    You want to use SimpleClustering. \n \
    This modifies the Digis (amplitude sharing between clusters). If you want to access these digis, set : \n \
    tpcCF->SetDigiPersistence(); \n \
    Then, copies of digis with (modified) amplitude are saved in the cluster"<<std::endl;
}

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

  if(ioman==0) {
    Error("TpcClusterFinderTask::Init","RootManager not instantiated!");
    return kERROR;
  }
  
  // Get input collection
  fdigiArray=(TClonesArray*) ioman->GetObject(fdigiBranchName);
  
  if(fdigiArray==0){
    Error("TpcClusterFinderTask::Init","Digi-array not found!");
    return kERROR;
  }
  
  // create and register output array
  fclusterArray = new TClonesArray("TpcCluster"); 
  ioman->Register(fClusterOutName,"Tpc",fclusterArray,fpersistence);


  // init the DigiMapper
  fpar->printParams();
  double sf= fpar->getFrontend()->samplingFrequency();
  double t0= fpar->getFrontend()->t0();
  double gain=fpar->getGain();

  if (fVerbose) std::cout << "T0 " << t0 << "sF " << sf << std::endl;
 
  fcluster_buffer = new std::vector<TpcCluster*>;

  // init the ClusterFinder
  if(!fsimple){
    ffinder=new TpcClusterFinder(fpar->getPadPlane(),
            fcluster_buffer,
            ftimeslice, fmode, -1,fDataMode,fDiffFactor,fClusterTimeCut,gain/fAdcSens,fC);
  }
  else{
    ffinder=new TpcClusterFinderSimple(fpar->getPadPlane(),
            fcluster_buffer,
            ftimeslice, fAdcSens, fC);
    ((TpcClusterFinderSimple*)(ffinder))->setNoXclust(false);
    ((TpcClusterFinderSimple*)(ffinder))->setSectorize(fsectorize);
    ((TpcClusterFinderSimple*)(ffinder))->setDoPRF(fDoPRF);
  }
  
  ffinder->checkConsistency();
  ffinder->setTrivialClustering(ftrivial);
  ffinder->saveRaw(fDigiPersistence);

  #ifdef PERFMON
    nDigivsTime = new TH2D("nDigis vs Time","nDigis vs Time",500,0,50000,500,0,100);
  #endif

  return kSUCCESS;
}


void
TpcClusterFinderTask::Exec(Option_t* opt)
{
  if (fVerbose) std::cerr<<"TpcClusterFinderTask::Exec"<<std::endl;

  // Reset output Array
  if(fclusterArray==0) Fatal("TpcClusterFinder::Exec)","No ClusterArray");
  fclusterArray->Delete();

  ffinder->reset();

  // put digis into vector
  unsigned int ndigis=fdigiArray->GetEntriesFast();
  std::vector<TpcDigi*> digis(ndigis);
  for(unsigned int idigi=0; idigi<ndigis; ++idigi)
    digis[idigi] = (TpcDigi*)fdigiArray->At(idigi);
  

  if (fVerbose) std::cerr<<"process digis ";
  #ifdef PERFMON
    TStopwatch timer;
    timer.Start();
  #endif
  try{
    ffinder->process(digis);   
  } catch (std::exception& e) {
    std::cout << e.what() << std::endl;
  } catch (...) {
    std::cout << "unknown exception..." << std::endl;
  }
  #ifdef PERFMON
    timer.Stop();
    Double_t ctime = timer.CpuTime();
    nDigivsTime->Fill(ndigis,ctime);
  #endif
  if (fVerbose) std::cerr<<"... done"<<std::endl;
  
  #ifdef PERFMON
    TFile* outfile=new TFile("nDigivsTime.root","RECREATE");
    nDigivsTime->Write();
    outfile->Close();
  #endif

  // put clusters into array and clean up buffer
  unsigned int ncl=fcluster_buffer->size();
  unsigned int ncl_rec=0;
  unsigned int ndig_rec=0;
  fclusterArray->Expand(ncl);
  double amp;
  unsigned int size;
  for(unsigned int icl=0;icl<ncl;++icl){ // loop over clusters
    amp  = (*fcluster_buffer)[icl]->amp();
    size = (*fcluster_buffer)[icl]->size();
    if( (amp>fthres) &&  ( (size>1 && amp>fClAmpCut*(double)size) || (size==1 && amp>fSDiClAmpCut))){
      // copy cluster
      //std::cerr << "nDigi=" <<  (*fcluster_buffer)[icl]->nDigi() << std::endl;
      //(*fcluster_buffer)[icl]->ClearDigis();
      TpcCluster* cl = new((*fclusterArray)[ncl_rec]) TpcCluster(*((*fcluster_buffer)[icl]));
      cl->SetIndex(ncl_rec);
      //
      ncl_rec++;
      ndig_rec+=size;
    }
    // delete cluster
    delete  (*fcluster_buffer)[icl];
    
  } // end loop over clusters
  if(fVerbose)
    std::cout << ncl_rec << " cluster created containing " << ndig_rec << " digis" << std::endl;

  fcluster_buffer->clear();
  return;
}


bool TpcDigiIndex(TpcDigi* digi1, TpcDigi* digi2){
  return(digi1->index() < digi2->index());
}


ClassImp(TpcClusterFinderTask)