def init_boundary_guard( file, param_limits, bg_lim, invalid_llh, prior=False, Tprior=None, custom_objects=None, ): if custom_objects == None: model = tf.keras.models.load_model(file) else: model = tf.keras.models.load_model(file, custom_objects=custom_objects) param_limits = tf.constant(param_limits, tf.float32) bg_lim = tf.constant(bg_lim, tf.float32) invalid_llh = tf.constant(invalid_llh, tf.float32) prior = tf.constant(prior, tf.bool) if Tprior is not None: with open(Tprior, "rb") as F: Tprior = pickle.load(F) Tprior = UnivariateSpline._from_tck(Tprior) Tprior.ext = 1 return dict( model=model, param_limits=param_limits, bg_lim=bg_lim, invalid_llh=invalid_llh, prior=prior, Tprior=Tprior, )
def _spline_dirichlet(self, x, y, k, s, w=None): """ Parameters ---------- x : array_like Input x coordinate values. y : array_like Input y coordinate values. k : int Degree of Spline polynomial. s : float (between 0 and 1) Sensitivity parameter (0 is for interpolating, 1 is for maximal smoothing). w : array_like, optional Predefined weights. Returns ------- spline: UnivariateSpline Returns Spline which best suits given minimization problem. """ t, c0, k = self._guess(x, y, k, s, w=w) con = { 'type': 'eq', 'fun': lambda c: splev(0, (t, c, k), der=0) - 1, } opt = minimize(self._err, c0, (x, y, t, k, w), constraints=con) copt = opt.x return UnivariateSpline._from_tck((t, copt, k))
def optimized_spline(x, y, k=3, s=0, w=None): t, c0, k = splrep(x, y, w, k=k, s=s) x0 = x[0] constraint = {} constraint['type'] = 'eq' constraint['fun'] = lambda c: splev(x0, (t, c, k), der=1) constraints = [constraint] res = minimize(error_function, c0, (x, y, t, k, w), constraints=constraints) return UnivariateSpline._from_tck((t, res.x, k))
def load_splines(dye='BPB', file=None): """ Load saved splines for """ splines = load_spline_tcks(file)[dye] return { k: UnivariateSpline._from_tck(tck_2_array(tck)) for k, tck in splines.items() }
def optimized_spline(x, y, k=3, s=0, w=None): t, c0, k = splrep(x, y, w, k=k, s=s) x0 = x[0] constraint = {} constraint['type'] = 'eq' constraint['fun'] = lambda c: splev(x0, (t, c, k), der=1) constraints = [constraint] res = minimize(error_function, c0, (x, y, t, k, w), constraints=constraints) return UnivariateSpline._from_tck((t, res.x, k))
def _load_pion_function(self): """Returns the universal function on a fixed energy range """ from pickle import load as pickle_load from scipy.interpolate import UnivariateSpline uf_file = join(global_path, 'data/pion_spline.pkl') with open(uf_file, 'r') as f: tck = pickle_load(f) self.pion_spl = UnivariateSpline._from_tck(tck)
def _load_pion_function(self): """Returns the universal function on a fixed energy range """ from pickle import load as pickle_load from scipy.interpolate import UnivariateSpline uf_file = join(config.data_dir, 'pion_spline.pkl') with open(uf_file, 'rb') as f: tck = pickle_load(f, encoding='latin1') self.pion_spl = UnivariateSpline._from_tck(tck)
def spline_neumann(x, y, k=3, s=0, w=None): t, c0, k = guess(x, y, k, s, w=w) x0 = x[0] # point at which zero slope is required con = { 'type': 'eq', 'fun': lambda c: splev(x0, (t, c, k), der=1), #'jac': lambda c: splev(x0, (t, c, k), der=2) # doesn't help, dunno why } opt = minimize(err, c0, (x, y, t, k, w), constraints=con) copt = opt.x return UnivariateSpline._from_tck((t, copt, k))
def alphapi(energies): """Returnes the scaling coefficient for pions as a function of energy Arguments --------- energies -- {array, float} energies where to evaluate, in GeV """ tp1 = 10**(-.18) tp2 = 10**(.55) he_alphapi = UnivariateSpline._from_tck(tck, ext=3) # ext='const' api = 2./3 * np.ones_like(energies) api[(tp1 < energies) * (energies < tp2)] = sigm( np.log10(energies[(tp1 < energies) * (energies < tp2)]), .2, .25, 8, .65, True) api[tp2 <= energies] = he_alphapi(np.log10(energies[tp2 <= energies])) return api
def function(self, x, *coefs): # Order of polynomial k = self.k # Number of coefficients n = k + 1 # Knot positions t_arr = np.zeros(n * 2, dtype=float) t_arr[:n] = min(x) t_arr[n:] = max(x) # Coefficients c_arr = np.zeros(n * 2, dtype=float) c_arr[:n] = coefs # Build Spline function tck = [t_arr, c_arr, k] model = UnivariateSpline._from_tck(tck) # Return predicted function return model(x)
def qeModel(ext): """ This function returns a callable object that returns the QE of a CCD (relative to CCD2) as a function of wavelength(s) in nm. The QE data is provided as a dict, keyed by the array_name() descriptor of the CCD. The value is either a list (interpreted as polynomial coefficients) or a dict describing a spline. NB. Spline objects defined in the dict return the decimal logarithm of the relative QE, while polynomials simply return the relative QE. In addition, if the model changes, the value can be a dict keyed by the earliest UT date at which each model should be applied. Parameters ---------- ext: single-slice AstroData object the extension to calculate the QE coefficients for Returns ------- callable: a function to convert wavelengths in nm to relative QE """ # All coefficients are for nm (not AA as in G-IRAF) qeData = { # GMOS-N EEV CCD1 and 3 "EEV_9273-16-03": [9.883090E-1, -1.390254E-5, 5.282149E-7, -6.847360E-10], "EEV_9273-20-03": [9.699E-1, 1.330E-4, -2.082E-7, 1.206E-10], # GMOS-N Hamamatsu CCD1 and 3 "BI13-20-4k-1": {"order": 3, "knots": [366.5, 413.500044, 435.500048, 465.000052, 478.500054, 507.500058, 693.000014, 1062.000039], "coeffs": [1.20848283, 1.59132929, 1.58317142, 1.25123198, 1.14410563, 0.98095206, 0.83416436, 1.03247587, 1.15355675, 1.10176507]}, "BI13-18-4k-2": {"order": 3, "knots": [341.750054, 389.500062, 414.000067, 447.500006, 493.000079, 592.000013, 694.500021, 1057.000048], "coeffs": [0.90570141, 0.99834392, 1.6311227 , 1.47271364, 1.13843214, 0.91170917, 0.88454097, 1.06456595, 1.16684561, 1.10476059]}, # IRAF coefficients #"BI13-20-4k-1": [-2.45481760e+03, 3.24130657e+01, -1.87380500e-01, # 6.23494400e-04, -1.31713482e-06, 1.83308885e-09, # -1.68145852e-12, 9.80603592e-16, -3.30016761e-19, # 4.88466076e-23], #"BI13-18-4k-2": [3.48333720e+03, -5.27904605e+01, 3.48210500e-01, # -1.31286828e-03, 3.12154994e-06, -4.85949692e-09, # 4.95886638e-12, -3.20198283e-15, 1.18833302e-18, # -1.93303639e-22], # GMOS-S EEV CCD1 and 3 "EEV_2037-06-03": {"1900-01-01": [2.8197, -8.101e-3, 1.147e-5, -5.270e-9], "2006-08-31": [2.225037, -4.441856E-3, 5.216792E-6, -1.977506E-9]}, "EEV_8261-07-04": {"1900-01-01": [1.3771, -1.863e-3, 2.559e-6, -1.0289e-9], "2006-08-31": [8.694583E-1, 1.021462E-3, -2.396927E-6, 1.670948E-9]}, # GMOS-S Hamamatsu CCD1 and 3 "BI5-36-4k-2": [-6.00810046e+02, 6.74834788e+00, -3.26251680e-02, 8.87677395e-05, -1.48699188e-07, 1.57120033e-10, -1.02326999e-13, 3.75794380e-17, -5.96238257e-21], "BI12-34-4k-1": [7.44793105e+02, -1.22941630e+01, 8.83657074e-02, -3.62949805e-04, 9.40246850e-07, -1.59549327e-09, 1.77557909e-12, -1.25086490e-15, 5.06582071e-19, -8.99166534e-23] } array_name = ext.array_name().split(',')[0] try: data = qeData[array_name] except KeyError: return None # Deal with date-dependent changes if isinstance(data, dict) and 'knots' not in data: obs_date = ext.ut_date() for k in sorted(data): if obs_date >= datetime.strptime(k, "%Y-%m-%d"): use_data = data[k] data = use_data # data is either a dict defining a spline that defines QE # or a list of polynomial coefficients that define QE if 'knots' in data: # Duplicate the knots at either end for the correct format order = data["order"] knots = data["knots"] knots[0:0] = [knots[0]] * order knots.extend(knots[-1:] * order) coeffs = data["coeffs"] + [0] * (order+1) spline = UnivariateSpline._from_tck((knots, coeffs, order)) return spline else: model_params = {'c{}'.format(i): c for i, c in enumerate(data)} model = models.Polynomial1D(degree=len(data)-1, **model_params) return model
def qeModel(ext): """ This function returns a callable object that returns the QE of a CCD (relative to CCD2) as a function of wavelength(s) in nm. The QE data is provided as a dict, keyed by the array_name() descriptor of the CCD. The value is either a list (interpreted as polynomial coefficients) or a dict describing a spline. NB. Spline objects defined in the dict return the decimal logarithm of the relative QE, while polynomials simply return the relative QE. In addition, if the model changes, the value can be a dict keyed by the earliest UT date at which each model should be applied. Parameters ---------- ext: single-slice AstroData object the extension to calculate the QE coefficients for Returns ------- callable: a function to convert wavelengths in nm to relative QE """ # All coefficients are for nm (not AA as in G-IRAF) qeData = { # GMOS-N EEV CCD1 and 3 "EEV_9273-16-03": [9.883090E-1, -1.390254E-5, 5.282149E-7, -6.847360E-10], "EEV_9273-20-03": [9.699E-1, 1.330E-4, -2.082E-7, 1.206E-10], # GMOS-N Hamamatsu CCD1 and 3 "BI13-20-4k-1": { "order": 3, "knots": [ 358.0, 380.0, 428.0, 468.0, 576.0, 648.0, 798.0, 932.0, 966.0, 994.0, 1010.0, 1028.0, 1044.0, 1076.0 ], "coeffs": [ 0.014629039930259876, 0.10133317072093591, 0.2384728514854233, 0.0778544705196136, -0.06232251896695778, -0.0671226704286497, 0.0017962888751030116, 0.02399802448657926, 0.06062000896013293, 0.04661836594286457, 0.05694058456700794, 0.020108979328507717, 0.00719658389760285, 0.029938578274652766, 0.05265151968369216, 0.04654560999567498 ] }, "BI13-18-4k-2": { "order": 3, "knots": [ 358.0, 432.0, 476.0, 520.0, 602.0, 640.0, 678.0, 752.0, 914.0, 1002.0, 1040.0, 1076.0 ], "coeffs": [ 0.02206208508099143, 0.2834094598715138, 0.07132646057310524, -0.01980030661665999, -0.05201598712929662, -0.06777120754328926, -0.012413172958416104, -0.015591358664326838, 0.03433933272643748, 0.04127142803163095, 0.06235368833554948, -0.008691968589858072, 0.06049075935311075, 0.0484080146014316 ] }, # GMOS-S EEV CCD1 and 3 "EEV_2037-06-03": { "1900-01-01": [2.8197, -8.101e-3, 1.147e-5, -5.270e-9], "2006-08-31": [2.225037, -4.441856E-3, 5.216792E-6, -1.977506E-9] }, "EEV_8261-07-04": { "1900-01-01": [1.3771, -1.863e-3, 2.559e-6, -1.0289e-9], "2006-08-31": [8.694583E-1, 1.021462E-3, -2.396927E-6, 1.670948E-9] }, # GMOS-S Hamamatsu CCD1 and 3 "BI5-36-4k-2": [ -6.00810046e+02, 6.74834788e+00, -3.26251680e-02, 8.87677395e-05, -1.48699188e-07, 1.57120033e-10, -1.02326999e-13, 3.75794380e-17, -5.96238257e-21 ], "BI12-34-4k-1": [ 7.44793105e+02, -1.22941630e+01, 8.83657074e-02, -3.62949805e-04, 9.40246850e-07, -1.59549327e-09, 1.77557909e-12, -1.25086490e-15, 5.06582071e-19, -8.99166534e-23 ] } array_name = ext.array_name().split(',')[0] try: data = qeData[array_name] except KeyError: return None # Deal with date-dependent changes if isinstance(data, dict) and 'knots' not in data: obs_date = ext.ut_date() for k in sorted(data): if obs_date >= datetime.strptime(k, "%Y-%m-%d"): use_data = data[k] data = use_data # data is either a dict defining a spline that defines log10(QE) # or a list of polynomial coefficients that define QE if 'knots' in data: # Duplicate the knots at either end for the correct format order = data["order"] knots = data["knots"] knots[0:0] = [knots[0]] * order knots.extend(knots[-1:] * order) coeffs = data["coeffs"] + [0] * (order + 1) spline = UnivariateSpline._from_tck((knots, coeffs, order)) return lambda x: 10**spline(x) else: model_params = {'c{}'.format(i): c for i, c in enumerate(data)} model = models.Polynomial1D(degree=len(data) - 1, **model_params) return model