import ROOT,sys,os,time,math,array
pandapath=os.environ.get('PANDAPATH')
sys.path.append(pandapath+'/macro/tpc/FOPI/python/argparse-1.2.1')
sys.path.append(pandapath+'/macro/tpc/FOPI/mberger')
import glob,math,argparse,ROOT
from functions import set_palette,openTree,thisIsTheEnd
from calibCluster import calibCluster
from pyFCNClusterCalib import pyFCNClusterCalib
from array import array

parser=argparse.ArgumentParser(description='calibrate parametrization of cluster error')
parser.add_argument('recofile',help='the reco file',type=str)
parser.add_argument('--runs',help='if data, the runs to use (3888)',type=str,default='')
parser.add_argument('--pattern',help='if data the file name patters ('')',type=str,default='')
parser.add_argument('--events',help='number of events to process (1000)',type=int,default=1000)
args=parser.parse_args()

ROOT.gROOT.ProcessLine(".x rootlogon.C") 
ROOT.gROOT.ProcessLine('gROOT->SetStyle("Plain")')
ROOT.gROOT.LoadMacro("stlPYROOT.h+")
set_palette()


tree=openTree(args.recofile,args.runs,args.pattern)

tree.SetBranchStatus("*",0)
tree.SetBranchStatus("CutCosmics.*",1)

#first create the new tree to work with
calibClusters=[]
ev=-1
'''
print 'collecting cluster'
for e in tree:
    ev+=1
    if ev>args.events:
        break
    for tr in e.CutCosmics:
        calibClusters.append(calibCluster())
        for icl in range(tr.nhits()):
            calibClusters[-1].setPlane(tr.GetMidPlaneO(icl), tr.GetMidPlaneU(icl), tr.GetMidPlaneV(icl))
            digipos=tr.GetDigiPos(icl)
            digiamp=tr.GetDigisOnPlaneAmp(icl)
            for idi in range(len(digipos)):
                calibClusters[-1].addDigi(digipos[idi],digiamp[idi])
'''
for i in range(100):
    calibClusters.append(calibCluster())
print 'start calibration'

             
"""
fitter = ROOT.Fit.Fitter()
fitter.Config().MinimizerOptions().SetMinimizerType("Minuit2")
#fitter.Config().MinimizerOptions().SetMinimizerAlgorithm("Simplex")
#fitter.Config().MinimizerOptions().SetMinimizerAlgorithm("Minimize")
fitter.Config().MinimizerOptions().SetMinimizerAlgorithm("Migrad")
fitter.Config().MinimizerOptions().SetPrintLevel(6)          
#fitter.Config().MinimizerOptions().SetMaxFunctionCalls(2)    
#fitter.Config().MinimizerOptions().SetMaxIterations(2)      
params=array('d',[1.,3.])
psteps=array('d',[1.,1.])
fitter.Config().SetParamsSettings(2,params,psteps)
#fitter.Config().ParSettings(0).ParameterSettings("offset",2.,2.)
fitter.Config().ParSettings(0).SetStepSize(1.)
print fitter.Config().ParSettings(0).StepSize()
fitter.Config().ParSettings(1).Set("slope",3.,3.)
"""

calibFCN=pyFCNClusterCalib()
calibFCN.setCalibClusterArray(calibClusters)
calibFCN.setStartParams([1,3,2])
calibFCN.setFitGauss(False)
fcnData=calibFCN.getFakeData()
fcnBinned,bw,dr=calibFCN.binData(fcnData[2])

def fcn(npar, gin, f, par, iflag):
    f[0]=calibFCN.DoEval(par)

finalPars = []
finalParsErr = []

gMinuit = ROOT.TMinuit(3)
gMinuit.SetFCN(fcn)

#minuit errors for parameter
arglist = array('d', 3*[1])
ierflg = ROOT.Long(0)

#arglist[0] = 1
gMinuit.mnexcm("SET ERR", arglist ,3,ierflg)

