pymakeplots 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

pymakeplots/pymakeplots.py

@@ -12,8 +12,8 @@ from mpl_toolkits.axes_grid1 import make_axes_locatable
 from matplotlib.patches import Ellipse,Rectangle
 from matplotlib import cm
 from matplotlib.colors import ListedColormap, LinearSegmentedColormap
-from matplotlib.offsetbox import AnchoredText
-from mpl_toolkits.axes_grid1.anchored_artists import AnchoredEllipse,AnchoredSizeBar
+from matplotlib.offsetbox import AnchoredText,AuxTransformBox, AnchoredOffsetbox
+from mpl_toolkits.axes_grid1.anchored_artists import AnchoredSizeBar
 from astropy.coordinates import ICRS
 import matplotlib.gridspec as gridspec
 from astropy.table import Table
@@ -23,6 +23,8 @@ import warnings
 from spectral_cube import SpectralCube
 from spectral_cube.utils import SpectralCubeWarning
 warnings.filterwarnings(action='ignore', category=SpectralCubeWarning, append=True)
+from scipy.stats import mode
+
 
 def running_mean(x, N):
     cumsum = np.cumsum(np.insert(x, 0, 0)) 
@@ -38,7 +40,7 @@ def rotateImage(img, angle, pivot):
 
 
 class pymakeplots:
-    def __init__(self,cube_flat=None,pb=None,cube=None):
+    def __init__(self,cube_flat=None,pb=None,cube=None,rest_value=None):
         self.galname=None
         self.gal_distance=None
         self.posang=None
@@ -66,6 +68,7 @@ class pymakeplots:
         self.bardist=None
         self.rmsfac=3
         self.restfreq=None
+        self.repfreq=None
         self.obj_ra=None
         self.obj_dec=None
         self.imagesize=None
@@ -78,29 +81,36 @@ class pymakeplots:
         self.spatial_trim = None
         self.maxvdisp=None
         self.cliplevel=None
+        self.points2plot=None
+        self.pointingsra=None
+        self.pointingsdec=None
+        self.pointingsdiam=None
         self.fits=False
         self.pvdthick=5.    
         self.flipped=False
         self.make_square=True
         self.useallpixels = False
+        self.suppress_subbeam_artifacts=False
         #self.wcs=None
         
         if (cube != None)&(pb==None)&(cube_flat==None):
             # only one cube given
-            self.input_cube_nopb(cube)
+            self.input_cube_nopb(cube,rest_value=rest_value)
             
         if (cube != None)&(pb!=None):
             # pbcorred cube and pb given
-            self.input_cube_pbcorr(cube,pb)
+            self.input_cube_pbcorr(cube,pb,rest_value=rest_value)
         
         if (cube_flat != None)&(pb!=None):
             # flat cube and pb given
             if np.any(self.pbcorr_cube) == None: #check if the user gave all three cubes, in which case this call is redundant
-                self.input_cube_flat(cube_flat,pb)  
+                self.input_cube_flat(cube_flat,pb,rest_value=rest_value)  
               
         if (cube != None)&(pb==None)&(cube_flat!=None):
             # pbcorred cube and flat cube given
-            self.input_cube_pbcorr_and_flat(cube,cube_flat)        
+            self.input_cube_pbcorr_and_flat(cube,cube_flat,rest_value=rest_value)
+        
+        self.cube_for_param_guesses=self.flat_cube            
             
     def vsystrans_inv(self,val):
         return val +self.vsys
@@ -124,21 +134,21 @@ class pymakeplots:
     def beam_area(self):
         return (np.pi*(self.bmaj/self.cellsize)*(self.bmin/self.cellsize))/(4*np.log(2))
         
-    def input_cube_pbcorr(self,path_to_pbcorr_cube,path_to_pb):
+    def input_cube_pbcorr(self,path_to_pbcorr_cube,path_to_pb,rest_value=None):
        
-       self.pbcorr_cube = self.read_primary_cube(path_to_pbcorr_cube) 
+       self.pbcorr_cube = self.read_primary_cube(path_to_pbcorr_cube,rest_value=rest_value) 
        
-       pb,hdr,_= self.read_in_a_cube(path_to_pb)
+       pb,hdr,_= self.read_in_a_cube(path_to_pb,rest_value=rest_value)
        if self.flipped: pb=np.flip(pb,axis=2)
 
        self.flat_cube = self.pbcorr_cube*pb
                           
     
-    def input_cube_flat(self,path_to_flat_cube,path_to_pb):
+    def input_cube_flat(self,path_to_flat_cube,path_to_pb,rest_value=None):
        
-       self.flat_cube = self.read_primary_cube(path_to_flat_cube)
+       self.flat_cube = self.read_primary_cube(path_to_flat_cube,rest_value=rest_value)
        
