Beispiel #1
0
def runbetaeta(Epn, height, fit="linear"):
	gamma = (Epn/nucleonmass) + 1
	beta = math.sqrt(1 - (1/gamma**2))
	
	if fit == "linear":	
		refractiveindex = atm.runindex(height)
	elif fit == "exp":
		refractiveindex = atm.expindex(height)
	
	return beta, refractiveindex
Beispiel #2
0
def runtheta(Epn, height, fit="linear"):
	
	gamma = (Epn/nucleonmass) + 1
	beta = math.sqrt(1 - (1/gamma**2))
	
	if fit == "linear":	
		refractiveindex = atm.runindex(height)
	elif fit == "exp":
		refractiveindex = atm.expindex(height)
	
	
	costheta = 1/(beta*refractiveindex)
	
	if costheta < 1:	
		theta=math.acos(costheta)
	else:
		theta=0
		
	return theta
	
	h = 120000
	
	heights = []
	ris = []
	linears=[]
	
	currentN=0
	
	while h > height:
		h += -deltah
		
		beta, ri = cr.runbetaeta(Epn, h, fit="exp")
		heights.append(h)
		ris.append(ri-1)
		linearri=atm.runindex(h)
		linears.append(linearri - 1)
		
		if float(beta) > (float(1)/float(ri)):
			radius, theta = cr.run(Epn, h, sinphi=1, fit="exp")
			
			n = scaling*(math.sin(theta)**2)
			
			DeltaE = (10**-9)*(n*2.74)/56.
			
			oldradius, oldtheta = cr.run(Epn, h+deltah, sinphi=1, fit="exp")
			
			deltar =  float(radius)- float(oldradius)
			
			area= math.pi * ((radius**2) -(oldradius**2))
			
