////////////////////////////////////
// KRATTA IDENTYFICATION AND CALIBRATION Task
// for the Asy-Eos experiment
// TKratCalib DEFINITION
// Feb 2013
// revison 02/2013
// E.d.F ver 1.0 
// sebastian.kupny@uj.edu.pl
// Changes:
////////////////////////////////////


#include "TKratCalib.h"

using std::cout;
using std::endl;

//______________________________________________________________________
TKratCalib::TKratCalib()
  : FairTask(),
  fASYEvent(0),
  fASYEventCopy(0),
  fSaveOutputToTree(kFALSE)
{
}

//______________________________________________________________________
TKratCalib::TKratCalib(const char* name, Int_t iVerbose ) :
  FairTask(name, iVerbose),
  fASYEvent(0),
  fASYEventCopy(0),
  fSaveOutputToTree(kFALSE)
{
  //fASYEventName  = "KRATTA_ASYEVENT_CLONE";
  fKratContInName  = "KRATTA_ASYEVENT_CLONE";
  fKratContOutName = "KRATTAEVENT";
}

//______________________________________________________________________
TKratCalib::~TKratCalib()
{
}

//______________________________________________________________________
void TKratCalib::SetParContainers()
{

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

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

}

//______________________________________________________________________
InitStatus TKratCalib::Init()
{

  // fLogger->Info(MESSAGE_ORIGIN," TKratCalib::Init()------------------Start ");  //Farroot version: v-13.05
  cout << "TKratCalib::Init()------------------Start" << endl;
  
  /// Configure Fairroot instances
  FairRootManager* ioman = FairRootManager::Instance();
  if ( ! ioman ) Fatal("Init", "No FairRootManager");
  
  ///Get access to fairroot data source
  fASYEventCopy =(TClonesArray*) ioman->GetObject( fKratContInName.Data() );
  fASYEvent = (ASYEvent*)fASYEventCopy;
  if (fASYEventCopy==NULL){
    cout << "[KRATUnpack::Init:] Error: Couldn't find necessary input ";
    cout << "data container with name: " << fKratContInName << " (of class ASYEvent).";
    cout << " It will breaks the analysis." << endl;
    getchar();
  }
  
  
  fKene     = new KrattaEne();
  fTgt      = fKene->tgt;
  
  ///Set fairroot output data
  fRootKRATEvent     = new TRootKRATEvent();
  fRootKRATEventCopy = new TClonesArray("TRootKRATEvent");
  fRootKRATEventCopy = (TClonesArray*) fRootKRATEvent;
  
  // ioman->Register("KRATTAEVENTCLASS", "Kratta calibrated event", fRootKRATEvent, kFALSE); /// Commented 2014-03-20 by SK TODO: check if  necessary
  //ioman->Register("KRATTAEVENT", "Kratta calibrated event CLONE", fRootKRATEventCopy, fSaveOutputToTree);
  ioman->Register(fKratContOutName, "KRATTA calib. event", fRootKRATEventCopy, fSaveOutputToTree);
  
  cout << "TKratCalib::Init()------------------End" << endl;
  
  return kSUCCESS;
}

//______________________________________________________________________
void TKratCalib::Exec(Option_t* opt)
{
  
  ///cout << "[TKratCalib::Exec] launched" << endl;

  TRootKRATParticle *ds  = NULL;
  fRootKRATEvent->Clear("C");
  
  fPeaksNo                  = fASYEvent->npeak;
  fKrattaAsyPeakClonesArray = fASYEvent->peak; 

  fRootKRATEvent->Run       = fASYEvent->run;
  fRootKRATEvent->Evt       = fASYEvent->evt;
  
  if ( fVerbose > 5){     /// Print info about KRATTA event
    //cout  <<"["<< fEntryIndex <<":] ";
    cout << *fRootKRATEvent;
    cout << " with " << fPeaksNo << " hit(s)";
    cout << endl;
  }
  
  for (Int_t pi = 0; pi < fPeaksNo; pi++ )
  {
    /// You can do that in such a way:
    ASYFadcPeak *peak = (ASYFadcPeak*) (*fKrattaAsyPeakClonesArray)[pi];
    Int_t mod = peak->mod;

    ds = fRootKRATEvent->GetPtrToAnotherOneHit();
    
    ///PIDTEST cout << "[ "<< mod<< "]"<< "Debug: PID before:\t" << ds->PID << endl;
    fSwiatowid.Analyze(peak, ds);
    ///PIDTEST cout << "[ "<< mod<< "]"<< "Debug: PID after:\t" << ds->PID << endl;
    /// Jersy's filtering:
    //int   iz = ds->Z;
    //int   ia = ds->A;
    //float ra = float(ds->RealA);
    //float rz = float(ds->RealZ);
    //if(rz>10 && ds->Spect==0) rz=1;
    //if(rz<0) rz=0;
    //bool skip = false;
    //if(ds->Spect<0) continue;
    //float pid = ds->RealA-float(ds->A)+float(ds->PID);
    //if(iz<=0 || ia<=0 || ra <= 0.f || ds->PID <=0){
    //  iz = int(rz+0.5);
    //  ia = 2*iz;
    //  pid = 2.f*rz-float(ia)+float(ds->PID);
    //  skip = true;
    //}

    //fKene->Calibrate(fRootKRATEvent->Run, peak,iz,ia, fRootKRATEvent, ds);
    fKene->Calibrate( peak, fRootKRATEvent, ds );
    
    ///PIDTEST cout << "[ "<< mod<< "]"<< "Debug: PID after calib:\t" << ds->PID << endl;
    ///PrintDebugInfo(28, 1, peak, fRootKRATEvent, ds);
    /// DEBUG: Wypisyanie logow celem porownania ze skryptem:
    //if ( fVerbose > 2 ){
    //if ( fVerbose > 2 && ds->PID > 0){
    //  cout << " - " << pi << ": "<< *ds << endl;
    //}
    if ( fVerbose > 6){   /// Print info about KRATTA subevents (hits)
      cout << "\t#" << pi << ": " << *ds << endl;
    }
  }
}

//______________________________________________________________________
void TKratCalib::PrintDebugInfo( Int_t module, Int_t PidLimit,  ASYFadcPeak *peak, TRootKRATEvent *kevt, TRootKRATParticle *kp)
{
  
  if(peak != NULL && kevt != NULL && kp != NULL ){
    if (module == kp->Module && kp->PID >= PidLimit ){
      cout << "Run="<< kevt->Run <<"\tEventID="<< kevt->Evt << endl;
      cout << *peak << endl;
      cout << *kp << endl;
    }    
  }
}

//______________________________________________________________________
void TKratCalib::Reset()
{
}   

//______________________________________________________________________
void TKratCalib::Finish()
{  
  //file_out->Write();
  //file_out->Close();
}  

ClassImp( TKratCalib )