//-----------------------------------------------------------
// File and Version Information:
// $Id$
//
// Description:
//      Implementation of class TpcPadResponseTask
//      see TpcPadResponseTask.hh for details
//
// Environment:
//      Software developed for the PANDA Detector at FAIR.
//
// Author List:
//      Sebastian Neubert    TUM            (original author)
//
//
//-----------------------------------------------------------

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

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

// C/C++ Headers ----------------------


// Collaborating Class Headers --------
#include "CbmRootManager.h"
#include "TClonesArray.h"
#include "TRandom.h"
#include "TpcSignal.h"
#include "TpcAvalanche.h"
#include "TpcPad.h"
#include "TpcPadPlane.h"
#include "TpcPadShapePool.h"
#include "TpcGem.h"

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


TpcPadResponseTask::TpcPadResponseTask()
  : CbmTask("TPC PadResponse"), _persistence(kFALSE), _minSignalAmp(0),
    _rmin(15.), _rmax(42.)
{
  _avalancheBranchName = "TpcAvalanche";
}


TpcPadResponseTask::~TpcPadResponseTask()
{}

InitStatus
TpcPadResponseTask::Init()
{
  //Get ROOT Manager
  CbmRootManager* ioman= CbmRootManager::Instance();

  if(ioman==0)
    {
      Error("TpcPadResponseTask::Init","RootManager not instantiated!");
      return kERROR;
    }
  
  // Get input collection
  _avalancheArray=(TClonesArray*) ioman->GetObject(_avalancheBranchName);
  
  if(_avalancheArray==0)
    {
      Error("TpcPadResponseTask::Init","Avalanche-array not found!");
      return kERROR;
    }
  
  // create and register output array
  _signalArray = new TClonesArray("TpcSignal"); 
  ioman->Register("TpcSignal","Tpc",_signalArray,_persistence);

  
  //TODO: Get these things from Database!!!
  _gem=new TpcGem(5000,           // Gain
                  0.05);          // Spread

  _padShapes = new TpcPadShapePool("2mmPads.dat",
				   *_gem,
				   0.5, // lookup range
				   0.02, // Lookup Step
				   0.01); // LookupIntegrationStep


    _padPlane= new TpcPadPlane(100,100,
			       1.,1.,
			       -50.,-50.);

  // Put Pads into PadPlane
  _padPlane->ReadFromFile("padplane.dat", _padShapes);


  std::cout<<*_padPlane<<std::endl;

  _eventcounter=0;

  //Create Histograms for recording spread of Avalanche-centre to hit Pads
  _xVariation = new TH1D("xSpread", 
			 "Hit Pad x-coordinates around Avalanche centre", 
			 200, -0.3, 0.3);
  _yVariation = new TH1D("ySpread", 
			 "Hit Pad y-coordinates around Avalanche centre", 
			 200, -0.3, 0.3);
  _2DHisto = new TH2D("2D_Histo", 
		      "2D Histogram containing x- and y-distribution",
		      200,-0.3,0.3,200,0,0.3);

  return kSUCCESS;
}


void
TpcPadResponseTask::Exec(Option_t* opt)
{
  // Reset output Array
  if(_signalArray==0) Fatal("TpcPadResponse::Exec)","No SignalArray");
  _signalArray->Delete(); // Note: signals will be cleand up in the adc!
  int nValidHits=0;
  Int_t na=_avalancheArray->GetEntriesFast();
  for(Int_t ia=0;ia<na;++ia){
    TpcAvalanche* Aval=(TpcAvalanche*)_avalancheArray->At(ia);

    std::vector<TpcPad*> hitPads;
    double xAv=Aval->x();
    double yAv=Aval->y();
    double r=sqrt(xAv*xAv+yAv*yAv);
    if(r<_rmin || r>_rmax) {
      Warning("Exec","Avalanche outside of allowed region! r=%f",r);
      continue;
    }
    _padPlane->GetPadList(xAv,yAv,
                         _gem->spread()*3,
                         hitPads);
    // Build Signals
    int nHits=hitPads.size();
    //std::cout<<nHits<<" Pads hit by avalanche"<<std::endl;
    
    for(int iHit=0; iHit<nHits; ++iHit){
      double Amp=Aval->amp()*hitPads[iHit]->GetValue(xAv,yAv);

      //Fill Histograms with these Values

      FillHistograms(xAv, yAv, hitPads[iHit]->x(), hitPads[iHit]->y() );      

      // cut on amplitude
      if(Amp>=_minSignalAmp){
        TpcSignal* sig=new((*_signalArray)[nValidHits]) TpcSignal(Aval->t(),Amp,
                                     hitPads[iHit]->id(),0,
                                     0);
        sig->setmcTrackId(Aval->mcTrackId());
        sig->setmcHitId(Aval->mcHitId());
        ++nValidHits;
      }
      else {
	//std::cout<<"PadAmp too small! Amp="<<Amp<<"<"<<_minSignalAmp<<std::endl;
      }
    } // end loop over hit pads

  } // end loop over avalanches

  ++_eventcounter;
  std::cout<<_signalArray->GetEntriesFast()<<" Signals created"<<std::endl;

  return;
}

void TpcPadResponseTask::FillHistograms(double xAv, double yAv,
					double xPad, double yPad) {
  
  _xVariation->Fill(xAv - xPad);
  _yVariation->Fill(yAv - yPad);
  _2DHisto->Fill(xAv - xPad, yAv - yPad);
}

//Method WriteHistograms() has to be called once in the runDigi.C macro!
void TpcPadResponseTask::WriteHistograms() {

  TFile* file = new TFile("histograms.root","UPDATE");
  file->mkdir("TpcPadResponse");
  file->cd("TpcPadResponse");

  _xVariation->Write();
  delete _xVariation;
  _yVariation->Write();
  delete _yVariation;
  _2DHisto->Write();
  delete _2DHisto;

  file->Close();
  delete file;
  }


ClassImp(TpcPadResponseTask)