-       pb,hdr,_= self.read_in_a_cube(path_to_pb)
+       pb,hdr,_= self.read_in_a_cube(path_to_pb,rest_value=rest_value)
        if self.flipped: pb=np.flip(pb,axis=2)
        
        self.pbcorr_cube = self.flat_cube.copy()*0.0
@@ -146,35 +156,41 @@ class pymakeplots:
        
 
 
-    def input_cube_nopb(self,path_to_cube):
+    def input_cube_nopb(self,path_to_cube,rest_value=None):
        
-       self.pbcorr_cube = self.read_primary_cube(path_to_cube) 
+       self.pbcorr_cube = self.read_primary_cube(path_to_cube,rest_value=rest_value) 
        
        self.flat_cube = self.pbcorr_cube
        
 
 
-    def input_cube_pbcorr_and_flat(self,path_to_pbcorr_cube,path_to_flat_cube):
+    def input_cube_pbcorr_and_flat(self,path_to_pbcorr_cube,path_to_flat_cube,rest_value=None):
+       
+       self.pbcorr_cube = self.read_primary_cube(path_to_pbcorr_cube,rest_value=rest_value) 
        
-       self.pbcorr_cube = self.read_primary_cube(path_to_pbcorr_cube) 
+       self.flat_cube,hdr,_ = self.read_in_a_cube(path_to_flat_cube,rest_value=rest_value)
        
-       self.flat_cube,hdr,_ = self.read_in_a_cube(path_to_flat_cube)
        if self.flipped: self.flat_cube=np.flip(self.flat_cube,axis=2)
            
     def smooth_mask(self,cube):
         """
         Apply a Gaussian blur, using sigma = 4 in the velocity direction (seems to work best), to the uncorrected cube.
-        The mode 'nearest' seems to give the best results.
         :return: (ndarray) mask to apply to the un-clipped cube
         """
         sigma = 1.5 * self.bmaj / self.cellsize
         smooth_cube = ndimage.uniform_filter(cube, size=[sigma, sigma,4], mode='constant')  # mode='nearest'
         newrms= self.rms_estimate(smooth_cube,0,1) 
-        self.cliplevel=newrms*self.rmsfac   
-        mask=(smooth_cube > self.cliplevel)
-        # print("Clip level:",((3e20*1.6014457E-20*91.9)/(self.bmaj*self.bmin))*self.cliplevel*self.dv)
-        # import ipdb
-        # ipdb.set_trace()
+        self.cliplevel=self.rms*self.rmsfac 
+        self.maskcliplevel=newrms*self.rmsfac   
+        mask=(smooth_cube > self.maskcliplevel)
+        
+        if self.suppress_subbeam_artifacts:
+            label,cnt=ndimage.label(mask)#.sum(axis=2))
+            hist,lab=np.histogram(label,bins=np.arange(cnt+1))
+            beampix=(self.bmaj*self.bmin)/(self.cellsize**2)
+            for thelabel in lab[0:-1][hist<(beampix*self.suppress_subbeam_artifacts)]:
+                mask[label == thelabel]=False
+        
         return mask      
 
 
@@ -302,7 +318,8 @@ class pymakeplots:
         return np.nanstd(cube[quarterx*1:3*quarterx,1*quartery:3*quartery,chanstart:chanend])
         
     def get_header_coord_arrays(self,hdr):
