// -------------------------------------------------------------------------
// -----                    CbmMvdSensorBufferTask  source file                -----
// -------------------------------------------------------------------------


/*
 *
 * ____________________________________________________________________________________________
  
 * ____________________________________________________________________________________________
 * --------------------------------------------------------------------------------------------
 */



// Includes from MVD
#include "CbmMvdSensorBufferTask.h"


#include "CbmMvdGeoPar.h"
#include "CbmMvdHit.h"
#include "CbmMvdHitMatch.h"
#include "CbmMvdPileupManager.h"
#include "CbmMvdPoint.h"
#include "CbmMvdStation.h"
#include "CbmMvdSensor.h"


#include "plugins/buffers/CbmMvdSensorFrameBuffer.h"
#include "plugins/buffers/CbmMvdSensorTrackingBuffer.h"
#include "plugins/tasks/CbmMvdSensorDigitizerTask.h"
#include "plugins/tasks/CbmMvdSensorFindHitTask.h"
//#include "omp.h"

// Includes from base
#include "FairGeoNode.h"
#include "FairRootManager.h"
#include "FairRunSim.h"
#include "FairRuntimeDb.h"
#include "CbmMCTrack.h"

// Includes from ROOT
#include "TArrayD.h"
#include "TClonesArray.h"
#include "TGeoManager.h"
//#include "TGeoShape.h"
#include "TGeoTube.h"
#include "TObjArray.h"
#include "TRandom3.h"
#include "TString.h"
#include "TVector3.h"
#include "TMath.h"
#include "TH1.h"
#include "TH2.h"

// Includes from C++
#include <iostream>
#include <iomanip>
#include <vector>
#include <map>

//#include "gsl/gsl_sf_erf.h"
//#include "CLHEP/Random/RandGauss.h"
//#include "CLHEP/Random/RandPoisson.h"
//#include "CLHEP/Random/RandFlat.h"


using std::cout;
using std::endl;
using std::map;
using std::setw;
using std::left;
using std::right;
using std::fixed;
using std::pair;
using std::setprecision;
using std::ios_base;
using std::vector;


// -----   Default constructor   ------------------------------------------
CbmMvdSensorBufferTask::CbmMvdSensorBufferTask()
    : FairTask("MVDSensorBuffer")
{
    bWriteOutput   = false;
    
}
// -------------------------------------------------------------------------



// -----   Standard constructor   ------------------------------------------
CbmMvdSensorBufferTask::CbmMvdSensorBufferTask(const char* name, Int_t iMode,
				 Int_t iVerbose)
: FairTask(name, iVerbose)
{
    cout << "Starting CbmMvdSensorBufferTask::CbmMvdSensorBufferTask() "<< endl;

    fMode          = iMode;
   
 }


// -------------------------------------------------------------------------



// -----   Destructor   ----------------------------------------------------
CbmMvdSensorBufferTask::~CbmMvdSensorBufferTask() {


}




// -----   Virtual public method Exec   ------------------------------------
void CbmMvdSensorBufferTask::Exec(Option_t* opt) {

fHits->Clear("C");

if(fInputPoints->GetEntriesFast() > 0)
{
cout << endl << "Send Input" << endl;
fDetector->SendInput(fInputPoints);
cout << endl << "Execute Chain" << endl;
fDetector->ExecChain();
cout << endl << "End Chain" << endl;


if(bWriteOutput)
    {
    cout << "Start writing Hits" << endl;  
    fDigis->AbsorbObjects(fDetector->GetOutputDigis()); 
    fHits->AbsorbObjects(fDetector->GetOutputHits());
    fHits->Compress();
    cout << endl;
    }
}
}// end of exec

// -------------------------------------------------------------------------


			      
// -----    Virtual private method Init   ----------------------------------
InitStatus CbmMvdSensorBufferTask::Init() {

  cout << "-I- " << GetName() << ": Initialisation..." << endl;

    cout << endl;
    cout << "---------------------------------------------" << endl;
    cout << "-I- Initialising " << GetName() << " ...." << endl;

    // **********  RootManager
    FairRootManager* ioman = FairRootManager::Instance();
    if ( ! ioman ) 
	{
	cout << "-E- " << GetName() << "::Init: No FairRootManager!" << endl;
	return kFATAL;
	}

    // **********  Get input arrays
    fInputPoints = (TClonesArray*) ioman->GetObject("MvdPoint"); 
   
    // **********  Register output array
    fHits =  new TClonesArray("CbmMvdHit", 10000);
    fDigis = new TClonesArray("CbmMvdDigi", 10000);
    ioman->Register("MvdPluginHits", "MvdHit", fHits, kTRUE);
    ioman->Register("MvdPluginDigis", "MvdDigi", fDigis, kTRUE);

    // Screen output
    cout << GetName() << " initialised with parameters: " << endl;
    //PrintParameters();
    cout << "---------------------------------------------" << endl;

    fDetector = CbmMvdDetector::Instance();
    
    CbmMvdSensorFrameBuffer* frameBuffer = new CbmMvdSensorFrameBuffer();
    CbmMvdSensorDigitizerTask* digiTask = new CbmMvdSensorDigitizerTask();
    CbmMvdSensorFindHitTask* findTask = new CbmMvdSensorFindHitTask();
  //  CbmMvdSensorTrackingBuffer* trackingBuffer = new CbmMvdSensorTrackingBuffer;
   

  //fDetector->AddPlugin(frameBuffer);
  fDetector->AddPlugin(digiTask);
  fDetector->AddPlugin(findTask);
    //fDetector->AddPlugin(trackingBuffer);
    
    fDetector->Init();
    
    
    return kSUCCESS;

 

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



// -----   Virtual public method Reinit   ----------------------------------
InitStatus CbmMvdSensorBufferTask::ReInit() {

    return kSUCCESS;
}
// -------------------------------------------------------------------------



// -----   Virtual method Finish   -----------------------------------------
void CbmMvdSensorBufferTask::Finish() {

    PrintParameters();

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



// -----   Private method Reset   ------------------------------------------
void CbmMvdSensorBufferTask::Reset() {
    fHits->Delete();

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



// -----   Private method PrintParameters   --------------------------------
void CbmMvdSensorBufferTask::PrintParameters() {
    
    cout.setf(ios_base::fixed, ios_base::floatfield);
    cout << "============================================================" << endl;
    cout << "============== Parameters Buffer Task ======================" << endl;
    cout << "============================================================" << endl;
    
    
    cout << "=============== End Task ===================================" << endl;
 
}
// -------------------------------------------------------------------------  



ClassImp(CbmMvdSensorBufferTask);