// USE THIS to use helixhits

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

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

// C/C++ Headers ----------------------
#include <algorithm>
#include <iostream>
#include <assert.h>

// Collaborating Class Headers --------
#include "FairRootManager.h"
#include "TClonesArray.h"
#include "GFTrack.h"
#include "GFRecoHitFactory.h"
#include "TGeoTrack.h"
#include "TGeoManager.h"
#include "PndSttRecoHit.h"
#include "PndSttHelixHit.h"
#include "GeaneTrackRep.h"
#include "GFException.h"
#include "GFKalman.h"

#include "FairRootManager.h"
#include "FairRunAna.h"
#include "FairRuntimeDb.h"
#include "PndSttTube.h"
#include "PndSttRecoHitProducer.h"
#include "PndSttMapCreator.h"


using namespace std;

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


PndSttKalmanTask2::PndSttKalmanTask2(){
  fVerbose = 0;
}

PndSttKalmanTask2::~PndSttKalmanTask2(){}

InitStatus
PndSttKalmanTask2::Init()
{
  counterevt = 0;

  cout << "PndSttKalmanTask2::Init()" << endl;

  FairRootManager *ioman = FairRootManager::Instance();
  
  if (!ioman) 
  {
      cout << "-E- PndSttRecoHirProducer: "
	   << "RootManager not instantised!" << endl;
      return kFATAL;
  }

  // open STTTrack array
  fTrackArray=(TClonesArray*) ioman->GetObject("Track");
  if(fTrackArray==0){
    Error("PndSttKalmanTask2::Init","track-array not found!");
    return kERROR;
  }

//   // open SttHelixHit array
//   fSttHelixHitArray=(TClonesArray*) ioman->GetObject("SttHelixHit");
//   if(fSttHelixHitArray==0){
//     Error("PndSttKalmanTask2::Init","stt helixhit-array not found!");
//     return kERROR;
//   }

  PndSttMapCreator *mapper = new PndSttMapCreator(fSttParameters);
  TClonesArray *tubeAr = mapper->FillTubeArray();

  // Build hit factory -----------------------------
  _theRecoHitFactory = new GFRecoHitFactory();
  
  TClonesArray* ar=(TClonesArray*) ioman->GetObject("SttHelixHit");
  if(ar==0){
    Error("PndSttKalmanTask2::Init","SttHeliHit array not found!");
  }
  else{ 
    // use helix hit
    _theRecoHitFactory->addProducer(FairRootManager::Instance()->GetBranchId("SttHelixHit"),new PndSttRecoHitProducer<PndSttHelixHit,PndSttRecoHit>(ar, tubeAr));
  }
  
  GFException::quiet(true);
  
  return kSUCCESS;
}

// CHECK added 
void PndSttKalmanTask2::SetParContainers() {
  FairRuntimeDb* rtdb = FairRunAna::Instance()->GetRuntimeDb();
  fSttParameters = (PndGeoSttPar*) rtdb->getContainer("PndGeoSttPar");
}

void
PndSttKalmanTask2::Exec(Option_t* opt)
{
  //  std::cout << "Event # " << counterevt << std::endl;
  counterevt++;
  //   std::cout<<"PndSttKalmanTask2::Exec"<<  std::endl;

  //  fTrackArray->Delete();  // CHECK!! this must not be commented, but 
  //                          // prevents the histo/variable filling... 
  //                          // let' s keep it this way for while and 
  //                          // we will check what happens
  
  if(fTrackArray)
    {

      Int_t ntracks=fTrackArray->GetEntriesFast();
      //      cout << "ntracks " << ntracks << endl;

      for(Int_t itr=0;itr<ntracks;++itr){
	GFTrack* trk = (GFTrack*) fTrackArray->At(itr);
	trk->addHitVector(_theRecoHitFactory->createMany(trk->getCand()));
	if(fVerbose >= 2) std::cout<<trk->getNumHits()<<" hits in track " <<itr<<std::endl;
	GFKalman k;
	//        k.setLazy(1);
	k.setNumIterations(1);
	k.processTrack(trk);
      }
    }
  return;
}


ClassImp(PndSttKalmanTask2)