y1, y2 = l.Point(
x1, x2, xd, yd, ml
) #12/02 LENTE PUNTUAL :::DEFAULT: USO FUNCION l.Point (LENTE PUNTUAL)
#+-+-+-+-+-+-+--+-+-DOS LENTES PUNTUALES+-+-+-+-+-+-+-+-+-+-+-+-
elif respuesta == '2P':
ml1 = 1.
ml2 = .1
#Masas de las lentes 1 y 2
x1l1 = 0.75
x2l1 = 0.
#COORDENADAS (X,Y) LENTE 1
x1l2 = 0.75
x2l2 = 0.
#COORDENADAS (X,Y) LENTE 2
y1, y2 = l.TwoPoints(x1, x2, x1l1, x2l1, x1l2, x2l2, ml1, ml2)
#+-+-+-+-+-+-+--+-+-+-+-BINARIAS+-+-+-+-+-+-+-+-+-+-+-+-
elif respuesta == 'BIN':
alpha = 1 #separaciones 'a'
e1 = 1
e2 = 1 - e1
# Razones de masa Mi/M #e1 [0,1]
#Y para que coincida con el centroide:
x1l1 = -e2 * alpha
x2l1 = 0
#COORDENADAS (X,Y) LENTE 1
x1l2 = e1 * alpha
x2l2 = 0.
#COORDENADAS (X,Y) LENTE 2
y1, y2 = l.TwoPoints(x1, x2, x1l1, x2l1, x1l2, x2l2, e1,
def lensing(name):
import lens as l
import source as s
print(nx)
print(n_y)
print(xl)
print(yl)
ys = 2.*yl/(n_y-1.)
# convertimos los parametros de la fuente a pixeles
ipos = int(round(xpos/ys)) # round redondea, en este caso a solo un numero
jpos = int(round(-ypos/ys)) # le pone el menos porque el imshow cambia en el eje y el signo
rpix = int(round(rad/ys))
a = s.gcirc(n_y,rpix,jpos,ipos) # Aqui se ha creado la fuente, esta en pixeles
# ================================================
# print(a)
ny = n_y
# Creamos el plano imagen
# ================ FUENTE ======================
# calculamos el tamanio fisico de los pixeles
xs = 2.*xl/(nx-1.) #El menos 1 es porque esta considerando los centros de los pixeles
ys = 2.*yl/(ny-1.)
b = np.zeros((nx,nx))
# Convertimos los pixeles de la imagenes a coordenadas
for j1 in range(nx):
for j2 in range(nx):
x1 = -xl+j1*xs
x2 = -xl+j2*xs
p = param(name)
# APLICAMOS LA TRANSFORMACION INVERSA
if name == 'Point':
y1,y2 = l.Point(x1,x2,p[0],p[1],p[2])
elif name == 'TwoPoints':
y1, y2 = l.TwoPoints(x1,x2,p[0],p[1],p[2],p[3],p[4],p[5])
elif name == 'ChangRefsdal':
y1,y2 = l.ChangRefsdal(x1,x2,p[0],p[1],p[2],p[3],p[4])
elif name == 'SIS':
y1,y2 = l.SIS(x1,x2,p[0],p[1],p[2])
elif name == 'SISChangRefsdal':
y1,y2 = l.SISChangRefsdal(x1,x2,p[0],p[1],p[2],p[3],p[4])
# CONVERTIMOS LAS COORDENADAS A PIXELES
i1 = int(round((y1+yl)/ys))
i2 = int(round((y2+yl)/ys))
# Vamos a ponerle una condicion para que los pixeles queden dentro de la fuente. En caso contrario les damos un valor arbitrario. Si i1,i2 estan contenidos en el rango (1,n) hacemos asignacion IMAGEN=FUENTE, sino, hacemos IMAGEN=C donde C es una constante arbitraria como por ejemplo el fondo de cielo
if ((i1>=0)&(i1<ny)&(i2>=0)&(i2<ny)):
b[j1,j2]=a[i1,i2]
else:
C = 0 # Esta constante puede ser cualquiera
b[j1,j2]=C
return a,b
from alcock import microlensing
ml1,ml2,x1l1,x2l1,x1l2,x2l2,theta,u0 = microlensing('LMC9')
# Pasamos a tamanio en pixel
for i in yr: # loop sobre todos los rayos
if ((i*100/nx)>=perc): #chequeamos si tenemos completado el perc
perc=perc+perc0
print(round(i*100/nx),"% ")
x1=-xl+y*xs
x2=-xl+x*xs
y1,y2=l.TwoPoints(x1,x2,x1l1,x2l1,x1l2,x2l2,ml1,ml2)
i1=(y1+yl)/ys
i2=(y2+yl)/ys
i1=np.round(i1)
i2=np.round(i2)
ind = (i1>=0)&(i1<ny)&(i2>=0)&(i2<ny)
i1n=i1[ind]
i2n=i2[ind]
for j in range(np.size(i1n)):
b[int(i2n[j]),int(i1n[j])]+=1
y=y+1.0
b=b/raypix
def lensing(name):
import lens as l
import source as s
import img_scale
print(nx)
print(n_y)
print(xl)
print(yl)
if jpg == True:
r, g, bb = s.fitsim(filename, jpg)
ss = r, g, bb
imgb = np.zeros((nx, nx, 3), dtype=np.int32)
imga = np.zeros((r.shape[0], r.shape[1], 3), dtype=np.int32)
else:
ss = s.fitsim(filename, jpg)
imgb = np.zeros((nx, nx, 3), dtype=float)
imga = np.zeros((ss.shape[0], ss.shape[1], 3), dtype=float)
# ================================================
index = 0
for a in ss: #EL PROBLEMA ESTA AQUI, NO PODEMOS USAR UNA IMAGEN Y ESTO A LA VEZ
# print(a)
ny = a[0].size
# Creamos el plano imagen
# ================ FUENTE ======================
# calculamos el tamanio fisico de los pixeles
xs = 2. * xl / (
nx - 1.
) #El menos 1 es porque esta considerando los centros de los pixeles
ys = 2. * yl / (ny - 1.)
b = np.zeros((nx, nx))
# Convertimos los pixeles de la imagenes a coordenadas
for j1 in range(nx):
for j2 in range(nx):
x1 = -xl + j1 * xs
x2 = -xl + j2 * xs
p = param(name)
# APLICAMOS LA TRANSFORMACION INVERSA
if name == 'Point':
y1, y2 = l.Point(x1, x2, p[0], p[1], p[2])
elif name == 'TwoPoints':
y1, y2 = l.TwoPoints(x1, x2, p[0], p[1], p[2], p[3], p[4],
p[5])
elif name == 'ChangRefsdal':
y1, y2 = l.ChangRefsdal(x1, x2, p[0], p[1], p[2], p[3],
p[4])
elif name == 'SIS':
y1, y2 = l.SIS(x1, x2, p[0], p[1], p[2])
elif name == 'SISChangRefsdal':
y1, y2 = l.SISChangRefsdal(x1, x2, p[0], p[1], p[2], p[3],
p[4])
# CONVERTIMOS LAS COORDENADAS A PIXELES
i1 = int(round((y1 + yl) / ys))
i2 = int(round((y2 + yl) / ys))
# Vamos a ponerle una condicion para que los pixeles queden dentro de la fuente. En caso contrario les damos un valor arbitrario. Si i1,i2 estan contenidos en el rango (1,n) hacemos asignacion IMAGEN=FUENTE, sino, hacemos IMAGEN=C donde C es una constante arbitraria como por ejemplo el fondo de cielo
if ((i1 >= 0) & (i1 < ny) & (i2 >= 0) & (i2 < ny)):
b[j1, j2] = a[i1, i2]
else:
C = 1. # Esta constante puede ser cualquiera
b[j1, j2] = C
imgb[:, :, index] = b
imga[:, :, index] = a
# index +=1
# imgb = img_scale.sqrt(b,scale_min=b.min(),scale_max=b.max()+50)
#imga = img_scale.sqrt(a,scale_min=a.min(),scale_max=a.max()+50)
index += 1
return imga, imgb