def min(a, gridwidth, eff, phi, epsilon, detections):
    def f(x, y, Z, Epn, height):
        sum = 0
        for detection in a:
            x0 = float(detection[0])
            y0 = float(detection[1])
            count = float(detection[2])
            bkgcount = float(detection[3])
            category = detection[4]
            sum += ll.run(x, y, Epn, Z, height, x0, y0, count, bkgcount,
                          category, eff, phi, epsilon)
        return sum

    #Runs Minimisation and outputs results

    startpos = [0, 0, 26.0, 1000, 30000]
    argumentx = "limit_x = (-300, 300), error_x = 100000, "
    argumenty = "limit_y = (-300, 300), error_y = 100000, "
    argumentZ = "fix_Z=True, "
    argumentE = "limit_Epn = (232, 4000), error_Epn=1000, "
    argumentheight = "limit_height = (17500, 70000), error_height=(100000), "
    argumenterror = "print_level=0, errordef = 100"

    m = eval("Minuit(f, x=" + str(startpos[0]) + ", " + argumentx + "y=" +
             str(startpos[1]) + ", " + argumenty + "Epn = " +
             str(startpos[3]) + ", " + argumentE + "Z=" + str(startpos[2]) +
             "," + argumentZ + "height = " + str(startpos[4]) + ", " +
             argumentheight + argumenterror + ")")
    m.migrad()
    params = m.values
    guess = [
        params['x'], params['y'], params['Epn'], params['Z'], params['height']
    ]
    guessfval = m.fval

    xsites = np.linspace(-150, 150, int(gridwidth))
    ysites = np.linspace(-150, 150, int(gridwidth))

    eraw = np.linspace(0, 1, num=3)
    R = eraw * 0.0178
    evals = ((1.7 * R / 321) + (3571**-1.7))**(-1 / 1.7)
    hvals = np.linspace(20000, 30000, num=3)
    hvals = [25000]

    zvalues = np.arange(20., 33.)

    minangle = 0.0
    j = 0

    while j < 5:
        coordinates = []
        j = 0
        minangle += 0.1
        for x in xsites:
            for y in ysites:
                n = 0

                for detection in a:
                    x0 = float(detection[0])
                    y0 = float(detection[1])
                    recordeddangle = float(detection[5])

                    dangle = ce.dangle(x0, y0, x, y)

                    if math.fabs(dangle -
                                 recordeddangle) < math.radians(minangle):
                        n += 1

                if n > (len(a) - 1):
                    coordinates.append([x, y])
                    j += 1
        if minangle > 20:
            j = 10

    ehvals = []
    for height in hvals:
        for Epn in evals:
            ri = atm.runindex(height)
            Ethreshold = float(cr.runemin(ri))
            if float(Epn) > float(Ethreshold):
                ehvals.append([Epn, height])

    xycount = len(coordinates)
    ehcount = len(ehvals)
    zcount = len(zvalues)
    line = [0, 0]

    #~ rg = guess
    #~ rf = guessfval

    print detections, "Detections -> ", xycount, "Valid Core Positions (", minangle, "Degrees from recorded axis)", ehcount, "Valid Height/Epn Combinations", zcount, "Charge Values", xycount * ehcount * zcount, "Total Minimisations"

    for z in zvalues:

        m = eval("Minuit(f, x=" + str(startpos[0]) + ", " + argumentx + "y=" +
                 str(startpos[1]) + ", " + argumenty + "Epn = " +
                 str(startpos[3]) + ", " + argumentE + "Z=" + str(z) + "," +
                 argumentZ + "height = " + str(startpos[4]) + ", " +
                 argumentheight + argumenterror + ")")
        m.migrad(resume=False)
        params = m.values
        zguess = [
            params['x'], params['y'], params['Epn'], params['Z'],
            params['height']
        ]
        zguessfval = m.fval

        for [x, y] in coordinates:
            for [e, h] in ehvals:
                m = eval("Minuit(f,  " + "Epn=" + str(e) + ", " + argumentE +
                         "height = " + str(h) + ", " + argumentheight + "Z=" +
                         str(z) + "," + argumentZ + "x=" + str(x) + ", " +
                         argumentx + "y=" + str(y) + ", " + argumenty +
                         argumenterror + ")")
                m.migrad(resume=False)
                params = m.values
                fval = m.fval
                values = m.get_fmin()
                if fval < zguessfval:
                    if values.is_valid:
                        zguess = [
                            params['x'], params['y'], params['Epn'],
                            params['Z'], params['height']
                        ]
                        zguessfval = fval
                        #~ print zguess, "(", zguessfval, ") Valid!"
                    #~ elif fval < rf:
                    #~ rf = fval
                    #~ rg = [params['x'], params['y'], params['Epn'], params['Z'], params['height']]
                    #~ print rg, "(", rf, ") Rejected!"

        print time.asctime(time.localtime()), zguess, "(", zguessfval, ")"
        #~ print rg, "(", rf, ") Rejected!"

        if zguessfval < guessfval:
            guess = zguess
            guessfval = zguessfval

    print "Final guess is", guess, math.degrees(phi), math.degrees(
        epsilon), "(", guessfval, ")"
    return guess[0], guess[1], guess[2], guess[3], guess[4], guessfval
