//_____________________________________________________________________________
// CLC analysis module: below are the examples of what one can do in 
// the interactive session
//_____________________________________________________________________________

/*

  ****** to run:

  TStnAna x("dataval_ar0192ea_clc.root");
  gInterpreter->ProcessLine(".U /data12/murat/online/./TClcAnaModule.so");
  TStnAna x("dataval_clc.root");
  gInterpreter->ProcessLine(".L /data12/murat/online/./TClcAnaModule.cc+");
  x.AddModule(new TClcAnaModule());
  TClcAnaModule* m = (TClcAnaModule*) x.GetModule("ClcAna");
  m->SetClcCalibVer(2);
  x.Run(1000);

  ****** how to display a histogram

  TClcAnaModule* m = (TClcAnaModule*) x.GetModule("ClcAna");
  ClcHistograms_t* c = m->GetHist();
  c->fNTdcHitsCh->Draw();

  ****** to process one event (#15 in the ntuple) and to print the CLC data"

  x.ProcessEvent(15)
  TClcAnaModule* m = (TClcAnaModule*) x.GetModule("ClcAna");
  TClcData* data = m->GetClcBlock();
  data->Print();

*/

#include "TF1.h"
#include "Stntuple/obj/TStnHeaderBlock.hh"
#include "Stntuple/obj/TStnTrackBlock.hh"

#include "TClcAnaModule.hh"

//_____________________________________________________________________________
TClcAnaModule::TClcAnaModule(const char* name, const char* title):
  TStnModule(name,title)
{
  fAdcThreshold = 1500.;
}

//_____________________________________________________________________________
TClcAnaModule::~TClcAnaModule() {
}