-
+        
+            
         cd1=self.spectralcube.wcs.pixel_scale_matrix[0,0]*3600
         cd2=self.spectralcube.wcs.pixel_scale_matrix[1,1]*3600
         x1=((np.arange(1,hdr['NAXIS1']+1)-(hdr['NAXIS1']//2))*cd1)# + hdr['CRVAL1']
@@ -311,37 +328,41 @@ class pymakeplots:
         v1=self.spectralcube.spectral_axis.value
 
         cd3= np.median(np.diff(v1))
+       
             
         return x1,y1,v1,np.abs(cd1),cd3                    
         
-    def read_in_a_cube(self,path):
-        self.spectralcube=SpectralCube.read(path).with_spectral_unit(u.km/u.s, velocity_convention='radio')#, rest_value=self.restfreq)
+    def read_in_a_cube(self,path,rest_value=None,primary=False):
+        
+        scube=SpectralCube.read(path).with_spectral_unit(u.km/u.s, velocity_convention='radio',rest_value=rest_value)
 
-        hdr=self.spectralcube.header
-        cube = np.squeeze(self.spectralcube.filled_data[:,:,:].T).value #squeeze to remove singular stokes axis if present
+        hdr=scube.header
+        cube = np.squeeze(scube.filled_data[:,:,:].T).value #squeeze to remove singular stokes axis if present
         cube[np.isfinite(cube) == False] = 0.0
         try:
-            beamtab=self.spectralcube.beam
+            beamtab=scube.beam
         except:
             try:
-                beamtab=self.spectralcube.beams[np.floor(self.spectralcube.beams.size/2).astype(int)]
+                beamtab=scube.beams[np.floor(scube.beams.size/2).astype(int)]
             except:
             #try flipping them
                 try:
-                    beamvals=[self.spectralcube.header['bmaj'],self.spectralcube.header['bmin']]
+                    beamvals=[scube.header['bmaj'],scube.header['bmin']]
                     beamtab=Beam(major=np.max(beamvals)*u.deg,minor=np.min(beamvals)*u.deg,pa=self.spectralcube.header['bpa']*u.deg)
                 except:
-                    beamtab=False
-            
+                    beamtab=False           
+        if primary:
+            self.spectralcube=scube
+            self.repfreq=np.median(self.spectralcube.with_spectral_unit(u.GHz).spectral_axis)
         return cube, hdr, beamtab
     
 
         
-    def read_primary_cube(self,cube):
+    def read_primary_cube(self,cube,rest_value=None):
         
         ### read in cube ###
-        datacube,hdr,beam = self.read_in_a_cube(cube)
-        
+        datacube,hdr,beam = self.read_in_a_cube(cube,rest_value=rest_value,primary=True)
+    
         self.bmaj=beam.major.to(u.arcsec).value
         self.bmin=beam.minor.to(u.arcsec).value
         self.bpa=beam.pa.value
@@ -351,15 +372,9 @@ class pymakeplots:
             self.galname=hdr['OBJECT']
         except:
             self.galname="Galaxy"
-            
-        
-                          
+         
         self.xcoord,self.ycoord,self.vcoord,self.cellsize,self.dv = self.get_header_coord_arrays(hdr)
-        #breakpoint()
-        
-        
 
-        
         if self.dv < 0:
             datacube = np.flip(datacube,axis=2)
             self.dv*=(-1)
@@ -369,7 +384,15 @@ class pymakeplots:
         
         self.rms= self.rms_estimate(datacube,self.linefree_chans_start,self.linefree_chans_end) 
         return datacube
-    
+   
+    def calc_offset(self,ra,dec):
+        refpos=SkyCoord(ra,dec)
+        xpix,ypix=self.spectralcube.wcs.celestial.world_to_pixel(refpos)
+        #self.xcentpix,self.ycentpix= xpix,ypix   
+        xoffsetarc=np.interp(xpix,np.arange(self.xcoord.size),self.xcoord)
+        yoffsetarc=np.interp(ypix,np.arange(self.ycoord.size),self.ycoord)
+        return xpix,ypix,xoffsetarc,yoffsetarc
+        
     def prepare_cubes(self):
         
         self.centskycoord=self.spectralcube.wcs.celestial.pixel_to_world(self.xcoord.size//2,self.ycoord.size//2).transform_to('icrs')
@@ -380,12 +403,19 @@ class pymakeplots:
         if self.obj_dec == None:
            self.obj_dec=self.y_skycent
         
-        refpos=SkyCoord(self.obj_ra*u.deg,self.obj_dec*u.deg)
-        xpix,ypix=self.spectralcube.wcs.celestial.world_to_pixel(refpos)
-            
-        xoffsetarc=np.interp(xpix,np.arange(self.xcoord.size),self.xcoord)
-        yoffsetarc=np.interp(ypix,np.arange(self.ycoord.size),self.ycoord)
 
+        xpix,ypix,xoffsetarc,yoffsetarc=self.calc_offset(self.obj_ra*u.deg,self.obj_dec*u.deg)
+        self.xcentpix,self.ycentpix= xpix,ypix  
+        
+        
+        ### want to overplot the pointings
+        if self.pointingsra != None:
+            pointingposes=SkyCoord(self.pointingsra,self.pointingsdec,frame='icrs',unit=(u.hourangle,u.deg))
+            _,_,pointoffsetx,pointoffsety=self.calc_offset(pointingposes.ra,pointingposes.dec)
+            self.points2plot=np.zeros((len(pointoffsetx),3))
+            self.points2plot[:,0]=pointoffsetx-xoffsetarc
+            self.points2plot[:,1]=pointoffsety-yoffsetarc
+            self.points2plot[:,2]=self.pointingsdiam.value
         
         self.clip_cube(xoffsetarc,yoffsetarc)
             
@@ -404,6 +434,8 @@ class pymakeplots:
         if self.all_axes_physical:
             self.xc=self.ang2kpctrans(self.xc)
             self.yc=self.ang2kpctrans(self.yc)
+            if self.pointingsra != None:
+                self.points2plot=self.ang2kpctrans(self.points2plot)
 
             
     
@@ -441,7 +473,7 @@ class pymakeplots:
         self.make_spec(axes=ax5,fits=fits)
         
         ### plotting PA on mom1
-        ypv=np.arange(-np.max(self.yc),np.max(self.yc),20)
+        ypv=np.arange(-np.max(self.yc),np.max(self.yc),self.cellsize)
         xpv=ypv*0.0
         ang=self.posang
         c = np.cos(np.deg2rad(ang))
@@ -450,7 +482,6 @@ class pymakeplots:
         y2 =  s*xpv + c*ypv
         ax2.scatter(0,0,facecolors='none',edgecolors='k')
         ax2.plot(x2,y2,'k--')
-        #breakpoint()
 
         ###### make summary box
         
@@ -478,6 +509,7 @@ class pymakeplots:
 
         if pdf:
             plt.savefig(self.galname+"_allplots.pdf", bbox_inches = 'tight')
+            plt.close()
         else:
             plt.show()
 
@@ -561,19 +593,27 @@ class pymakeplots:
         
         
         
-        if self.chans2do == None:
-            # use the mask to try and guess the channels with signal.
-            mask_cumsum=np.nancumsum((self.pbcorr_cube > self.rmsfac*self.rms).sum(axis=0).sum(axis=0))
-            w_low,=np.where(mask_cumsum/np.max(mask_cumsum) < 0.02)
-            w_high,=np.where(mask_cumsum/np.max(mask_cumsum) > 0.98)
+        if np.any(self.chans2do == None):
             
-            if w_low.size ==0: w_low=np.array([0])
-            if w_high.size ==0: w_high=np.array([self.vcoord.size])
-            self.chans2do=[np.clip(np.max(w_low)-2,0,self.vcoord.size),np.clip(np.min(w_high)+2,0,self.vcoord.size)]
-    
+            clip=4.0
+            vwidth=4000
+            while vwidth > 1500:
+                clip+=0.1        
+                # use the mask to try and guess the channels with signal.
+                mask_cumsum=np.nancumsum((self.cube_for_param_guesses > clip*self.rms).sum(axis=0).sum(axis=0))
+                w_low,=np.where(mask_cumsum/np.nanmax(mask_cumsum) < 0.05)
+                w_high,=np.where(mask_cumsum/np.nanmax(mask_cumsum) > 0.95)
+            
+                if w_low.size ==0: w_low=np.array([0])
+                if w_high.size ==0: w_high=np.array([self.vcoord.size])
+                #breakpoint()
+                self.chans2do=[np.clip(np.max(w_low)-7,0,self.vcoord.size-1),np.clip(np.min(w_high)+7,0,self.vcoord.size-1)]
+                vwidth=self.vcoord[self.chans2do[1]]-self.vcoord[self.chans2do[0]]
+            #print(clip)    
+                
         if self.vsys == None:
             # use the cube to try and guess the vsys
-            self.vsys=((self.pbcorr_cube*(self.pbcorr_cube > self.rmsfac*self.rms)).sum(axis=0).sum(axis=0)*self.vcoord).sum()/((self.pbcorr_cube*(self.pbcorr_cube > self.rmsfac*self.rms)).sum(axis=0).sum(axis=0)).sum()
+            self.vsys=((self.cube_for_param_guesses*(self.cube_for_param_guesses > self.rmsfac*self.rms)).sum(axis=0).sum(axis=0)*self.vcoord).sum()/((self.cube_for_param_guesses*(self.cube_for_param_guesses > self.rmsfac*self.rms)).sum(axis=0).sum(axis=0)).sum()
         
         if self.imagesize != None:
             if np.array(self.imagesize).size == 1:
@@ -587,7 +627,7 @@ class pymakeplots:
         
         if self.spatial_trim == None:
             
-            mom0=(self.pbcorr_cube > self.rmsfac*self.rms).sum(axis=2)
+            mom0=(self.cube_for_param_guesses > self.rmsfac*self.rms).sum(axis=2)
             mom0[mom0>0]=1
             
             cumulative_x = np.nancumsum(mom0.sum(axis=1),dtype=float)
@@ -637,19 +677,16 @@ class pymakeplots:
         return cb         
             
         
-    def add_beam(self,ax):    
+    def add_beam(self,ax):
+        aux_tr_box = AuxTransformBox(ax.transData)
+                
         if self.all_axes_physical:
-            ae = AnchoredEllipse(ax.transData, width=self.ang2kpctrans(self.bmaj), height=self.ang2kpctrans(self.bmin), angle=self.bpa+90,
-                             loc='lower left', pad=0.5, borderpad=0.4,
-                             frameon=False)
+            aux_tr_box.add_artist(Ellipse((0, 0), width=self.ang2kpctrans(self.bmaj), height=self.ang2kpctrans(self.bmin), angle=self.bpa+90,edgecolor='black',facecolor='none',linewidth=1.5))                 
         else:
-            ae = AnchoredEllipse(ax.transData, width=self.bmaj, height=self.bmin, angle=self.bpa+90,
-                             loc='lower left', pad=0.5, borderpad=0.4,
-                             frameon=False)                   
-        ae.ellipse.set_edgecolor('black')
-        ae.ellipse.set_facecolor('none')
-        ae.ellipse.set_linewidth(1.5)
-        ax.add_artist(ae)
+            aux_tr_box.add_artist(Ellipse((0, 0), width=self.bmaj, height=self.bmin, angle=self.bpa+90,edgecolor='black',facecolor='none',linewidth=1.5))                 
+        box = AnchoredOffsetbox(child=aux_tr_box, loc='lower left', pad=0.5, borderpad=0.4,frameon=False)
+        ax.add_artist(box)                     
+
         
             
         
@@ -701,6 +738,29 @@ class pymakeplots:
             
             
         self.add_beam(ax1)
+        
+        if np.any(self.points2plot != None):
+            naca=0
+            nalma=0
+            for xp,yp,diam in self.points2plot:
+                if diam/np.min(self.points2plot[:,2])>1.7:
+                    ls=':' #aca
+                    if naca ==0:
+                        label='ACA'
+                    else:
+                        label=None
+                    naca+=1
+                else:
+                    ls='--' #12m
+                    if nalma ==0:
+                        label='12m'
+                    else:
+                        label=None
+                    nalma+=1
+                circle2 = plt.Circle((xp, yp), diam/2., color='k',ls=ls, fill=False,alpha=0.2,label=label)
+                ax1.add_patch(circle2)
+            ax1.legend(frameon=False,loc='upper left',fontsize='x-small',markerscale=0.5)    
+        
         if self.make_square:
             ax1.set_xlim(np.min([self.xc[0],self.yc[0]]),np.max([self.xc[-1],self.yc[-1]]))
             ax1.set_ylim(np.min([self.xc[0],self.yc[0]]),np.max([self.xc[-1],self.yc[-1]]))
@@ -725,7 +785,7 @@ class pymakeplots:
         mom1=mom0.copy()*np.nan
         mom1[mom0 != 0.0] = (((self.pbcorr_cube_trim*self.mask_trim)*self.vcoord_trim).sum(axis=2))[mom0 != 0.0]/mom0[mom0 != 0.0]
         
-        
+
         vticks=np.linspace((-1)*np.ceil(np.max(np.abs(self.vcoord_trim-self.vsys))/10.)*10.,np.ceil(np.max(np.abs(self.vcoord_trim-self.vsys))/10.)*10.,5)
         
         im1=ax1.contourf(self.xc,self.yc,mom1.T-self.vsys,levels=self.vcoord_trim-self.vsys,cmap=sauron,vmin=vticks[0],vmax=vticks[-1])
@@ -771,12 +831,13 @@ class pymakeplots:
                     mom2[i,j]=np.sqrt(np.sum(np.abs(self.pbcorr_cube_trim[i,j,:]*self.mask_trim[i,j,:]) * (self.vcoord_trim - mom1[i,j]) ** 2, axis=0) / np.sum(abs(self.pbcorr_cube_trim[i,j]*self.mask_trim[i,j,:]), axis=0))
         
         if self.maxvdisp == None:
-            self.maxvdisp=np.ceil(np.clip(np.nanstd(mom2)*4,0,np.nanmax(mom2))/10.)*10.
-        
-        
-        
+            self.maxvdisp=np.ceil(np.clip(np.nanstd(mom2)*4,20,np.nanmax(mom2))/10.)*10.
+        else:
+            self.maxvdisp=np.ceil(np.clip(np.nanstd(mom2)*4,20,self.maxvdisp)/10.)*10.
+        if np.isfinite(self.maxvdisp)==False:
+            self.maxvdisp=50.
+        #breakpoint()
         mom2levs=np.linspace(0,self.maxvdisp,10)
-        
         im1=ax1.contourf(self.xc,self.yc,mom2.T,levels=mom2levs,cmap=sauron,vmax=self.maxvdisp)
         
         if self.all_axes_physical:
@@ -796,7 +857,7 @@ class pymakeplots:
         vticks=np.arange(0,5)*dvticks
         
         cb=self.colorbar(im1,ticks=vticks)
-        cb.set_label("$\sigma_{obs}$ (km s$^{-1}$)")
+        cb.set_label('$\\sigma_{obs}$ (km s$^{-1}$)')
 
         
         self.add_beam(ax1)
@@ -860,8 +921,8 @@ class pymakeplots:
         newhdu.header['CUNIT2']=self.spectralcube.header['CUNIT2']
         newhdu.header['BMAJ']=self.bmaj/3600.
         newhdu.header['BMIN']=self.bmin/3600.
-        newhdu.header['BPA']=self.bpa/3600.
-        newhdu.header['MOMCLIP']=(self.cliplevel, self.bunit+' km/s')
+        newhdu.header['BPA']=self.bpa
+        newhdu.header['MOMCLIP']=(self.maskcliplevel, self.bunit+' km/s')
         newhdu.header['VSYS']=(self.vsys,'km/s')
         newhdu.header['comment'] = 'Moment map created with pymakeplots'
 
@@ -881,7 +942,7 @@ class pymakeplots:
             filename=self.galname+"_pvd.fits"
         else:
             filename=self.fits+"_pvd.fits"
-            
+           
         newhdu = fits.PrimaryHDU(pvd)
         newhdu.header['CRPIX1']=1
         newhdu.header['CRVAL1']=xx[0]
@@ -895,10 +956,10 @@ class pymakeplots:
         newhdu.header['CUNIT2']='km/s'
         newhdu.header['BMAJ']=self.bmaj/3600.
         newhdu.header['BMIN']=self.bmin/3600.
-        newhdu.header['BPA']=self.bpa/3600.
+        newhdu.header['BPA']=self.bpa
         newhdu.header['PVDANGLE']=(self.posang,'deg')
         newhdu.header['PVDTHICK']=(self.pvdthick,'pixels')
-        newhdu.header['MOMCLIP']=(self.cliplevel, self.bunit+' km/s')
+        newhdu.header['MOMCLIP']=(self.maskcliplevel, self.bunit+' km/s')
         newhdu.header['VSYS']=(self.vsys,'km/s')
         newhdu.header['comment'] = 'Moment map created with pymakeplots'
         newhdu.header['BUNIT'] = self.bunit+' km/s'
@@ -906,7 +967,7 @@ class pymakeplots:
         newhdu.writeto(filename,overwrite=True)   
             
     def make_pvd(self,axes=None,fits=False,pdf=False):
-        
+        self.fits=fits
         if np.any(self.xc) == None:
             self.prepare_cubes()
         
@@ -921,31 +982,67 @@ class pymakeplots:
         if self.posang==None:
             # try fitting the moment one to get the kinematic pa
             if not self.silent: print("No position angle given, estimating using the observed moment one.")
-            mom0=(self.pbcorr_cube_trim*self.mask_trim).sum(axis=2)
+            mom0=(self.flat_cube_trim*self.mask_trim).sum(axis=2)
             mom1=mom0.copy()*np.nan
-            mom1[mom0 != 0.0] = (((self.pbcorr_cube_trim*self.mask_trim)*self.vcoord_trim).sum(axis=2))[mom0 != 0.0]/mom0[mom0 != 0.0]
-            mom1=mom1.T
+            mom1[mom0 != 0.0] = (((self.flat_cube_trim*self.mask_trim)*self.vcoord_trim).sum(axis=2))[mom0 != 0.0]/mom0[mom0 != 0.0]
+            mom1=mom1.T 
             
-
-            # if the cube is small, use it directly to estimate posang. If its large, then interpolate down to keep runtime low.
-            if (self.pbcorr_cube_trim[:,:,0].size < 50*50) or (self.useallpixels):
-                xv, yv = np.meshgrid(self.xc,self.yc)
-                x,y,v = xv[np.isfinite(mom1)],yv[np.isfinite(mom1)],mom1[np.isfinite(mom1)]
-            else:
-                print("Downsampling the observed moment one in PA estimate for speed. Set `useallpixels` to override.")    
-                mom1[np.isfinite(mom1) == False] = self.vsys
-                interper = interpolate.interp2d(self.xc,self.yc,mom1-self.vsys,bounds_error=False,fill_value=np.nan)
-                x=np.linspace(np.min(self.xc),np.max(self.xc),50)
-                y=np.linspace(np.min(self.yc),np.max(self.yc),50)
-                v= interper(x,y)
-                xv, yv = np.meshgrid(x,y)
-                x,y,v = xv.flatten(),yv.flatten(),v.flatten()
+            # ### sigma clip
+            # mom1[np.abs(mom1/np.nanstd(mom1))>5]=np.nan
+            
+            ### select largest contigious structure
+            label,cnt=ndimage.label(self.mask_trim.sum(axis=2))
+            mode_label= mode(label[label>0])
+            
+            hist,lab=np.histogram(label[label>0],bins=np.arange(cnt+1)+1)
+            beampix=(self.bmaj*self.bmin)/(self.cellsize**2)
+            
+            
+            if len(lab[0:-1][hist<beampix]) != len(lab[0:-1]):
                 
-            self.posang,_,_ = fit_kinematic_pa(x[np.isfinite(v)],y[np.isfinite(v)],v[np.isfinite(v)],nsteps=36,plot=False,quiet=True)
+                ## remove beam size artifacts
+                for thelabel in lab[0:-1][hist<beampix]:
+                    mom1[label.T ==  thelabel]=np.nan
+                  
+                ## keep biggest structures that contain >80% of remaining pixels
+                remainlab=lab[0:-1][hist>beampix]  
+                remainhist=hist[hist>beampix]
+                st=np.argsort(remainhist)    
+                for thelabel in remainlab[st][np.nancumsum(remainhist[st]/np.sum(remainhist)) < 0.2]:
+                    mom1[label.T ==  thelabel]=np.nan 
+                    
+            else:    
+                mom1[label.T != mode_label.mode]=np.nan
             
+            #self.useallpixels=True
+            
+            ### remove median
+            mom1-=np.nanmedian(mom1)
+            
+            
+            
+            #breakpoint()
+            # if the cube is small, use it directly to estimate posang. If its large, then interpolate down to keep runtime low.
+            # if (self.pbcorr_cube_trim[:,:,0].size < 50*50) or (self.useallpixels):
+            xv, yv = np.meshgrid(self.xc,self.yc)
+            x,y,v = xv[np.isfinite(mom1)],yv[np.isfinite(mom1)],mom1[np.isfinite(mom1)]
+            # else:
+            #     print("Downsampling the observed moment one in PA estimate for speed. Set `useallpixels` to override.")
+            #mom1[np.isfinite(mom1) == False] = self.vsys
+            #breakpoint()
+            # interper = interpolate.RegularGridInterpolator((self.xc,self.yc),(mom1-self.vsys).T,bounds_error=False,fill_value=np.nan)
+            # x=np.linspace(np.min(self.xc),np.max(self.xc),self.xc.size//2)
+            # y=np.linspace(np.min(self.yc),np.max(self.yc),self.yc.size//2)
+            # xv, yv = np.meshgrid(x,y)
+            # v= interper((xv,yv))
+            # x,y,v = xv.flatten(),yv.flatten(),v.flatten()
+            
+            #breakpoint()
+            self.posang,_,_ = fit_kinematic_pa(x[np.isfinite(v)],y[np.isfinite(v)],v[np.isfinite(v)],nsteps=36,plot=False,quiet=True)
+
             if np.sin(np.deg2rad((self.posang+45)*2)) > 0:
                 # do y axis cut
-                if np.nanmean(mom1[self.yc > 0,:]) > np.nanmean(mom1[self.yc < 0,:]):
+                if np.nansum(mom1[self.yc > 0,:])/(mom1[self.yc > 0,:]).size > np.nansum(mom1[self.yc < 0,:])/(mom1[self.yc < 0,:]).size:
                     # posang should be gt 180
                     if self.posang < 180: self.posang += 180
                 else:
@@ -953,21 +1050,20 @@ class pymakeplots:
                     if self.posang > 180: self.posang -= 180    
             else:
                 # do x axis cut
-                if np.nanmean(mom1[:,self.xc > 0]) > np.nanmean(mom1[:,self.xc < 0]):
+                if np.nansum(mom1[:,self.xc > 0])/(mom1[:,self.xc > 0]).size > np.nansum(mom1[:,self.xc < 0])/(mom1[:,self.xc < 0]).size:
                     # posang should be gt 180
                     if self.posang < 180: self.posang += 180
                 else:
                      # posang should be lt 180
                     if self.posang > 180: self.posang -= 180
             if not self.silent: print("PA estimate (degrees): ",np.round(self.posang,1))        
-        
-                    
+
         centpix_x=np.where(np.isclose(self.xc,0.0,atol=self.cellsize/1.9))[0]
         centpix_y=np.where(np.isclose(self.yc,0.0,atol=self.cellsize/1.9))[0]
-        #breakpoint()
+        
 
 
-        rotcube= rotateImage(self.pbcorr_cube_trim*self.mask_trim,90-self.posang,[centpix_y[0],centpix_x[0]])
+        rotcube= rotateImage(self.pbcorr_cube_trim*self.mask_trim,90-self.posang,[centpix_x[0],centpix_y[0]])
 
 
         pvd=rotcube[:,np.array(rotcube.shape[1]//2-self.pvdthick).astype(int):np.array(rotcube.shape[1]//2+self.pvdthick).astype(int),:].sum(axis=1)
@@ -998,34 +1094,44 @@ class pymakeplots:
         newcmp = ListedColormap(oldcmp(np.linspace(0.15, 1, 256)))
         
 
+        if np.nanmax(pvd) < self.cliplevel:
+            contour_levels=np.linspace(np.nanmax(pvd)/2.,np.nanmax(pvd),10)
+            if np.sum(contour_levels)==0:
+                contour_levels=np.array([self.cliplevel,self.cliplevel+0.1])
+        else:
+            contour_levels=np.linspace(self.cliplevel,np.nanmax(pvd),10)
         
-        axes.contourf(pvdaxis,vaxis,pvd.T,levels=np.linspace(self.cliplevel,np.nanmax(pvd),10),cmap=newcmp)
-        axes.contour(pvdaxis,vaxis,pvd.T,levels=np.linspace(self.cliplevel,np.nanmax(pvd),10),colors='black')
+        axes.contourf(pvdaxis,vaxis,pvd.T,levels=contour_levels,cmap=newcmp)
+        axes.contour(pvdaxis,vaxis,pvd.T,levels=contour_levels,colors='black')
         
         if self.all_axes_physical:
              axes.set_xlabel('Offset (kpc)')
+             secaxy = axes.secondary_xaxis('top', functions=(self.ang2kpctrans_inv, self.ang2kpctrans))
+             secaxy.set_xlabel('Offset (")')
         else:
              axes.set_xlabel('Offset (")')
-       
+             secaxy = axes.secondary_xaxis('top', functions=(self.ang2kpctrans, self.ang2kpctrans_inv))
+             secaxy.set_xlabel('Offset (kpc)')
+             
         axes.set_ylabel('Velocity (km s$^{-1}$)')
         
-        secaxy = axes.secondary_xaxis('top', functions=(self.ang2kpctrans, self.ang2kpctrans_inv))
-        secaxy.set_xlabel('Offset (kpc)')
+
         
         secax = axes.secondary_yaxis('right', functions=(self.vsystrans, self.vsystrans_inv))
         secax.set_ylabel(r'V$_{\rm offset}$ (km s$^{-1}$)')
 
-        anchored_text = AnchoredText("PA: "+str(round(self.posang,1))+"$^{\circ}$", loc=loc1,frameon=False)
+        anchored_text = AnchoredText("PA: "+str(round(self.posang,1))+'$^{\\circ}$', loc=loc1,frameon=False)
         axes.add_artist(anchored_text)
         
         if self.gal_distance != None and not self.all_axes_physical:
             self.scalebar(axes,loc=loc2)
-        
+
         if self.fits:
             self.write_pvd_fits(pvdaxis,vaxis,pvd.T)
         
         if pdf:
             plt.savefig(self.galname+"_pvd.pdf", bbox_inches = 'tight')
+            plt.close()
         else:
             if not outsideaxis: plt.show()
     
@@ -1097,6 +1203,7 @@ class pymakeplots:
         
         if pdf:
             plt.savefig(self.galname+"_spec.pdf", bbox_inches = 'tight')
+            plt.close()
         else:
             if not outsideaxis: plt.show()
         

{pymakeplots-0.2.0.dist-info → pymakeplots-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymakeplots
-Version: 0.2.0
+Version: 0.2.2
 Home-page: https://github.com/TimothyADavis/pymakeplots
 Author: Timothy A. Davis
 Author-email: DavisT@cardiff.ac.uk
@@ -12,8 +12,8 @@ Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: numpy
-Requires-Dist: matplotlib (>3.3.1)
-Requires-Dist: scipy
+Requires-Dist: matplotlib >3.3.1
+Requires-Dist: scipy >=1.14.0
 Requires-Dist: astropy
 Requires-Dist: spectral-cube
 Requires-Dist: radio-beam

pymakeplots-0.2.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+pymakeplots/__init__.py,sha256=PLKnIm6rIKYjH_b6L9UBCFtv1lKt5GItdBKDbSOhuMU,87
+pymakeplots/pymakeplots.py,sha256=_N8Wp2teEfr6W9SqBi3bb2WV3F7vxzfVhWDnhq_Qa1E,48843
+pymakeplots/sauron_colormap.py,sha256=8APka-_L432wyICcHcySjk3qmjNOynb3iDjjlMuUTU0,4448
+pymakeplots-0.2.2.dist-info/LICENSE.md,sha256=qtvmvajOPCad_5HMY5u49hldzBIXz7tbHbuGSG_HE5o,1077
+pymakeplots-0.2.2.dist-info/METADATA,sha256=YlzzxZMuONkCuzkhi_5tHinfu6TsqW8MzdpB5jG_QTg,1847
+pymakeplots-0.2.2.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
+pymakeplots-0.2.2.dist-info/top_level.txt,sha256=KgG17vI_D6BsiKRe_81UU5709tXc6Ha7gx1IwjA7ur8,12
+pymakeplots-0.2.2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+pymakeplots-0.2.2.dist-info/RECORD,,

{pymakeplots-0.2.0.dist-info → pymakeplots-0.2.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.38.4)
+Generator: setuptools (70.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pymakeplots-0.2.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-pymakeplots/__init__.py,sha256=PLKnIm6rIKYjH_b6L9UBCFtv1lKt5GItdBKDbSOhuMU,87
-pymakeplots/pymakeplots.py,sha256=-QBfg3BnC6I3RuGh9nFpfHXTQHNmGP8FsgboBCQ3cxk,43686
-pymakeplots/sauron_colormap.py,sha256=8APka-_L432wyICcHcySjk3qmjNOynb3iDjjlMuUTU0,4448
-pymakeplots-0.2.0.dist-info/LICENSE.md,sha256=qtvmvajOPCad_5HMY5u49hldzBIXz7tbHbuGSG_HE5o,1077
-pymakeplots-0.2.0.dist-info/METADATA,sha256=-bZdjlHzVwuuEnhWLyWoCJeNtFUCVNymSPe-yhETRmo,1840
-pymakeplots-0.2.0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-pymakeplots-0.2.0.dist-info/top_level.txt,sha256=KgG17vI_D6BsiKRe_81UU5709tXc6Ha7gx1IwjA7ur8,12
-pymakeplots-0.2.0.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-pymakeplots-0.2.0.dist-info/RECORD,,