def min(a, gridwidth, eff, phi, epsilon, detections):
	
	def f(x,y,Z,Epn, height):
		sum = 0
		for detection in a:
			x0 = float(detection[0])
			y0 = float(detection[1])
			count = float(detection[2])
			bkgcount = float(detection[3])
			category = detection[4]
			sum += ll.run(x,y,Epn,Z, height, x0,y0, count, bkgcount, category, eff, phi, epsilon)
		return sum

	
	#Runs Minimisation and outputs results
	
	startpos=[0, 0, 26.0, 1000, 30000]
	argumentx = "limit_x = (-300, 300), error_x = 100000, "
	argumenty = "limit_y = (-300, 300), error_y = 100000, "
	argumentZ = "fix_Z=True, "
	argumentE = "limit_Epn = (232, 4000), error_Epn=1000, "
	argumentheight = "limit_height = (17500, 70000), error_height=(100000), "
	argumenterror = "print_level=0, errordef = 100"

	m = eval("Minuit(f, x="+ str(startpos[0]) + ", " + argumentx + "y="+ str(startpos[1]) + ", " + argumenty+ "Epn = "+ str(startpos[3]) + ", " + argumentE + "Z=" + str(startpos[2]) + "," +argumentZ + "height = " + str(startpos[4]) + ", " + argumentheight + argumenterror + ")")
	m.migrad()
	params = m.values
	guess = [params['x'], params['y'], params['Epn'], params['Z'], params['height']]
	guessfval = m.fval

	xsites = np.linspace(-150, 150, int(gridwidth))
	ysites = np.linspace(-150, 150, int(gridwidth))
	
	eraw = np.linspace(0, 1, num=3)
	R = eraw*0.0178
	evals = ((1.7*R/321)+(3571**-1.7))**(-1/1.7)
	hvals = np.linspace(20000, 30000, num=3)
	hvals = [25000]
	
	zvalues = np.arange(20.,33.)
	
	minangle = 0.0
	j = 0
	
	while j < 5:
		coordinates = []
		j = 0
		minangle += 0.1
		for x in xsites:
				for y in ysites:
						n=0
						
						for detection in a:
							x0 = float(detection[0])
							y0 = float(detection[1])
							recordeddangle = float(detection[5])
							
							dangle = ce.dangle(x0, y0, x, y)
							
							if math.fabs(dangle - recordeddangle) < math.radians(minangle):
								n+=1
							
						if n > (len(a)-1):
							coordinates.append([x,y])
							j+=1
		if minangle > 20:
			j=10
							
	ehvals=[]
	for height in hvals:
		for Epn in evals:
			ri = atm.runindex(height)
			Ethreshold = float(cr.runemin(ri))
			if float(Epn) > float(Ethreshold):
				ehvals.append([Epn, height])
	
	xycount = len(coordinates)			
	ehcount = len(ehvals)
	zcount = len(zvalues)
	line = [0,0]
	
	#~ rg = guess
	#~ rf = guessfval
		
	print detections, "Detections -> ", xycount, "Valid Core Positions (", minangle, "Degrees from recorded axis)", ehcount, "Valid Height/Epn Combinations", zcount, "Charge Values", xycount*ehcount*zcount, "Total Minimisations"
	
	for z in zvalues:
		
		m = eval("Minuit(f, x="+ str(startpos[0]) + ", " + argumentx + "y="+ str(startpos[1]) + ", " + argumenty+ "Epn = "+ str(startpos[3]) + ", " + argumentE + "Z=" + str(z) + "," +argumentZ + "height = " + str(startpos[4]) + ", " + argumentheight + argumenterror + ")")
		m.migrad(resume=False)
		params = m.values
		zguess = [params['x'], params['y'], params['Epn'], params['Z'], params['height']]
		zguessfval = m.fval
		
		for [x, y] in coordinates:							
				for [e, h] in ehvals:
					m = eval("Minuit(f,  " + "Epn=" + str(e) + ", " + argumentE + "height = " + str(h) + ", " + argumentheight + "Z=" + str(z) + "," +argumentZ + "x="+ str(x) + ", " + argumentx + "y="+ str(y) + ", " + argumenty+ argumenterror + ")")
					m.migrad(resume=False)
					params = m.values
					fval = m.fval
					values = m.get_fmin()
					if fval < zguessfval:
						if values.is_valid:
							zguess = [params['x'], params['y'], params['Epn'], params['Z'], params['height']]
							zguessfval = fval
							#~ print zguess, "(", zguessfval, ") Valid!" 
						#~ elif fval < rf:
							#~ rf = fval
							#~ rg = [params['x'], params['y'], params['Epn'], params['Z'], params['height']]
							#~ print rg, "(", rf, ") Rejected!"
							
							
		
		print time.asctime(time.localtime()), zguess, "(", zguessfval, ")"
		#~ print rg, "(", rf, ") Rejected!"
		
		if zguessfval < guessfval:
			guess = zguess
			guessfval = zguessfval
	
	print "Final guess is", guess, math.degrees(phi), math.degrees(epsilon), "(", guessfval, ")"
	return guess[0], guess[1], guess[2], guess[3], guess[4], guessfval
