def diff(self, l=None, alpha=2.): ''' Evaluate the derivative of the profile function at a coordinate point. l can be any value or array. No warning is printed in case of extrapolation, which is done with a power law at small or large l values The default y-grid is returned if l is None and alpha is 2 (the default) @keyword l: The coordinate point(s). If None, the default coordinate grid is used. (default: None) @type l: array/float @keyword alpha: The exponent of the wavelength-dependent power law extrapolation, such that kappa ~ lambda^-alpha (default: 2.) @type alpha: float @return: The derivative evaluated at l @rtype: array/float ''' #-- Return self.y since l was given as None if l is None and alpha == self.alpha: return self.dydx #-- l can still be None. Apparently different alpha requested. So calc. if l is None: l = self.l #-- First retrieve the original profile. Don't warn since we re-do the # extrapolation anyway. This will have the wrong alpha if alpha is not # 2, but we re-do the extrapolation anyway. The original profile will # be untouched. dydl = super(Opacity, self).diff(l, warn=0) #-- If self.func or self.dfunc is not an interpolator, no warnings # needed, and no extrapolation needed either. if not (self.interp_dfunc and self.interp_func): return dydl #-- Determine the regions where extrapolation is done, i.e. outside the # original l-grid's range. lmin, lmax = self.xin[0], self.xin[-1] ymin, ymax = self.yin[0], self.yin[-1] #-- Replace the extrapolated values with the new power law. Make sure l # and y are an array for this. larr, dydl = Data.arrayify(l), Data.arrayify(dydl) dydl[larr < lmin] = ymin * (larr[larr < lmin] / lmin)**(-alpha - 1.) * -alpha / lmin dydl[larr > lmax] = ymax * (larr[larr > lmax] / lmax)**(-alpha - 1.) * -alpha / lmax return dydl if isinstance(l, collections.Iterable) else dydl[0]
def diff(self,l=None,alpha=2.): ''' Evaluate the derivative of the profile function at a coordinate point. l can be any value or array. No warning is printed in case of extrapolation, which is done with a power law at small or large l values The default y-grid is returned if l is None and alpha is 2 (the default) @keyword l: The coordinate point(s). If None, the default coordinate grid is used. (default: None) @type l: array/float @keyword alpha: The exponent of the wavelength-dependent power law extrapolation, such that kappa ~ lambda^-alpha (default: 2.) @type alpha: float @return: The derivative evaluated at l @rtype: array/float ''' #-- Return self.y since l was given as None if l is None and alpha == self.alpha: return self.dydx #-- l can still be None. Apparently different alpha requested. So calc. if l is None: l = self.l #-- First retrieve the original profile. Don't warn since we re-do the # extrapolation anyway. This will have the wrong alpha if alpha is not # 2, but we re-do the extrapolation anyway. The original profile will # be untouched. dydl = super(Opacity,self).diff(l,warn=0) #-- If self.func or self.dfunc is not an interpolator, no warnings # needed, and no extrapolation needed either. if not (self.interp_dfunc and self.interp_func): return dydl #-- Determine the regions where extrapolation is done, i.e. outside the # original l-grid's range. lmin, lmax = self.xin[0], self.xin[-1] ymin, ymax = self.yin[0], self.yin[-1] #-- Replace the extrapolated values with the new power law. Make sure l # and y are an array for this. larr, dydl = Data.arrayify(l), Data.arrayify(dydl) dydl[larr<lmin] = ymin*(larr[larr<lmin]/lmin)**(-alpha-1.)*-alpha/lmin dydl[larr>lmax] = ymax*(larr[larr>lmax]/lmax)**(-alpha-1.)*-alpha/lmax return dydl if isinstance(l,collections.Iterable) else dydl[0]
def eval(self,l=None,alpha=2.): ''' Evaluate the profile function at a coordinate point. l can be any value or array. No warning is printed in case of extrapolation, which is done with a power law at small or large l values The default y-grid is returned if l is None and alpha is 2 (the default) @keyword l: The coordinate point(s). If None, the default coordinate grid is used. (default: None) @type l: array/float @keyword alpha: The exponent of the wavelength-dependent power law extrapolation, such that kappa ~ lambda^-alpha (default: 2.) @type alpha: float @return: The profile evaluated at l @rtype: array/float ''' #-- Return self.y since l was given as None if l is None and alpha == self.alpha: return self.y #-- l can still be None. Apparently different alpha requested. So calc. if l is None: l = self.l #-- First retrieve the original profile. Don't warn since we re-do the # extrapolation anyway. If this is the first call from the __init__ # method of Opacity(), this will be the standard grid. y = super(Opacity,self).eval(l,warn=0) #-- If self.func is not an interpolator, no warnings needed, and no # extrapolation needed either. if not self.interp_func: return y #-- Determine the regions where extrapolation is done, i.e. outside the # original l-grid's range. lmin, lmax = self.xin[0], self.xin[-1] ymin, ymax = self.yin[0], self.yin[-1] #-- Replace the extrapolated values with the new power law. Make sure l # and y are an array for this. larr, y = Data.arrayify(l), Data.arrayify(y) y[larr<lmin] = ymin*(larr[larr<lmin]/lmin)**(-alpha) y[larr>lmax] = ymax*(larr[larr>lmax]/lmax)**(-alpha) return y if isinstance(l,collections.Iterable) else y[0]
def eval(self, l=None, alpha=2.): ''' Evaluate the profile function at a coordinate point. l can be any value or array. No warning is printed in case of extrapolation, which is done with a power law at small or large l values The default y-grid is returned if l is None and alpha is 2 (the default) @keyword l: The coordinate point(s). If None, the default coordinate grid is used. (default: None) @type l: array/float @keyword alpha: The exponent of the wavelength-dependent power law extrapolation, such that kappa ~ lambda^-alpha (default: 2.) @type alpha: float @return: The profile evaluated at l @rtype: array/float ''' #-- Return self.y since l was given as None if l is None and alpha == self.alpha: return self.y #-- l can still be None. Apparently different alpha requested. So calc. if l is None: l = self.l #-- First retrieve the original profile. Don't warn since we re-do the # extrapolation anyway. If this is the first call from the __init__ # method of Opacity(), this will be the standard grid. y = super(Opacity, self).eval(l, warn=0) #-- If self.func is not an interpolator, no warnings needed, and no # extrapolation needed either. if not self.interp_func: return y #-- Determine the regions where extrapolation is done, i.e. outside the # original l-grid's range. lmin, lmax = self.xin[0], self.xin[-1] ymin, ymax = self.yin[0], self.yin[-1] #-- Replace the extrapolated values with the new power law. Make sure l # and y are an array for this. larr, y = Data.arrayify(l), Data.arrayify(y) y[larr < lmin] = ymin * (larr[larr < lmin] / lmin)**(-alpha) y[larr > lmax] = ymax * (larr[larr > lmax] / lmax)**(-alpha) return y if isinstance(l, collections.Iterable) else y[0]
def eval(self,x=None,y=None,warn=1): ''' Evaluate the profile function at a coordinate point. x/y can be any value or array. If func is an interpolation object, it is in principle limited by the x/y-range of the interpolator. It is advised not to extend much beyond the given x/y-range. If one of the two variables is None, it is replaced by the default grid. @keyword x: The primary coordinate point(s). If None, the default coordinate grid is used. (default: None) @type x: array/float @keyword y: The secondary coordinate point(s). If None, the default coordinate grid is used. (default: None) @type y: array/float @keyword warn: Warn when extrapolation occurs. (default: 1) @type warn: bool @return: The profile evaluated at x and y @rtype: array/float ''' #-- Select the actual x/y arrays xarr = self.x if x is None else x yarr = self.y if y is None else y #-- Run the boundary check for interpolators if self.interp_func and warn: #-- Are all requested values in range of the original grid? if np.any((xarr>self.x[-1])|(xarr<self.x[0])) \ or np.any((yarr>self.y[-1])|(yarr<self.y[0])): m = 'Warning! There were values outside of 2D interpolation '+\ 'range in module {}.'.format(sys.modules[self.__module__]) xvals, yvals = Data.arrayify(xarr), Data.arrayify(yarr) xsel = xvals[(xvals>self.x[-1])|(xvals<self.x[0])] ysel = yvals[(yvals>self.y[-1])|(yvals<self.y[0])] m += '\nx: {}, \ny: {}'.format(str(xsel),str(ysel)) print(m) #-- Return self.z since x and y were given as None if x is None and y is None: return self.z #-- call the interpolator or the function return self.func(xarr,yarr,*self._args,**self._kwargs)
def eval(self, x=None, y=None, warn=1): ''' Evaluate the profile function at a coordinate point. x/y can be any value or array. If func is an interpolation object, it is in principle limited by the x/y-range of the interpolator. It is advised not to extend much beyond the given x/y-range. If one of the two variables is None, it is replaced by the default grid. @keyword x: The primary coordinate point(s). If None, the default coordinate grid is used. (default: None) @type x: array/float @keyword y: The secondary coordinate point(s). If None, the default coordinate grid is used. (default: None) @type y: array/float @keyword warn: Warn when extrapolation occurs. (default: 1) @type warn: bool @return: The profile evaluated at x and y @rtype: array/float ''' #-- Select the actual x/y arrays xarr = self.x if x is None else x yarr = self.y if y is None else y #-- Run the boundary check for interpolators if self.interp_func and warn: #-- Are all requested values in range of the original grid? if np.any((xarr>self.x[-1])|(xarr<self.x[0])) \ or np.any((yarr>self.y[-1])|(yarr<self.y[0])): m = 'Warning! There were values outside of 2D interpolation '+\ 'range in module {}.'.format(sys.modules[self.__module__]) xvals, yvals = Data.arrayify(xarr), Data.arrayify(yarr) xsel = xvals[(xvals > self.x[-1]) | (xvals < self.x[0])] ysel = yvals[(yvals > self.y[-1]) | (yvals < self.y[0])] m += '\nx: {}, \ny: {}'.format(str(xsel), str(ysel)) print(m) #-- Return self.z since x and y were given as None if x is None and y is None: return self.z #-- call the interpolator or the function return self.func(xarr, yarr, *self._args, **self._kwargs)
def setNoise(self,vexp=None): """ Calculate the noise of the dataset, by taking the standard deviation of the velocity range lower than v_lsr - 2*vexp. If this is not available, the velocity range is taken to be where it is smaller than 1.1*vexp. If the size of the above selection still is too small, None is returned. The gas terminal velocity has to have been set previously or passed to this method as a keyword. @keyword vexp: The terminal gas velocity, only required if vexp is not set yet for this LPDataReader object! (default: None) @type vexp: float @return: The noise of the dataset @rtype: float """ if not vexp is None and not self['contents'].has_key('vexp'): self['contents']['vexp'] = float(vexp) if not self['contents'].has_key('vexp'): print 'Cannot set noise without an estimate for the terminal gas'+\ ' velocity. Pass as keyword to this method!' return None vel = self['contents']['velocity'] flux = self['contents']['flux'] vlsr = self['contents']['vlsr'] vexp = self['contents']['vexp'] noise = Data.getStd(wave=vel,flux=flux,wmin=vlsr-5*vexp,\ wmax=vlsr-2*vexp,minsize=10) if noise is None: noise = Data.getStd(wave=vel,flux=flux,wmin=vlsr-3*vexp,\ wmax=vlsr-1.8*vexp,minsize=10) if noise is None: noise = Data.getStd(wave=vel,flux=flux,wmin=vlsr-3*vexp,\ wmax=vlsr-1.1*vexp,minsize=10) if noise is None: noise = Data.getStd(wave=vel,flux=flux,wmin=vlsr-3*vexp,\ wmax=vlsr-1.1*vexp,minsize=5) if noise is None: print 'WARNING! Noise cannot be determined, not enough data ' + \ 'points outside the emission line.' self['contents']['noise'] = noise
def __convolveSphinx(self,star): ''' Convolve the Sphinx output with the SPIRE resolution. The convolution is done in wave number (cm^-1). @param star: The Star() object for which Sphinx profiles are loaded @type star: Star() ''' #- Get sphinx model output and merge, for all star models in star_grid if not self.resolution: print '* Resolution is undefined. Cannot convolve Sphinx.' return print '* Reading Sphinx model and merging.' sphinx_wav,sphinx_flux = star['LAST_GASTRONOOM_MODEL'] \ and self.mergeSphinx(star) \ or [[],[]] if not sphinx_wav: print '* No Sphinx data found.' return sphinx_wav = 1./array(sphinx_wav)*10**(4) sphinx_flux = array(sphinx_flux) sphinx_wav = sphinx_wav[::-1] sphinx_flux = sphinx_flux[::-1] #-- eliminate some of the zeroes in the grid to reduce calculation time # (can reduce the array by a factor up to 100!!) s = self.sigma lcs = array(sorted([1./line.wavelength for line in star['GAS_LINES']])) new_wav, new_flux = [sphinx_wav[0]],[sphinx_flux[0]] for w,f in zip(sphinx_wav[1:],sphinx_flux[1:]): if f != 0 or (w < 5*s+lcs[argmin(abs(lcs-w))] \ and w > lcs[argmin(abs(lcs-w))]-5*s): new_wav.append(w) new_flux.append(f) new_wav, new_flux = array(new_wav), array(new_flux) #-- convolve the model fluxes with a gaussian and constant sigma(spire) print '* Convolving Sphinx model for SPIRE.' convolution = Data.convolveArray(new_wav,new_flux,s) for data_wav,fn in zip(self.data_wave_list,self.data_filenames): rebinned = [] #-- Convert wavelengths to wave number for integration, and reverse data_cm = data_wav[::-1] data_cm = 1./data_cm*10**4 rebinned = [trapz(y=convolution[abs(new_wav-wavi)<=self.resolution/self.oversampling],\ x=new_wav[abs(new_wav-wavi)<=self.resolution/self.oversampling])\ /(self.resolution/self.oversampling) for wavi in data_cm] #-- Reverse the rebinned fluxes so they match up with the # wavelength grid. rebinned = array(rebinned)[::-1] self.sphinx_convolution[star['LAST_SPIRE_MODEL']][fn] = rebinned
def diff(self,r=None,warn=1,inner_eps=None): ''' Evaluate the derivative of the profile function at a coordinate point. r can be any value or array. The default y-grid is returned if r is None and inner_eps is 0.5 (the default). @keyword r: The coordinate point(s). If None, the default coordinate grid is used. (default: None) @type r: array/float @keyword warn: Warn when extrapolation occurs. (default: 1) @type warn: bool @keyword inner_eps: The exponent of the Teps power law inner wind extrapolation. If default, the inner_eps defined upon initialisation is used. (default: None) @type inner_eps: float @return: The derivative evaluated at r @rtype: array/float ''' #-- First retrieve the original profile. If this is the first call from # the __init__ method of Opacity(), this will be the standard grid. dydx = super(Temperature,self).diff(r,warn=warn) #-- No inner power law requested, just pass on the original if not self.inner: return dydx #-- Return self.dydr since r was given as None, if the eps is correct if inner_eps is None: inner_eps = self.inner_eps if r is None and inner_eps == self.inner_eps: return self.y #-- r can still be None. Apparently different inner_eps requested. # So calc the profile anew with the inner wind law. Need r defined. if r is None: r = self.r #-- Replace the extrapolated values in the inner wind with the new power # law. Make sure r is an array for this. rarr = Data.arrayify(r) dy_fac = Teps(rarr[rarr<self.r0],T0=self.T0,r0=self.r0,\ epsilon=inner_eps-1) dydx[rarr<self.r0] = -dy_fac*inner_eps/self.r0 return dydx if isinstance(r,collections.Iterable) else dydx[0]
def __convolveSphinx(self, star): ''' Convolve the Sphinx output with the SPIRE resolution. The convolution is done in wave number (cm^-1). @param star: The Star() object for which Sphinx profiles are loaded @type star: Star() ''' #- Get sphinx model output and merge, for all star models in star_grid if not self.resolution: print '* Resolution is undefined. Cannot convolve Sphinx.' return print '* Reading Sphinx model and merging.' sphinx_wav,sphinx_flux = star['LAST_GASTRONOOM_MODEL'] \ and self.mergeSphinx(star) \ or [[],[]] if not sphinx_wav: print '* No Sphinx data found.' return sphinx_wav = 1. / array(sphinx_wav) * 10**(4) sphinx_flux = array(sphinx_flux) sphinx_wav = sphinx_wav[::-1] sphinx_flux = sphinx_flux[::-1] #-- eliminate some of the zeroes in the grid to reduce calculation time # (can reduce the array by a factor up to 100!!) s = self.sigma lcs = array( sorted([1. / line.wavelength for line in star['GAS_LINES']])) new_wav, new_flux = [sphinx_wav[0]], [sphinx_flux[0]] for w, f in zip(sphinx_wav[1:], sphinx_flux[1:]): if f != 0 or (w < 5*s+lcs[argmin(abs(lcs-w))] \ and w > lcs[argmin(abs(lcs-w))]-5*s): new_wav.append(w) new_flux.append(f) new_wav, new_flux = array(new_wav), array(new_flux) #-- convolve the model fluxes with a gaussian and constant sigma(spire) print '* Convolving Sphinx model for SPIRE.' convolution = Data.convolveArray(new_wav, new_flux, s) for data_wav, fn in zip(self.data_wave_list, self.data_filenames): rebinned = [] #-- Convert wavelengths to wave number for integration, and reverse data_cm = data_wav[::-1] data_cm = 1. / data_cm * 10**4 rebinned = [trapz(y=convolution[abs(new_wav-wavi)<=self.resolution/self.oversampling],\ x=new_wav[abs(new_wav-wavi)<=self.resolution/self.oversampling])\ /(self.resolution/self.oversampling) for wavi in data_cm] #-- Reverse the rebinned fluxes so they match up with the # wavelength grid. rebinned = array(rebinned)[::-1] self.sphinx_convolution[star['LAST_SPIRE_MODEL']][fn] = rebinned
def diff(self, r=None, warn=1, inner_eps=None): ''' Evaluate the derivative of the profile function at a coordinate point. r can be any value or array. The default y-grid is returned if r is None and inner_eps is 0.5 (the default). @keyword r: The coordinate point(s). If None, the default coordinate grid is used. (default: None) @type r: array/float @keyword warn: Warn when extrapolation occurs. (default: 1) @type warn: bool @keyword inner_eps: The exponent of the Teps power law inner wind extrapolation. If default, the inner_eps defined upon initialisation is used. (default: None) @type inner_eps: float @return: The derivative evaluated at r @rtype: array/float ''' #-- First retrieve the original profile. If this is the first call from # the __init__ method of Opacity(), this will be the standard grid. dydx = super(Temperature, self).diff(r, warn=warn) #-- No inner power law requested, just pass on the original if not self.inner: return dydx #-- Return self.dydr since r was given as None, if the eps is correct if inner_eps is None: inner_eps = self.inner_eps if r is None and inner_eps == self.inner_eps: return self.y #-- r can still be None. Apparently different inner_eps requested. # So calc the profile anew with the inner wind law. Need r defined. if r is None: r = self.r #-- Replace the extrapolated values in the inner wind with the new power # law. Make sure r is an array for this. rarr = Data.arrayify(r) dy_fac = Teps(rarr[rarr<self.r0],T0=self.T0,r0=self.r0,\ epsilon=inner_eps-1) dydx[rarr < self.r0] = -dy_fac * inner_eps / self.r0 return dydx if isinstance(r, collections.Iterable) else dydx[0]
def eval(self,x=None,warn=1): ''' Evaluate the profile function at a coordinate point. x can be any value or array. If func is an interpolation object, it is in principle limited by the x-range of the interpolator. It is advised not to extend much beyond the given x-range. The default y-grid is returned if x is None.a @keyword x: The coordinate point(s). If None, the default coordinate grid is used. (default: None) @type x: array/float @keyword warn: Warn when extrapolation occurs. (default: 1) @type warn: bool @return: The profile evaluated at x @rtype: array/float ''' #-- Run the boundary check for interpolators if self.interp_func and warn: #-- Select the actual x array (for the cases that x is None) xarr = self.x if x is None else x #-- Are all requested values in range of the original grid? if np.any((xarr>self.xin[-1])|(xarr<self.xin[0])): m = 'Warning! There were values outside of interpolation '+\ 'range in module {}.'.format(sys.modules[self.__module__]) vals = Data.arrayify(xarr) sel = vals[(vals>self.xin[-1])|(vals<self.xin[0])] m += '\n {}'.format(str(sel)) print(m) #-- Return self.y since x was given as None if x is None: return self.y #-- call the interpolator or the function return self.func(x,*self._args,**self._kwargs)
def eval(self, x=None, warn=1): ''' Evaluate the profile function at a coordinate point. x can be any value or array. If func is an interpolation object, it is in principle limited by the x-range of the interpolator. It is advised not to extend much beyond the given x-range. The default y-grid is returned if x is None.a @keyword x: The coordinate point(s). If None, the default coordinate grid is used. (default: None) @type x: array/float @keyword warn: Warn when extrapolation occurs. (default: 1) @type warn: bool @return: The profile evaluated at x @rtype: array/float ''' #-- Run the boundary check for interpolators if self.interp_func and warn: #-- Select the actual x array (for the cases that x is None) xarr = self.x if x is None else x #-- Are all requested values in range of the original grid? if np.any((xarr > self.xin[-1]) | (xarr < self.xin[0])): m = 'Warning! There were values outside of interpolation '+\ 'range in module {}.'.format(sys.modules[self.__module__]) vals = Data.arrayify(xarr) sel = vals[(vals > self.xin[-1]) | (vals < self.xin[0])] m += '\n {}'.format(str(sel)) print(m) #-- Return self.y since x was given as None if x is None: return self.y #-- call the interpolator or the function return self.func(x, *self._args, **self._kwargs)
def get(self,ptype,prop,index=None): ''' Return a property for a given type of property possibly for a given index. In case a single value is requested via index, the property value is extracted from the array. @param ptype: The type of property. 'coll_trans', 'trans' or 'level'. @type ptype: str @param prop: The property itself. eg 'energy' for level, or 'lup' for trans, or 'rates' for coll_trans. @type prop: str @keyword index: The index. In case of default, all are returned. Can be any array-like object that includes indices (default: None) @type index: int/array @return: The property sorted by property type index, or a single element @rtype: float/int/array ''' #-- Return all if no index specified, otherwise set an iterable. if index is None: return self[ptype][prop] #-- Prefer explicit selection on indexing. Using indexing instead of # np.in1d to maintain the original shape of index. Assumes indexing in # files goes 1 -> i_max. This is normally the case. Much faster. #selection = self[ptype][prop][np.in1d(self[ptype]['index'],index)] selection = self[ptype][prop][Data.arrayify(index)-1] #-- If a non-iterable object was passed as index, return just one value # if only one value was indeed found. Otherwise, just return as is. if selection.shape != (1,) or isinstance(index,collections.Iterable): return selection else: return selection[0]
def get(self, ptype, prop, index=None): ''' Return a property for a given type of property possibly for a given index. In case a single value is requested via index, the property value is extracted from the array. @param ptype: The type of property. 'coll_trans', 'trans' or 'level'. @type ptype: str @param prop: The property itself. eg 'energy' for level, or 'lup' for trans, or 'rates' for coll_trans. @type prop: str @keyword index: The index. In case of default, all are returned. Can be any array-like object that includes indices (default: None) @type index: int/array @return: The property sorted by property type index, or a single element @rtype: float/int/array ''' #-- Return all if no index specified, otherwise set an iterable. if index is None: return self[ptype][prop] #-- Prefer explicit selection on indexing. Using indexing instead of # np.in1d to maintain the original shape of index. Assumes indexing in # files goes 1 -> i_max. This is normally the case. Much faster. #selection = self[ptype][prop][np.in1d(self[ptype]['index'],index)] selection = self[ptype][prop][Data.arrayify(index) - 1] #-- If a non-iterable object was passed as index, return just one value # if only one value was indeed found. Otherwise, just return as is. if selection.shape != (1, ) or isinstance(index, collections.Iterable): return selection else: return selection[0]
def __convolveSphinx(self,star): ''' Check if sphinx output has already been convolved (pacs db) and do so if not. @param star: The parameter set @type star: Star() ''' #- check for which filenames the convolution has already been done finished_conv_filenames = self.checkStarDb(star) finished_conv_filenames = [this_f for this_f in finished_conv_filenames if this_f in [os.path.split(f)[1] for f in self.data_filenames]] #- if after db check pacs id is undefined, then there is no pacs model, #- and the convolution will be done anyway if self.redo_convolution and star['LAST_PACS_MODEL']: for filename in finished_conv_filenames: ori = os.path.join(cc.path.gout,'stars',self.star_name,\ 'PACS_results',star['LAST_PACS_MODEL'],\ '_'.join(['sphinx',filename])) backup = os.path.join(cc.path.gout,'stars',self.star_name,\ 'PACS_results',star['LAST_PACS_MODEL'],\ '_'.join(['backup','sphinx',filename])) subprocess.call(['mv %s %s'%(ori,backup)],shell=True) self.db[star['LAST_PACS_MODEL']]['filenames'] = [] finished_conv_filenames = [] filenames_to_do = [this_f for this_f in [os.path.split(f)[1] for f in self.data_filenames] if this_f not in finished_conv_filenames] #-Get sphinx model output and merge, for all star models in star_grid if filenames_to_do: #- if list is not empty, some filenames still need a convolution print '* Reading Sphinx model and merging.' merged = star['LAST_GASTRONOOM_MODEL'] \ and self.mergeSphinx(star) \ or [[],[]] sphinx_wave = merged[0] sphinx_flux = merged[1] if not sphinx_wave: print '* No Sphinx data found.' return #- convolve the model fluxes with a gaussian at central wavelength #- from data_wave_list for every star, and appropriate sigma print '* Convolving Sphinx model, after correction for v_lsr.' if not self.data_delta_list: self.setDataResolution() for filename in filenames_to_do: i_file = [os.path.split(f)[1] for f in self.data_filenames].index(filename) if not star['LAST_PACS_MODEL']: star['LAST_PACS_MODEL'] = \ 'pacs_%.4i-%.2i-%.2ih%.2i-%.2i-%.2i'\ %(gmtime()[0],gmtime()[1],gmtime()[2],\ gmtime()[3],gmtime()[4],gmtime()[5]) self.db[star['LAST_PACS_MODEL']] = \ dict([('filenames',[]),\ ('trans_list',star.getTransList(dtype='PACS')),\ ('cooling_id',star['LAST_GASTRONOOM_MODEL'])]) DataIO.testFolderExistence(\ os.path.join(cc.path.gout,'stars',self.star_name,\ 'PACS_results',star['LAST_PACS_MODEL'])) #-- Correct for the v_lsr of the central source sphinx_wave_corr = array(sphinx_wave)*(1./(1-self.vlsr/self.c)) sph_conv = Data.doConvolution(\ x_in=sphinx_wave_corr,\ y_in=sphinx_flux,\ x_out=self.data_wave_list[i_file],\ widths=self.data_delta_list[i_file],\ oversampling=self.oversampling) sph_fn = os.path.join(cc.path.gout,'stars',self.star_name,\ 'PACS_results',star['LAST_PACS_MODEL'],\ '_'.join(['sphinx',filename])) DataIO.writeCols(filename=sph_fn,\ cols=[self.data_wave_list[i_file],sph_conv]) self.db[star['LAST_PACS_MODEL']]['filenames'].append(filename) self.db.addChangedKey(star['LAST_PACS_MODEL'])
def __init__(self,x,func=interp_file,dfunc=None,order=3,*args,\ **kwargs): ''' Create an instance of the Profiler() class. Requires a coordinate grid and a function object for the profile. A function for the derivative is optional. The functions can also be given as an interpolation object. The optional args and kwargs give the additional arguments for the two function, which are ignored in case func is an interpolation object. The default coordinate grid is evaluated for both the function and the derivative. They are saved in self.y and self.dydx. Alternatively, new evaluations can be attained through eval and diff. Note that if func is an interpolator object, the original input x and y grids can be passed as additional keywords xin and yin, which would then be arrays. Otherwise, the x and the interpolator(x) are set as xin and yin. xin and yin are ignored if func is a function, even if it returns an interpolator (in which case the original grids are known) @param x: The default coordinate points, minimum three points. In the case of an interpolation function, this is the default grid returned by the instance. The original x/y of the interpolated profile are saved as xori/yori in the object. @type x: array @keyword func: The function that describes the profile with respect to x. Can be given as an interp1d object. Default is a read function that interpolates data and returns the interpolator object. If interpolation object, x and eval(x) are assumed to be the original grids, unless xin and yin are given as keywords with arrays as values for the original grids. (default: interp_file) @type func: function/interp1d object @keyword dfunc: Function that describes the derivative of the profile with respect to x. Can be given as an interpolation object. If None, a generic central difference is taken & interpolated with a spline of which the order can be chosen. (default: None) @type dfunc: function/interpolation object @keyword order: Order of the spline interpolation of the derivative. Default is cubic. Not used for the interpolation if func returns an interpolation object. Use read_order in that case. (default: 3) @type order: int @keyword args: Additional parameters passed to the functions when eval or diff are called. (default: []) @type args: tuple @keyword kwargs: Additional keywords passed to the functions when eval or diff are called. (default: {}) @type kwargs: dict ''' #-- Check len of coordinate input. Cannot be less than three for the # derivative. if len(x) < 3: raise ValueError('Coordinate grid must have more than 2 elements.') #-- If the function is given as a string, retrieve it from the local # child module, or from the Profiler module (as parent). If the latter # case then check if the function comes from one of Profiler's # attributes, such as the loaded DataIO module. # Can also simply be a constant value, so try making a float first. if isinstance(func,str): try: #-- Check if a constant was given, rather than a function kwargs['c'] = float(func) func = constant except ValueError: #-- Note that self.module refers to the child, not Profiler if hasattr(sys.modules[self.__module__],func): func = getattr(sys.modules[self.__module__],func) #-- Recursively find the function of loaded modules in Profiler # or a function of the Profiler module itself if no '.' else: func = DataIO.read(func=func,module=sys.modules[__name__],\ return_func=1) #-- set functional args, remember spline order. args/kwargs for # func and dfunc are saved separately. They are removed if either are # interpolation objects. They are always accessible, the _** variables # are passed to the evaluation. self.args = args self.kwargs = kwargs self._args = self.args self._dargs = self.args self._dkwargs = self.kwargs self._kwargs = self.kwargs self.order = order #-- Grab default xin and yin keys in case they are included, and remove # from the arguments dictionary. None if not available. xin = self.kwargs.pop('xin',None) yin = self.kwargs.pop('yin',None) #-- By default no interpolation, so leave this off. self.interp_func = 0 self.interp_dfunc = 0 #-- Defaults for xori/yori, not used in case of normal functions self.xin = np.empty(0) self.yin = np.empty(0) #-- Evaluate the default grid with function. Set x as None first so it # can actually evaluate. Set x once derivative has been evaluated. self.x = None if not (isinstance(func,interp1d) or isinstance(func,UnivariateSpline)): #-- Evaluate the function, and check what is returned: array or # interpolation object y = func(x,*args,**kwargs) #-- Interpolation object: so set that as this instance's func. In # this case, the variable x passed to the class is the default x # grid of this instance. The original x/y-grid is saved as xi, yi if isinstance(y,tuple): self.func = y[2] self.xin = y[0] self.yin = y[1] self._args = [] self._kwargs = {} self.interp_func = 1 self.y = self.func(x) else: self.func = func self.y = y #-- func is an interpolation object, so just run the normal evaluation. # Set _args/_kwargs to empty, so none are ever passed to the interpol else: self.func = func self._args = [] self._kwargs = {} self.interp_func = 1 self.y = self.func(x) self.yin = yin if not yin is None else self.y self.xin = xin if not xin is None else x #-- Set the derivative function, resorting to default if needed if not dfunc is None: self.dfunc = dfunc elif self.func == constant: self.dfunc = zero else: #-- Extend array slightly to allow odeint to succeed. # Need better fix for this. #x0 = x[0]-(x[1]-x[0])#*0.5 #xn = x[-1]+(x[-1]-x[-2])#*0.5 #x_ext = np.hstack([[x0],x,[xn]]) #-- Evaluate the function, and set up an interpolator for # central difference. The interpolator will extrapolate # beyond the given x range. This is necessary for odeint to work. # Usually x-range is not exceeded much. self.dfunc = spline1d(x=x,y=op.diff_central(self.y,x),\ k=self.order) if (isinstance(self.dfunc,interp1d) \ or isinstance(self.dfunc,UnivariateSpline)): self._dargs = [] self._dkwargs = {} self.interp_dfunc = 1 #-- Evaluate the derivative with the default grid self.dydx = self.dfunc(x,*self._dargs,**self._dkwargs) #-- Now set x. self.x = Data.arrayify(x)
def __init__(self,x,y,func,*args,**kwargs): ''' Create an instance of the Profiler2D() class. Requires 2 coordinate arrays and a function object for profile. The function can also be given as an interpolation object. The optional args and kwargs give the additional arguments for the function, which are ignored in case func is an interpolation object. The default coordinate grids are both evaluated for the function. They are saved in self.z, as an array of dimensions (x.size,y.size). Alternatively, new evaluations can be attained through eval and diff. @param x: The default coordinates of the primary independent variable. Minimum three points. @type x: array @param y: The default coordinates of the secondary independent variable. Minimum three points. @type y: array @param func: The function that describes the profile with respect to x and y. Can be given as a 2D interpolation object. @type func: function/interpolation object @keyword args: Additional parameters passed to the functions when eval or diff are called. (default: []) @type args: tuple @keyword kwargs: Additional keywords passed to the functions when eval or diff are called. (default: {}) @type kwargs: dict ''' #-- If the function is given as a string, retrieve it from the local # child module, or from the Profiler module (as parent). If the latter # check if the function comes from one of Profiler's attributes, such # as the loaded DataIO module. if isinstance(func,str): try: #-- Note that self.module refers to the child, not Profiler func = getattr(sys.modules[self.__module__],func) except AttributeError: #-- Recursively find the function of loaded modules in Profiler # or a function of the Profiler module itself if no '.' func = DataIO.read(sys.modules[__name__],return_func=1) #-- set functional args, remember spline order. args/kwargs for # func are saved separately. They are removed if either are # interpolation objects. They are always accessible, the _** variables # are passed to the evaluation. self.args = args self.kwargs = kwargs self._args = args self._kwargs = kwargs self.func = func if isinstance(self.func,interp2d) \ or isinstance(self.func,BivariateSpline): self.interp_func = 1 self._args = [] self._kwargs = {} else: self.interp_func = 0 #-- Evaluate the default grid with function. Set x as None first so it # can actually evaluate. self.x = None self.y = None self.z = self.func(x,y,*self._args,**self._kwargs) #-- Now set x and y. Make sure they are arrays. self.x = Data.arrayify(x) self.y = Data.arrayify(y)
def __init__(self,x,func=interp_file,dfunc=None,order=3,*args,\ **kwargs): ''' Create an instance of the Profiler() class. Requires a coordinate grid and a function object for the profile. A function for the derivative is optional. The functions can also be given as an interpolation object. The optional args and kwargs give the additional arguments for the two function, which are ignored in case func is an interpolation object. The default coordinate grid is evaluated for both the function and the derivative. They are saved in self.y and self.dydx. Alternatively, new evaluations can be attained through eval and diff. Note that if func is an interpolator object, the original input x and y grids can be passed as additional keywords xin and yin, which would then be arrays. Otherwise, the x and the interpolator(x) are set as xin and yin. xin and yin are ignored if func is a function, even if it returns an interpolator (in which case the original grids are known) @param x: The default coordinate points, minimum three points. In the case of an interpolation function, this is the default grid returned by the instance. The original x/y of the interpolated profile are saved as xori/yori in the object. @type x: array @keyword func: The function that describes the profile with respect to x. Can be given as an interp1d object. Default is a read function that interpolates data and returns the interpolator object. If interpolation object, x and eval(x) are assumed to be the original grids, unless xin and yin are given as keywords with arrays as values for the original grids. (default: interp_file) @type func: function/interp1d object @keyword dfunc: Function that describes the derivative of the profile with respect to x. Can be given as an interpolation object. If None, a generic central difference is taken & interpolated with a spline of which the order can be chosen. (default: None) @type dfunc: function/interpolation object @keyword order: Order of the spline interpolation of the derivative. Default is cubic. Not used for the interpolation if func returns an interpolation object. Use read_order in that case. (default: 3) @type order: int @keyword args: Additional parameters passed to the functions when eval or diff are called. (default: []) @type args: tuple @keyword kwargs: Additional keywords passed to the functions when eval or diff are called. (default: {}) @type kwargs: dict ''' #-- Check len of coordinate input. Cannot be less than three for the # derivative. if len(x) < 3: raise ValueError('Coordinate grid must have more than 2 elements.') #-- If the function is given as a string, retrieve it from the local # child module, or from the Profiler module (as parent). If the latter # case then check if the function comes from one of Profiler's # attributes, such as the loaded DataIO module. # Can also simply be a constant value, so try making a float first. if isinstance(func, str): try: #-- Check if a constant was given, rather than a function kwargs['c'] = float(func) func = constant except ValueError: #-- Note that self.module refers to the child, not Profiler if hasattr(sys.modules[self.__module__], func): func = getattr(sys.modules[self.__module__], func) #-- Recursively find the function of loaded modules in Profiler # or a function of the Profiler module itself if no '.' else: func = DataIO.read(func=func,module=sys.modules[__name__],\ return_func=1) #-- set functional args, remember spline order. args/kwargs for # func and dfunc are saved separately. They are removed if either are # interpolation objects. They are always accessible, the _** variables # are passed to the evaluation. self.args = args self.kwargs = kwargs self._args = self.args self._dargs = self.args self._dkwargs = self.kwargs self._kwargs = self.kwargs self.order = order #-- Grab default xin and yin keys in case they are included, and remove # from the arguments dictionary. None if not available. xin = self.kwargs.pop('xin', None) yin = self.kwargs.pop('yin', None) #-- By default no interpolation, so leave this off. self.interp_func = 0 self.interp_dfunc = 0 #-- Defaults for xori/yori, not used in case of normal functions self.xin = np.empty(0) self.yin = np.empty(0) #-- Evaluate the default grid with function. Set x as None first so it # can actually evaluate. Set x once derivative has been evaluated. self.x = None if not (isinstance(func, interp1d) or isinstance(func, UnivariateSpline)): #-- Evaluate the function, and check what is returned: array or # interpolation object y = func(x, *args, **kwargs) #-- Interpolation object: so set that as this instance's func. In # this case, the variable x passed to the class is the default x # grid of this instance. The original x/y-grid is saved as xi, yi if isinstance(y, tuple): self.func = y[2] self.xin = y[0] self.yin = y[1] self._args = [] self._kwargs = {} self.interp_func = 1 self.y = self.func(x) else: self.func = func self.y = y #-- func is an interpolation object, so just run the normal evaluation. # Set _args/_kwargs to empty, so none are ever passed to the interpol else: self.func = func self._args = [] self._kwargs = {} self.interp_func = 1 self.y = self.func(x) self.yin = yin if not yin is None else self.y self.xin = xin if not xin is None else x #-- Set the derivative function, resorting to default if needed if not dfunc is None: self.dfunc = dfunc elif self.func == constant: self.dfunc = zero else: #-- Extend array slightly to allow odeint to succeed. # Need better fix for this. #x0 = x[0]-(x[1]-x[0])#*0.5 #xn = x[-1]+(x[-1]-x[-2])#*0.5 #x_ext = np.hstack([[x0],x,[xn]]) #-- Evaluate the function, and set up an interpolator for # central difference. The interpolator will extrapolate # beyond the given x range. This is necessary for odeint to work. # Usually x-range is not exceeded much. self.dfunc = spline1d(x=x,y=op.diff_central(self.y,x),\ k=self.order) if (isinstance(self.dfunc,interp1d) \ or isinstance(self.dfunc,UnivariateSpline)): self._dargs = [] self._dkwargs = {} self.interp_dfunc = 1 #-- Evaluate the derivative with the default grid self.dydx = self.dfunc(x, *self._dargs, **self._dkwargs) #-- Now set x. self.x = Data.arrayify(x)
def doDataStats(self,method='clipping'): ''' Calculate mean, std, rms for the data files. They are saved in self.data_stats. @keyword method: Std/Mean/RMS determination method. Can be 'clipping' or 'preset'. The former 1-sigma clips based on mean/std/... of full spectrum, then takes mean/std/... of clipped spectrum. Latter takes preset values from Data.dat. (default: 'clipping') @type method: string ''' method = method.lower() if method not in ['preset','clipping']: method = 'clipping' self.data_stats = dict() if self.instrument: if not self.data_info: self.setDataInfo() for filename,data_wave,data_flux,band in \ zip(self.instrument.data_filenames,\ self.instrument.data_wave_list,\ self.instrument.data_flux_list,\ self.instrument.data_ordernames): these_stats = dict() iband = self.data_info['bands'].index(band) these_stats['sigma'] = self.data_info['sigmas'][iband] if method == 'preset': w_std_min = self.data_info['w_std_min'][iband] w_std_max = self.data_info['w_std_max'][iband] if w_std_min < data_wave[0] or w_std_max > data_wave[-1]: method = 'clipping' test_mean = Data.getMean(wave=data_wave,flux=data_flux,\ wmin=w_std_min,wmax=w_std_max) if test_mean is None: method = 'clipping' if method == 'clipping': totmean = Data.getMean(wave=data_wave,flux=data_flux) totstd = Data.getStd(wave=data_wave,flux=data_flux) limits = (-totstd,totstd) these_stats['mean'] = Data.getMean(flux=data_flux,\ limits=limits) these_stats['std'] = Data.getStd(flux=data_flux,\ limits=limits) these_stats['rms'] = Data.getRMS(flux=data_flux-\ these_stats['mean'],\ limits=limits) else: these_stats['mean'] = Data.getMean(wave=data_wave,\ flux=data_flux,\ wmin=w_std_min,\ wmax=w_std_max) these_stats['std'] = Data.getStd(wave=data_wave,\ flux=data_flux,\ wmin=w_std_min,\ wmax=w_std_max) these_stats['rms'] = Data.getRMS(wave=data_wave,\ flux=data_flux-\ these_stats['mean'],\ wmin=w_std_min,\ wmax=w_std_max) print '* Data statistics for %s using "%s" method:'\ %(filename,method) if method == 'preset': print '* Taken between %.2f and %.2f micron.'\ %(w_std_min,w_std_max) print 'mean = ',these_stats['mean'],' Jy' print 'std = ',these_stats['std'],' Jy' print 'RMS = ',these_stats['rms'],' Jy' self.data_stats[filename] = these_stats print '***********************************'
def prepInput(star,path,repl_str=''): ''' Prepare inputfiles for LIME from a GASTRoNOoM and MCMax model. Input is taken from the model ouput and written into files. The output folder can be chosen. The model_id tag can be replaced with an arbitrary string. Input is converted to SI units, except opacities, which are in cm2/g. @param star: The model object including the GASTRoNOoM and MCMax model ids. @type star: Star() @param path: The target folder for the files. @type path: str @keyword repl_str: Replacement string for the model_id tag. (default: '') @type repl_str: str ''' #-- First opacities and t_dust, which are not part of the GASTRoNOoM output mcmid = star['LAST_MCMAX_MODEL'] fnopac = os.path.join(path,'opac_%s.dat'%(repl_str and repl_str or mcmid)) DataIO.writeCols(fnopac,star.getWeightedKappas()) #-- Write dust temperature to a file. fntd = os.path.join(path,'td_%s.dat'%(repl_str and repl_str or mcmid)) rad = star.getDustRad(unit='m') td = star.getDustTemperature() DataIO.writeCols(fntd,[rad,td]) #-- Finally the gas properties if not repl_str: repl_str = star['LAST_GASTRONOOM_MODEL'] #-- Radius for nh2 and vel rad = star.getGasRad(unit='m',ftype='fgr_all') if rad.size > 10000: icutoff = np.argmin(abs(rad-1e14)) rad = Data.reduceArray(rad,20,1e14,'remove') else: icutoff = None #-- h2 number density nh2 = star.getGasNumberDensity(ftype='fgr_all') nh2 = nh2*10**6 if not icutoff is None: nh2 = Data.reduceArray(nh2,20,nh2[icutoff],'remove') fnnh2 = os.path.join(path,'nh2_%s.dat'%repl_str) DataIO.writeCols(fnnh2,[rad,nh2]) #-- Velocity profile vel = star.getGasVelocity(ftype='fgr_all') vel = vel*10**-2 if not icutoff is None: vel = Data.reduceArray(vel,20,vel[icutoff],'remove') fnvel = os.path.join(path,'vg_%s.dat'%repl_str) DataIO.writeCols(fnvel,[rad,vel]) #-- CO abundance rad = star.getGasRad(ftype='1',mstr='12C16O',unit='m') nh2 = star.getGasNumberDensity(ftype='1',mstr='12C16O') nco = star.getGasNumberDensity(ftype='1',mstr='12C16O',molecule=1) aco = nco/nh2 fnaco = os.path.join(path,'aco_%s.dat'%repl_str) DataIO.writeCols(fnaco,[rad,aco])
def __init__(self, x, y, func, *args, **kwargs): ''' Create an instance of the Profiler2D() class. Requires 2 coordinate arrays and a function object for profile. The function can also be given as an interpolation object. The optional args and kwargs give the additional arguments for the function, which are ignored in case func is an interpolation object. The default coordinate grids are both evaluated for the function. They are saved in self.z, as an array of dimensions (x.size,y.size). Alternatively, new evaluations can be attained through eval and diff. @param x: The default coordinates of the primary independent variable. Minimum three points. @type x: array @param y: The default coordinates of the secondary independent variable. Minimum three points. @type y: array @param func: The function that describes the profile with respect to x and y. Can be given as a 2D interpolation object. @type func: function/interpolation object @keyword args: Additional parameters passed to the functions when eval or diff are called. (default: []) @type args: tuple @keyword kwargs: Additional keywords passed to the functions when eval or diff are called. (default: {}) @type kwargs: dict ''' #-- If the function is given as a string, retrieve it from the local # child module, or from the Profiler module (as parent). If the latter # check if the function comes from one of Profiler's attributes, such # as the loaded DataIO module. if isinstance(func, str): try: #-- Note that self.module refers to the child, not Profiler func = getattr(sys.modules[self.__module__], func) except AttributeError: #-- Recursively find the function of loaded modules in Profiler # or a function of the Profiler module itself if no '.' func = DataIO.read(sys.modules[__name__], return_func=1) #-- set functional args, remember spline order. args/kwargs for # func are saved separately. They are removed if either are # interpolation objects. They are always accessible, the _** variables # are passed to the evaluation. self.args = args self.kwargs = kwargs self._args = args self._kwargs = kwargs self.func = func if isinstance(self.func,interp2d) \ or isinstance(self.func,BivariateSpline): self.interp_func = 1 self._args = [] self._kwargs = {} else: self.interp_func = 0 #-- Evaluate the default grid with function. Set x as None first so it # can actually evaluate. self.x = None self.y = None self.z = self.func(x, y, *self._args, **self._kwargs) #-- Now set x and y. Make sure they are arrays. self.x = Data.arrayify(x) self.y = Data.arrayify(y)