//_____________________________________________________________________________
void TClcAnaModule::BookHistograms() {
  char name [200];
  char title[200];

  Delete("hist");
				// book histograms

  sprintf(title,"CLC: N(ADC hits)");
  fHist.fNAdcHits = new TH1F("h_clc_nadc_hits", title,200 ,0,200);
  AddHistogram(fHist.fNAdcHits);

  sprintf(title,"CLC: N(TDC hits)");
  fHist.fNTdcHits = new TH1F("h_clc_ntdc_hits", title,200 ,0,200);
  AddHistogram(fHist.fNTdcHits);

  sprintf(title,"CLC: N(TDC hits) 1 ");
  fHist.fNTdcHits1 = new TH1F("h_clc_ntdc_hits_1", title,200 ,0,200);
  AddHistogram(fHist.fNTdcHits1);

  sprintf(title,"CLC: N (TDC hits) per channle ");
  fHist.fNTdcHitsCh = new TH1F("h_clc_ntdc_hits_ch", title,20 ,0,20);
  AddHistogram(fHist.fNTdcHitsCh);

  sprintf(name, "h_clc_myron_vs_tdc");
  sprintf(title,"CLC: TDC channel 1 myron vs T2+132*myron");
  fHist.fMyronVsTdc = new TH2F(name, title,500 ,0,100,4,0,4);
  AddHistogram(fHist.fMyronVsTdc);

  for (int i=0; i<96; i++) {
    sprintf(name, "h_clc_adc_%02i",i);
    sprintf(title,"CLC: ADC channel %02i",i);
    fHist.fAdc[i] = new TH1F(name, title,500,0,25000);
    AddHistogram(fHist.fAdc[i]);

    sprintf(name, "h_clc_adc1_%02i",i);
    sprintf(title,"CLC: ADC channel %02i L1:41",i);
    fHist.fAdc1[i] = new TH1F(name, title,500 ,0,25000);
    AddHistogram(fHist.fAdc1[i]);

    sprintf(name, "h_clc_tdc0_%02i",i);
    sprintf(title,"CLC: TDC0 (raw TDC counts) channel %02i",i);
    fHist.fTdc0[i] = new TH1F(name, title,400 ,0,2000);
    AddHistogram(fHist.fTdc0[i]);

    sprintf(name, "h_clc_tdc_%02i",i);
    sprintf(title,"CLC: TDC channel %02i",i);
    fHist.fTdc[i] = new TH1F(name, title,250 ,1000,1250);
    AddHistogram(fHist.fTdc[i]);

    sprintf(name, "h_clc_time_%02i",i);
    sprintf(title,"CLC: TDC1 channel %02i: LeadingEdge+T0",i);
    fHist.fTime[i] = new TH1F(name, title,500,0,50);
    AddHistogram(fHist.fTime[i]);

    sprintf(name, "h_clc_tdc2_%02i",i);
    sprintf(title,"CLC: TDC2 channel %02i: 100-w/slope-132*myron",i);
    fHist.fTdc2[i] = new TH1F(name, title,500,0,100);
    AddHistogram(fHist.fTdc2[i]);

    sprintf(name, "h_clc_tdc3_%02i",i);
    sprintf(title,"CLC: TDC3 channel %02i: t+w/10 ",i);
    fHist.fTdc3[i] = new TH1F(name, title,500,900,1400);
    AddHistogram(fHist.fTdc3[i]);

    sprintf(name, "h_clc_wid_%02i",i);
    sprintf(title,"CLC: TDC channel %02i pulse width",i);
    fHist.fWid[i] = new TH1F(name, title,500 ,0,500);
    AddHistogram(fHist.fWid[i]);

    sprintf(name, "h_clc_dtdc_%02i",i);
    sprintf(title,"CLC: LeadingEdge(ref)-LeadingEdge(i) channel %02i",i);
    fHist.fDeltaTdc[i] = new TH1F(name, title,100,-50,50);
    AddHistogram(fHist.fDeltaTdc[i]);

    sprintf(name, "h_clc_dtime_%02i",i);
    sprintf(title,"CLC: Time(ref)-Time(i) channel %02i",i);
    fHist.fDeltaTime[i] = new TH1F(name, title,100,-50,50);
    AddHistogram(fHist.fDeltaTime[i]);

    sprintf(name, "h_clc_dt2_%02i",i);
    sprintf(title,"CLC: T2(ref)-T2(i) channel %02i",i);
    fHist.fDeltaT2[i] = new TH1F(name, title,200,-50,50);
    AddHistogram(fHist.fDeltaT2[i]);

    sprintf(name, "h_clc_dt3_%02i",i);
    sprintf(title,"CLC: T3(ref)-T3(i) channel %02i",i);
    fHist.fDeltaT3[i] = new TH1F(name, title,200,-50,50);
    AddHistogram(fHist.fDeltaT3[i]);

    sprintf(name, "h_clc_dt3_vs_adc_%02i",i);
    sprintf(title,"CLC: T3(ref)-T3(i) vs Adc(i) channel %02i",i);
    fHist.fDt3VsAdc[i] = new TH2F(name, title,22,0,1100,200,-20,20);
    AddHistogram(fHist.fDt3VsAdc[i]);
  }

  for (int i=0; i<2; i++) {
    sprintf(name, "h_clc_hits_module_%i",i);
    sprintf(title,"CLC: Nhits module %i",i);
    fHist.fNHitsModule [i]  = new TH1F(name,title,100,0,100);
    AddHistogram(fHist.fNHitsModule[i]);

    sprintf(name, "h_clc_hit_ch_module_%i",i);
    sprintf(title,"CLC: N(TDC channels with hits) module %i",i);
    fHist.fNHitChModule[i]  = new TH1F(name,title,100,0,100);
    AddHistogram(fHist.fNHitChModule[i]);

    sprintf(name, "h_clc_module_time_%i",i);
    sprintf(title,"CLC: Mean time module %i",i);
    fHist.fModuleTime[i]  = new TH1F(name,title,500,-1250,1250);
    AddHistogram(fHist.fModuleTime[i]);

    sprintf(name, "h_clc_module_timew_%i",i);
    sprintf(title,"CLC: Mean timew module %i",i);
    fHist.fModuleTimew[i]  = new TH1F(name,title,500,-1250,1250);
    AddHistogram(fHist.fModuleTimew[i]);

    for (int j=0; j<3; j++) {
      sprintf(name, "h_clc_hits_layer_%i_%i",i,j);
      sprintf(title,"CLC: Nhits module %i layer %i",i,j);
      fHist.fNHitsLayer[i][j]  = new TH1F(name,title,50,0,50);
      AddHistogram(fHist.fNHitsLayer[i][j]);

      sprintf(name, "h_clc_hit_ch_layer_%i_%i",i,j);
      sprintf(title,"CLC: N(TDC channels with hits) module %i layer %i",i,j);
      fHist.fNHitChLayer[i][j]  = new TH1F(name,title,20,0,20);
      AddHistogram(fHist.fNHitChLayer[i][j]);

      sprintf(name, "h_clc_time_layer_%i_%i",i,j);
      sprintf(title,"CLC: mean time module %i layer %i",i,j);
      fHist.fLayerTime[i][j]  = new TH1F(name,title,500,-1250,1250);
      AddHistogram(fHist.fLayerTime[i][j]);

      sprintf(name, "h_clc_timew_layer_%i_%i",i,j);
      sprintf(title,"CLC: mean timew module %i layer %i",i,j);
      fHist.fLayerTimew[i][j]  = new TH1F(name,title,500,-1250,1250);
      AddHistogram(fHist.fLayerTimew[i][j]);
    }
  }

  sprintf(name, "h_clc_myron_vs_tdc35");
  sprintf(title,"CLC1: myron vs raw TDC-35 time +132*myron ");
  fHist.fMyronVsTdc35 = new TH2F(name, title,400 ,0,2000,4,0,4);
  AddHistogram(fHist.fMyronVsTdc35);

  sprintf(name, "h_clc_myron_vs_adc");
  sprintf(title,"CLC1: myron vs raw ADC counts (all channels) ");
  fHist.fMyronVsAdcCounts = new TH2F(name, title,400 ,0,2000,4,0,4);
  AddHistogram(fHist.fMyronVsAdcCounts);

  sprintf(name, "h_clc_t35_vs_t82");
  sprintf(title,"CLC1: TDC time 35 vs TDC time 82");
  fHist.fTdc35VsTdc82 = new TH2F(name, title,400 ,0,2000,400,0,2000);
  AddHistogram(fHist.fTdc35VsTdc82);

  sprintf(name, "h_clc_module_deltat");
  sprintf(title,"CLC: delta(t) module");
  fHist.fModuleDeltaT  = new TH1F(name,title,200,-100,100);
  AddHistogram(fHist.fModuleDeltaT);

  sprintf(name, "h_clc_module_deltatw");
  sprintf(title,"CLC: delta(tw) module");
  fHist.fModuleDeltaTw  = new TH1F(name,title,200,-100,100);
  AddHistogram(fHist.fModuleDeltaTw);

  sprintf(name, "h_clc_module_z");
  sprintf(title,"CLC: Z module");
  fHist.fModuleZ  = new TH1F(name,title,200,-500,500);
  AddHistogram(fHist.fModuleZ);

  sprintf(name, "h_clc_module_zw");
  sprintf(title,"CLC: Zw module");
  fHist.fModuleZw  = new TH1F(name,title,200,-500,500);
  AddHistogram(fHist.fModuleZw);

  sprintf(name, "h_clc_delta_z");
  sprintf(title,"CLC: Z(CLC module)-Z(CTC)");
  fHist.fDeltaZ  = new TH1F(name,title,200,-250,250);
  AddHistogram(fHist.fDeltaZ);

  sprintf(name, "h_clc_delta_zw");
  sprintf(title,"CLC: Zw(CLC module)-Z(CTC)");
  fHist.fDeltaZw  = new TH1F(name,title,200,-250,250);
  AddHistogram(fHist.fDeltaZw);

  sprintf(name, "h_clc_delta_z5");
  sprintf(title,"CLC: Z(CLC module)-Z(CTC) N(tracks) > 5");
  fHist.fDeltaZ5  = new TH1F(name,title,200,-250,250);
  AddHistogram(fHist.fDeltaZ5);

  sprintf(name, "h_clc_delta_z5w");
  sprintf(title,"CLC: Zw(CLC module)-Z(CTC) N(tracks) > 5");
  fHist.fDeltaZ5w  = new TH1F(name,title,200,-250,250);
  AddHistogram(fHist.fDeltaZ5w);

  sprintf(name, "h_clc_zclc_vs_zcot");
  sprintf(title,"CLC: Z(CLC module) vs Z(CTC) N(tracks) > 5");
  fHist.fZClcVsZCot = new TH2F(name,title,200,-250,250,200,-250,250);
  AddHistogram(fHist.fZClcVsZCot);

  sprintf(name, "h_clc_zwclc_vs_zcot");
  sprintf(title,"CLC: Zw(CLC module) vs Z(CTC) N(tracks) > 5");
  fHist.fZwClcVsZCot = new TH2F(name,title,200,-250,250,200,-250,250);
  AddHistogram(fHist.fZwClcVsZCot);

  for (int i=0; i<3; i++) {
    sprintf(name, "h_clc_deltat_layer_%i",i);
    sprintf(title,"CLC: deltat layer %i",i);
    fHist.fLayerDeltaT[i]  = new TH1F(name,title,200,-100,100);
    AddHistogram(fHist.fLayerDeltaT[i]);

    sprintf(name, "h_clc_z_layer_%i",i);
    sprintf(title,"CLC: Z calculated using layer %i",i);
    fHist.fLayerZ[i]  = new TH1F(name,title,200,-500,500);
    AddHistogram(fHist.fLayerZ[i]);

    sprintf(name, "h_clc_deltatw_layer_%i",i);
    sprintf(title,"CLC: deltaTw layer %i",i);
    fHist.fLayerDeltaTw[i]  = new TH1F(name,title,200,-100,100);
    AddHistogram(fHist.fLayerDeltaTw[i]);

    sprintf(name, "h_clc_zw_layer_%i",i);
    sprintf(title,"CLC: Zw calculated using layer %i",i);
    fHist.fLayerZw[i]  = new TH1F(name,title,200,-500,500);
    AddHistogram(fHist.fLayerZw[i]);
  }

  sprintf(title,"CLC: Nhits(west) vs Nhits(east)");
  fHist.fNHitsM01 = new TH2F("h_clc_nhits_m01", title,100 ,0,100,100,0,100);
  AddHistogram(fHist.fNHitsM01);

  sprintf(title,"CLC: N hit channels (west) vs N hit channels (east)");
  fHist.fNHitChM01 = new TH2F("h_clc_nhit_ch_m01", title,100 ,0,100,100,0,100);
  AddHistogram(fHist.fNHitChM01);

}