Beispiel #6
0
def min(fullsimulation, layout, gridwidth, raweff):
	measured = fullsimulation.detected
	true = fullsimulation.true

	def full(x,y, Epn):
		energy = 56*Epn
		testevent = event(x, y, measured.epsilon, energy, 26, 25000, measured.phi, N=56, layout=layout, smear=False)
		testevent.simulatetelescopes(raweff)
		testevent.calculatefulllikelihood(measured)
		ll = testevent.minusllfull
		#~ print "x", x, "y", y, "Epn", Epn, "ll", ll
		return ll

	#Runs Minimisation and outputs results
	
	fullstartpos=[0, 0, 1000, 20000]
	argumentx = "limit_x = (-300, 300), error_x = 100000, "
	argumenty = "limit_y = (-300, 300), error_y = 100000, "
	argumentZ = "limit_Z = (16,36), error_Z = 2, "
	argumentheight = "limit_height = (15000, 65000), error_height=(100000), "
	argumentE = "limit_Epn = (232, 4000), error_Epn=1000, "
	argumenterror = "print_level=0, errordef = 100"

	m = eval("Minuit(full, x="+ str(fullstartpos[0]) + ", " + argumentx + "y="+ str(fullstartpos[1]) + ", " + argumenty+ "Epn = "+ str(fullstartpos[2]) + ", " + argumentE + argumenterror + ")")
	m.migrad()
	guessparams = m.values
	guessfval = m.fval

	xsites = np.linspace(-150, 150, 300)
	ysites = np.linspace(-150, 150, 300)
	
	eraw = np.linspace(0, 1, num=50)
	R = eraw**3.01*(10**-3)
	evals =	((1.7*R/321)+(2411**-1.7))**(-1/1.7)
	
	minangle = 0.0
	j = 0
	#~ 
	while j < 20:
		coordinates = []
		j = 0
		minangle += 0.1
		for x in xsites:
				for y in ysites:
						n=0
						for tel in measured.telescopes:
							newdangle = ce.dangle(tel.x,tel.y, x, y)
							
							if math.fabs(newdangle - tel.dangle) < math.radians(minangle):
								n+=1
							
						if n > (len(measured.telescopes)-1):
							coordinates.append([x,y])
							j+=1
		if minangle > 20:
			j=200
		#~ 
	for [x, y] in coordinates:							
			for e in evals:
				m = eval("Minuit(full,  " + "Epn=" + str(e) + ", " + argumentE + "x="+ str(x) + ", " + argumentx + "y="+ str(y) + ", " + argumenty+ argumenterror + ")")
				m.migrad(resume=False)
				params = m.values
				fval = m.fval
				values = m.get_fmin()
				if fval < guessfval:
					if values.is_valid:
						guessparams = params
						guessfval = fval						
	
	print "Final guess is", guessparams, "(", guessfval, ")"
	print "Measured values are", [measured.rayxpos, measured.rayypos, measured.epn], "(", true.minusllfull, ")", true.fullmultiplicity
	
	fullreconx = guessparams['x']
	fullrecony = guessparams['y']
	reconEpn = guessparams['Epn']
	
	def dc(Z,height, x, y):
		energy = 56*reconEpn
		testevent = event(x, y, measured.epsilon, energy, Z, height, measured.phi, N=56, layout=layout, smear=False)
		testevent.simulatetelescopes(raweff)
		testevent.calculatedclikelihood(measured)
		testevent.calculatefulllikelihood(measured)
		if math.fabs(Z-26) > 10:
			print "x", x, "y", y, "Height", height, "Z", Z,   
		ll = testevent.minuslldc
		if math.fabs(Z-26) > 10:
			print "ll1",ll, 
		ll += testevent.minusllfull
		if math.fabs(Z-26) > 10:
			print "ll2", ll
		return ll

	xsites = np.linspace(-150, 150, int(gridwidth))
	ysites = np.linspace(-150, 150, int(gridwidth))
	
	eraw = np.linspace(0, 1, num=3)
	R = eraw*0.0178
	evals = ((1.7*R/321)+(3571**-1.7))**(-1/1.7)
	hvals = np.linspace(20000, 30000, num=3)
	
	zvalues = np.arange(20.,33.)
	
	minangle = 0.0
	j = 0
							
	ehvals=[]
	for height in hvals:
		for Epn in evals:
			ri = atm.runindex(height)
			Ethreshold = float(cr.runemin(ri))
			if float(Epn) > float(Ethreshold):
				ehvals.append([Epn, height])
	#~ 
	xycount = len(coordinates)			
	ehcount = len(ehvals)
	zcount = len(zvalues)
	line = [0,0]
	
	print ehvals
		
	print measured.DCmultiplicity, "Detections -> "
	print xycount, "Valid Core Positions (", minangle, "Degrees from recorded axis)", ehcount, "Valid Height/Epn Combinations", zcount, "Charge Values", xycount*ehcount*zcount, "Total Minimisations"
	
	m = eval("Minuit(dc, x="+ str(fullreconx) + ", " + argumentx + "y="+ str(fullrecony) + ", " + argumenty+  "Z=26," +argumentZ + "height = 20000, " + argumentheight + argumenterror + ")")
	m.migrad(resume=False)
	params = m.values
	guessparams = params
	guessfval = m.fval
	
	for z in zvalues:					
		for h in hvals:
			for [x, y] in coordinates:
				m = eval("Minuit(dc,  x="+ str(x) + ", " + argumentx + "y="+ str(y) + ", " + argumenty+  "height = " + str(h) + ", " + argumentheight + "Z=" + str(z) + "," +argumentZ + argumenterror + ")")
				m.migrad(resume=False)
				params = m.values
				fval = m.fval
				values = m.get_fmin()
				if fval < guessfval:
					if values.is_valid:							
						if fval < guessfval:
							guessparams = params
							guessfval = fval
	
	print "Final guess is", guessparams, math.degrees(measured.phi), math.degrees(measured.epsilon), "(", guessfval, ")"
	
	reconZ = guessparams["Z"]
	reconheight = guessparams["height"]
	reconx = guessparams["x"]
	recony = guessparams["y"]
	
	energy = reconEpn*56
	print "Recon", [reconx, recony, reconEpn, reconZ, reconheight]
	print "True", [true.rayxpos, true.rayypos, true.epn, true.Z, true.height]
	fullsimulation.reconstructed = event(reconx, recony, measured.epsilon, energy, reconZ, reconheight, measured.phi, N=56, layout=layout, smear=False)
	fullsimulation.reconstructed.simulatetelescopes(raweff)
	fullsimulation.getreconstructedlikelihood()
	fullsimulation.reconstructed.fullrayxpos = fullreconx
	fullsimulation.reconstructed.fullrayypos = fullrecony
