def perturb_detector(self, params, which): logH = 0.0 if which == ba_idx: #lets call this phi params[which] += (tf_phi_max + np.pi/2)*dnest4.randh() params[which] = dnest4.wrap(params[which], -np.pi/2, tf_phi_max) elif which == c_idx: #call it omega params[which] += 0.1*dnest4.randh() params[which] = dnest4.wrap(params[which], 0.07, 0.2) elif which == dc_idx: #d params[which] += 0.01*dnest4.randh() params[which] = dnest4.wrap(params[which], 0.7, 0.9) elif which == rc1_idx or which == rc2_idx or which == rcfrac_idx: #all normally distributed priors logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 params[which] += prior_vars[which]*dnest4.randh() logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 elif which == aliasrc_idx: params[which] += 9.9*dnest4.randh() params[which] = dnest4.wrap(params[which], 0.1, 10) elif which == grad_idx: logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 params[which] += prior_vars[which] *dnest4.randh() params[which] = dnest4.wrap(params[which], detector.gradList[0], detector.gradList[-1]) logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 elif which == imp_avg_idx: logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 params[which] += prior_vars[which] *dnest4.randh() params[which] = dnest4.wrap(params[which], detector.impAvgList[0], detector.impAvgList[-1]) logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 elif which == trap_idx: params[which] += (1000 - traprc_min)*dnest4.randh() params[which] = dnest4.wrap(params[which], traprc_min, 1000) elif which >= velo_first_idx and which < velo_first_idx+4: logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 params[which] += prior_vars[which]*dnest4.randh() params[which] = dnest4.wrap(params[which], 1, priors[which]*10) logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 elif which == velo_first_idx+4 or which == velo_first_idx+5: params[which] += (beta_lims[1] - beta_lims[0]) *dnest4.randh() params[which] = dnest4.wrap(params[which], beta_lims[0], beta_lims[1]) else: #velocity or rc params: cant be below 0, can be arb. large print ("which value %d not supported" % which) exit(0) return logH
def random_position(r, z): r_init, z_init = r, z r += dnest4.randh() * 0.1 z += dnest4.randh() * 0.1 r = dnest4.wrap(r, 0, detector.detector_radius) z = dnest4.wrap(z, 0, detector.detector_length) if not detector.IsInDetector(r, 0.1, z): # print "not in detector..." return random_position(r_init, z_init) else: return (r, z)
def random_position(r, z): r_init,z_init = r,z r += dnest4.randh()*0.1 z += dnest4.randh()*0.1 r = dnest4.wrap(r, 0, detector.detector_radius) z = dnest4.wrap(z, 0, detector.detector_length) if not detector.IsInDetector(r, 0.1, z): # print "not in detector..." return random_position(r_init,z_init) else: return (r,z)
def get_new_rad(self, rad, theta): detector = self.detector #FIND THE MAXIMUM RADIUS STILL INSIDE THE DETECTOR theta_eq = np.arctan(detector.detector_length / detector.detector_radius) theta_taper = np.arctan(detector.taper_length / detector.detector_radius) if theta <= theta_taper: z = np.tan(theta) * (detector.detector_radius - detector.taper_length) / (1 - np.tan(theta)) max_rad = z / np.sin(theta) elif theta <= theta_eq: max_rad = detector.detector_radius / np.cos(theta) else: theta_comp = np.pi / 2 - theta max_rad = detector.detector_length / np.cos(theta_comp) #AND THE MINIMUM (from PC dimple) #min_rad = 1./ ( np.cos(theta)**2/detector.pcRad**2 + np.sin(theta)**2/detector.pcLen**2 ) min_rad = np.amax([detector.pcRad, detector.pcLen]) new_rad = rad + (max_rad - min_rad) * dnest4.randh() new_rad = dnest4.wrap(new_rad, min_rad, max_rad) return new_rad
def perturb(self, params): """ Perturb the current parameters by proposing a new position. This takes a numpy array of parameters as input, and modifies it in-place. In just perturbs one parameter at a time. Args: params (:class:`np.ndarray`): the current parameters (this is modified by the function) Returns: float: the natural logarithm of the Metropolis-Hastings proposal ratio. """ logH = 0.0 # log of the Metropolis-Hastings prior x proposal ratio # randomly choose which parameter to perturb which = np.random.randint(len(params)) mmu = 0. msigma = 10. if which == 0: # update H for Gaussian prior logH -= -0.5 * ((params[which] - mmu) / msigma)**2 params[which] += 1. * randh( ) # scale factor of 1. (randh is a heavy-tailed distribution to occasionally sample distant values, although this isn't really required in this case) if which == 0: # update H for Gaussian prior logH += -0.5 * ((params[which] - mmu) / msigma)**2 else: # wrap c value so that it stays within the prior range params[which] = wrap(params[which], cmin, cmax) return logH
def perturb(self, params): """ Perturb the current parameters by proposing a new position. This takes a numpy array of parameters as input, and modifies it in-place. In just perturbs one parameter at a time. Args: params (:class:`np.ndarray`): the current parameters (this is modified by the function) Returns: float: the natural logarithm of the Metropolis-Hastings proposal ratio. """ logH = 0.0 # log of the Metropolis-Hastings prior x proposal ratio # randomly choose which parameter to perturb which = np.random.randint(len(params)) mmu = 0. msigma = 10. if which == 0: # update H for Gaussian prior logH -= -0.5*((params[which]-mmu)/msigma)**2 params[which] += 1.*randh() # scale factor of 1. (randh is a heavy-tailed distribution to occasionally sample distant values, although this isn't really required in this case) if which == 0: # update H for Gaussian prior logH += -0.5*((params[which]-mmu)/msigma)**2 else: # wrap c value so that it stays within the prior range params[which] = wrap(params[which], cmin, cmax) return logH
def get_new_theta(self,rad,theta): detector = self.detector if rad < np.amin([detector.detector_radius - detector.taper_length, detector.detector_length]): max_val = np.pi/2 min_val = 0 else: if rad < detector.detector_radius - detector.taper_length: #can't possibly hit the taper min_val = 0 elif rad < np.sqrt(detector.detector_radius**2 + detector.taper_length**2): #low enough that it could hit the taper region a = detector.detector_radius - detector.taper_length z = 0.5 * (np.sqrt(2*rad**2-a**2) - a) min_val = np.arcsin(z/rad) else: #longer than could hit the taper min_val = np.arccos(detector.detector_radius/rad) if rad < detector.detector_length: max_val = np.pi/2 else: max_val = np.pi/2 - np.arccos(detector.detector_length/rad) new_theta = theta + (max_val - min_val)*dnest4.randh() new_theta = dnest4.wrap(new_theta, min_val, max_val) return new_theta
def get_new_theta(self, rad, theta): detector = self.detector if rad < np.amin([ detector.detector_radius - detector.taper_length, detector.detector_length ]): max_val = np.pi / 2 min_val = 0 else: if rad < detector.detector_radius - detector.taper_length: #can't possibly hit the taper min_val = 0 elif rad < np.sqrt(detector.detector_radius**2 + detector.taper_length**2): #low enough that it could hit the taper region a = detector.detector_radius - detector.taper_length z = 0.5 * (np.sqrt(2 * rad**2 - a**2) - a) min_val = np.arcsin(z / rad) else: #longer than could hit the taper min_val = np.arccos(detector.detector_radius / rad) if rad < detector.detector_length: max_val = np.pi / 2 else: max_val = np.pi / 2 - np.arccos(detector.detector_length / rad) new_theta = theta + (max_val - min_val) * dnest4.randh() new_theta = dnest4.wrap(new_theta, min_val, max_val) return new_theta
def perturb(self, params): """ Unlike in C++, this takes a numpy array of parameters as input, and modifies it in-place. The return value is still logH. """ logH = 0.0 which = rng.randint(3) if which == 0 or which == 1: logH -= -0.5*(params[which]/1E3)**2 params[which] += 1E3*dnest4.randh() logH += -0.5*(params[which]/1E3)**2 else: log_sigma = np.log(params[2]) log_sigma += 20*dnest4.randh() # Note the difference between dnest4.wrap in Python and # DNest4::wrap in C++. The former *returns* the wrapped value. log_sigma = dnest4.wrap(log_sigma, -10.0, 10.0) params[2] = np.exp(log_sigma) return logH
def perturb_gaussian_parameter(self, parameter): mu = self.mean var = self.variance logH = 0 logH -= -0.5*((parameter - mu)/var)**2 parameter += var*dnest4.randh() if (self.lim_lo > -max_float) or (self.lim_hi<np.inf): parameter = dnest4.wrap(parameter, self.lim_lo, self.lim_hi) logH += -0.5*((parameter - mu)/var)**2 return (logH, parameter)
def perturb(self, params): """ Unlike in C++, this takes a numpy array of parameters as input, and modifies it in-place. The return value is still logH. """ logH = 0.0 which = rng.randint(3) if which == 0 or which == 1: logH -= -0.5 * (params[which] / 1E3)**2 params[which] += 1E3 * dnest4.randh() logH += -0.5 * (params[which] / 1E3)**2 else: log_sigma = np.log(params[2]) log_sigma += 20 * dnest4.randh() # Note the difference between dnest4.wrap in Python and # DNest4::wrap in C++. The former *returns* the wrapped value. log_sigma = dnest4.wrap(log_sigma, -10.0, 10.0) params[2] = np.exp(log_sigma) return logH
def perturb(self, params): """ Unlike in C++, this takes a numpy array of parameters as input, and modifies it in-place. The return value is still logH. """ logH = 0.0 which = rng.randint(len(params)) if which == 0: params[which] += (detector.detector_radius) * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, detector.detector_radius) elif which == 1: max_val = np.pi / 4 params[which] += np.pi / 4 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, max_val) if params[which] < 0 or params[which] > np.pi / 4: print "wtf phi" #params[which] = np.clip(params[which], 0, max_val) elif which == 2: params[which] += (detector.detector_length) * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, detector.detector_length) elif which == 3: #scale min_scale = wf.wfMax - 0.01 * wf.wfMax max_scale = wf.wfMax + 0.005 * wf.wfMax params[which] += (max_scale - min_scale) * dnest4.randh() params[which] = dnest4.wrap(params[which], min_scale, max_scale) # print " adjusted scale to %f" % ( params[which]) elif which == 4: #t0 params[which] += 1 * dnest4.randh() params[which] = dnest4.wrap(params[which], min_maxt, max_maxt) elif which == 5: #smooth params[which] += 0.1 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 25) # print " adjusted smooth to %f" % ( params[which]) # elif which == 6: #wf baseline slope (m) # logH -= -0.5*(params[which]/1E-4)**2 # params[which] += 1E-4*dnest4.randh() # logH += -0.5*(params[which]/1E-4)**2 # elif which == 7: #wf baseline incercept (b) # logH -= -0.5*(params[which]/1E-2)**2 # params[which] += 1E-2*dnest4.randh() # logH += -0.5*(params[which]/1E-2)**2 # params[which] += 0.01*dnest4.randh() # params[which]=dnest4.wrap(params[which], -1, 1) # print " adjusted b to %f" % ( params[which]) else: #velocity or rc params: cant be below 0, can be arb. large print "which value %d not supported" % which exit(0) return logH
def perturb_detector(self, params): which = rng.randint(len(priors)) if which == ba_idx: #b over a params[which] += 0.1 * dnest4.randh() params[which] = dnest4.wrap(params[which], -0.9, 15) elif which == c_idx: #b over a params[which] += 0.01 * dnest4.randh() params[which] = dnest4.wrap(params[which], -0.9, -0.7) elif which == dc_idx: #b over a params[which] += 0.01 * dnest4.randh() params[which] = dnest4.wrap(params[which], -1.05, -0.975) elif which == rc1_idx: params[which] += 30 * dnest4.randh() params[which] = dnest4.wrap(params[which], 60, 90) elif which == rc2_idx: params[which] += 5 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 5) elif which == rcfrac_idx: params[which] += 0.1 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0.9, 1) elif which == grad_idx: params[which] += (len(detector.gradList) - 1) * dnest4.randh() params[which] = np.int( dnest4.wrap(params[which], 0, len(detector.gradList) - 1)) elif which >= velo_first_idx and which < velo_first_idx + 6: params[which] += (velo_width * priors[which] - 1 / velo_width * priors[which]) * dnest4.randh() params[which] = dnest4.wrap(params[which], 0.1 * priors[which], (10.) * priors[which]) elif which == trap_idx: log_traprc = np.log(params[which]) log_traprc += 20 * dnest4.randh() log_traprc = dnest4.wrap(log_traprc, 0., 20.0) params[which] = np.exp(log_traprc) else: #velocity or rc params: cant be below 0, can be arb. large print "which value %d not supported" % which exit(0)
def perturb_detector(self, params): which = rng.randint(len(priors)) if which == ba_idx: #b over a params[which] += 0.1*dnest4.randh() params[which] = dnest4.wrap(params[which], -0.9, 15) elif which == c_idx: #b over a params[which] += 0.01*dnest4.randh() params[which] = dnest4.wrap(params[which], -0.9, -0.7) elif which == dc_idx: #b over a params[which] += 0.01*dnest4.randh() params[which] = dnest4.wrap(params[which], -1.05, -0.975) elif which == rc1_idx: params[which] += 30*dnest4.randh() params[which] = dnest4.wrap(params[which], 60, 90) elif which == rc2_idx: params[which] += 5*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 5) elif which == rcfrac_idx: params[which] += 0.1*dnest4.randh() params[which] = dnest4.wrap(params[which], 0.9, 1) elif which == grad_idx: params[which] += (len(detector.gradList)-1)*dnest4.randh() params[which] = np.int(dnest4.wrap(params[which], 0, len(detector.gradList)-1)) elif which >= velo_first_idx and which < velo_first_idx+6: params[which] += (velo_width*priors[which] - 1/velo_width*priors[which]) *dnest4.randh() params[which] = dnest4.wrap(params[which], 0.1*priors[which], (10.)*priors[which]) elif which == trap_idx: log_traprc = np.log(params[which]) log_traprc += 20*dnest4.randh() log_traprc = dnest4.wrap(log_traprc, 0., 20.0) params[which] = np.exp(log_traprc) else: #velocity or rc params: cant be below 0, can be arb. large print "which value %d not supported" % which exit(0)
def get_new_rad(self,rad, theta): detector = self.detector #FIND THE MAXIMUM RADIUS STILL INSIDE THE DETECTOR theta_eq = np.arctan(detector.detector_length/detector.detector_radius) theta_taper = np.arctan(detector.taper_length/detector.detector_radius) if theta <= theta_taper: z = np.tan(theta)*(detector.detector_radius - detector.taper_length) / (1-np.tan(theta)) max_rad = z / np.sin(theta) elif theta <= theta_eq: max_rad = detector.detector_radius / np.cos(theta) else: theta_comp = np.pi/2 - theta max_rad = detector.detector_length / np.cos(theta_comp) #AND THE MINIMUM (from PC dimple) #min_rad = 1./ ( np.cos(theta)**2/detector.pcRad**2 + np.sin(theta)**2/detector.pcLen**2 ) min_rad = np.amax([detector.pcRad, detector.pcLen]) new_rad = rad + (max_rad - min_rad)*dnest4.randh() new_rad = dnest4.wrap(new_rad, min_rad, max_rad) return new_rad
def perturb(self, params): """ Each step we perturb all the parameters which is more effective from computation point of view. """ logH = 0.0 parDict = self.__model.get_modelParDict() pIndex = 0 for modelName in self.__model._modelList: parFitDict = parDict[modelName] for parName in parFitDict.keys(): parRange = parFitDict[parName]["range"] parType = parFitDict[parName]["type"] if parType == "c": #print "[DN4M]: continual" r1, r2 = parRange params[pIndex] += ( r2 - r1) * dnest4.randh() #Uniform distribution if (params[pIndex] < r1) or (params[pIndex] > r2): #print "[DNest4Model]: perturb out boundary!" logH -= np.inf elif parType == "d": #print "[DN4M]: discrete" rangeLen = len(parRange) iBng = -1 * parRange.index(params[pIndex]) iPar = iBng + rng.randint(rangeLen) params[pIndex] = parRange[iPar] if not params[pIndex] in parRange: #print "[DNest4Model]: perturb out boundary!" logH -= np.inf else: raise TypeError( "The parameter type '{0}' is not recognised!".format( parType)) parFitDict[parName]["value"] = params[pIndex] pIndex += 1 return logH
def perturb_uniform_parameter(self, parameter): logH = 0 parameter += (self.lim_hi - self.lim_lo) *dnest4.randh() parameter = dnest4.wrap(parameter, self.lim_lo, self.lim_hi) return (logH, parameter)
def perturb(self, params): """ Unlike in C++, this takes a numpy array of parameters as input, and modifies it in-place. The return value is still logH. """ logH = 0.0 reps = 1; if(rng.rand() < 0.5): reps += np.int(np.power(100.0, rng.rand())); # print "going to perturb %d reps" % reps for i in range(reps): # print " rep iteration %d" % i which = rng.randint(len(params)) if which == 0: rad_idx = 0 theta_idx = 2 theta = params[theta_idx] #FIND THE MAXIMUM RADIUS STILL INSIDE THE DETECTOR theta_eq = np.arctan(detector.detector_length/detector.detector_radius) theta_taper = np.arctan(detector.taper_length/detector.detector_radius) # print "theta: %f pi" % (theta / np.pi) if theta <= theta_taper: z = np.tan(theta)*(detector.detector_radius - detector.taper_length) / (1-np.tan(theta)) max_rad = z / np.sin(theta) elif theta <= theta_eq: max_rad = detector.detector_radius / np.cos(theta) # print "max rad radius: %f" % max_rad else: theta_comp = np.pi/2 - theta max_rad = detector.detector_length / np.cos(theta_comp) # print "max rad length: %f" % max_rad #AND THE MINIMUM (from PC dimple) #min_rad = 1./ ( np.cos(theta)**2/detector.pcRad**2 + np.sin(theta)**2/detector.pcLen**2 ) min_rad = np.amax([detector.pcRad, detector.pcLen]) total_max_rad = np.sqrt(detector.detector_length**2 + detector.detector_radius**2 ) params[which] += total_max_rad*dnest4.randh() params[which] = dnest4.wrap(params[which] , min_rad, max_rad) elif which ==2: #theta rad_idx = 0 rad = params[rad_idx] # print "rad: %f" % rad if rad < np.amin([detector.detector_radius - detector.taper_length, detector.detector_length]): max_val = np.pi/2 min_val = 0 # print "theta: min %f pi, max %f pi" % (min_val, max_val) else: if rad < detector.detector_radius - detector.taper_length: #can't possibly hit the taper # print "less than taper adjustment" min_val = 0 elif rad < np.sqrt(detector.detector_radius**2 + detector.taper_length**2): #low enough that it could hit the taper region # print "taper adjustment" a = detector.detector_radius - detector.taper_length z = 0.5 * (np.sqrt(2*rad**2-a**2) - a) min_val = np.arcsin(z/rad) else: #longer than could hit the taper # print " longer thantaper adjustment" min_val = np.arccos(detector.detector_radius/rad) if rad < detector.detector_length: max_val = np.pi/2 else: max_val = np.pi/2 - np.arccos(detector.detector_length/rad) # print "theta: min %f pi, max %f pi" % (min_val, max_val) params[which] += np.pi/2*dnest4.randh() params[which] = dnest4.wrap(params[which], min_val, max_val) # if which == 0: # params[which] += (detector.detector_radius)*dnest4.randh() # params[which] = dnest4.wrap(params[which] , 0, detector.detector_radius) elif which == 1: max_val = np.pi/4 params[which] += np.pi/4*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, max_val) if params[which] < 0 or params[which] > np.pi/4: print "wtf phi" #params[which] = np.clip(params[which], 0, max_val) # elif which == 2: # params[which] += (detector.detector_length)*dnest4.randh() # params[which] = dnest4.wrap(params[which] , 0, detector.detector_length) elif which == 3: #scale min_scale = wf.wfMax - 0.01*wf.wfMax max_scale = wf.wfMax + 0.005*wf.wfMax params[which] += (max_scale-min_scale)*dnest4.randh() params[which] = dnest4.wrap(params[which], min_scale, max_scale) # print " adjusted scale to %f" % ( params[which]) elif which == 4: #t0 params[which] += 1*dnest4.randh() params[which] = dnest4.wrap(params[which], min_maxt, max_maxt) elif which == 5: #smooth params[which] += 0.1*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 25) # print " adjusted smooth to %f" % ( params[which]) # elif which == 6: #wf baseline slope (m) # logH -= -0.5*(params[which]/1E-4)**2 # params[which] += 1E-4*dnest4.randh() # logH += -0.5*(params[which]/1E-4)**2 # elif which == 7: #wf baseline incercept (b) # logH -= -0.5*(params[which]/1E-2)**2 # params[which] += 1E-2*dnest4.randh() # logH += -0.5*(params[which]/1E-2)**2 # params[which] += 0.01*dnest4.randh() # params[which]=dnest4.wrap(params[which], -1, 1) # print " adjusted b to %f" % ( params[which]) else: #velocity or rc params: cant be below 0, can be arb. large print "which value %d not supported" % which exit(0) return logH
def perturb_detector(self, params, which): logH = 0.0 detector = self.detector num_waveforms = self.num_waveforms priors = self.priors prior_vars = self.prior_vars if which == phi_idx: #lets call this phi logH -= -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 params[which] += prior_vars[which] * dnest4.randh() params[which] = dnest4.wrap(params[which], -np.pi, 0) logH += -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 elif which == omega_idx: #call it omega logH -= -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 params[which] += prior_vars[which] * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, np.pi) logH += -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 elif which == d_idx: #d logH -= -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 params[which] += prior_vars[which] * dnest4.randh() params[which] = dnest4.wrap(params[which], 0.5, 0.999) # params[which] = dnest4.wrap(params[which], 0, 5000) logH += -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 elif which == rc1_idx or which == rc2_idx or which == rcfrac_idx: #all normally distributed priors logH -= -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 params[which] += prior_vars[which] * dnest4.randh() if which == rcfrac_idx: params[which] = dnest4.wrap(params[which], 0, 1) logH += -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 # # elif which == num0_idx: # sig = 3*timeStepMult # logH -= -0.5*((params[which] - 0.)/sig)**2 # params[which] += sig*dnest4.randh() # logH += -0.5*((params[which] - 0.)/sig)**2 # elif which == aliasrc_idx: # params[which] += 19.9*dnest4.randh() # params[which] = dnest4.wrap(params[which], 0.1, 20) elif which == grad_idx: # logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 # params[which] += prior_vars[which] *dnest4.randh() # params[which] = dnest4.wrap(params[which], detector.gradList[0], detector.gradList[-1]) # logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 paramlist = detector.gradList params[which] += (paramlist[-1] - paramlist[0]) * dnest4.randh() params[which] = dnest4.wrap(params[which], paramlist[0], paramlist[-1]) elif which == imp_avg_idx: # logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 # params[which] += prior_vars[which] *dnest4.randh() # params[which] = dnest4.wrap(params[which], detector.impAvgList[0], detector.impAvgList[-1]) # logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 paramlist = detector.impAvgList params[which] += (paramlist[-1] - paramlist[0]) * dnest4.randh() params[which] = dnest4.wrap(params[which], paramlist[0], paramlist[-1]) elif which == pcrad_idx: paramlist = detector.pcRadList params[which] += (paramlist[-1] - paramlist[0]) * dnest4.randh() params[which] = dnest4.wrap(params[which], paramlist[0], paramlist[-1]) elif which == pclen_idx: paramlist = detector.pcLenList params[which] += (paramlist[-1] - paramlist[0]) * dnest4.randh() params[which] = dnest4.wrap(params[which], paramlist[0], paramlist[-1]) elif which == trap_idx: # let's go with log10-uniform on this # log_trap = np.log10(params[which]) # log_trap += 3*dnest4.randh() # log_trap = dnest4.wrap(log_trap, 1, 4) # params[which] = 10**(log_trap) # p_guess = 350 # sig = 50 # logH -= -0.5*((params[which] - p_guess )/sig)**2 # params[which] += sig*dnest4.randh() # params[which] = dnest4.wrap(params[which], 100, 600) # logH += -0.5*((params[which] - p_guess)/sig)**2 traprc_min = 10 params[which] += (1000 - traprc_min) * dnest4.randh() params[which] = dnest4.wrap(params[which], traprc_min, 1000) elif which == untrap_idx: traprc_min = 1000 params[which] += (1000000 - traprc_min) * dnest4.randh() params[which] = dnest4.wrap(params[which], traprc_min, 1000000) elif which == energy_idx: wf_guess = self.conf.energy_guess sig = 10 logH -= -0.5 * ((params[which] - wf_guess) / sig)**2 params[which] += sig * dnest4.randh() params[which] = dnest4.wrap(params[which], wf_guess - 30, wf_guess + 30) logH += -0.5 * ((params[which] - wf_guess) / sig)**2 elif which >= velo_first_idx and which < velo_first_idx + 4: logH -= -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 params[which] += prior_vars[which] * dnest4.randh() params[which] = dnest4.wrap(params[which], 1, priors[which] * 10) logH += -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 elif which == velo_first_idx + 4 or which == velo_first_idx + 5: params[which] += (self.conf.beta_lims[1] - self.conf.beta_lims[0]) * dnest4.randh() params[which] = dnest4.wrap(params[which], self.conf.beta_lims[0], self.conf.beta_lims[1]) else: #velocity or rc params: cant be below 0, can be arb. large print("which value %d not supported" % which) exit(0) return logH
def perturb(self, params): """ Unlike in C++, this takes a numpy array of parameters as input, and modifies it in-place. The return value is still logH. """ logH = 0.0 which = rng.randint(len(params)) if which >= len(priors): #this is a waveform variable! wf_which = np.floor((which - len(priors)) / num_waveforms) # print "which idx is %d, value is %f" % (which, params[which]) # print " wf which is %d" % wf_which if wf_which == 0 or wf_which == 4: #radius and t0 wf_idx = (which - len(priors)) % num_waveforms rad_idx = len(priors) + wf_idx theta_idx = len(priors) + 2 * num_waveforms + wf_idx t0_idx = len(priors) + 4 * num_waveforms + wf_idx theta = params[theta_idx] #FIND THE MAXIMUM RADIUS STILL INSIDE THE DETECTOR theta_eq = np.arctan(detector.detector_length / detector.detector_radius) theta_taper = np.arctan(detector.taper_length / detector.detector_radius) # print "theta: %f pi" % (theta / np.pi) if theta <= theta_taper: z = np.tan(theta) * (detector.detector_radius - detector.taper_length) / ( 1 - np.tan(theta)) max_rad = z / np.sin(theta) elif theta <= theta_eq: max_rad = detector.detector_radius / np.cos(theta) # print "max rad radius: %f" % max_rad else: theta_comp = np.pi / 2 - theta max_rad = detector.detector_length / np.cos(theta_comp) # print "max rad length: %f" % max_rad #AND THE MINIMUM (from PC dimple) #min_rad = 1./ ( np.cos(theta)**2/detector.pcRad**2 + np.sin(theta)**2/detector.pcLen**2 ) min_rad = np.amax([detector.pcRad, detector.pcLen]) mean = [0, 0] cov = [[1, -0.8], [-0.8, 1]] jumps = np.array((0.1 * dnest4.randh(), 0.1 * dnest4.randh())) (r_jump, t0_jump) = np.dot(cov, jumps) params[rad_idx] = dnest4.wrap(params[rad_idx] + r_jump, min_rad, max_rad) params[t0_idx] = dnest4.wrap(params[t0_idx] + t0_jump, min_t0, max_t0) elif wf_which == 1: max_val = np.pi / 4 params[which] += np.pi / 4 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, max_val) if params[which] < 0 or params[which] > np.pi / 4: print "wtf phi" #params[which] = np.clip(params[which], 0, max_val) elif wf_which == 2: #theta wf_idx = (which - len(priors)) % num_waveforms rad_idx = len(priors) + wf_idx rad = params[rad_idx] # print "rad: %f" % rad if rad < np.amin([ detector.detector_radius - detector.taper_length, detector.detector_length ]): max_val = np.pi / 2 min_val = 0 # print "theta: min %f pi, max %f pi" % (min_val, max_val) else: if rad < detector.detector_radius - detector.taper_length: #can't possibly hit the taper # print "less than taper adjustment" min_val = 0 elif rad < np.sqrt(detector.detector_radius**2 + detector.taper_length**2): #low enough that it could hit the taper region # print "taper adjustment" a = detector.detector_radius - detector.taper_length z = 0.5 * (np.sqrt(2 * rad**2 - a**2) - a) min_val = np.arcsin(z / rad) else: #longer than could hit the taper # print " longer thantaper adjustment" min_val = np.arccos(detector.detector_radius / rad) if rad < detector.detector_length: max_val = np.pi / 2 else: max_val = np.pi / 2 - np.arccos( detector.detector_length / rad) # print "theta: min %f pi, max %f pi" % (min_val, max_val) params[which] += (max_val - min_val) * dnest4.randh() params[which] = dnest4.wrap(params[which], min_val, max_val) # params[which] = np.clip(params[which], min_val, max_val) if params[which] < min_val or params[which] > max_val: print "wtf theta" elif wf_which == 3: #scale wf_idx = (which - len(priors)) % num_waveforms wf = wfs[wf_idx] params[which] += dnest4.randh() params[which] = dnest4.wrap(params[which], wf.wfMax - 10 * wf.baselineRMS, wf.wfMax + 10 * wf.baselineRMS) params[which] = np.clip(params[which], wf.wfMax - 50 * wf.baselineRMS, wf.wfMax + 50 * wf.baselineRMS) # print " adjusted scale to %f" % ( params[which]) elif wf_which == 5: #smooth params[which] += 0.1 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 25) # print " adjusted smooth to %f" % ( params[which]) elif wf_which == 6: #wf baseline slope (m) params[which] += 0.0001 * dnest4.randh() params[which] = dnest4.wrap(params[which], -0.001, 0.001) # print " adjusted m to %f" % ( params[which]) elif wf_which == 7: #wf baseline incercept (b) params[which] += 0.01 * dnest4.randh() params[which] = dnest4.wrap(params[which], -1, 1) # print " adjusted b to %f" % ( params[which]) elif which == ba_idx: #b over a params[which] += 0.1 * dnest4.randh() params[which] = dnest4.wrap(params[which], -0.9, 15) elif which == c_idx: #b over a params[which] += 0.01 * dnest4.randh() params[which] = dnest4.wrap(params[which], -0.9, -0.7) elif which == dc_idx: #b over a params[which] += 0.01 * dnest4.randh() params[which] = dnest4.wrap(params[which], -1.05, -0.975) elif which == rc1_idx: space = np.exp(-1. / 90) - np.exp(-1. / 60) params[which] += space * dnest4.randh() params[which] = dnest4.wrap(params[which], np.exp(-1. / 60), np.exp(-1. / 90)) elif which == rc2_idx: space = np.exp(-1. / 10) - np.exp(-1. / .01) params[which] += space * dnest4.randh() params[which] = dnest4.wrap(params[which], np.exp(-1. / 0.01), np.exp(-1. / 10)) elif which == rcfrac_idx: params[which] += 0.1 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0.9, 1) elif which == grad_idx: params[which] += (len(detector.gradList) - 1) * dnest4.randh() params[which] = np.int( dnest4.wrap(params[which], 0, len(detector.gradList) - 1)) elif which >= velo_first_idx and which < velo_first_idx + 6: velo_which = (which - velo_first_idx) % 3 #TODO: consider long transforming priors on two of these if velo_which == 0: #mu0 parameter params[which] += (100E3 - 10E3) * dnest4.randh() params[which] = dnest4.wrap(params[which], 10E3, 100E3) elif velo_which == 1: #ln(1/beta) space = np.log(1 / .1) params[which] += space * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, np.log(1 / .1)) elif velo_which == 2: space = 10E3 * 100 - 100E3 * 300 params[which] += space * dnest4.randh() params[which] = dnest4.wrap(params[which], 10E3 * 100, 100E3 * 300) elif which == trap_idx: space = np.exp(-1. / 5000) - np.exp(-1. / 50) params[which] += space * dnest4.randh() params[which] = dnest4.wrap(params[which], np.exp(-1. / 50), np.exp(-1. / 5000)) else: #velocity or rc params: cant be below 0, can be arb. large print "which value %d not supported" % which exit(0) return logH
def perturb(coords, ndim, width): i = np.random.randint(ndim) coords[i] += (width[i]) * dnest4.randh() # Note: use the return value of wrap, unlike in C++ coords[i] = dnest4.wrap(coords[i], -0.5 * width[i], 0.5 * width[i]) return 0.0
def perturb_wf(self, params, wf_idx, ): #do both wf and detector params in case theres strong correlation logH = 0.0 num_waveforms = self.mpi_manager.num_waveforms detector = self.mpi_manager.detector reps = 1 if rng.rand() < 0.5: reps += np.int(np.power(100.0, rng.rand())); for i in range(reps): wf_which = rng.randint(6) # my_which = rng.randint(len(priors) + 8) # if my_which < len(priors): # #detector variable # logH += self.perturb_detector(params, my_which) # # else: if wf_which < 6: #this is a waveform variable! # wf_which = np.int(my_which - len(priors)) #which idx of the global params array which = len(priors) + wf_which*num_waveforms + wf_idx rad_idx = len(priors) + wf_idx theta_idx = len(priors) + 2*num_waveforms+ wf_idx self.changed_wfs[wf_idx] = 1 if wf_which == 0: theta = params[theta_idx] #FIND THE MAXIMUM RADIUS STILL INSIDE THE DETECTOR theta_eq = np.arctan(detector.detector_length/detector.detector_radius) theta_taper = np.arctan(detector.taper_length/detector.detector_radius) if theta <= theta_taper: z = np.tan(theta)*(detector.detector_radius - detector.taper_length) / (1-np.tan(theta)) max_rad = z / np.sin(theta) elif theta <= theta_eq: max_rad = detector.detector_radius / np.cos(theta) else: theta_comp = np.pi/2 - theta max_rad = detector.detector_length / np.cos(theta_comp) #AND THE MINIMUM (from PC dimple) #min_rad = 1./ ( np.cos(theta)**2/detector.pcRad**2 + np.sin(theta)**2/detector.pcLen**2 ) min_rad = np.amax([detector.pcRad, detector.pcLen]) total_max_rad = np.sqrt(detector.detector_length**2 + detector.detector_radius**2 ) params[which] += total_max_rad*dnest4.randh() params[which] = dnest4.wrap(params[which] , min_rad, max_rad) elif wf_which ==2: #theta rad = params[rad_idx] if rad < np.amin([detector.detector_radius - detector.taper_length, detector.detector_length]): max_val = np.pi/2 min_val = 0 else: if rad < detector.detector_radius - detector.taper_length: #can't possibly hit the taper min_val = 0 elif rad < np.sqrt(detector.detector_radius**2 + detector.taper_length**2): #low enough that it could hit the taper region a = detector.detector_radius - detector.taper_length z = 0.5 * (np.sqrt(2*rad**2-a**2) - a) min_val = np.arcsin(z/rad) else: #longer than could hit the taper min_val = np.arccos(detector.detector_radius/rad) if rad < detector.detector_length: max_val = np.pi/2 else: max_val = np.pi/2 - np.arccos(detector.detector_length/rad) params[which] += np.pi/2*dnest4.randh() params[which] = dnest4.wrap(params[which], min_val, max_val) # if wf_which == 0: # params[which] += (detector.detector_radius)*dnest4.randh() # params[which] = dnest4.wrap(params[which] , 0, detector.detector_radius) elif wf_which == 1: max_val = np.pi/4 params[which] += np.pi/4*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, max_val) if params[which] < 0 or params[which] > np.pi/4: print ("wtf phi") # elif wf_which == 2: # params[which] += (detector.detector_length)*dnest4.randh() # params[which] = dnest4.wrap(params[which] , 0, detector.detector_length) elif wf_which == 3: #scale wf = self.mpi_manager.wfs[wf_idx] min_scale = wf.wfMax - 0.01*wf.wfMax max_scale = wf.wfMax + 0.005*wf.wfMax params[which] += (max_scale-min_scale)*dnest4.randh() params[which] = dnest4.wrap(params[which], min_scale, max_scale) elif wf_which == 4: #t0 params[which] += 1*dnest4.randh() params[which] = dnest4.wrap(params[which], self.min_maxt, self.max_maxt) elif wf_which == 5: #smooth params[which] += 0.1*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 25) else: print( "wf which value %d (which value %d) not supported" % (wf_which, which) ) exit(0) return logH
def perturb_wf( self, params, wf_idx, ): #do both wf and detector params in case theres strong correlation logH = 0.0 num_waveforms = self.num_waveforms detector = self.detector priors = self.priors wf_params = 6 reps = 1 if rng.rand() < 0.5: reps += np.int(np.power(100.0, rng.rand())) for i in range(reps): wf_which = rng.randint(wf_params) # my_which = rng.randint(len(priors) + 8) # if my_which < len(priors): # #detector variable # logH += self.perturb_detector(params, my_which) # # else: if wf_which < wf_params: #this is a waveform variable! # wf_which = np.int(my_which - len(priors)) #which idx of the global params array which = len(priors) + wf_which * num_waveforms + wf_idx rad_idx = len(priors) + wf_idx theta_idx = len(priors) + 2 * num_waveforms + wf_idx self.changed_wfs[wf_idx] = 1 if wf_which == 0: theta = params[theta_idx] IsInDetector = 0 while not (IsInDetector): new_rad = self.get_new_rad(params[which], theta) r = new_rad * np.cos(theta) z = new_rad * np.sin(theta) IsInDetector = detector.IsInDetector(r, 0, z) params[which] = new_rad elif wf_which == 2: #theta rad = params[rad_idx] IsInDetector = 0 while not (IsInDetector): new_theta = self.get_new_theta(rad, params[which]) r = rad * np.cos(new_theta) z = rad * np.sin(new_theta) IsInDetector = detector.IsInDetector(r, 0, z) params[which] = new_theta # if wf_which == 0: # params[which] += (detector.detector_radius)*dnest4.randh() # params[which] = dnest4.wrap(params[which] , 0, detector.detector_radius) elif wf_which == 1: max_val = np.pi / 4 params[which] += np.pi / 4 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, max_val) # elif wf_which == 3: #scale # wf_guess = self.conf.energy_guess # sig = 10 # # logH -= -0.5*((params[which] - wf_guess )/sig)**2 # params[which] += sig*dnest4.randh() # params[which] = dnest4.wrap(params[which], wf_guess - 30, wf_guess + 30) # logH += -0.5*((params[which] - wf_guess)/sig)**2 elif wf_which == 3: #t0 #gaussian around 0, sigma... 5? t0_sig = self.maxt_sigma logH -= -0.5 * ( (params[which] - self.alignidx_guess) / t0_sig)**2 params[which] += t0_sig * dnest4.randh() params[which] = dnest4.wrap(params[which], self.min_maxt, self.max_maxt) logH += -0.5 * ( (params[which] - self.alignidx_guess) / t0_sig)**2 elif wf_which == 4: #smooth #gaussian around 10 smooth_guess = 20 sig = 20 * timeStepMult logH -= -0.5 * ( (params[which] - smooth_guess * timeStepMult) / sig)**2 params[which] += sig * dnest4.randh() params[which] = dnest4.wrap(params[which], 1, 40 * timeStepMult) logH += -0.5 * ( (params[which] - smooth_guess * timeStepMult) / sig)**2 elif wf_which == 5: #p #gaussian around 10 if self.conf.smooth_type == "gen_gaus": p_guess = 2 sig = 10 logH -= -0.5 * ((params[which] - p_guess) / sig)**2 params[which] += sig * dnest4.randh() params[which] = dnest4.wrap(params[which], 1, 20) logH += -0.5 * ((params[which] - p_guess) / sig)**2 elif self.conf.smooth_type == "skew": params[which] += 20 * dnest4.randh() params[which] = dnest4.wrap(params[which], -20, 0) else: print("wf which value %d (which value %d) not supported" % (wf_which, which)) exit(0) return logH
def perturb_detector(self, params, which): logH = 0.0 if which == ba_idx: #lets call this phi params[which] += (tf_phi_max + np.pi / 2) * dnest4.randh() params[which] = dnest4.wrap(params[which], -np.pi / 2, tf_phi_max) elif which == c_idx: #call it omega params[which] += 0.1 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0.07, 0.2) elif which == dc_idx: #d params[which] += 0.01 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0.7, 0.9) elif which == rc1_idx or which == rc2_idx or which == rcfrac_idx: #all normally distributed priors logH -= -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 params[which] += prior_vars[which] * dnest4.randh() logH += -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 elif which == aliasrc_idx: params[which] += 9.9 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0.1, 10) elif which == grad_idx: logH -= -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 params[which] += prior_vars[which] * dnest4.randh() params[which] = dnest4.wrap(params[which], detector.gradList[0], detector.gradList[-1]) logH += -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 elif which == imp_avg_idx: logH -= -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 params[which] += prior_vars[which] * dnest4.randh() params[which] = dnest4.wrap(params[which], detector.impAvgList[0], detector.impAvgList[-1]) logH += -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 elif which == trap_idx: params[which] += (1000 - traprc_min) * dnest4.randh() params[which] = dnest4.wrap(params[which], traprc_min, 1000) elif which >= velo_first_idx and which < velo_first_idx + 4: logH -= -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 params[which] += prior_vars[which] * dnest4.randh() params[which] = dnest4.wrap(params[which], 1, priors[which] * 10) logH += -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 elif which == velo_first_idx + 4 or which == velo_first_idx + 5: params[which] += (beta_lims[1] - beta_lims[0]) * dnest4.randh() params[which] = dnest4.wrap(params[which], beta_lims[0], beta_lims[1]) else: #velocity or rc params: cant be below 0, can be arb. large print("which value %d not supported" % which) exit(0) return logH
def perturb(self, coords): i = np.random.randint(self.ndim) coords[i] += self.width*dnest4.randh() # Note: use the return value of wrap, unlike in C++ coords[i] = dnest4.wrap(coords[i], -0.5*self.width, 0.5*self.width) return 0.0
def perturb_wf(self, params, wf_idx, ): #do both wf and detector params in case theres strong correlation logH = 0.0 num_waveforms = self.num_waveforms detector = self.detector priors = self.priors wf_params = 6 reps = 1 if rng.rand() < 0.5: reps += np.int(np.power(100.0, rng.rand())); for i in range(reps): wf_which = rng.randint(wf_params) # my_which = rng.randint(len(priors) + 8) # if my_which < len(priors): # #detector variable # logH += self.perturb_detector(params, my_which) # # else: if wf_which < wf_params: #this is a waveform variable! # wf_which = np.int(my_which - len(priors)) #which idx of the global params array which = len(priors) + wf_which*num_waveforms + wf_idx rad_idx = len(priors) + wf_idx theta_idx = len(priors) + 2*num_waveforms+ wf_idx self.changed_wfs[wf_idx] = 1 if wf_which == 0: theta = params[theta_idx] IsInDetector = 0 while not(IsInDetector): new_rad = self.get_new_rad(params[which], theta) r = new_rad * np.cos(theta) z = new_rad * np.sin(theta) IsInDetector = detector.IsInDetector(r, 0,z) params[which] = new_rad elif wf_which ==2: #theta rad = params[rad_idx] IsInDetector = 0 while not(IsInDetector): new_theta = self.get_new_theta(rad, params[which]) r = rad * np.cos(new_theta) z = rad * np.sin(new_theta) IsInDetector = detector.IsInDetector(r, 0,z) params[which] = new_theta # if wf_which == 0: # params[which] += (detector.detector_radius)*dnest4.randh() # params[which] = dnest4.wrap(params[which] , 0, detector.detector_radius) elif wf_which == 1: max_val = np.pi/4 params[which] += np.pi/4*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, max_val) # elif wf_which == 3: #scale # wf_guess = self.conf.energy_guess # sig = 10 # # logH -= -0.5*((params[which] - wf_guess )/sig)**2 # params[which] += sig*dnest4.randh() # params[which] = dnest4.wrap(params[which], wf_guess - 30, wf_guess + 30) # logH += -0.5*((params[which] - wf_guess)/sig)**2 elif wf_which == 3: #t0 #gaussian around 0, sigma... 5? t0_sig = self.maxt_sigma logH -= -0.5*((params[which] - self.alignidx_guess )/t0_sig)**2 params[which] += t0_sig*dnest4.randh() params[which] = dnest4.wrap(params[which], self.min_maxt, self.max_maxt) logH += -0.5*((params[which] - self.alignidx_guess)/t0_sig)**2 elif wf_which == 4: #smooth #gaussian around 10 smooth_guess = 20 sig = 20*timeStepMult logH -= -0.5*((params[which] - smooth_guess*timeStepMult )/sig)**2 params[which] += sig*dnest4.randh() params[which] = dnest4.wrap(params[which], 1, 40*timeStepMult) logH += -0.5*((params[which] - smooth_guess*timeStepMult)/sig)**2 elif wf_which == 5: #p #gaussian around 10 if self.conf.smooth_type == "gen_gaus": p_guess = 2 sig = 10 logH -= -0.5*((params[which] - p_guess )/sig)**2 params[which] += sig*dnest4.randh() params[which] = dnest4.wrap(params[which], 1, 20) logH += -0.5*((params[which] - p_guess)/sig)**2 elif self.conf.smooth_type == "skew": params[which] += 20*dnest4.randh() params[which] = dnest4.wrap(params[which], -20, 0) else: print( "wf which value %d (which value %d) not supported" % (wf_which, which) ) exit(0) return logH
def perturb(self, params): """ Unlike in C++, this takes a numpy array of parameters as input, and modifies it in-place. The return value is still logH. """ logH = 0.0 self.changed_wfs[:] = 0 det_or_wf = rng.randint(2) if det_or_wf == 0: which = rng.randint(len(priors)) else: which = rng.randint(num_waveforms*8) + len(priors) if which < len(priors): self.changed_wfs[:] = 1 if which >= len(priors): #this is a waveform variable! wf_which = np.int(np.floor((which - len(priors)) / num_waveforms)) wf_idx = (which - len(priors)) % num_waveforms self.changed_wfs[wf_idx] = 1 if wf_which == 0: params[which] += (detector.detector_radius)*dnest4.randh() params[which] = dnest4.wrap(params[which] , 0, detector.detector_radius) elif wf_which == 1: max_val = np.pi/4 params[which] += np.pi/4*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, max_val) if params[which] < 0 or params[which] > np.pi/4: print "wtf phi" #params[which] = np.clip(params[which], 0, max_val) elif wf_which == 2: params[which] += (detector.detector_length)*dnest4.randh() params[which] = dnest4.wrap(params[which] , 0, detector.detector_length) elif wf_which == 3: #scale wf = wfs[wf_idx] min_scale = wf.wfMax - 0.01*wf.wfMax max_scale = wf.wfMax + 0.005*wf.wfMax params[which] += (max_scale-min_scale)*dnest4.randh() params[which] = dnest4.wrap(params[which], min_scale, max_scale) # print " adjusted scale to %f" % ( params[which]) elif wf_which == 4: #t0 params[which] += 1*dnest4.randh() params[which] = dnest4.wrap(params[which], min_maxt, max_maxt) elif wf_which == 5: #smooth params[which] += 0.1*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 25) # print " adjusted smooth to %f" % ( params[which]) elif wf_which == 6: #wf baseline slope (m) logH -= -0.5*(params[which]/1E-4)**2 params[which] += 1E-4*dnest4.randh() logH += -0.5*(params[which]/1E-4)**2 elif wf_which == 7: #wf baseline incercept (b) logH -= -0.5*(params[which]/1E-2)**2 params[which] += 1E-2*dnest4.randh() logH += -0.5*(params[which]/1E-2)**2 # params[which] += 0.01*dnest4.randh() # params[which]=dnest4.wrap(params[which], -1, 1) # print " adjusted b to %f" % ( params[which]) elif which == ba_idx: #lets call this phi params[which] += np.pi*dnest4.randh() params[which] = dnest4.wrap(params[which], -np.pi/2, np.pi/2) elif which == c_idx: #call it omega params[which] += 0.1*dnest4.randh() params[which] = dnest4.wrap(params[which], 0.13, 0.14) elif which == dc_idx: #d params[which] += 0.01*dnest4.randh() params[which] = dnest4.wrap(params[which], 0.81, 0.82) elif which == rc1_idx or which == rc2_idx or which == rcfrac_idx: #all normally distributed priors logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 params[which] += prior_vars[which]*dnest4.randh() logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 elif which == grad_idx: params[which] += (len(detector.gradList)-1)*dnest4.randh() params[which] = np.int(dnest4.wrap(params[which], 0, len(detector.gradList)-1)) elif which >= velo_first_idx and which < velo_first_idx+6: mu_max = 100E5 velo_which = (which - velo_first_idx)%3 #TODO: consider long transforming priors on two of these if velo_which ==0: #mu0 parameter params[which] += (mu_max - 10E3) *dnest4.randh() params[which] = dnest4.wrap(params[which], 10E3, mu_max) elif velo_which ==1: #ln(1/beta) space = np.log(1/.1) params[which] += space *dnest4.randh() params[which] = dnest4.wrap(params[which], 0, np.log(1/.1)) elif velo_which == 2: minval, maxval = 5E6, 1E8 params[which] += (maxval-minval) *dnest4.randh() params[which] = dnest4.wrap(params[which], minval, maxval) elif which == trap_idx: params[which] += prior_vars[trap_idx]*dnest4.randh() params[which] = dnest4.wrap(params[which], 50, 1000) else: #velocity or rc params: cant be below 0, can be arb. large print "which value %d not supported" % which exit(0) return logH
def perturb(self, params): """ Unlike in C++, this takes a numpy array of parameters as input, and modifies it in-place. The return value is still logH. """ logH = 0.0 which = rng.randint(len(params)) if which >= len(priors): #this is a waveform variable! wf_which = np.floor((which - len(priors)) / num_waveforms) if wf_which == 0: params[which] += (detector.detector_radius) * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, detector.detector_radius) elif wf_which == 1: max_val = np.pi / 4 params[which] += np.pi / 4 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, max_val) if params[which] < 0 or params[which] > np.pi / 4: print "wtf phi" #params[which] = np.clip(params[which], 0, max_val) elif wf_which == 2: params[which] += (detector.detector_length) * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, detector.detector_length) elif wf_which == 3: #scale wf_idx = (which - len(priors)) % num_waveforms wf = wfs[wf_idx] params[which] += dnest4.randh() params[which] = dnest4.wrap(params[which], wf.wfMax - 10 * wf.baselineRMS, wf.wfMax + 10 * wf.baselineRMS) params[which] = np.clip(params[which], wf.wfMax - 50 * wf.baselineRMS, wf.wfMax + 50 * wf.baselineRMS) # print " adjusted scale to %f" % ( params[which]) elif wf_which == 4: #t0 params[which] += 1 * dnest4.randh() params[which] = dnest4.wrap(params[which], min_maxt, max_maxt) elif wf_which == 5: #smooth params[which] += 0.1 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 25) # print " adjusted smooth to %f" % ( params[which]) elif wf_which == 6: #wf baseline slope (m) logH -= -0.5 * (params[which] / 1E-4)**2 params[which] += 1E-4 * dnest4.randh() logH += -0.5 * (params[which] / 1E-4)**2 elif wf_which == 7: #wf baseline incercept (b) logH -= -0.5 * (params[which] / 1E-2)**2 params[which] += 1E-2 * dnest4.randh() logH += -0.5 * (params[which] / 1E-2)**2 # params[which] += 0.01*dnest4.randh() # params[which]=dnest4.wrap(params[which], -1, 1) # print " adjusted b to %f" % ( params[which]) elif which == ba_idx: #b over a params[which] += 70 * dnest4.randh() params[which] = dnest4.wrap(params[which], -50, 20) elif which == c_idx: #b over a #this is now 1/gain (so assume it goes from 1 to e^-...7?) log_gain = np.log(params[which]) log_gain += 10 * dnest4.randh() log_gain = dnest4.wrap(log_gain, -10, 0.0) params[which] = np.exp(log_gain) # params[which] += 4*dnest4.randh() # params[which] = dnest4.wrap(params[which], -2, 2) elif which == dc_idx: #b over a params[which] += 1 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 1) elif which == rc1_idx or which == rc2_idx or which == rcfrac_idx: #all normally distributed priors logH -= -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 params[which] += prior_vars[which] * dnest4.randh() logH += -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 else: #velocity or rc params: cant be below 0, can be arb. large print "which value %d not supported" % which exit(0) return logH
def perturb_wf(self, params, wf_idx): wf_which = rng.randint(8) #8 wf params which = len(priors) + wf_which*num_waveforms + wf_idx if wf_which == 0 or wf_which == 4: #radius and t0 wf_idx = (which - len(priors)) % num_waveforms rad_idx = len(priors) + wf_idx theta_idx = len(priors) + 2*num_waveforms+ wf_idx t0_idx = len(priors) + 4*num_waveforms+ wf_idx theta = params[theta_idx] #FIND THE MAXIMUM RADIUS STILL INSIDE THE DETECTOR theta_eq = np.arctan(detector.detector_length/detector.detector_radius) theta_taper = np.arctan(detector.taper_length/detector.detector_radius) # print "theta: %f pi" % (theta / np.pi) if theta <= theta_taper: z = np.tan(theta)*(detector.detector_radius - detector.taper_length) / (1-np.tan(theta)) max_rad = z / np.sin(theta) elif theta <= theta_eq: max_rad = detector.detector_radius / np.cos(theta) # print "max rad radius: %f" % max_rad else: theta_comp = np.pi/2 - theta max_rad = detector.detector_length / np.cos(theta_comp) # print "max rad length: %f" % max_rad #AND THE MINIMUM (from PC dimple) #min_rad = 1./ ( np.cos(theta)**2/detector.pcRad**2 + np.sin(theta)**2/detector.pcLen**2 ) min_rad = np.amax([detector.pcRad, detector.pcLen]) mean = [0, 0] cov = [[1, -0.8], [-0.8, 1]] jumps = np.array((0.1*dnest4.randh(), 0.1*dnest4.randh())) (r_jump, t0_jump) = np.dot(cov, jumps) params[rad_idx] = dnest4.wrap(params[rad_idx] + r_jump , min_rad, max_rad) params[t0_idx] = dnest4.wrap(params[t0_idx] + t0_jump , min_t0, max_t0) elif wf_which == 1: max_val = np.pi/4 params[which] += np.pi/4*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, max_val) if params[which] < 0 or params[which] > np.pi/4: print "wtf phi" #params[which] = np.clip(params[which], 0, max_val) elif wf_which ==2: #theta wf_idx = (which - len(priors)) % num_waveforms rad_idx = len(priors) + wf_idx rad = params[rad_idx] # print "rad: %f" % rad if rad < np.amin([detector.detector_radius - detector.taper_length, detector.detector_length]): max_val = np.pi/2 min_val = 0 # print "theta: min %f pi, max %f pi" % (min_val, max_val) else: if rad < detector.detector_radius - detector.taper_length: #can't possibly hit the taper # print "less than taper adjustment" min_val = 0 elif rad < np.sqrt(detector.detector_radius**2 + detector.taper_length**2): #low enough that it could hit the taper region # print "taper adjustment" a = detector.detector_radius - detector.taper_length z = 0.5 * (np.sqrt(2*rad**2-a**2) - a) min_val = np.arcsin(z/rad) else: #longer than could hit the taper # print " longer thantaper adjustment" min_val = np.arccos(detector.detector_radius/rad) if rad < detector.detector_length: max_val = np.pi/2 else: max_val = np.pi/2 - np.arccos(detector.detector_length/rad) # print "theta: min %f pi, max %f pi" % (min_val, max_val) params[which] += (max_val-min_val)*dnest4.randh() params[which] = dnest4.wrap(params[which], min_val, max_val) # params[which] = np.clip(params[which], min_val, max_val) if params[which] < min_val or params[which] > max_val: print "wtf theta" elif wf_which == 3: #scale wf_idx = (which - len(priors)) % num_waveforms wf = wfs[wf_idx] params[which] += dnest4.randh() params[which] = dnest4.wrap(params[which], wf.wfMax - 10*wf.baselineRMS, wf.wfMax + 10*wf.baselineRMS) params[which] = np.clip(params[which], wf.wfMax - 50*wf.baselineRMS, wf.wfMax + 50*wf.baselineRMS) # print " adjusted scale to %f" % ( params[which]) elif wf_which == 5: #smooth params[which] += 0.1*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 25) # print " adjusted smooth to %f" % ( params[which]) elif wf_which == 6: #wf baseline slope (m) params[which] += 0.001*dnest4.randh() params[which]=dnest4.wrap(params[which], -0.01, 0.01) # print " adjusted m to %f" % ( params[which]) elif wf_which == 7: #wf baseline incercept (b) params[which] += 0.01*dnest4.randh() params[which]=dnest4.wrap(params[which], -1, 1) # print " adjusted b to %f" % ( params[which]) else: print "unknown wf param number drawn: %d" % wf_which exit(0)
def perturb(self, params): """ Unlike in C++, this takes a numpy array of parameters as input, and modifies it in-place. The return value is still logH. """ logH = 0.0 #this adjusts one wf at a time #choose which set of params to adjust (detector, wf 1, wf2...) # # num_sets = num_waveforms+1 # set_idx = rng.randint(num_sets) # # #choose how many t # reps = 1; # if(rng.rand() < 0.5): # reps += np.int(np.power(100.0, rng.rand())); # # for i in range(reps): # if set_idx == 0: # #detector param # which = rng.randint(len(priors)) # else: # #waveform param (from the one waveform we're adjusting this go-around # which = rng.randint(8) + len(priors) + (set_idx-1)*num_waveforms #this adjusts wfs simultaneouslt reps = 1; if(rng.rand() < 0.5): reps += np.int(np.power(100.0, rng.rand())); for i in range(reps): if(rng.rand() < 0.5): #detector param which = rng.randint(len(priors)) else: #waveform param (from any of the waveforms) which = rng.randint(8*num_waveforms) + len(priors) if which >= len(priors): #this is a waveform variable! wf_which = np.int(np.floor((which - len(priors)) / num_waveforms)) wf_idx = (which - len(priors)) % num_waveforms wf_idx = (which - len(priors)) % num_waveforms rad_idx = len(priors) + wf_idx theta_idx = len(priors) + 2*num_waveforms+ wf_idx self.changed_wfs[wf_idx] = 1 if wf_which == 0: theta = params[theta_idx] #FIND THE MAXIMUM RADIUS STILL INSIDE THE DETECTOR theta_eq = np.arctan(detector.detector_length/detector.detector_radius) theta_taper = np.arctan(detector.taper_length/detector.detector_radius) # print "theta: %f pi" % (theta / np.pi) if theta <= theta_taper: z = np.tan(theta)*(detector.detector_radius - detector.taper_length) / (1-np.tan(theta)) max_rad = z / np.sin(theta) elif theta <= theta_eq: max_rad = detector.detector_radius / np.cos(theta) # print "max rad radius: %f" % max_rad else: theta_comp = np.pi/2 - theta max_rad = detector.detector_length / np.cos(theta_comp) # print "max rad length: %f" % max_rad #AND THE MINIMUM (from PC dimple) #min_rad = 1./ ( np.cos(theta)**2/detector.pcRad**2 + np.sin(theta)**2/detector.pcLen**2 ) min_rad = np.amax([detector.pcRad, detector.pcLen]) total_max_rad = np.sqrt(detector.detector_length**2 + detector.detector_radius**2 ) params[which] += total_max_rad*dnest4.randh() params[which] = dnest4.wrap(params[which] , min_rad, max_rad) elif wf_which ==2: #theta rad = params[rad_idx] # print "rad: %f" % rad if rad < np.amin([detector.detector_radius - detector.taper_length, detector.detector_length]): max_val = np.pi/2 min_val = 0 # print "theta: min %f pi, max %f pi" % (min_val, max_val) else: if rad < detector.detector_radius - detector.taper_length: #can't possibly hit the taper # print "less than taper adjustment" min_val = 0 elif rad < np.sqrt(detector.detector_radius**2 + detector.taper_length**2): #low enough that it could hit the taper region # print "taper adjustment" a = detector.detector_radius - detector.taper_length z = 0.5 * (np.sqrt(2*rad**2-a**2) - a) min_val = np.arcsin(z/rad) else: #longer than could hit the taper # print " longer thantaper adjustment" min_val = np.arccos(detector.detector_radius/rad) if rad < detector.detector_length: max_val = np.pi/2 else: max_val = np.pi/2 - np.arccos(detector.detector_length/rad) # print "theta: min %f pi, max %f pi" % (min_val, max_val) params[which] += np.pi/2*dnest4.randh() params[which] = dnest4.wrap(params[which], min_val, max_val) # if wf_which == 0: # params[which] += (detector.detector_radius)*dnest4.randh() # params[which] = dnest4.wrap(params[which] , 0, detector.detector_radius) elif wf_which == 1: max_val = np.pi/4 params[which] += np.pi/4*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, max_val) if params[which] < 0 or params[which] > np.pi/4: print "wtf phi" # elif wf_which == 2: # params[which] += (detector.detector_length)*dnest4.randh() # params[which] = dnest4.wrap(params[which] , 0, detector.detector_length) elif wf_which == 3: #scale wf = wfs[wf_idx] min_scale = wf.wfMax - 0.01*wf.wfMax max_scale = wf.wfMax + 0.005*wf.wfMax params[which] += (max_scale-min_scale)*dnest4.randh() params[which] = dnest4.wrap(params[which], min_scale, max_scale) # print " adjusted scale to %f" % ( params[which]) elif wf_which == 4: #t0 params[which] += 1*dnest4.randh() params[which] = dnest4.wrap(params[which], min_maxt, max_maxt) elif wf_which == 5: #smooth params[which] += 0.1*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 25) # print " adjusted smooth to %f" % ( params[which]) elif wf_which == 6: #wf baseline slope (m) logH -= -0.5*(params[which]/1E-4)**2 params[which] += 1E-4*dnest4.randh() logH += -0.5*(params[which]/1E-4)**2 elif wf_which == 7: #wf baseline incercept (b) logH -= -0.5*(params[which]/1E-2)**2 params[which] += 1E-2*dnest4.randh() logH += -0.5*(params[which]/1E-2)**2 else: print "wf which value %d (which value %d) not supported" % (wf_which, which) exit(0) # params[which] += 0.01*dnest4.randh() # params[which]=dnest4.wrap(params[which], -1, 1) # print " adjusted b to %f" % ( params[which]) elif which == ba_idx: #lets call this phi params[which] += (tf_phi_max + np.pi/2)*dnest4.randh() params[which] = dnest4.wrap(params[which], -np.pi/2, tf_phi_max) elif which == c_idx: #call it omega params[which] += 0.1*dnest4.randh() params[which] = dnest4.wrap(params[which], 0.13, 0.14) elif which == dc_idx: #d params[which] += 0.01*dnest4.randh() params[which] = dnest4.wrap(params[which], 0.81, 0.82) elif which == rc1_idx or which == rc2_idx or which == rcfrac_idx: #all normally distributed priors logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 params[which] += prior_vars[which]*dnest4.randh() logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 elif which == grad_idx: params[which] += (detector.gradList[-1] - detector.gradList[0])*dnest4.randh() params[which] = dnest4.wrap(params[which], detector.gradList[0], detector.gradList[-1]) elif which == imp_avg_idx: params[which] += (detector.impAvgList[-1] - detector.impAvgList[0])*dnest4.randh() params[which] = dnest4.wrap(params[which], detector.impAvgList[0], detector.impAvgList[-1]) elif which >= velo_first_idx and which < velo_first_idx+6: mu_max = 100E5 velo_which = (which - velo_first_idx)%3 #TODO: consider long transforming priors on two of these if velo_which ==0: #mu0 parameter params[which] += (mu_max - 10E3) *dnest4.randh() params[which] = dnest4.wrap(params[which], 10E3, mu_max) elif velo_which ==1: #ln(1/beta) space = np.log(1/.1) params[which] += space *dnest4.randh() params[which] = dnest4.wrap(params[which], 0, np.log(1/.1)) elif velo_which == 2: minval, maxval = 5E6, 1E8 params[which] += (maxval-minval) *dnest4.randh() params[which] = dnest4.wrap(params[which], minval, maxval) # elif which >= k0_first_idx and which < k0_first_idx+4: # minval, maxval = -50, 50 # params[which] += (maxval-minval) *dnest4.randh() # params[which] = dnest4.wrap(params[which], minval, maxval) elif which == trap_idx: params[which] += (1000 - traprc_min)*dnest4.randh() params[which] = dnest4.wrap(params[which], traprc_min, 1000) else: #velocity or rc params: cant be below 0, can be arb. large print "which value %d not supported" % which exit(0) return logH
def perturb_wf( self, params, wf_idx, ): #do both wf and detector params in case theres strong correlation logH = 0.0 reps = 1 if rng.rand() < 0.5: reps += np.int(np.power(100.0, rng.rand())) for i in range(reps): wf_which = rng.randint(6) # my_which = rng.randint(len(priors) + 8) # if my_which < len(priors): # #detector variable # logH += self.perturb_detector(params, my_which) # # else: if wf_which < 6: #this is a waveform variable! # wf_which = np.int(my_which - len(priors)) #which idx of the global params array which = len(priors) + wf_which * num_waveforms + wf_idx rad_idx = len(priors) + wf_idx theta_idx = len(priors) + 2 * num_waveforms + wf_idx self.changed_wfs[wf_idx] = 1 if wf_which == 0: theta = params[theta_idx] #FIND THE MAXIMUM RADIUS STILL INSIDE THE DETECTOR theta_eq = np.arctan(detector.detector_length / detector.detector_radius) theta_taper = np.arctan(detector.taper_length / detector.detector_radius) # print "theta: %f pi" % (theta / np.pi) if theta <= theta_taper: z = np.tan(theta) * (detector.detector_radius - detector.taper_length) / ( 1 - np.tan(theta)) max_rad = z / np.sin(theta) elif theta <= theta_eq: max_rad = detector.detector_radius / np.cos(theta) # print "max rad radius: %f" % max_rad else: theta_comp = np.pi / 2 - theta max_rad = detector.detector_length / np.cos(theta_comp) # print "max rad length: %f" % max_rad #AND THE MINIMUM (from PC dimple) #min_rad = 1./ ( np.cos(theta)**2/detector.pcRad**2 + np.sin(theta)**2/detector.pcLen**2 ) min_rad = np.amax([detector.pcRad, detector.pcLen]) total_max_rad = np.sqrt(detector.detector_length**2 + detector.detector_radius**2) params[which] += total_max_rad * dnest4.randh() params[which] = dnest4.wrap(params[which], min_rad, max_rad) elif wf_which == 2: #theta rad = params[rad_idx] # print "rad: %f" % rad if rad < np.amin([ detector.detector_radius - detector.taper_length, detector.detector_length ]): max_val = np.pi / 2 min_val = 0 # print "theta: min %f pi, max %f pi" % (min_val, max_val) else: if rad < detector.detector_radius - detector.taper_length: #can't possibly hit the taper # print "less than taper adjustment" min_val = 0 elif rad < np.sqrt(detector.detector_radius**2 + detector.taper_length**2): #low enough that it could hit the taper region # print "taper adjustment" a = detector.detector_radius - detector.taper_length z = 0.5 * (np.sqrt(2 * rad**2 - a**2) - a) min_val = np.arcsin(z / rad) else: #longer than could hit the taper # print " longer thantaper adjustment" min_val = np.arccos(detector.detector_radius / rad) if rad < detector.detector_length: max_val = np.pi / 2 else: max_val = np.pi / 2 - np.arccos( detector.detector_length / rad) # print "theta: min %f pi, max %f pi" % (min_val, max_val) params[which] += np.pi / 2 * dnest4.randh() params[which] = dnest4.wrap(params[which], min_val, max_val) # if wf_which == 0: # params[which] += (detector.detector_radius)*dnest4.randh() # params[which] = dnest4.wrap(params[which] , 0, detector.detector_radius) elif wf_which == 1: max_val = np.pi / 4 params[which] += np.pi / 4 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, max_val) if params[which] < 0 or params[which] > np.pi / 4: print("wtf phi") # elif wf_which == 2: # params[which] += (detector.detector_length)*dnest4.randh() # params[which] = dnest4.wrap(params[which] , 0, detector.detector_length) elif wf_which == 3: #scale wf = wfs[wf_idx] min_scale = wf.wfMax - 0.01 * wf.wfMax max_scale = wf.wfMax + 0.005 * wf.wfMax params[which] += (max_scale - min_scale) * dnest4.randh() params[which] = dnest4.wrap(params[which], min_scale, max_scale) # print " adjusted scale to %f" % ( params[which]) elif wf_which == 4: #t0 params[which] += 1 * dnest4.randh() params[which] = dnest4.wrap(params[which], min_maxt, max_maxt) elif wf_which == 5: #smooth params[which] += 0.1 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 25) # print " adjusted smooth to %f" % ( params[which]) # elif wf_which == 6: #wf baseline slope (m) # logH -= -0.5*(params[which]/1E-4)**2 # params[which] += 1E-4*dnest4.randh() # logH += -0.5*(params[which]/1E-4)**2 # elif wf_which == 7: #wf baseline incercept (b) # logH -= -0.5*(params[which]/1E-2)**2 # params[which] += 1E-2*dnest4.randh() # logH += -0.5*(params[which]/1E-2)**2 else: print("wf which value %d (which value %d) not supported" % (wf_which, which)) exit(0) # params[which] += 0.01*dnest4.randh() # params[which]=dnest4.wrap(params[which], -1, 1) # print " adjusted b to %f" % ( params[which]) return logH
def perturb(self, params): """ Unlike in C++, this takes a numpy array of parameters as input, and modifies it in-place. The return value is still logH. """ logH = 0.0 which = rng.randint(len(params)) if which >= len(priors): #this is a waveform variable! wf_which = np.floor((which - len(priors)) / num_waveforms) if wf_which == 0: params[which] += (detector.detector_radius)*dnest4.randh() params[which] = dnest4.wrap(params[which] , 0, detector.detector_radius) elif wf_which == 1: max_val = np.pi/4 params[which] += np.pi/4*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, max_val) if params[which] < 0 or params[which] > np.pi/4: print "wtf phi" #params[which] = np.clip(params[which], 0, max_val) elif wf_which == 2: params[which] += (detector.detector_length)*dnest4.randh() params[which] = dnest4.wrap(params[which] , 0, detector.detector_length) elif wf_which == 3: #scale wf_idx = (which - len(priors)) % num_waveforms wf = wfs[wf_idx] params[which] += dnest4.randh() params[which] = dnest4.wrap(params[which], wf.wfMax - 10*wf.baselineRMS, wf.wfMax + 10*wf.baselineRMS) params[which] = np.clip(params[which], wf.wfMax - 50*wf.baselineRMS, wf.wfMax + 50*wf.baselineRMS) # print " adjusted scale to %f" % ( params[which]) elif wf_which == 4: #t0 params[which] += 1*dnest4.randh() params[which] = dnest4.wrap(params[which], min_maxt, max_maxt) elif wf_which == 5: #smooth params[which] += 0.1*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 25) # print " adjusted smooth to %f" % ( params[which]) elif wf_which == 6: #wf baseline slope (m) logH -= -0.5*(params[which]/1E-4)**2 params[which] += 1E-4*dnest4.randh() logH += -0.5*(params[which]/1E-4)**2 elif wf_which == 7: #wf baseline incercept (b) logH -= -0.5*(params[which]/1E-2)**2 params[which] += 1E-2*dnest4.randh() logH += -0.5*(params[which]/1E-2)**2 # params[which] += 0.01*dnest4.randh() # params[which]=dnest4.wrap(params[which], -1, 1) # print " adjusted b to %f" % ( params[which]) elif which == ba_idx: #b over a params[which] += 70*dnest4.randh() params[which] = dnest4.wrap(params[which], -50, 20) elif which == c_idx: #b over a #this is now 1/gain (so assume it goes from 1 to e^-...7?) log_gain = np.log(params[which]) log_gain += 10*dnest4.randh() log_gain = dnest4.wrap(log_gain, -10, 0.0) params[which] = np.exp(log_gain) # params[which] += 4*dnest4.randh() # params[which] = dnest4.wrap(params[which], -2, 2) elif which == dc_idx: #b over a params[which] += 1*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 1) elif which == rc1_idx or which == rc2_idx or which == rcfrac_idx: #all normally distributed priors logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 params[which] += prior_vars[which]*dnest4.randh() logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 else: #velocity or rc params: cant be below 0, can be arb. large print "which value %d not supported" % which exit(0) return logH
def perturb(self, params): """ Unlike in C++, this takes a numpy array of parameters as input, and modifies it in-place. The return value is still logH. """ logH = 0.0 which = rng.randint(len(params)) if which == 0 or which == 4: #radius and t0 #FIND THE MAXIMUM RADIUS STILL INSIDE THE DETECTOR theta_eq = np.arctan(detector.detector_length / detector.detector_radius) theta_taper = np.arctan(detector.taper_length / detector.detector_radius) theta = params[2] # print "theta: %f pi" % (theta / np.pi) if theta <= theta_taper: z = np.tan(theta) * (detector.detector_radius - detector.taper_length) / (1 - np.tan(theta)) max_rad = z / np.sin(theta) elif theta <= theta_eq: max_rad = detector.detector_radius / np.cos(theta) # print "max rad radius: %f" % max_rad else: theta_comp = np.pi / 2 - theta max_rad = detector.detector_length / np.cos(theta_comp) # print "max rad length: %f" % max_rad #AND THE MINIMUM (from PC dimple) #min_rad = 1./ ( np.cos(theta)**2/detector.pcRad**2 + np.sin(theta)**2/detector.pcLen**2 ) min_rad = np.amax([detector.pcRad, detector.pcLen]) mean = [0, 0] cov = [[1, -0.8], [-0.8, 1]] jumps = np.array((0.1 * dnest4.randh(), 0.1 * dnest4.randh())) (r_jump, t0_jump) = np.dot(cov, jumps) params[0] = dnest4.wrap(params[0] + r_jump, min_rad, max_rad) params[4] = dnest4.wrap(params[4] + t0_jump, min_t0, max_t0) if not checkPosition(params): print "... in radius step" elif which == 1: max_val = np.pi / 4 params[which] += np.pi / 4 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, max_val) if params[which] < 0 or params[which] > np.pi / 4: print "wtf phi" #params[which] = np.clip(params[which], 0, max_val) elif which == 2: #theta rad = params[0] # print "rad: %f" % rad if rad < np.amin([ detector.detector_radius - detector.taper_length, detector.detector_length ]): max_val = np.pi / 2 min_val = 0 # print "theta: min %f pi, max %f pi" % (min_val, max_val) else: if rad < detector.detector_radius - detector.taper_length: #can't possibly hit the taper # print "less than taper adjustment" min_val = 0 elif rad < np.sqrt(detector.detector_radius**2 + detector.taper_length**2): #low enough that it could hit the taper region # print "taper adjustment" a = detector.detector_radius - detector.taper_length z = 0.5 * (np.sqrt(2 * rad**2 - a**2) - a) min_val = np.arcsin(z / rad) else: #longer than could hit the taper # print " longer thantaper adjustment" min_val = np.arccos(detector.detector_radius / rad) if rad < detector.detector_length: max_val = np.pi / 2 else: max_val = np.pi / 2 - np.arccos( detector.detector_length / rad) # print "theta: min %f pi, max %f pi" % (min_val, max_val) params[which] += (max_val - min_val) * dnest4.randh() params[which] = dnest4.wrap(params[which], min_val, max_val) # params[which] = np.clip(params[which], min_val, max_val) if params[which] < min_val or params[which] > max_val: print "wtf theta" if not checkPosition(params): print "... in theta step with rad %f" % rad print "theta: min %f pi, max %f pi" % (min_val / np.pi, max_val / np.pi) elif which == 3: #scale params[which] += dnest4.randh() params[which] = dnest4.wrap(params[which], wf.wfMax - 10 * wf.baselineRMS, wf.wfMax + 10 * wf.baselineRMS) # elif which == 4: #t0 # params[which] += 0.1*dnest4.randh() # params[which] = np.clip(params[which], 0, wf.wfLength) elif which == 5: #smooth params[which] += 0.1 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 20) elif which == 6 or which == 7: #m and b, respectively #normally distributed, no cutoffs params[which] += prior_vars[which] * dnest4.randh() if which == 6: dnest4.wrap(params[which], -0.01, 0.01) params[which] = np.clip(params[which], -0.01, 0.01) if which == 7: dnest4.wrap(params[which], -01, 01) params[which] = np.clip(params[which], -01, 01) else: print "which value %d not supported" % which exit(0) return logH
def perturb(self, params): """ Unlike in C++, this takes a numpy array of parameters as input, and modifies it in-place. The return value is still logH. """ logH = 0.0 which = rng.randint(len(params)) if which >= len(priors): #this is a waveform variable! wf_which = np.floor((which - len(priors)) / num_waveforms) if wf_which == 0: params[which] += (detector.detector_radius)*dnest4.randh() params[which] = dnest4.wrap(params[which] , 0, detector.detector_radius) elif wf_which == 1: max_val = np.pi/4 params[which] += np.pi/4*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, max_val) if params[which] < 0 or params[which] > np.pi/4: print "wtf phi" #params[which] = np.clip(params[which], 0, max_val) elif wf_which == 2: params[which] += (detector.detector_length)*dnest4.randh() params[which] = dnest4.wrap(params[which] , 0, detector.detector_length) elif wf_which == 3: #scale wf_idx = (which - len(priors)) % num_waveforms wf = wfs[wf_idx] min_scale = wf.wfMax - 0.01*wf.wfMax max_scale = wf.wfMax + 0.005*wf.wfMax params[which] += (max_scale-min_scale)*dnest4.randh() params[which] = dnest4.wrap(params[which], min_scale, max_scale) # print " adjusted scale to %f" % ( params[which]) elif wf_which == 4: #t0 params[which] += 1*dnest4.randh() params[which] = dnest4.wrap(params[which], min_maxt, max_maxt) elif wf_which == 5: #smooth params[which] += 0.1*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 25) # print " adjusted smooth to %f" % ( params[which]) elif wf_which == 6: #wf baseline slope (m) logH -= -0.5*(params[which]/1E-4)**2 params[which] += 1E-4*dnest4.randh() logH += -0.5*(params[which]/1E-4)**2 elif wf_which == 7: #wf baseline incercept (b) logH -= -0.5*(params[which]/1E-2)**2 params[which] += 1E-2*dnest4.randh() logH += -0.5*(params[which]/1E-2)**2 # params[which] += 0.01*dnest4.randh() # params[which]=dnest4.wrap(params[which], -1, 1) # print " adjusted b to %f" % ( params[which]) elif which == ba_idx: #b over a params[which] += 600*dnest4.randh() params[which] = dnest4.wrap(params[which], -200, 400) elif which == c_idx: #b over a params[which] += 0.01*dnest4.randh() params[which] = dnest4.wrap(params[which], -0.82, -0.8) elif which == dc_idx: #b over a params[which] += 0.01*dnest4.randh() params[which] = dnest4.wrap(params[which], -1.03, -0.98) elif which == rc1_idx or which == rc2_idx or which == rcfrac_idx: #all normally distributed priors logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 params[which] += prior_vars[which]*dnest4.randh() logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 elif which == grad_idx: params[which] += (len(detector.gradList)-1)*dnest4.randh() params[which] = np.int(dnest4.wrap(params[which], 0, len(detector.gradList)-1)) elif which >= velo_first_idx and which < velo_first_idx+6: velo_which = (which - velo_first_idx)%3 #TODO: consider long transforming priors on two of these if velo_which ==0: #mu0 parameter params[which] += (500E3 - 10E3) *dnest4.randh() params[which] = dnest4.wrap(params[which], 10E3, 500E3) elif velo_which ==1: #ln(1/beta) space = np.log(1/.1) params[which] += space *dnest4.randh() params[which] = dnest4.wrap(params[which], 0, np.log(1/.1)) elif velo_which == 2: space = 10E3 * 100 - 500E3 * 300 params[which] += space *dnest4.randh() params[which] = dnest4.wrap(params[which], 10E3 * 100, 500E3 * 300) elif which == trap_idx: params[which] += prior_vars[trap_idx]*dnest4.randh() params[which] = dnest4.wrap(params[which], 50, 1000) else: #velocity or rc params: cant be below 0, can be arb. large print "which value %d not supported" % which exit(0) return logH
def perturb_detector(self, params, which): logH = 0.0 detector = self.detector num_waveforms = self.num_waveforms priors = self.priors prior_vars = self.prior_vars if which == phi_idx: #lets call this phi logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 params[which] += prior_vars[which]*dnest4.randh() params[which] = dnest4.wrap(params[which], -np.pi, 0) logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 elif which == omega_idx: #call it omega logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 params[which] += prior_vars[which]*dnest4.randh() params[which] = dnest4.wrap(params[which], 0, np.pi) logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 elif which == d_idx: #d logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 params[which] += prior_vars[which]*dnest4.randh() params[which] = dnest4.wrap(params[which], 0.5, 0.999) # params[which] = dnest4.wrap(params[which], 0, 5000) logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 elif which == rc1_idx or which == rc2_idx or which == rcfrac_idx: #all normally distributed priors logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 params[which] += prior_vars[which]*dnest4.randh() if which == rcfrac_idx: params[which] = dnest4.wrap(params[which], 0, 1) logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 # # elif which == num0_idx: # sig = 3*timeStepMult # logH -= -0.5*((params[which] - 0.)/sig)**2 # params[which] += sig*dnest4.randh() # logH += -0.5*((params[which] - 0.)/sig)**2 # elif which == aliasrc_idx: # params[which] += 19.9*dnest4.randh() # params[which] = dnest4.wrap(params[which], 0.1, 20) elif which == grad_idx: # logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 # params[which] += prior_vars[which] *dnest4.randh() # params[which] = dnest4.wrap(params[which], detector.gradList[0], detector.gradList[-1]) # logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 paramlist = detector.gradList params[which] += (paramlist[-1] - paramlist[0])*dnest4.randh() params[which] = dnest4.wrap(params[which], paramlist[0], paramlist[-1]) elif which == imp_avg_idx: # logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 # params[which] += prior_vars[which] *dnest4.randh() # params[which] = dnest4.wrap(params[which], detector.impAvgList[0], detector.impAvgList[-1]) # logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 paramlist = detector.impAvgList params[which] += (paramlist[-1] - paramlist[0])*dnest4.randh() params[which] = dnest4.wrap(params[which], paramlist[0], paramlist[-1]) elif which == pcrad_idx: paramlist = detector.pcRadList params[which] += (paramlist[-1] - paramlist[0])*dnest4.randh() params[which] = dnest4.wrap(params[which], paramlist[0], paramlist[-1]) elif which == pclen_idx: paramlist = detector.pcLenList params[which] += (paramlist[-1] - paramlist[0])*dnest4.randh() params[which] = dnest4.wrap(params[which], paramlist[0], paramlist[-1]) elif which == trap_idx: # let's go with log10-uniform on this # log_trap = np.log10(params[which]) # log_trap += 3*dnest4.randh() # log_trap = dnest4.wrap(log_trap, 1, 4) # params[which] = 10**(log_trap) # p_guess = 350 # sig = 50 # logH -= -0.5*((params[which] - p_guess )/sig)**2 # params[which] += sig*dnest4.randh() # params[which] = dnest4.wrap(params[which], 100, 600) # logH += -0.5*((params[which] - p_guess)/sig)**2 traprc_min = 10 params[which] += (1000 - traprc_min)*dnest4.randh() params[which] = dnest4.wrap(params[which], traprc_min, 1000) elif which == untrap_idx: traprc_min = 1000 params[which] += (1000000 - traprc_min)*dnest4.randh() params[which] = dnest4.wrap(params[which], traprc_min, 1000000) elif which == energy_idx: wf_guess = self.conf.energy_guess sig = 10 logH -= -0.5*((params[which] - wf_guess )/sig)**2 params[which] += sig*dnest4.randh() params[which] = dnest4.wrap(params[which], wf_guess - 30, wf_guess + 30) logH += -0.5*((params[which] - wf_guess)/sig)**2 elif which >= velo_first_idx and which < velo_first_idx+4: logH -= -0.5*((params[which] - priors[which])/prior_vars[which])**2 params[which] += prior_vars[which]*dnest4.randh() params[which] = dnest4.wrap(params[which], 1, priors[which]*10) logH += -0.5*((params[which] - priors[which])/prior_vars[which])**2 elif which == velo_first_idx+4 or which == velo_first_idx+5: params[which] += (self.conf.beta_lims[1] - self.conf.beta_lims[0]) *dnest4.randh() params[which] = dnest4.wrap(params[which], self.conf.beta_lims[0], self.conf.beta_lims[1]) else: #velocity or rc params: cant be below 0, can be arb. large print ("which value %d not supported" % which) exit(0) return logH
def perturb_wf(self, params, wf_idx): wf_which = rng.randint(8) #8 wf params which = len(priors) + wf_which * num_waveforms + wf_idx if wf_which == 0 or wf_which == 4: #radius and t0 wf_idx = (which - len(priors)) % num_waveforms rad_idx = len(priors) + wf_idx theta_idx = len(priors) + 2 * num_waveforms + wf_idx t0_idx = len(priors) + 4 * num_waveforms + wf_idx theta = params[theta_idx] #FIND THE MAXIMUM RADIUS STILL INSIDE THE DETECTOR theta_eq = np.arctan(detector.detector_length / detector.detector_radius) theta_taper = np.arctan(detector.taper_length / detector.detector_radius) # print "theta: %f pi" % (theta / np.pi) if theta <= theta_taper: z = np.tan(theta) * (detector.detector_radius - detector.taper_length) / (1 - np.tan(theta)) max_rad = z / np.sin(theta) elif theta <= theta_eq: max_rad = detector.detector_radius / np.cos(theta) # print "max rad radius: %f" % max_rad else: theta_comp = np.pi / 2 - theta max_rad = detector.detector_length / np.cos(theta_comp) # print "max rad length: %f" % max_rad #AND THE MINIMUM (from PC dimple) #min_rad = 1./ ( np.cos(theta)**2/detector.pcRad**2 + np.sin(theta)**2/detector.pcLen**2 ) min_rad = np.amax([detector.pcRad, detector.pcLen]) mean = [0, 0] cov = [[1, -0.8], [-0.8, 1]] jumps = np.array((0.1 * dnest4.randh(), 0.1 * dnest4.randh())) (r_jump, t0_jump) = np.dot(cov, jumps) params[rad_idx] = dnest4.wrap(params[rad_idx] + r_jump, min_rad, max_rad) params[t0_idx] = dnest4.wrap(params[t0_idx] + t0_jump, min_t0, max_t0) elif wf_which == 1: max_val = np.pi / 4 params[which] += np.pi / 4 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, max_val) if params[which] < 0 or params[which] > np.pi / 4: print "wtf phi" #params[which] = np.clip(params[which], 0, max_val) elif wf_which == 2: #theta wf_idx = (which - len(priors)) % num_waveforms rad_idx = len(priors) + wf_idx rad = params[rad_idx] # print "rad: %f" % rad if rad < np.amin([ detector.detector_radius - detector.taper_length, detector.detector_length ]): max_val = np.pi / 2 min_val = 0 # print "theta: min %f pi, max %f pi" % (min_val, max_val) else: if rad < detector.detector_radius - detector.taper_length: #can't possibly hit the taper # print "less than taper adjustment" min_val = 0 elif rad < np.sqrt(detector.detector_radius**2 + detector.taper_length**2): #low enough that it could hit the taper region # print "taper adjustment" a = detector.detector_radius - detector.taper_length z = 0.5 * (np.sqrt(2 * rad**2 - a**2) - a) min_val = np.arcsin(z / rad) else: #longer than could hit the taper # print " longer thantaper adjustment" min_val = np.arccos(detector.detector_radius / rad) if rad < detector.detector_length: max_val = np.pi / 2 else: max_val = np.pi / 2 - np.arccos( detector.detector_length / rad) # print "theta: min %f pi, max %f pi" % (min_val, max_val) params[which] += (max_val - min_val) * dnest4.randh() params[which] = dnest4.wrap(params[which], min_val, max_val) # params[which] = np.clip(params[which], min_val, max_val) if params[which] < min_val or params[which] > max_val: print "wtf theta" elif wf_which == 3: #scale wf_idx = (which - len(priors)) % num_waveforms wf = wfs[wf_idx] params[which] += dnest4.randh() params[which] = dnest4.wrap(params[which], wf.wfMax - 10 * wf.baselineRMS, wf.wfMax + 10 * wf.baselineRMS) params[which] = np.clip(params[which], wf.wfMax - 50 * wf.baselineRMS, wf.wfMax + 50 * wf.baselineRMS) # print " adjusted scale to %f" % ( params[which]) elif wf_which == 5: #smooth params[which] += 0.1 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 25) # print " adjusted smooth to %f" % ( params[which]) elif wf_which == 6: #wf baseline slope (m) params[which] += 0.001 * dnest4.randh() params[which] = dnest4.wrap(params[which], -0.01, 0.01) # print " adjusted m to %f" % ( params[which]) elif wf_which == 7: #wf baseline incercept (b) params[which] += 0.01 * dnest4.randh() params[which] = dnest4.wrap(params[which], -1, 1) # print " adjusted b to %f" % ( params[which]) else: print "unknown wf param number drawn: %d" % wf_which exit(0)
def perturb(self, params): """ Unlike in C++, this takes a numpy array of parameters as input, and modifies it in-place. The return value is still logH. """ logH = 0.0 #this adjusts one wf at a time #choose which set of params to adjust (detector, wf 1, wf2...) # # num_sets = num_waveforms+1 # set_idx = rng.randint(num_sets) # # #choose how many t # reps = 1; # if(rng.rand() < 0.5): # reps += np.int(np.power(100.0, rng.rand())); # # for i in range(reps): # if set_idx == 0: # #detector param # which = rng.randint(len(priors)) # else: # #waveform param (from the one waveform we're adjusting this go-around # which = rng.randint(8) + len(priors) + (set_idx-1)*num_waveforms #this adjusts wfs simultaneouslt reps = 1 if (rng.rand() < 0.5): reps += np.int(np.power(100.0, rng.rand())) for i in range(reps): if (rng.rand() < 0.5): #detector param which = rng.randint(len(priors)) else: #waveform param (from any of the waveforms) which = rng.randint(8 * num_waveforms) + len(priors) if which >= len(priors): #this is a waveform variable! wf_which = np.int( np.floor((which - len(priors)) / num_waveforms)) wf_idx = (which - len(priors)) % num_waveforms wf_idx = (which - len(priors)) % num_waveforms rad_idx = len(priors) + wf_idx theta_idx = len(priors) + 2 * num_waveforms + wf_idx self.changed_wfs[wf_idx] = 1 if wf_which == 0: theta = params[theta_idx] #FIND THE MAXIMUM RADIUS STILL INSIDE THE DETECTOR theta_eq = np.arctan(detector.detector_length / detector.detector_radius) theta_taper = np.arctan(detector.taper_length / detector.detector_radius) # print "theta: %f pi" % (theta / np.pi) if theta <= theta_taper: z = np.tan(theta) * (detector.detector_radius - detector.taper_length) / ( 1 - np.tan(theta)) max_rad = z / np.sin(theta) elif theta <= theta_eq: max_rad = detector.detector_radius / np.cos(theta) # print "max rad radius: %f" % max_rad else: theta_comp = np.pi / 2 - theta max_rad = detector.detector_length / np.cos(theta_comp) # print "max rad length: %f" % max_rad #AND THE MINIMUM (from PC dimple) #min_rad = 1./ ( np.cos(theta)**2/detector.pcRad**2 + np.sin(theta)**2/detector.pcLen**2 ) min_rad = np.amax([detector.pcRad, detector.pcLen]) total_max_rad = np.sqrt(detector.detector_length**2 + detector.detector_radius**2) params[which] += total_max_rad * dnest4.randh() params[which] = dnest4.wrap(params[which], min_rad, max_rad) elif wf_which == 2: #theta rad = params[rad_idx] # print "rad: %f" % rad if rad < np.amin([ detector.detector_radius - detector.taper_length, detector.detector_length ]): max_val = np.pi / 2 min_val = 0 # print "theta: min %f pi, max %f pi" % (min_val, max_val) else: if rad < detector.detector_radius - detector.taper_length: #can't possibly hit the taper # print "less than taper adjustment" min_val = 0 elif rad < np.sqrt(detector.detector_radius**2 + detector.taper_length**2): #low enough that it could hit the taper region # print "taper adjustment" a = detector.detector_radius - detector.taper_length z = 0.5 * (np.sqrt(2 * rad**2 - a**2) - a) min_val = np.arcsin(z / rad) else: #longer than could hit the taper # print " longer thantaper adjustment" min_val = np.arccos(detector.detector_radius / rad) if rad < detector.detector_length: max_val = np.pi / 2 else: max_val = np.pi / 2 - np.arccos( detector.detector_length / rad) # print "theta: min %f pi, max %f pi" % (min_val, max_val) params[which] += np.pi / 2 * dnest4.randh() params[which] = dnest4.wrap(params[which], min_val, max_val) # if wf_which == 0: # params[which] += (detector.detector_radius)*dnest4.randh() # params[which] = dnest4.wrap(params[which] , 0, detector.detector_radius) elif wf_which == 1: max_val = np.pi / 4 params[which] += np.pi / 4 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, max_val) if params[which] < 0 or params[which] > np.pi / 4: print "wtf phi" # elif wf_which == 2: # params[which] += (detector.detector_length)*dnest4.randh() # params[which] = dnest4.wrap(params[which] , 0, detector.detector_length) elif wf_which == 3: #scale wf = wfs[wf_idx] min_scale = wf.wfMax - 0.01 * wf.wfMax max_scale = wf.wfMax + 0.005 * wf.wfMax params[which] += (max_scale - min_scale) * dnest4.randh() params[which] = dnest4.wrap(params[which], min_scale, max_scale) # print " adjusted scale to %f" % ( params[which]) elif wf_which == 4: #t0 params[which] += 1 * dnest4.randh() params[which] = dnest4.wrap(params[which], min_maxt, max_maxt) elif wf_which == 5: #smooth params[which] += 0.1 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, 25) # print " adjusted smooth to %f" % ( params[which]) elif wf_which == 6: #wf baseline slope (m) logH -= -0.5 * (params[which] / 1E-4)**2 params[which] += 1E-4 * dnest4.randh() logH += -0.5 * (params[which] / 1E-4)**2 elif wf_which == 7: #wf baseline incercept (b) logH -= -0.5 * (params[which] / 1E-2)**2 params[which] += 1E-2 * dnest4.randh() logH += -0.5 * (params[which] / 1E-2)**2 else: print "wf which value %d (which value %d) not supported" % ( wf_which, which) exit(0) # params[which] += 0.01*dnest4.randh() # params[which]=dnest4.wrap(params[which], -1, 1) # print " adjusted b to %f" % ( params[which]) elif which == ba_idx: #lets call this phi params[which] += (tf_phi_max + np.pi / 2) * dnest4.randh() params[which] = dnest4.wrap(params[which], -np.pi / 2, tf_phi_max) elif which == c_idx: #call it omega params[which] += 0.1 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0.13, 0.14) elif which == dc_idx: #d params[which] += 0.01 * dnest4.randh() params[which] = dnest4.wrap(params[which], 0.81, 0.82) elif which == rc1_idx or which == rc2_idx or which == rcfrac_idx: #all normally distributed priors logH -= -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 params[which] += prior_vars[which] * dnest4.randh() logH += -0.5 * ( (params[which] - priors[which]) / prior_vars[which])**2 elif which == grad_idx: params[which] += (detector.gradList[-1] - detector.gradList[0]) * dnest4.randh() params[which] = dnest4.wrap(params[which], detector.gradList[0], detector.gradList[-1]) elif which == imp_avg_idx: params[which] += (detector.impAvgList[-1] - detector.impAvgList[0]) * dnest4.randh() params[which] = dnest4.wrap(params[which], detector.impAvgList[0], detector.impAvgList[-1]) elif which >= velo_first_idx and which < velo_first_idx + 6: mu_max = 100E5 velo_which = (which - velo_first_idx) % 3 #TODO: consider long transforming priors on two of these if velo_which == 0: #mu0 parameter params[which] += (mu_max - 10E3) * dnest4.randh() params[which] = dnest4.wrap(params[which], 10E3, mu_max) elif velo_which == 1: #ln(1/beta) space = np.log(1 / .1) params[which] += space * dnest4.randh() params[which] = dnest4.wrap(params[which], 0, np.log(1 / .1)) elif velo_which == 2: minval, maxval = 5E6, 1E8 params[which] += (maxval - minval) * dnest4.randh() params[which] = dnest4.wrap(params[which], minval, maxval) # elif which >= k0_first_idx and which < k0_first_idx+4: # minval, maxval = -50, 50 # params[which] += (maxval-minval) *dnest4.randh() # params[which] = dnest4.wrap(params[which], minval, maxval) elif which == trap_idx: params[which] += (1000 - traprc_min) * dnest4.randh() params[which] = dnest4.wrap(params[which], traprc_min, 1000) else: #velocity or rc params: cant be below 0, can be arb. large print "which value %d not supported" % which exit(0) return logH