Source code

Download source archive ↓

src/analysis.py

1"""Cone selection, calibrated photometry and spherical three-band matching."""
2import io
3import json
4import math
5import tarfile
6import numpy as np
7from astropy.io import fits
8from astropy.coordinates import SkyCoord,search_around_sky
9import astropy.units as u
10
11
12class ChunkReader(io.RawIOBase):
13    def __init__(self,chunks):self.chunks=iter(chunks);self.pending=memoryview(b'')
14    def readable(self):return True
15    def readinto(self,target):
16        while not self.pending:
17            try:self.pending=memoryview(next(self.chunks))
18            except StopIteration:return 0
19        n=min(len(target),len(self.pending));target[:n]=self.pending[:n];self.pending=self.pending[n:];return n
20
21
22def validate_cone(params):
23    ra,dec,radius=params['cone']
24    if not all(isinstance(x,(int,float)) and math.isfinite(x) for x in [ra,dec,radius]) or not (0<=ra<360 and -90<=dec<=90 and .001<=radius<=1):raise ValueError('Expected ICRS RA [0,360), Dec [-90,90], radius [0.001,1] degrees')
25    return SkyCoord(ra*u.deg,dec*u.deg,frame='icrs'),radius
26
27
28def select(chunks,params):
29    center,radius=validate_cone(params);rows=[];scanned=0;bad=0;band=None
30    with io.BufferedReader(ChunkReader(chunks),buffer_size=65536) as stream:
31        with tarfile.open(fileobj=stream,mode='r|') as archive:
32            for member in archive:
33                if not member.isfile() or member.size>24*1024*1024 or not member.name.endswith('.fits'):raise ValueError('Invalid catalog bundle member')
34                data=archive.extractfile(member).read()
35                with fits.open(io.BytesIO(data),memmap=False) as hdus:
36                    table=hdus['CATALOG'];values=table.data;scanned+=len(values);current=table.header['BAND']
37                    if band is not None and band!=current:raise ValueError('Mixed bands in catalog')
38                    band=current
39                    if table.header.get('RADESYS')!='ICRS':raise ValueError('ICRS required')
40                    coordinates=SkyCoord(np.asarray(values['RA'])*u.deg,np.asarray(values['DEC'])*u.deg,frame='icrs')
41                    inside=coordinates.separation(center).deg<=radius
42                    valid=inside&(values['QUALITY']==0)&np.isfinite(values['FLUX'])&(values['FLUX']>0)&np.isfinite(values['FLUX_ERR'])&(values['FLUX_ERR']>0)
43                    snr=values['FLUX']/np.maximum(values['FLUX_ERR'],1e-20);valid&=snr>=params.get('min_snr',5)
44                    bad+=int(np.count_nonzero(inside&~valid))
45                    for i in np.flatnonzero(valid):
46                        flux=float(values['FLUX'][i]);error=float(values['FLUX_ERR'][i]);mag=table.header['MAGZP']-2.5*math.log10(flux)+table.header['ZPCORR']
47                        rows.append({'source_id':int(values['SOURCE_ID'][i]),'ra':float(values['RA'][i]),'dec':float(values['DEC'][i]),
48                                     'mag':mag,'mag_error':2.5/math.log(10)*error/flux,'snr':float(snr[i])})
49                    if len(rows)>50000:raise ValueError('More than 50,000 selected sources; choose a smaller sky region')
50        while stream.read(65536):pass
51    return {'synthetic':True,'band':band,'cone':params['cone'],'rows':rows,'scanned_rows':scanned,'quality_rejections':bad,
52            'photometry':'synthetic AB-like magnitude = MAGZP - 2.5 log10(FLUX) + ZPCORR'}
53
54
55def sky(rows):return SkyCoord([r['ra'] for r in rows]*u.deg,[r['dec'] for r in rows]*u.deg,frame='icrs')
56
57
58def pair(reference,other,radius):
59    if not reference or not other:return {},set()
60    a,b,sep,_=search_around_sky(sky(reference),sky(other),radius*u.arcsec)
61    by_a={};by_b={}
62    for ia,ib,d in zip(a.tolist(),b.tolist(),sep.arcsec.tolist()):
63        by_a.setdefault(ia,[]).append((d,ib));by_b.setdefault(ib,[]).append((d,ia))
64    accepted={};ambiguous=set()
65    for ia,choices in by_a.items():
66        choices.sort();distance,ib=choices[0];reverse=sorted(by_b[ib])
67        if len(choices)>1 or len(reverse)>1:ambiguous.add(ia);continue
68        if reverse[0][1]==ia:accepted[ia]=(ib,distance)
69    return accepted,ambiguous
70
71
72def crossmatch(g,r,i,params):
73    validate_cone(params)
74    if [v['band'] for v in [g,r,i]]!=['g','r','i'] or any(v['cone']!=params['cone'] for v in [g,r,i]):raise ValueError('Band/region mismatch')
75    radius=params.get('match_radius_arcsec',.8)
76    if not isinstance(radius,(int,float)) or not math.isfinite(radius) or not .05<=radius<=3:raise ValueError('Match radius must be 0.05–3 arcsec')
77    gr,agr=pair(g['rows'],r['rows'],radius);gi,agi=pair(g['rows'],i['rows'],radius);rows=[];counts={'missing_r':0,'missing_i':0,'ambiguous':0}
78    for index,gv in enumerate(g['rows']):
79        if index in agr or index in agi:counts['ambiguous']+=1;continue
80        if index not in gr:counts['missing_r']+=1;continue
81        if index not in gi:counts['missing_i']+=1;continue
82        ri,rd=gr[index];ii,idistance=gi[index];rv=r['rows'][ri];iv=i['rows'][ii]
83        # All three pairwise separations must be consistent, not only g–r/g–i.
84        distance=float(sky([rv]).separation(sky([iv])).arcsec[0])
85        if distance>radius:counts['ambiguous']+=1;continue
86        color_gr=gv['mag']-rv['mag'];color_ri=rv['mag']-iv['mag']
87        classification='red_candidate' if color_gr>=1.5 and color_ri>=.8 else 'blue_candidate' if color_gr<=0 and color_ri<=0 else 'stellar_locus'
88        rows.append({'source_id':gv['source_id'],'ra':gv['ra'],'dec':gv['dec'],'g':gv['mag'],'r':rv['mag'],'i':iv['mag'],
89             'g_r':color_gr,'r_i':color_ri,'g_r_error':math.hypot(gv['mag_error'],rv['mag_error']),
90             'r_i_error':math.hypot(rv['mag_error'],iv['mag_error']),'gr_separation_arcsec':rd,'gi_separation_arcsec':idistance,
91             'ri_separation_arcsec':distance,'class':classification,
92             'matched_source_ids':{'g':gv['source_id'],'r':rv['source_id'],'i':iv['source_id']}})
93    return {'synthetic':True,'cone':params['cone'],'rows':rows,'unmatched':counts,'match_radius_arcsec':radius,
94       'band_counts':{v['band']:len(v['rows']) for v in [g,r,i]},'scanned_rows':sum(v['scanned_rows'] for v in [g,r,i]),
95       'quality_rejections':sum(v['quality_rejections'] for v in [g,r,i]),
96       'classes':{name:sum(r['class']==name for r in rows) for name in ['red_candidate','blue_candidate','stellar_locus']},
97       'method':'ICRS spherical, unique mutual matches; all pairwise separations within radius; calibrated synthetic g/r/i colors. Classes are illustrative color selections, not physical identifications.'}
98
99
100def read_json(ctx,name):
101    data=bytearray()
102    for block in ctx.input(name).bytes():
103        data.extend(block)
104        if len(data)>32*1024*1024:raise ValueError('Selected catalog exceeds transfer limit')
105    return json.loads(data)
106
107
108def process(ctx):
109    params=dict(ctx.params)
110    if params['operation']=='select':value=select(ctx.input('source').bytes(),params)
111    elif params['operation']=='crossmatch':
112        g=read_json(ctx,'g');i=read_json(ctx,'i');r=read_json(ctx,'r')
113        value=crossmatch(g,r,i,params)
114    else:raise ValueError('Unknown operation')
115    output=ctx.bytes_output('result','json');output.write(json.dumps(value,allow_nan=False).encode())
116
117
118def infer_outputs(inputs,params):
119    from xstream_operator import descriptor,result
120    return result({'result':descriptor(['bytes'],['json'],None,certainty='known')})
121
122
123def preview_outputs(inputs,params,limits):
124    from xstream_operator import preview_process
125    return preview_process(process,inputs,params,limits)
126
127if __name__=='__main__':
128    from xstream_operator import run_operator
129    run_operator(process,infer_outputs,preview_outputs=preview_outputs)