def gentable(phouts, formato='commented_header', tabesq='imagen', path=None):
'''
Dado uno o más archivos output de la tarea phot de IRAF, con extensión
",phot" y la apertura de los radios de las isofotas genera un objeto Table
de astropy y devuelve uno o más archivos de salida en formato ascii.
Si se ingresan varias tablas phot tendrá que ser en formato de filelist.
Se deberá ingresar cómo quiere que se organicen las tablas, si es una tabla
por imagen (cada fila una estrella, con sus radios de apertura) o una tabla
por estrella por imagen (cada fila un radio de apertura).
INPUT
phouts : Archivo .phot o lista de archivos .phot
(path) : camino al phouts.
(formato) : formato de astropy.io.ascii., por defecto usa
"commented_header"
(tabfiles) : Esquema de generación de tablas. Por defecto, usa "imagen"
'''
if path is not None:
originalpath = aux.chdir(path, save=True)
formato = aux.default(formato, 'commented_header')
tabesq = aux.default(tabesq, 'imagen')
if tabesq == 'estrella':
tablestars(phouts, formato)
elif tabesq == 'imagen':
tablesimg(phouts, formato)
print(Fore.RED + 'Tablas completas')
if path is not None:
aux.chdir(originalpath)
def filtersep2(images,field=None,path=None):
field=aux.default(field,'FILTER02')
imagesl='@'+images
if path is not None: # moves to path, saves working directory
originalpath=aux.chdir(path,save=True)
listafull = aux.hselect(imagesl,field)
imagelist= np.genfromtxt(images,dtype=None)
if field == 'FILTER02':
j=0
filt=[]
for x in listafull:
var=str(x)[-2]
if var == 'e' :
filt.append('U')
aux.hedit(imagelist[j],fields="FILTNEW",value='U')
else:
filt.append(var)
aux.hedit(imagelist[j],fields="FILTNEW",value=var)
j=j+1
else:
filt=[]
j=0
for x in listafull:
filt.append(x)
aux.hedit(imagelist[j],fields='FILTNEW',value=x)
j=j+1
filt1=np.unique(filt)
listadearchivos=[]
for f in filt1:
filterfile=os.path.splitext(images)[0]+f+'.in'
aux.rm(filterfile)
listadearchivos.append(filterfile)
h=open(filterfile,'w+')
# para cada imagen
for im in imagelist:
#agarra el filtro
x=aux.hselect(im,"FILTNEW")
if x[0].strip() in f: # lo compara con el filtro que estoy buscando
print >> h, im # si es igual lo guarda en la lista
h.close()
if path is not None:
aux.chdir(originalpath)
return filt1,listadearchivos
def flatw(filters,
listobj,
path=None,
mastbia=None,
dark=False,
mastdark=None,
area=None,
sec=None):
'''
Dada una lista con los flats por filtro, realiza el masterflat en cada
filtro de dicha lista.
INPUT
filters : Lista de filtros.
listobj : Lista de flats por filtro.
(path) : Carácteres que indica el camino a flatlist.
(mastbia) : Archivo que contiene el masterbias. Por defecto usa
"Zero.fits" y toma el mismo path que el flatlist.
(Dark) : Si es verdadero, corrije por Dark.
(mastdark) : Archivo que contiene el masterdark. Por defecto usa
"Dark.fits" y toma el mismo path que el flatlist.
---------------------------------------
Given a list of flats per filter, generates the masterflat for each image
in said filtered set.
INPUT
filters : Filter list.
listobj : Flat per filter list.
(path) : String that indicates the path to flatlist.
(mastbia) : File that contains the masterbias. If none uses
(Dark) : If true, apply Dark correction.
"Zero.fits" and always use the same path as flatlist.
(mastdark) : File that contains the msaterdark. If none uses
"Dark.fits" and always use the same path as flatlist.
'''
if path is not None:
originalpath = aux.chdir(path, save=True)
i = 0
aux.rm('mflatlist.in')
f = open('mflatlist.in', 'w+')
for x in filters:
outfile = os.path.splitext(listobj[i])[0] + '.fits'
f.write(outfile + '\n')
reduc.masterflat(listobj[i], outfile, mastbia, dark, mastdark, path,
area, sec)
i = i + 1
f.close()
if path is not None:
aux.chdir(originalpath)
def skynoises(images,path=None):
'''
Llama a skynoise para una lista de imagenes.
'''
if path is not None:
originalpath=aux.chdir(path,save=True)
lista=np.genfromtxt(images,dtype=None)
i=0
sigmas=[]
for im in lista:
sigmas.append(skynoise(im,path))
i=i+1
if path is not None:
aux.chdir(originalpath)
return(sigmas)
def multifull(images,path=None):
if path is not None:
originalpath=aux.chdir(path,save=True)
obser=telescopefinder(images,path)
redf=RF(images,path)
images=np.genfromtxt(images,dtype=None)
fwhm=[]
for im in images:
binn=aux.hselect(im,'CCDSUM') # gets binning of the image
binn=binn[0] # access element 0 of the array
binn=binn[1] # access first character
binn=int(binn) # converts string to integer
fwhm.append(fullwidth(obser,binn,redf))
if path is not None:
aux.chdir(originalpath)
return(fwhm)
def multisf(imagelist,
farr,
sarr,
thold,
zmin=None,
zmax=None,
path=None,
outfile=None):
if path is not None:
originalpath = aux.chdir(path, save=True)
listaim = np.genfromtxt(imagelist, dtype=None)
if zmin is None:
zmin = []
for im in listaim:
zmin.append('INDEF')
if zmax is None:
zmax = []
for im in listaim:
zmax.append('INDEF')
if outfile is None:
outfile = []
for im in listaim:
imn = os.path.splitext(im)[0]
aux.rm(imn + '.coo') #delete all previous coord files if exist
outfile.append(imn + '.coo')
f = open('coords.in', 'w+')
for out in outfile:
print >> f, out
f.close()
i = 0
for im in listaim:
unisf(im, farr[i], sarr[i], thold, zmin[i], zmax[i], path, outfile[i])
i = i + 1
if path is not None:
aux.chdir(originalpath)
def RF(images, path=None):
if path is not None:
originalpath = aux.chdir(path, save=True)
ext = os.path.splitext(images)[-1]
tel = telescopefinder(images)
if ext == '.fit' or ext == '.fits':
if tel == 'JS':
comnt = aux.hselect(images, 'COMMENT')
criterio = "c/Red. Focal"
if criterio in comnt[0]:
redF = True
else:
redF = False
else:
redf = False
else:
im = np.genfromtxt(images, dtype=None)[0]
if tel == 'JS':
comnt = aux.hselect(im, 'COMMENT')
comnt = comnt[0]
criterio = "c/Red. Focal"
if criterio in comnt:
redF = True
else:
redF = False
else:
redF = False
if path is not None:
aux.chdir(originalpath)
return redF
def telescopefinder(image, path=None):
if path is not None:
originalpath = aux.chdir(path, save=True)
a = os.path.splitext(image)[-1]
if a == '.fit' or a == '.fits':
telfield = aux.hselect(image, 'TELESCOP')
if 'HSH' in telfield:
telescopio = 'HSH'
else:
telescopio = 'JS'
else:
lista = np.genfromtxt(image, dtype=None)
im = lista[0]
telfield = aux.hselect(im, 'TELESCOP')
if 'HSH' in telfield:
telescopio = 'HSH'
else:
telescopio = 'JS'
if path is not None:
aux.chdir(originalpath)
return telescopio
def filtersep(images,path=None,field=None):
'''
Dada una lista de imágenes y el parámetro del header de las mismas, busca
el flitro de cada imágen, las separa por filtro en listas, en archivos
distintos.
Devuelve una lista de todos los filtros de las imágenes.
Por defecto interpreta que se están tomando datos con el telescopio
de 2.15m de CASLEO, con su respectivo formato: "(N) X" donde N es un
número asociado a filtro X, que se encuentra en el campo "FILTER02" del
header de la imagen. Si lo encuentra en free usa el "FILTER01".
INPUT
images : Archivo .in con los nombres de las imágenes.
(path) : Camino al archivo images
OUTPUT
name type
listadefiltros nparray : Lista de filtros en las imágenes.
listadearchivos list : Lista de archivos de lista que generó la tarea.
'''
if path is not None: # moves to path, saves working directory
originalpath=aux.chdir(path,save=True)
# le agrego un arroba
# para pasarlo como argumento en iraf
imagesl='@'+images
field=aux.default(field,'FILTER02')
listafull = aux.hselect(imagesl,field) # genera lista de todos los filtros
# excluyo el filtro 1 que es ningùn filtro.
listaextra=[]
for x in listafull:
if "(1)" in x: # excluyo los filtros free:
listaextra.append(x)
listafull=listaextra
listafull2= aux.hselect(imagesl,"FILTER01") # busco los filtros 1
listasisi=[]
for x in listafull2:
if not('Free' in x or 'Libre' in x or 'free' in x or'libre' in x):
listasisi.append(x)
# print listasisi
listafull2=listasisi
# separa individualmente x filtro
listadefiltros = np.unique(listafull+listafull2)
# me genero una lista de las imágenes
listaimagenes = np.genfromtxt(images,dtype=None)
i=0
for filt in listadefiltros:
filt = filt.strip()[-2] # se queda con el último carácter
listadefiltros[i]=filt # lo guarda en listadefiltros
i=i+1
# A cada imagen le asigna un nuevo valor en el header que contiene
# el filtro de cada imagen, en el formato de un solo caracter.
for im in listaimagenes:
x=aux.hselect(im,field) # obtengo el filtro, lo guardo en un array x
y=aux.hselect(im,"FILTER01")
orfilt=x[0] # separo el elemento único del array
orfilt2=y[0]
if not ("(1)" in orfilt):
orfilt=orfilt.strip()[-2] # me quedo con el último carácter no blanco.
aux.hedit(im,fields="FILTNEW",value=orfilt)
else:
orfilt2=orfilt2.strip()[-2]
aux.hedit(im,fields="FILTNEW",value=orfilt2)
#genera lista vacia de archivos
listadearchivos=[]
#guarda el nombre del archivo input
imagename=os.path.splitext(images)[0]
for f in listadefiltros: # por cada filtro
#genera un nuevo nombre de archivo .in
if type(f) == str:
newf=imagename+f+'.in'
else:
newf=imagename+str(f)+'.in'
# los agrega a la lista de archivos
listadearchivos.append(newf)
#crea el archivo
h=open(newf,'w+')
# para cada imagen
for im in listaimagenes:
#agarra el filtro
x=aux.hselect(im,"FILTNEW")
if x[0].strip() in f: # lo compara con el filtro que estoy buscando
print >> h, im # si es igual lo guarda en la lista
h.close()
if path is not None:
aux.chdir(originalpath)
return listadefiltros,listadearchivos
def skynoise(image,path=None):
'''
Calcula el ruido del cielo de una imagen.
Toma una moda de la imagen total con \verb|imstat|. Luego genera una lista
de n puntos aleatorios entre los límites de la imagen, con
$n=\frac{anchoCCD^2}{10}$, y corre \verb|imexa| sobre cada punto, sacando
la estadística. Descarta los puntos que superen en cuentas 3 veces la moda
y toma la media de la desviación estandar del cielo de los puntos
restantes. Este valor es el que devuelve como aproximación del skynoise.
INPUT
image : una imagen
(path): camino a imagen
'''
if path is not None:
originalpath=aux.chdir(path,save=True)
stat= iraf.imstat(image,fields='mode',Stdout=1) #get the mode of the image
moda=float(stat[1]) # reads the mode as a float variable
binn=aux.hselect(image,'CCDSUM') # gets binning of the image
binn=binn[0] # access element 0 of the array
binn=binn[1] # access first character
binn=int(binn) # converts string to integer
#------------------------------------------------------------------
ccdsec=aux.hselect(image,'CCDSEC') # para agarrar imagenes con trim
if ccdsec[0]=='':
limits=aux.hselect(image,'CCDSIZE') # gets ccd pixel size
else:
limits=aux.hselect(image,'BIASSEC')
limit=limits[0] # gets element 0 of the array
limit=limit.strip() # removes white space
dd=[] # stores position of double dot
c=[] # stores position of comma
i=0
for x in limit: # for every character
if x==':': # if character is :
dd.append(i) #stores index
elif x==',': # if character is ,
c.append(i) #stores index
i=i+1
#-----------------------------------------------------------------
#
# x1=int(limit[1:dd[0]]) # saves first limit
# y1=int(limit[c[0]+1:dd[1]]) #saves las limit
x2=int(limit[dd[0]+1:c[0]])
y2=int(limit[dd[1]+1:-1])
l1=x2/binn # limit one
l2=y2/binn # limit two
# set random numbers aux file
aux.rm('ruidoceleste.coo') #delete if already exists
output='ruidoceleste.coo'
coords=[]
nrandom=int((l1**2)/100.) #quadratic growth
f=open(output,'a+') # creates outfile
for i in range(nrandom): # creates l1/10 random coordinates
x=random.randint(1,l1) # random x coord, from x1 to l1
y=random.randint(1,l2) # random y coord, from y1 to l2
coords.append([x,y])
print >> f,x,y # writes coords in file
f.close()
iraf.unlearn(iraf.imexamine) #unlearns imexamine first
# tuve que mandar estos comandos para que no me cambie el z1yz2 cada vez
# que calculaba todo. Cosa de como tenia mi seteado mi iraf ( o no?)
iraf.imexamine.autoredraw='no' #noredraw of the image
# iraf.display.zscale='no'
iraf.imexamine.allframes='no'
iraf.imexamine.use_display='no'
iraf.imexamine.imagecur=output # sets imexa infile
iraf.imexamine.defkey='m' # sets key to use in imexa
imst=iraf.imexamine(image,frame=1,Stdout=1) # calls imexa
stdev=[]
maxi=[]
for lin in imst[1:]:
stdev.append(float(lin.split()[4]))
maxi.append(float(lin.split()[6]))
# criterio de seleccion <3*moda no es estrella
validos=[]
for j in range(nrandom):
if maxi[j] < 3*moda:
validos.append(stdev[j])
sigmasky=mode(validos) # toma la moda
sigmasky=sigmasky[0][0]
# tomo la media de la disperción
# sigmasky=np.mean(validos)
# print validos
aux.rm(output) # mata el archivo auxiliar
if path is not None:
aux.chdir(originalpath)
return(sigmasky)
def photom(images,anillo,danillo,apertura,outfile=None,path=None,coords='coords.in'):
'''
Dada una lista de imágenes, realiza la fotometría de apertura con
la tarea phot.
INPUT
images : Lista de imágenes .in o archivo .fits
(coords) : Archivo con las coordenadas de los objetos, por defecto
es "coords.in"
anillo : radio annulus
danillo : radio dannulus
apertura : Apretura de los radios, ingresada como un string
ej: r1,r2:rn-1,rn
(outfile): Nombre de archivo(s) de salida. por defecto es el nombre de
images en extension phot
(path) : Línea que indica el camino al directorio de archivos.
------------------------------------------------------------------
Given a image list, performs aperture photometry via phot task.
INPUT
images : .in image list or .fits file.
coords : file with objects' coordinates.
anillo : ?
danillo : ??
(outfile): Name of the output file(s).
(path) : String that indicates the path to the files.
'''
if path is not None:
originalpath=aux.chdir(path,save=True)
iraf.noao()
iraf.digiphot()
iraf.apphot()
iraf.unlearn(iraf.datapars)
iraf.unlearn(iraf.fitskypars)
iraf.unlearn(iraf.photpars)
iraf.unlearn(iraf.phot) #eterno resplandor de una tarea sin recuerdos
# serie de comandos que indican el campo del header donde ir a buscar info
iraf.datapars.ccdread="rdnoise"
iraf.datapars.gain="gain"
iraf.datapars.exposure="exptime"
iraf.datapars.airmass="airmass"
iraf.datapars.filter="filtnew"
iraf.datapars.obstime="time-obs"
# setea parámetros de la fotometría
iraf.fitskypars.annulus=anillo # radio del anillo interior (cuentas obj - cuentas d cielo)
iraf.fitskypars.dannulus=danillo # radio del anillo exterior(cuentas cielo)
# iraf.photpars.apertures="0.5,1:30:1"
iraf.photpars.apertures= apertura # intervalo de radios a tomar
iraf.phot.interac='no'
iraf.phot.verify='no'
iraf.phot.verbose='no'
if (os.path.splitext(images)[-1] == '.fit' or
os.path.splitext(images)[-1] == '.fits'):
iraf.phot.image=images
iraf.phot.coords=coords
outfile=aux.default(outfile,os.path.splitext(images)[0]+'.phot',borrar=True)
iraf.phot.output=outfile
else:
iraf.phot.image='@'+images
iraf.phot.coords='@'+coords
outfile=aux.default(outfile,os.path.splitext(images)[0]+'_phots.in',borrar=True)
imagelista=np.genfromtxt(images,dtype=None)
f=open(outfile,'a+')
for im in imagelista :
f.write(os.path.splitext(im)[0]+'.phot'+'\n')
aux.rm(os.path.splitext(im)[0]+'.phot')
f.close()
iraf.phot.output='@'+outfile
iraf.phot()
#%%
# contador de cantidad de filas en un archivo -sin contar los comentarios-
# if (os.path.splitext(images)[-1] == '.fit' or
# os.path.splitext(images)[-1] == '.fits'):
# with open(coords) as fp:
# for curline in fp:
# check if the current line
# starts with "#"
# if curline.startswith("#"): #if it's a commented line
# continue #do nothing
# else:
# line = fp.readline() #initialize reading
# cnt = 1
# while line:
#print("Line {}: {}".format(cnt, line.strip()))
#eso puede servir para comprimir los dos for en
#uno solo, pero no sé como jeje... pronto pronto...
# line = fp.readline()
# cnt += 1 #count how many lines -stars- in coords file.
# fp.close()
if path is not None:
aux.chdir(originalpath)
def procw(filters,
listobj,
path=None,
mastbia=None,
dark=False,
mastdark=None,
flatin='mflatlist.in',
prefix=None,
area=None,
sec=None):
'''
Dada una lista con los flats por filtro, realiza el masterflat en cada
filtro de dicha lista.
INPUT
filters : Lista de filtros.
listobj : Lista de imágenes por filtro.
(path) : Carácteres que indica el camino al imagelist.
(mastbia) : Archivo que contiene el masterbias. Por defecto usa
"Zero.fits" y toma el mismo path que el flatlist.
(Dark) : Si es verdadero, corrije por Dark.
(mastdark) : Archivo que contiene el masterdark. Por defecto usa
"Dark.fits" y toma el mismo path que el flatlist.
(flatin) : Lista de master flats en cada filtro.
(prefix) : Prefijo que se agregará a las imágenes reducidas. Por defecto,
usa "R"
---------------------------------------
Given a list of flats per filter, generates the masterflat for each image
in said filtered set.
INPUT
filters : Filter list.
listobj : Image per filter list.
(path) : String that indicates the path to imagelist.
(mastbia) : File that contains the masterbias. If none uses
(Dark) : If true, apply Dark correction.
"Zero.fits" and always use the same path as flatlist.
(mastdark) : File that contains the msaterdark. If none uses
"Dark.fits" and always use the same path as flatlist.
(flatin) : Flat per filter list.
(prefix) : Prefix added to the reduced image list. If none, uses "R".
'''
if path is not None:
originalpath = aux.chdir(path, save=True)
flatlist = np.genfromtxt(flatin, dtype=None)
i = 0
for x in filters:
#outfile=os.path.splitext(listobj[i])[0]+'.fits'
image = listobj[i]
flat = flatlist[i]
# if
rg.fillheader(image)
reduc.process(image, path, dark, mastbia, mastdark, flat, prefix, area,
sec)
i = i + 1
if path is not None:
aux.chdir(originalpath)
def unisf(image,
fwhm,
sigma,
thold,
zmin='INDEF',
zmax='INDEF',
path=None,
outfile=None):
'''
Dada una lista de imágenes, identifica las estrellas de campo y
genera un archivo de coordenadas.
INPUT
image : Archivo .in con los nombres de las imágenes, o la imagen
simple.
fwmh : Ancho a mitad de intensidad máxima de las estrellas.
sigma : Desviación estándar del cielo.
thold : Amplitud mínima por encima del valor de fondo.
(zmin) : Valor mínimo de cuentas a considerar.
(zmax) : Valor máximo de cuentas a considerar.
(path) : String que indica el camino a la imagen.
(outfile) : Nombre del archivo de salida. Por defecto usa el nombre de
la imagen y agrega un .coo .
---------------------------------------
Given a images list, identifies field stars and generates a coordinates
file.
INPUT
image : .in file with the name of each image, or a single image.
fwmh : Full width half maximum of intensity of stars.
sigma : Standard deviation of the sky.
thold : Minimum amplitude above background level.
(zmin) : Minimum counts value to consider.
(zmax) : Maximum counts value to consider.
(path) : String that indicates the path do the images.
(outfile) : Name of the output file, including .coo. By default, uses
image name and adds .coo extension.
'''
if path is not None:
originalpath = aux.chdir(path, save=True)
iraf.noao() #loads noao
iraf.digiphot() #loads digiphot
iraf.apphot() #loads apphot
iraf.unlearn(iraf.daofind)
iraf.unlearn(iraf.datapars)
iraf.unlearn(iraf.findpars) #unlearns every task required
iraf.datapars.fwhmpsf = fwhm
iraf.datapars.sigma = sigma
iraf.datapars.datamin = zmin
iraf.datapars.datamax = zmax #sets meaningful parameters
iraf.findpars.thresho = thold #sets meaningful threshold
iraf.daofind.verify = "no" #avoid checking parameters given
aux.default(outfile, image + '.coo', borrar=True)
iraf.daofind.output = outfile
iraf.daofind.image = image
iraf.daofind()
#execute iraf task 'daofind'
if path is not None:
aux.chdir(originalpath)