//_____________________________________________________________________________
int TClcAnaModule::BeginJob() {

				// register the data block

  RegisterDataBlock("TriggerBlock",&fTriggerBlock);
  RegisterDataBlock("ClcDataBlock",&fClcBlock    );
  RegisterDataBlock("VertexBlock" ,&fVertexBlock );

					// book histograms
  BookHistograms();

  if (! fClcBlock) fEnabled = 0;

  return 0;
}


//_____________________________________________________________________________
int TClcAnaModule::BeginRun() {
  // initialize run-dependent calibration constants

  fClcBlock->SetCalibVersion(fClcCalibVer);
  int rc =  fClcBlock->ReadCalibrations(GetHeaderBlock()->RunNumber());
  return rc;
}

//_____________________________________________________________________________
int TClcAnaModule::Event(int ientry) {
					// in case of a TChain, ientry is the 
					// entry number in the current file
					// read the trigger block to look at
					// the myron flag
  fTriggerBlock->GetEntry(ientry);
  TTsid* tsid = fTriggerBlock->Tsid();
  TTfrd* tfrd = fTriggerBlock->Tfrd();
					// process only requested bucket
  int myron = tsid->MyronFlag();
  if (fMyronFlag >= 0) {
    if (myron != fMyronFlag) return 0;
  }
					// myron is OK, read CLC data
  fClcBlock->GetEntry(ientry);
					// do whatever you want
  if (fDebugLevel) {
    fClcBlock->Print();
  }
					// calculate timing
  for (int im=0; im<2; im++) {
					// calculate mean time for the module
					// (including its layers)

    fClcBlock->Module(im)->CalculateMeanTime(0.,2000.,1500);
  }

  fHist.fNAdcHits->Fill(fClcBlock->NAdcHits());
  fHist.fNTdcHits->Fill(fClcBlock->NTdcHits());

  if (tfrd->PrescaledL1Bit(41)) {
    fHist.fNTdcHits1->Fill(fClcBlock->NTdcHits());
  }

					// define reference channels for the 
					// delay calibration, use channels 
					// #1 (west) and #49(east)
  int          mod_ok[2] = {0,0};
  TClcChannel* ref[2];

  for (int im=0; im<2; im++) {
    int iref = fClcBlock->Module(im)->RefChannel();
    ref[im] = fClcBlock->Channel(iref);
    if (ref[im]->NTdcHits() == 1) {
      int t = ref[im]->Time(0)+myron*132;
      if ( (ref[im]->AdcCounts() > 150) && (t > 1060) && (t < 1100)) {
	mod_ok[im] = 1;
      }
      fHist.fMyronVsTdc->Fill(ref[im]->T2(0)+myron*132.,(float)myron);
    }
  }

  TClcChannel* ch_35 = fClcBlock->Channel(35);
  TClcChannel* ch_82 = fClcBlock->Channel(82);

  if ( (ch_35->NTdcHits() == 1) && (ch_82->NTdcHits() == 1)) {
    fHist.fTdc35VsTdc82->Fill(ch_82->Time(0)+myron*132.,
			      ch_35->Time(0)+myron*132.,
			      1.);
    fHist.fMyronVsTdc35->Fill(ch_35->TdcWord(0)->LeadingEdge()+myron*132.,
			      (float) myron,1);
  }

  int imod;
  for (int i=0; i<96; i++) {
    TClcChannel* ch = fClcBlock->Channel(i);

    if (i<48) imod = 0;
    else      imod = 1;

    fHist.fAdc[i]->Fill(ch->AdcCounts());
    if (! ch->Bad()) {
      fHist.fMyronVsAdcCounts->Fill(ch->AdcCounts(),(float) myron,1);
    }

    int n_tdc_hits = ch->NTdcHits();
    if (n_tdc_hits > 0) {
      fHist.fAdc1[i]->Fill(ch->AdcCounts());
    }

    fHist.fNTdcHitsCh->Fill(n_tdc_hits);

    if (ch->AdcCounts() > 150) {
      float t0, width, t1, t2;
      
      for (int j=0; j<n_tdc_hits; j++) {
	t0    = ch->TdcWord(j)->LeadingEdge();
	width = ch->TdcWord(j)->Width();
	t1    = ch->Time(j);
	t2    = ch->T2(j)+132.*myron;
	
	fHist.fTdc0[i]->Fill(ch->TdcWord(j)->LeadingEdge()+myron*132.);
	fHist.fTdc [i]->Fill(t0+myron*85);
	fHist.fWid [i]->Fill(width);
	fHist.fTime[i]->Fill(t1+myron*132.-1200);
	fHist.fTdc2[i]->Fill(t2);
	fHist.fTdc3[i]->Fill(t1+myron*100);
	
					// calibrate delays
	if (n_tdc_hits == 1) {
	  if (mod_ok[imod]) {
					// WEST: calib time OK
	    
	    fHist.fDeltaTdc [i]->Fill(ref[imod]->TdcWord(0)->LeadingEdge()-t0);
	    fHist.fDeltaTime[i]->Fill(ref[imod]->Time(0)-ch->Time(0));
	    fHist.fDeltaT2  [i]->Fill(ref[imod]->T2(0)-ch->T2(0));
	    fHist.fDeltaT3  [i]->Fill(ref[imod]->T3(0)-ch->T3(0));
	    fHist.fDt3VsAdc [i]->Fill((float) ch->AdcCounts(),
				      ref[imod]->T3(0)-ch->T3(0));
	  }
	}
      }
    }
  }

  for (int i=0; i<2; i++) {
    TClcModule* m = fClcBlock->Module(i);
    fHist.fNHitsModule [i]->Fill(m->NTdcHits());
    fHist.fNHitChModule[i]->Fill(m->NChannelsAbove(fAdcThreshold));
    fHist.fModuleTime  [i]->Fill(m->MeanTime());
    fHist.fModuleTimew [i]->Fill(m->MeanTimeW());
    for (int j=0; j<3; j++) {
      TClcLayer* lay = m->Layer(j);
      fHist.fNHitsLayer [i][j]->Fill(lay->NTdcHits());
      fHist.fNHitChLayer[i][j]->Fill(lay->NChannelsAbove(fAdcThreshold));
      fHist.fLayerTime  [i][j]->Fill(lay->MeanTime());
      fHist.fLayerTimew [i][j]->Fill(lay->MeanTimeW());
    }
  }
					// m0 - west, m1 - east
  float dt, dtw;

  TClcModule* m0 = fClcBlock->Module(0);
  TClcModule* m1 = fClcBlock->Module(1);

  TClcLayer*  l0;
  TClcLayer*  l1;

  for (int i=0; i<3; i++) {
    l0 = m0->Layer(i);
    l1 = m1->Layer(i);
					// when calculating delta(t) require
					// both measured times to be reasonable

    if (l0->NChannelsAbove(fAdcThreshold) > 0) {
      if (l1->NChannelsAbove(fAdcThreshold) > 0) {
	dt  = l0->MeanTime()-l1->MeanTime();
	dtw = l0->MeanTimeW()-l1->MeanTimeW();
      }
      else {
	dt = 99.;
      }
    }
    else {
      dt = -99.;
    }
    fHist.fLayerDeltaT[i]->Fill(dt);
    fHist.fLayerZ     [i]->Fill(dt/2*29.997);

    fHist.fLayerDeltaTw[i]->Fill(dtw);
    fHist.fLayerZw     [i]->Fill(dtw/2*29.997);
  }
					// now - mean times for the modules

  if (m0->NChannelsAbove(fAdcThreshold) > 0) {
    if (m1->NChannelsAbove(fAdcThreshold) > 0) {
      dt  = m0->MeanTime()-m1->MeanTime();
      dtw = m0->MeanTimeW()-m1->MeanTimeW();
    }
    else {
      dt = 99.;
    }
  }
  else {
    dt = -99.;
  }

  fHist.fModuleDeltaT->Fill(dt);
  fHist.fModuleDeltaTw->Fill(dtw);
  
  float vz  = dt/2*29.997;
  float vzw = dtw/2*29.997;

  fHist.fModuleZ->Fill(vz);
  fHist.fModuleZw->Fill(vzw);

  if (fabs(dt) < 99.) {
				// execute this fragment only if vertex data
				// are available
    if (fVertexBlock) {
      fVertexBlock->GetEntry(ientry);
      int nv = fVertexBlock->NVertices(0);
      if (nv == 1) {
	TStnVertex* v = fVertexBlock->Vertex(0);
	fHist.fDeltaZ->Fill(vz-v->Z());
	if (v->NTracks() > 5) {
	  fHist.fDeltaZ5->Fill(vz-v->Z());
	  fHist.fZClcVsZCot->Fill(vz,v->Z(),1.);

	  fHist.fDeltaZ5->Fill(vzw-v->Z());
	  fHist.fZClcVsZCot->Fill(vzw,v->Z(),1.);
	}
      }
    }
  }
    
  fHist.fNHitsM01->Fill ((float) m0->NTdcHits    (),(float) m1->NTdcHits    ());
  fHist.fNHitChM01->Fill((float) m0->NHitChannels(),(float) m1->NHitChannels());
      
  return 0;			       
}


