//-----------------------------------------------------------
// File and Version Information:
// $Id$
//
// Description:
//      Use Abstract class to obtain residuals to a (outside)
//      reference track
//
// Environment:
//      Software developed for the PANDA Detector at FAIR.
//
// Author List:
//      Felix Boehmer                      (original author)
//      Physics Department E18, TUM
//
//
//-----------------------------------------------------------


#include "TpcRefTrackResidualTask.h"
#include "AbsRefTrackResCalc.h"
#include "TClonesArray.h"
#include "TpcRefResidualCollection.h"

#include <iostream>
#include <string>


ClassImp(TpcRefTrackResidualTask)

TpcRefTrackResidualTask::TpcRefTrackResidualTask()
: fPersistence(kFALSE),
  fOutArray(NULL),
  fOutBranch("TpcRefTrackResidual"),
  fCalc(NULL),
  DEBUG(false)
{
  ;
}


TpcRefTrackResidualTask::~TpcRefTrackResidualTask() {
  delete fCalc;
}

InitStatus
TpcRefTrackResidualTask::Init() {
  
  //check that the residual calculater has been set:
  if(fCalc==NULL) {
    Fatal("TpcRefTrackResidualTask::Init()",
	  "No residual calculator has been set! Use SetResCalculator()");
    return kFATAL;
  }
  
  //connect to the framework:
  FairRootManager* ioman = FairRootManager::Instance();
  if(ioman==0) {
    Fatal("TpcRefTrackResidualTask::Init()","RootManager not instantiated!");
    return kFATAL;
  }
  //get input branches: THESE HAVE TO BE ADDED TO YOUR RES-CALCULATOR
  //ON MACRO LEVEL BEFORE!
  std::map<TString, TClonesArray*>* branches = fCalc->getBranchMap();
  std::map<TString, TClonesArray*>::iterator it;
  for(it=branches->begin(); it!=branches->end(); it++) {
    TClonesArray* br = (TClonesArray*) ioman->GetObject(it->first);
    if(br==NULL) {
      std::string s("Branch ");
      s.append(it->first.Data());
      s.append(" requested by residual calculator, but not found in tree!");
      Fatal("TpcRefTrackResidualTask::Init()",s.c_str());
    }
    //set this pointer in the calculator's internal map
    //this way it will point to the TClonesArray handled by the framework
    it->second = br;
  }

  bool err = fCalc->init();
  if(err) 
    Fatal("TpcRefTrackResidualTask::Init()", "Calculator init() failed");
  
  //register output array
  fOutArray = new TClonesArray("TpcRefResidualCollection");
  ioman->Register(fOutBranch, "Tpc", fOutArray, fPersistence);
  
  return kSUCCESS;
}

void
TpcRefTrackResidualTask::Exec(Option_t* opt) {
  //clear output array:
  fOutArray->Delete();
  
  //this is basically all that has to happen... 
  //take care of the proper data access and consistency checks inside
  //fCalc implementation!
  int err = fCalc->calc();
  if(err) {
    Warning("TpcRefTrackResidualTask::Exec()","ResCalc object returned ERROR!");
    return;
  }
  std::vector<TpcRefResidualCollection*>* resColls = NULL;
  if(err==0)
    resColls = fCalc->getResiduals();
 
  if(resColls!=NULL) {
    //filling of output array
    for(unsigned int irc=0; irc<resColls->size(); irc++) {
      Int_t size = fOutArray->GetEntriesFast();
      new ((*fOutArray)[size]) TpcRefResidualCollection(*(*resColls)[irc]);
      //(*fOutArray)[size] = (*resColls)[irc];
    }
  }
}