//-----------------------------------------------------------
// 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 "FairRootManager.h"
#include "FairRunAna.h"
#include "FairRuntimeDb.h"
#include "TpcDigiPar.h"
#include "TClonesArray.h"
#include "TRandom.h"
#include "TpcSignal.h"
#include "TpcAvalanche.h"
#include "TpcPad.h"
#include "TpcPadPlane.h"
#include "TpcGem.h"
#include "PndDetectorList.h"
#include "QAPlotCollection.h"

#include <iostream>

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


TpcPadResponseTask::TpcPadResponseTask()
  : FairTask("TPC PadResponse", 0), fpersistence(kFALSE), fminSignalAmp(0),
    frmin(15.5), frmax(41.5), fselected(false), finitialized(kFALSE), fqa(NULL),fsimple(kFALSE)
    //TODO: parameter management
{
  favalancheBranchName = "TpcAvalanche";
}


TpcPadResponseTask::~TpcPadResponseTask()
{}

void
TpcPadResponseTask::SetParContainers() {

  std::cout<<"TpcPadResponseTask::SetParContainers"<<std::endl;
  std::cout.flush();

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

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

  // Get Tpc digitisation parameter container
  fpar= (TpcDigiPar*) db->getContainer("TpcDigiPar");
  if (! fpar ) Fatal("SetParContainers", "TpcDigiPar not found");
}




InitStatus
TpcPadResponseTask::Init()
{
  finitialized=false;

  //Get ROOT Manager
  FairRootManager* ioman= FairRootManager::Instance();

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

  
  fpadPlane= fpar->getPadPlane();
  std::cout<<*fpadPlane<<std::endl;
  
  fgem=fpar->getGem();

  frmin=fpar->getRMin();
  frmax=fpar->getRMax();
  fminSignalAmp=fpar->getMinSigAmp();

  feventcounter=0;

  //Create Histograms for recording spread of Avalanche-centre to hit Pads
  if(fqa!=NULL){
	  fxVariation = fqa->getTH1D("xSpread","Hit Pad x-coordinates around Avalanche centre", 
			 200, -0.3, 0.3);
	  fyVariation = fqa->getTH1D("ySpread", 
			 "Hit Pad y-coordinates around Avalanche centre", 
			 200, -0.3, 0.3);
	  f2DHisto = fqa->getTH2D("xySpread","xSpread vs ySpread",
		      200,-0.3,0.3,200,-0.3,0.3);
  }
  fselected=fsecids.size()>0;

  if(fsimple)
    std::cout<<"TpcPadResonseTask::Simple Padresponse is activated!\n";

  finitialized=true;
  return kSUCCESS;
}


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

    std::vector<TpcPad*> hitPads;
    double xAv=Aval->x();
    double yAv=Aval->y();
    double r=sqrt(xAv*xAv+yAv*yAv);
    if(r<frmin || r>frmax) {
      //Warning("Exec","Avalanche outside of allowed region! r=%f",r);
      continue;
    }
    fpadPlane->GetPadList(xAv,yAv,
                         fgem->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){
      TpcPad* pad=hitPads[iHit];
      if(fselected){
        // find sectorid
        std::map<unsigned int,bool>::iterator it=fsecids.find(pad->sectorId());
        if(it==fsecids.end())continue;
      }

      double Amp=0;
      if (fsimple)
      {
    	  //Amp=Aval->amp()*pad->Contains(xAv,yAv);
    	  double weight=(1-sqrt( (xAv-pad->x())*(xAv-pad->x()) + (pad->y()-yAv)*(pad->y()-yAv) )/0.15) ;
    	  if (weight<0)
    		  weight=0;
    	  Amp=Aval->amp();//*weight;
      	  //std::cout<<"av: ("<<xAv<<","<<yAv<<") pad: ("<<pad->x()<<","<<pad->y()<<") contains:"<<pad->Contains(xAv,yAv)<<"\n";
      	  //std::cout<<"distance pad-av: "<<pad->x()-xAv<<" "<<pad->y()-yAv<<" r:"<<sqrt((pad->x()-xAv)*(pad->x()-xAv) + (pad->y()-yAv)*(pad->y()-yAv))<<"\n";
      }
      else
    	  Amp=Aval->amp()*pad->GetValue(xAv,yAv); //TODO check consistency: is the integrated amplitude on all pads correct

      if(fpar->getGaussianNoise()){
        Amp+=gRandom->Gaus(0.,fpar->getGaussianNoiseAmp());
      }
      //Fill Histograms with these Values

      FillHistograms(xAv, yAv, pad->x(), pad->y() );      

      // cut on amplitude
      if(Amp>=fminSignalAmp){
        TpcSignal* sig=new((*fsignalArray)[nValidHits]) TpcSignal(Aval->t(),Amp,
                                     pad->id(),0,
                                     Aval);
        sig->setIndex(nValidHits);
	//        sig->SetLink(FairLink(favalancheBranchName, ia));
        ++nValidHits;
      }
      else {
        //std::cout<<"PadAmp too small! Amp="<<Amp<<"<"<<fminSignalAmp<<std::endl;
      }
    } // end loop over hit pads

  } // end loop over avalanches

  ++feventcounter;
  if (fVerbose) std::cout<<fsignalArray->GetEntriesFast()<<" Signals created"<<std::endl;

  return;
}

void TpcPadResponseTask::FillHistograms(double xAv, double yAv,
					double xPad, double yPad) {
  if(fqa!=NULL){
	  fxVariation->Fill(xAv - xPad);
	  fyVariation->Fill(yAv - yPad);
	  f2DHisto->Fill(xAv - xPad, yAv - yPad);
  }
}

//!Method WriteHistograms() has to be called once in the runDigi.C macro!
//! This method is deprecated - replaced by the QAPlotcollection!
void TpcPadResponseTask::WriteHistograms() {

  if(!finitialized || fqa==NULL)return;
  TFile* file = FairRootManager::Instance()->GetOutFile();
  file->mkdir("TpcPadResponse");
  file->cd("TpcPadResponse");

  fxVariation->Write();
  fyVariation->Write();
  f2DHisto->Write();

}


ClassImp(TpcPadResponseTask)