//_____________________________________________________________________________
int TClcAnaModule::EndJob() {
  printf("----- end job: ---- %s\n",GetName());
  return 0;
}


//_____________________________________________________________________________
void TClcAnaModule::FitT0() {

  if (fHist.fFitT0) {
    delete fHist.fFitT0;
    delete fHist.fFitSigma;
    delete fHist.fFitChi2;
    delete fHist.fFitDeltaTime;
    delete fHist.fFitDeltaTdc2;
  }

  fHist.fFitT0        = new TH1F("h_clc_fit_t0","CLC: relative delays",100,0,100);
  fHist.fFitSigma     = new TH1F("h_clc_fit_width","CLC: width ",100,0,100);
  fHist.fFitChi2      = new TH1F("h_clc_fit_chi2","CLC: chi2",100,0,100);

  fHist.fFitDeltaTime = new TH1F("h_clc_fit_t1","CLC: relative delays",100,0,100);
  fHist.fFitDeltaTdc2 = new TH1F("h_clc_fit_t2","CLC: relative delays",100,-5,5);

  for (int i=0; i<96; i++) {
    fHist.fDeltaTdc [i]->Fit("gaus","q0","");
    fHist.fDeltaTime[i]->Fit("gaus","q0","");
  }

  TF1* f;
  for (int i=0; i<96; i++) {
    f = fHist.fDeltaTdc[i]->GetFunction("gaus");
    
    fHist.fFitT0->SetBinContent(i+1,f->GetParameter(1));
    fHist.fFitT0->SetBinError(i+1,f->GetParError(1));

    fHist.fFitSigma->SetBinContent(i+1,f->GetParameter(2));
    fHist.fFitSigma->SetBinError(i+1,f->GetParError(2));

    fHist.fFitChi2->SetBinContent(i+1,f->GetChisquare());

    f = fHist.fDeltaTime[i]->GetFunction("gaus");
    
    fHist.fFitDeltaTime->SetBinContent(i+1,f->GetParameter(1));
    fHist.fFitDeltaTime->SetBinError(i+1,f->GetParError(1));

    fHist.fFitDeltaTdc2->Fill(f->GetParameter(1));

  }
}

//_____________________________________________________________________________
void TClcAnaModule::PrintT0FitResults() {
//-----------------------------------------------------------------------------
//  print results - want it to be done as a separate step
//-----------------------------------------------------------------------------
  for (int i=0; i<6; i++) {
    printf("----------------------------------------------------------------------\n");
    printf("ch#      A0    sig(A0)      T0   sig(T0)     Sig      sig(Sig)  chi**2\n");
    printf("----------------------------------------------------------------------\n");
    for (int j=16*i; j<16*(i+1); j++) {

					// print the fit parameters

      TF1* f = fHist.fDeltaTdc[j]->GetFunction("gaus");

      if (f) {
	printf (" %2i  %8.3f %8.3f  %8.3f %8.3f  %8.3f  %8.3f %8.3f \n",
		j, 
		(float) f->GetParameter(0), (float) f->GetParError(0),
		(float) f->GetParameter(1), (float) f->GetParError(1),
		(float) f->GetParameter(2), (float) f->GetParError(2),
		(float) f->GetChisquare());
      }
      else {
	printf(" %2i fit error\n",j);
      }
    }
  }
}