//* $Id: */
#include "PndAnandDetectorHitFinder.h"

#include "PndAnandDetectorDigi.h"
#include "PndAnandDetectorHit.h"

#include "PndDetectorList.h"

#include "FairRootManager.h"
#include "FairRunAna.h"
#include "FairRuntimeDb.h"

#include "TClonesArray.h"
#include "TMath.h"
#include "TH2F.h"

#include <iomanip>

using std::cerr;
using std::cout;
using std::endl;
using std::fixed;
using std::flush;
using std::left;
using std::map;
using std::right;
using std::set;
using std::setprecision;
using std::setw;

// -----   Default constructor   ------------------------------------------
PndAnandDetectorHitFinder::PndAnandDetectorHitFinder() : 
  FairTask("Anand Hit Finder", 0),
  fDigis  (NULL),
  fHits   (NULL),
  fNDigis    (0),
  fNHits     (0),
  fTNofEvents(0),
  fTNofDigis (0),
  fTNofHits  (0),
  fRunTimeBased(kFALSE),
  fFunctor   (NULL)
{
}
// -------------------------------------------------------------------------

// -----   Constructor with name   -----------------------------------------
PndAnandDetectorHitFinder::PndAnandDetectorHitFinder(const char* name, Int_t iVerbose) 
  : FairTask(name, iVerbose),
  fDigis  (NULL),
  fHits   (NULL),
  fNDigis    (0),
  fNHits     (0),
  fTNofEvents(0),
  fTNofDigis (0),
  fTNofHits  (0),
  fRunTimeBased(kFALSE),
  fFunctor   (NULL)
{
}
// -------------------------------------------------------------------------

// -----   Destructor   ----------------------------------------------------
PndAnandDetectorHitFinder::~PndAnandDetectorHitFinder() {
  if ( fHits ) {
    fHits->Delete();
    delete fHits;
  }
  if ( 0!=fFunctor ) delete fFunctor;
}
// -------------------------------------------------------------------------



// -----   Public method Exec   --------------------------------------------
void PndAnandDetectorHitFinder::Exec(Option_t* opt) {

  //  cout << "======== PndAnandDetectorHitFinder::Exec(Event = " << fTNofEvents << " ) ====================" << endl;
 
  // Clear output array
  fDigis->Clear();
  
  if ( fRunTimeBased ) { 
    fDigis = FairRootManager::Instance()->GetData("AnandDigi", fFunctor, 20.);
    if(fVerbose > 1)
      std::cout << "-I- " << fTNofEvents << " > PndAnandDetectorHitFinder::Exec Digis: " << fDigis->GetEntries() << std::endl;
  }

  fNDigis = fDigis->GetEntriesFast();

  PndAnandDetectorDigi*     digi = NULL;

  fTNofDigis += fNDigis;
  fNHits = 0;  

  for (Int_t iDigi=0; iDigi<fNDigis; iDigi++) {
    digi  = (PndAnandDetectorDigi*)    fDigis->At(iDigi);

    TVector3 position;
    position.SetXYZ(digi->GetChannelNr()%1000-500,
		    digi->GetChannelNr()/1000-500,
		    digi->GetStationId());
    TVector3 dposition; 
    dposition.SetXYZ(0.5,0.5,0.1);
    
    new ((*fHits)[fNHits++]) PndAnandDetectorHit(digi->GetStationId(),
						 0,
						 position,
						 dposition,
						 digi->GetTimeStamp());
  }

  //  cout << "         PndAnandDetectorHitFinder::Exec. Created " << fNHits << " hits out of " << fNDigis << "  digis." << endl;

  fTNofEvents++;
  fTNofDigis += fNDigis;
  fTNofHits  += fNHits;
}
// -------------------------------------------------------------------------

    


// -----   Private method SetParContainers   -------------------------------
void PndAnandDetectorHitFinder::SetParContainers() {

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

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




// -----   Private method Init   -------------------------------------------
InitStatus PndAnandDetectorHitFinder::Init() {

  // Get input array
  FairRootManager* ioman = FairRootManager::Instance();
  if ( ! ioman ) Fatal("Init", "No FairRootManager");
  fDigis = (TClonesArray*) ioman->GetObject("AnandDigi");

  fFunctor = new TimeGap();

  // Register output array
  fHits = new TClonesArray("PndAnandDetectorHit", 1000);
  ioman->Register("AnandHit", "Hit in the Anand Detector", fHits, kTRUE);
  
  cout << "-I- " << fName.Data() << "::Init(). Initialization succesfull." << endl;  
  
  return kSUCCESS;
}
// -------------------------------------------------------------------------




// -----   Private method ReInit   -----------------------------------------
InitStatus PndAnandDetectorHitFinder::ReInit() {
  return kSUCCESS;
}
// -------------------------------------------------------------------------

// -----   Public method Finish   ------------------------------------------
void PndAnandDetectorHitFinder::Finish() {
  if ( fHits ) fHits->Clear();

  cout << "-------------------- " << fName.Data() << " : Summary -----------------------" << endl;
  cout << " Events:        " << setw(10) << fTNofEvents << endl;
  cout << " Digis:         " << setw(10) << fTNofDigis  << "    ( " << (Double_t)fTNofDigis/((Double_t)fTNofEvents) << " per event )" << endl;
  cout << " Hits:          " << setw(10) << fTNofHits   << "    ( " << (Double_t)fTNofHits /((Double_t)fTNofEvents) << " per event )" << endl;
  cout << "                       -->    ( " << (Double_t)fTNofHits  /((Double_t)fTNofDigis ) << " per digi )" << endl;
  cout << "---------------------------------------------------------------------" << endl; 

}
// -------------------------------------------------------------------------


ClassImp(PndAnandDetectorHitFinder)