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)