def min(fullsimulation, layout, gridwidth, raweff):
    measured = fullsimulation.detected
    true = fullsimulation.true

    def full(x, y, Epn):
        energy = 56 * Epn
        testevent = event(x, y, measured.epsilon, energy, 26, 25000, measured.phi, N=56, layout=layout, smear=False)
        testevent.simulatetelescopes(raweff)
        testevent.calculatefulllikelihood(measured)
        ll = testevent.minusllfull
        # ~ print "x", x, "y", y, "Epn", Epn, "ll", ll
        return ll

        # Runs Minimisation and outputs results

    fullstartpos = [0, 0, 1000, 20000]
    argumentx = "limit_x = (-300, 300), error_x = 100000, "
    argumenty = "limit_y = (-300, 300), error_y = 100000, "
    argumentZ = "limit_Z = (16,36), error_Z = 2, "
    argumentheight = "limit_height = (15000, 65000), error_height=(100000), "
    argumentE = "limit_Epn = (232, 4000), error_Epn=1000, "
    argumenterror = "print_level=0, errordef = 100"

    m = eval(
        "Minuit(full, x="
        + str(fullstartpos[0])
        + ", "
        + argumentx
        + "y="
        + str(fullstartpos[1])
        + ", "
        + argumenty
        + "Epn = "
        + str(fullstartpos[2])
        + ", "
        + argumentE
        + argumenterror
        + ")"
    )
    m.migrad()
    guessparams = m.values
    guessfval = m.fval

    xsites = np.linspace(-150, 150, 300)
    ysites = np.linspace(-150, 150, 300)

    eraw = np.linspace(0, 1, num=50)
    R = eraw ** 3.01 * (10 ** -3)
    evals = ((1.7 * R / 321) + (2411 ** -1.7)) ** (-1 / 1.7)

    minangle = 0.0
    j = 0
    # ~
    while j < 20:
        coordinates = []
        j = 0
        minangle += 0.1
        for x in xsites:
            for y in ysites:
                n = 0
                for tel in measured.telescopes:
                    newdangle = ce.dangle(tel.x, tel.y, x, y)

                    if math.fabs(newdangle - tel.dangle) < math.radians(minangle):
                        n += 1

                if n > (len(measured.telescopes) - 1):
                    coordinates.append([x, y])
                    j += 1
        if minangle > 20:
            j = 200
            # ~
    for [x, y] in coordinates:
        for e in evals:
            m = eval(
                "Minuit(full,  "
                + "Epn="
                + str(e)
                + ", "
                + argumentE
                + "x="
                + str(x)
                + ", "
                + argumentx
                + "y="
                + str(y)
                + ", "
                + argumenty
                + argumenterror
                + ")"
            )
            m.migrad(resume=False)
            params = m.values
            fval = m.fval
            values = m.get_fmin()
            if fval < guessfval:
                if values.is_valid:
                    guessparams = params
                    guessfval = fval

    print "Final guess is", guessparams, "(", guessfval, ")"
    print "Measured values are", [
        measured.rayxpos,
        measured.rayypos,
        measured.epn,
    ], "(", true.minusllfull, ")", true.fullmultiplicity

    fullreconx = guessparams["x"]
    fullrecony = guessparams["y"]
    reconEpn = guessparams["Epn"]

    def dc(Z, height, x, y):
        energy = 56 * reconEpn
        testevent = event(x, y, measured.epsilon, energy, Z, height, measured.phi, N=56, layout=layout, smear=False)
        testevent.simulatetelescopes(raweff)
        testevent.calculatedclikelihood(measured)
        testevent.calculatefulllikelihood(measured)
        if math.fabs(Z - 26) > 10:
            print "x", x, "y", y, "Height", height, "Z", Z,
        ll = testevent.minuslldc
        if math.fabs(Z - 26) > 10:
            print "ll1", ll,
        ll += testevent.minusllfull
        if math.fabs(Z - 26) > 10:
            print "ll2", ll
        return ll

    xsites = np.linspace(-150, 150, int(gridwidth))
    ysites = np.linspace(-150, 150, int(gridwidth))

    eraw = np.linspace(0, 1, num=3)
    R = eraw * 0.0178
    evals = ((1.7 * R / 321) + (3571 ** -1.7)) ** (-1 / 1.7)
    hvals = np.linspace(20000, 30000, num=3)

    zvalues = np.arange(20.0, 33.0)

    minangle = 0.0
    j = 0

    ehvals = []
    for height in hvals:
        for Epn in evals:
            ri = atm.runindex(height)
            Ethreshold = float(cr.runemin(ri))
            if float(Epn) > float(Ethreshold):
                ehvals.append([Epn, height])
                # ~
    xycount = len(coordinates)
    ehcount = len(ehvals)
    zcount = len(zvalues)
    line = [0, 0]

    print ehvals

    print measured.DCmultiplicity, "Detections -> "
    print xycount, "Valid Core Positions (", minangle, "Degrees from recorded axis)", ehcount, "Valid Height/Epn Combinations", zcount, "Charge Values", xycount * ehcount * zcount, "Total Minimisations"

    m = eval(
        "Minuit(dc, x="
        + str(fullreconx)
        + ", "
        + argumentx
        + "y="
        + str(fullrecony)
        + ", "
        + argumenty
        + "Z=26,"
        + argumentZ
        + "height = 20000, "
        + argumentheight
        + argumenterror
        + ")"
    )
    m.migrad(resume=False)
    params = m.values
    guessparams = params
    guessfval = m.fval

    for z in zvalues:
        for h in hvals:
            for [x, y] in coordinates:
                m = eval(
                    "Minuit(dc,  x="
                    + str(x)
                    + ", "
                    + argumentx
                    + "y="
                    + str(y)
                    + ", "
                    + argumenty
                    + "height = "
                    + str(h)
                    + ", "
                    + argumentheight
                    + "Z="
                    + str(z)
                    + ","
                    + argumentZ
                    + argumenterror
                    + ")"
                )
                m.migrad(resume=False)
                params = m.values
                fval = m.fval
                values = m.get_fmin()
                if fval < guessfval:
                    if values.is_valid:
                        if fval < guessfval:
                            guessparams = params
                            guessfval = fval

    print "Final guess is", guessparams, math.degrees(measured.phi), math.degrees(measured.epsilon), "(", guessfval, ")"

    reconZ = guessparams["Z"]
    reconheight = guessparams["height"]
    reconx = guessparams["x"]
    recony = guessparams["y"]

    energy = reconEpn * 56
    print "Recon", [reconx, recony, reconEpn, reconZ, reconheight]
    print "True", [true.rayxpos, true.rayypos, true.epn, true.Z, true.height]
    fullsimulation.reconstructed = event(
        reconx, recony, measured.epsilon, energy, reconZ, reconheight, measured.phi, N=56, layout=layout, smear=False
    )
    fullsimulation.reconstructed.simulatetelescopes(raweff)
    fullsimulation.getreconstructedlikelihood()
    fullsimulation.reconstructed.fullrayxpos = fullreconx
    fullsimulation.reconstructed.fullrayypos = fullrecony