# Set initial parameter values for fit
vstart = array( 'd', (1, 3, 2) )
# Set step size for fit
step =   array( 'd', (100, 10, 10) )

# Define the parameters for the fit
gMinuit.mnparm(0, "offset",  vstart[0], step[0], 0,0,ierflg)
gMinuit.mnparm(1, "slope" ,  vstart[1], step[1], 0,0,ierflg)
gMinuit.mnparm(2, "gauss" ,  vstart[2], step[2], 0,0,ierflg)

#gMinuit.mnfixp(0,ierflg)
#gMinuit.mnfixp(0,ierflg)

arglist[0] = 60000 # Number of calls to FCN before giving up. 
arglist[1] = 0.1  # Tolerance
gMinuit.mnexcm("MIGRAD", arglist ,3,ierflg)
print 'first iteration complete'
calibFCN.setFitOffset(False)
calibFCN.setFitSlope(False)
gMinuit.mnexcm("MIGRAD", arglist ,3,ierflg)

calibFCN.writeTuple()

gMinuit.mncuve()
amin, edm, errdef = ROOT.Double(0.18), ROOT.Double(0.19),ROOT.Double(0.20)
nvpar, nparx, icstat = ROOT.Long(1), ROOT.Long(2), ROOT.Long(3)
gMinuit.mnstat(amin,edm,errdef,nvpar,nparx,icstat);

gMinuit.mnprin(3,amin);
  
dumx, dumxerr = ROOT.Double(0),ROOT.Double(0)
for i in range(0,3):
    gMinuit.GetParameter(i,dumx, dumxerr)
    finalPars.append(float(dumx))
    finalParsErr.append(float(dumxerr))

print "A:\t", finalPars[0], "+/-", finalParsErr[0]
print "B:\t", finalPars[1], "+/-", finalParsErr[1]
print "C:\t", finalPars[2], "+/-", finalParsErr[2]

#print calibFCN.DoEval([2,4])
#print calibFCN.DoEval([1,3])
#print calibFCN.DoEval([0,0])
#print 'done thingy'
fcnData2=calibFCN.getFakeData()
fcnBinned2,bw2,dr2=calibFCN.binData(fcnData2[2])
#print bw,bw2,dr,dr2
#fitter.FitFCN(calibFCN)#,params)
#result=fitter.Result()
#params_result=result.GetParams()
#print 'stepsize:',fitter.Config().ParSettings(0).StepSize()
#print 'result:',params_result[0],params_result[1]
hist=ROOT.TH2D('datahist','data',100,0,100,1000,-500,500)
hist2=ROOT.TH2D('datahist2','data2',100,0,100,1000,-500,500)
#print fcnData
for i in range(len(fcnData)):
    for point in fcnData[i]:
        hist.Fill(i,point)
    for point in fcnData2[i]:
        #print point
        hist2.Fill(i,point)
        
hist_binned=ROOT.TH1D('binned','binned',calibFCN.histbins,0,calibFCN.histbins)
hist_binned2=ROOT.TH1D('binned2','binned2',calibFCN.histbins,0,calibFCN.histbins)
for i in range(calibFCN.histbins):
    #print i,fcnBinned[i]
    hist_binned.Fill(i,fcnBinned[i])
    hist_binned2.Fill(i,fcnBinned2[i])
    
histg=ROOT.TH1D('hg','gaus',40,-2,2)
i=-2
while i<2:
    histg.Fill(i,calibFCN.getGausExpected(i,2))
    i+=0.1
    
canvas=ROOT.TCanvas('c','c',1000,1000)
canvas.Divide(2,2)
canvas.cd(1)
hist.Draw()
hist2.SetLineColor(2)
hist2.SetMarkerColor(2)
hist2.Draw('same')
canvas.cd(2)
hist_binned.Draw()
hist_binned2.SetLineColor(2)
hist_binned2.Draw("same")
canvas.cd(3)
histg.Draw()

thisIsTheEnd()