def sample_kuepper_flatteningforce_post(nsamples: int, qmean: float,
qerr: float, frfz: float,
frfzerr: float) -> Sequence:
"""Sample Kuepper et al. (2015) Flattening Force Posterior.
Parameters
----------
nsamples : int
qmean : float
qerr : float
frfz : float
frfzerr : float
Returns
-------
samples : ndarray
"""
params = [1.58, 37.9, 0.95]
funcargs = (qmean, qerr, frfz, frfzerr)
samples = bovy_mcmc.markovpy(
params,
0.2,
lambda x: kuepper_flatteningforce_post(x, *funcargs),
(),
isDomainFinite=[[False, False] for ii in range(len(params))],
domain=[[0.0, 0.0] for ii in range(len(params))],
nsamples=nsamples,
nwalkers=2 * len(params),
)
samples = np.array(samples).T
return samples
def fitDens(data,
locations,
effsel,
distmods,
type='exp',
mcmc=False,
nsamples=10000,
verbose=True,
init=None,
retMaxL=False):
"""
NAME:
fitDens
PURPOSE:
fit the density profile of a set of stars
INPUT:
data - recarray with the data
locations - locations of the APOGEE effective selection function
effsel - array (nloc,nD) of the effective selection function, includes area of the field
distmods - grid of distance moduli on which the effective selection function is pre-computed
type= ('exp') type of density profile to fit
mcmc= (False) run MCMC or not
nsamples= (10000) number of MCMC samples to obtain
verbose= (True) set this to False for no optimize convergence messages
init= (None) if set, these are the initial conditions
retMaxL= (False) if True, return the maximum likelihood
OUTPUT:
(best-fit, samples, maximum-likelihood) based on options
HISTORY:
2015-03-24 - Written - Bovy (IAS)
"""
# Setup the density function and its initial parameters
densfunc = _setup_densfunc(type)
if init is None:
init = _setup_initparams_densfunc(type, data)
# Setup the integration of the effective volume
effsel, Rgrid, phigrid, zgrid = _setup_effvol(locations, effsel, distmods)
# Get the data's R,phi,z
dataR = data['RC_GALR_H']
dataphi = data['RC_GALPHI_H']
dataz = data['RC_GALZ_H']
# Optimize
out = optimize.fmin(
lambda x: _mloglike(x, densfunc, type, dataR, dataphi, dataz, effsel,
Rgrid, phigrid, zgrid),
init,
disp=verbose)
if 'explinflare' in type:
step = [0.2, 0.2, 0.2, 0.2, 0.02] # need small step for Rfinv
else:
step = 0.2
if mcmc:
samples = bovy_mcmc.markovpy(
out,
step,
lambda x: loglike(x, densfunc, type, dataR, dataphi, dataz, effsel,
Rgrid, phigrid, zgrid), (),
isDomainFinite=[[False, False] for ii in range(len(out))],
domain=[[0., 0.] for ii in range(len(out))],
nsamples=nsamples,
nwalkers=2 * len(out))
if verbose: print_samples_qa(samples)
out = (
out,
numpy.array(samples).T,
)
else:
out = (out, )
if retMaxL:
out = out + (loglike(out[0], densfunc, type, dataR, dataphi, dataz,
effsel, Rgrid, phigrid, zgrid), )
return out
def pixelFitVel(options,args):
if options.sample.lower() == 'g':
if options.select.lower() == 'program':
raw= read_gdwarfs(_GDWARFFILE,logg=True,ebv=True,sn=options.snmin,
distfac=options.distfac)
else:
raw= read_gdwarfs(logg=True,ebv=True,sn=options.snmin,
distfac=options.distfac)
elif options.sample.lower() == 'k':
if options.select.lower() == 'program':
raw= read_kdwarfs(_KDWARFFILE,logg=True,ebv=True,sn=options.snmin,
distfac=options.distfac)
else:
raw= read_kdwarfs(logg=True,ebv=True,sn=options.snmin,
distfac=options.distfac)
if not options.bmin is None:
#Cut on |b|
raw= raw[(numpy.fabs(raw.b) > options.bmin)]
#Bin the data
binned= pixelAfeFeh(raw,dfeh=options.dfeh,dafe=options.dafe)
#Savefile
if os.path.exists(args[0]):#Load savefile
savefile= open(args[0],'rb')
fits= pickle.load(savefile)
ii= pickle.load(savefile)
jj= pickle.load(savefile)
savefile.close()
else:
fits= []
ii, jj= 0, 0
#Sample?
if options.mcsample:
if ii < len(binned.fehedges)-1 and jj < len(binned.afeedges)-1:
print "First do all of the fits ..."
print "Returning ..."
return None
if os.path.exists(args[1]): #Load savefile
savefile= open(args[1],'rb')
samples= pickle.load(savefile)
ii= pickle.load(savefile)
jj= pickle.load(savefile)
savefile.close()
else:
samples= []
ii, jj= 0, 0
#Model
if options.model.lower() == 'hwr':
like_func= _HWRLikeMinus
pdf_func= _HWRLike
step= [0.01,0.3,0.3,0.3,0.3]
create_method=['full','step_out','step_out',
'step_out','step_out']
isDomainFinite=[[True,True],[True,True],
[True,True],[True,True],
[False,True]]
domain=[[0.,1.],[-10.,10.],[-100.,100.],[-100.,100.],
[0.,4.6051701859880918]]
elif options.model.lower() == 'hwrrz':
like_func= _HWRRZLikeMinus
pdf_func= _HWRRZLike
step= [0.01,0.3,0.3,0.3,0.3,
0.3,0.3,0.3,0.3,
0.3,0.3,0.3]
create_method=['full',
'step_out','step_out',
'step_out','step_out',
'step_out','step_out',
'step_out','step_out',
'step_out','step_out']
# 'step_out']
isDomainFinite=[[True,True],
[True,True],[True,True],[True,True],[False,True],
[True,True],[True,True],[True,True],[False,True],
[True,True],[True,True]]#,[True,True]]
domain=[[0.,1.],
[-10.,10.],[-100.,100.],[-100.,100.],[0.,4.6051701859880918],
[-10.,10.],[-100.,100.],[-100.,100.],[0.,4.6051701859880918],
[-2.,2.],[-10.,10.]]#,[-100.,100.]]
elif options.model.lower() == 'isotherm':
like_func= _IsothermLikeMinus
pdf_func= _IsothermLike
step= [0.01,0.05,0.3]
create_method=['full','step_out','step_out']
isDomainFinite=[[True,True],[False,False],
[False,True]]
domain=[[0.,1.],[0.,0.],[0.,4.6051701859880918]]
#Run through the bins
while ii < len(binned.fehedges)-1:
while jj < len(binned.afeedges)-1:
data= binned(binned.feh(ii),binned.afe(jj))
if len(data) < options.minndata:
if options.mcsample: samples.append(None)
else: fits.append(None)
jj+= 1
if jj == len(binned.afeedges)-1:
jj= 0
ii+= 1
break
continue
print binned.feh(ii), binned.afe(jj), len(data)
#Create XYZ and R, vxvyvz, cov_vxvyvz
R= ((8.-data.xc)**2.+data.yc**2.)**0.5
#Confine to R-range?
if not options.rmin is None and not options.rmax is None:
dataindx= (R >= options.rmin)*\
(R < options.rmax)
data= data[dataindx]
R= R[dataindx]
XYZ= numpy.zeros((len(data),3))
XYZ[:,0]= data.xc
XYZ[:,1]= data.yc
XYZ[:,2]= data.zc+_ZSUN
if options.pivotmean:
d= numpy.fabs((XYZ[:,2]-numpy.mean(numpy.fabs(XYZ[:,2]))))
else:
d= numpy.fabs((XYZ[:,2]-numpy.median(numpy.fabs(XYZ[:,2]))))
vxvyvz= numpy.zeros((len(data),3))
vxvyvz[:,0]= data.vxc
vxvyvz[:,1]= data.vyc
vxvyvz[:,2]= data.vzc
cov_vxvyvz= numpy.zeros((len(data),3,3))
cov_vxvyvz[:,0,0]= data.vxc_err**2.
cov_vxvyvz[:,1,1]= data.vyc_err**2.
cov_vxvyvz[:,2,2]= data.vzc_err**2.
cov_vxvyvz[:,0,1]= data.vxvyc_rho*data.vxc_err*data.vyc_err
cov_vxvyvz[:,0,2]= data.vxvzc_rho*data.vxc_err*data.vzc_err
cov_vxvyvz[:,1,2]= data.vyvzc_rho*data.vyc_err*data.vzc_err
if options.vr or options.vrz:
#Rotate vxvyvz to vRvTvz
cosphi= (8.-XYZ[:,0])/R
sinphi= XYZ[:,1]/R
vR= -vxvyvz[:,0]*cosphi+vxvyvz[:,1]*sinphi
vT= vxvyvz[:,0]*sinphi+vxvyvz[:,1]*cosphi
#Subtract mean vR
vR-= numpy.mean(vR)
vxvyvz[:,0]= vR
vxvyvz[:,1]= vT
for rr in range(len(XYZ[:,0])):
rot= numpy.array([[cosphi[rr],sinphi[rr]],
[-sinphi[rr],cosphi[rr]]])
sxy= cov_vxvyvz[rr,0:2,0:2]
sRT= numpy.dot(rot,numpy.dot(sxy,rot.T))
cov_vxvyvz[rr,0:2,0:2]= sRT
#Fit this data
#Initial condition
if options.model.lower() == 'hwr':
params= numpy.array([0.02,numpy.log(30.),0.,0.,numpy.log(6.)])
elif options.model.lower() == 'hwrrz':
params= numpy.array([0.02,numpy.log(30.),0.,0.,numpy.log(6.),
numpy.log(30.),0.,0.,numpy.log(6.),
0.2,0.])#,0.])
elif options.model.lower() == 'isotherm':
params= numpy.array([0.02,numpy.log(30.),numpy.log(6.)])
if not options.mcsample:
#Optimize likelihood
params= optimize.fmin_powell(like_func,params,
args=(XYZ,vxvyvz,cov_vxvyvz,R,d,
options.vr,options.vrz))
if options.chi2:
#Calculate chi2 and chi2/dof
chi2, dof= like_func(params,XYZ,vxvyvz,cov_vxvyvz,R,d,options.vr,options.vrz,
chi2=True)
dof-= len(params)
params.resize(len(params)+2)
params[-2]= chi2
params[-1]= chi2/dof
print numpy.exp(params)
fits.append(params)
else:
#Load best-fit params
params= fits[jj+ii*binned.npixafe()]
print numpy.exp(params)
thesesamples= bovy_mcmc.markovpy(params,
#thesesamples= bovy_mcmc.slice(params,
#step,
0.01,
pdf_func,
(XYZ,vxvyvz,cov_vxvyvz,R,d,
options.vr),#options.vrz),
#create_method=create_method,
isDomainFinite=isDomainFinite,
domain=domain,
nsamples=options.nsamples)
#Print some helpful stuff
printthis= []
for kk in range(len(params)):
xs= numpy.array([s[kk] for s in thesesamples])
printthis.append(0.5*(numpy.exp(numpy.mean(xs))-numpy.exp(numpy.mean(xs)-numpy.std(xs))-numpy.exp(numpy.mean(xs))+numpy.exp(numpy.mean(xs)+numpy.std(xs))))
print printthis
samples.append(thesesamples)
jj+= 1
if jj == len(binned.afeedges)-1:
jj= 0
ii+= 1
if options.mcsample: save_pickles(args[1],samples,ii,jj)
else: save_pickles(args[0],fits,ii,jj)
if jj == 0: #this means we've reset the counter
break
if options.mcsample: save_pickles(args[1],samples,ii,jj)
else: save_pickles(args[0],fits,ii,jj)
return None
def sample(
nsamples: int = 1000,
params: Optional[Sequence] = None,
fitc: bool = False,
ro: float = REFR0,
vo: float = REFV0,
fitvoro: bool = False,
c: float = 1.0,
dblexp: bool = False,
addpal5: bool = False,
addgd1: bool = False,
plots: bool = True,
mc16: bool = False,
addgas: bool = False,
_use_emcee: bool = True,
) -> Sequence:
"""Sample from potential.
Parameters
----------
nsamples : int, optional
params : list, optional
fitc : bool, optional
ro : float, optional
vo : float, optional
fitvoro : bool, optional
c : float, optional
dblexp : bool, optional
addpal5 : bool, optional
addgd1 : bool, optional
plots : bool, optional
mc16 : bool, optional
addgas : bool, optional
_use_emcee : bool, optional
Returns
-------
samples
"""
(
(surfrs, kzs, kzerrs),
termdata,
termdata_mc16,
funcargs,
) = _get_data_and_make_funcargs(
fitc, ro, vo, fitvoro, c, dblexp, addpal5, addgd1, mc16, addgas
)
# ---------------------
if params is None:
params = fit(
fitc=fitc,
ro=ro,
vo=vo,
fitvoro=fitvoro,
c=c,
dblexp=dblexp,
plots=False,
addpal5=addpal5,
addgd1=addgd1,
addgas=addgas,
)[0]
samples = bovy_mcmc.markovpy( # TODO Deprecate
params,
0.2,
lambda x: -like_func(x, *funcargs),
(),
isDomainFinite=[[False, False] for ii in range(len(params))],
domain=[[0.0, 0.0] for ii in range(len(params))],
nsamples=nsamples,
nwalkers=2 * len(params),
_use_emcee=_use_emcee,
)
samples = np.array(samples).T
if plots:
plot.plot_samples(samples, fitc, fitvoro, ro=ro, vo=vo)
return samples
def fitMass():
#Read data
vcircdata= numpy.loadtxt('vcirc.txt',comments='#',delimiter='|')
vcircdata[:,0]/= _REFR0
vcircdata[:,1]/= _REFV0
vcircdata[:,2]/= _REFV0
#Set-up
bp= HernquistPotential(a=0.6/_REFR0,normalize=1./3.)
if _dexp:
dp= DoubleExponentialDiskPotential(normalize=1./3.,
hr=3.25/_REFR0,
hz=0.3/_REFR0)
else:
dp= MiyamotoNagaiPotential(normalize=1./3.,
a=3.25/_REFR0,
b=0.3/_REFR0)
hp= NFWPotential(normalize=1./3.,
a=5./_REFR0)
init= numpy.array([0.6,0.35,218./_REFV0,15./_REFR0,3.25/_REFR0])
#print _convertrho
out= optimize.fmin_powell(obj,init,args=(vcircdata,bp,dp,hp),
callback=cb)
print out
#Calculate mass
#Halo mass
halo= halomass(out)
bulge= halomass(out)
disk= diskmass(out)
print halo, disk, bulge, totalmass(out)
#Sample
samples= bovy_mcmc.markovpy(out,0.05,
(lambda x: -obj(x,vcircdata,bp,dp,hp)),
(),
isDomainFinite=[[True,True],
[True,True],
[True,True],
[True,True],
[True,True]],
domain=[[0.,1.],
[0.,1.],
[0.,2.],
[0.,10.],
[0.,2.]],
nwalkers=8,
nsamples=10000)
print "Done with sampling ..."
print numpy.mean(numpy.array(samples),axis=0)
print numpy.std(numpy.array(samples),axis=0)
samples= numpy.random.permutation(samples)[0:500]
#halo
totalmasssamples= []
for s in samples:
totalmasssamples.append(halomass(s))
totalmasssamples= numpy.array(totalmasssamples)
print "halo mass: ", numpy.mean(totalmasssamples), numpy.std(totalmasssamples)
print sixtyeigthinterval(halomass(out),totalmasssamples,quantile=.68)
#total
totalmasssamples= []
for s in samples:
totalmasssamples.append(totalmass(s))
totalmasssamples= numpy.array(totalmasssamples)
print "total mass: ", numpy.mean(totalmasssamples), numpy.std(totalmasssamples)
print sixtyeigthinterval(totalmass(out),totalmasssamples,quantile=.68)
bovy_plot.bovy_print()
bovy_plot.bovy_hist(totalmasssamples,bins=16,range=[0.,2.])
bovy_plot.bovy_end_print('totalmass.png')
return None
#disk
totalmasssamples= []
for s in samples:
totalmasssamples.append(diskmass(s))
totalmasssamples= numpy.array(totalmasssamples)
print "disk mass: ", numpy.mean(totalmasssamples), numpy.std(totalmasssamples)
#bulge
totalmasssamples= []
for s in samples:
totalmasssamples.append(bulgemass(s))
totalmasssamples= numpy.array(totalmasssamples)
print "bulge mass: ", numpy.mean(totalmasssamples), numpy.std(totalmasssamples)
return None
def fitDens(data,
locations,effsel,distmods,
type='exp',
mcmc=False,nsamples=10000,
verbose=True,
init=None,
retMaxL=False):
"""
NAME:
fitDens
PURPOSE:
fit the density profile of a set of stars
INPUT:
data - recarray with the data
locations - locations of the APOGEE effective selection function
effsel - array (nloc,nD) of the effective selection function, includes area of the field
distmods - grid of distance moduli on which the effective selection function is pre-computed
type= ('exp') type of density profile to fit
mcmc= (False) run MCMC or not
nsamples= (10000) number of MCMC samples to obtain
verbose= (True) set this to False for no optimize convergence messages
init= (None) if set, these are the initial conditions
retMaxL= (False) if True, return the maximum likelihood
OUTPUT:
(best-fit, samples, maximum-likelihood) based on options
HISTORY:
2015-03-24 - Written - Bovy (IAS)
"""
# Setup the density function and its initial parameters
densfunc= _setup_densfunc(type)
if init is None:
init= _setup_initparams_densfunc(type,data)
# Setup the integration of the effective volume
effsel, Rgrid, phigrid, zgrid= _setup_effvol(locations,effsel,distmods)
# Get the data's R,phi,z
dataR= data['RC_GALR_H']
dataphi= data['RC_GALPHI_H']
dataz= data['RC_GALZ_H']
# Optimize
out= optimize.fmin(lambda x: _mloglike(x,densfunc,type,
dataR,dataphi,dataz,
effsel,Rgrid,phigrid,zgrid),
init,disp=verbose)
if 'explinflare' in type:
step= [0.2,0.2,0.2,0.2,0.02] # need small step for Rfinv
else:
step= 0.2
if mcmc:
samples= bovy_mcmc.markovpy(out,
step,
lambda x: loglike(x,densfunc,type,
dataR,dataphi,dataz,
effsel,Rgrid,
phigrid,zgrid),
(),
isDomainFinite=[[False,False] for ii in range(len(out))],
domain= [[0.,0.] for ii in range(len(out))],
nsamples=nsamples,
nwalkers=2*len(out))
if verbose: print_samples_qa(samples)
out= (out,numpy.array(samples).T,)
else:
out= (out,)
if retMaxL:
out= out+(loglike(out[0],densfunc,type,dataR,dataphi,dataz,
effsel,Rgrid,
phigrid,zgrid),)
return out
def verysimplenfwfit(plotfilename,wcprior=False,wmassprior=False):
#Fit
p= optimize.fmin_powell(chi2,[-0.5,0.7],args=(wcprior,wmassprior))
print mvir(p), conc(p)*numpy.exp(p[1])*8.
vo= numpy.exp(p[0])
a= numpy.exp(p[1])
nfw= potential.NFWPotential(normalize=1.,a=a)
rs= numpy.linspace(0.01,350.,1001)
masses= numpy.array([nfw.mass(r/8.) for r in rs])
bovy_plot.bovy_print(fig_width=6.)
bovy_plot.bovy_plot(rs,
masses*bovy_conversion.mass_in_1010msol(220.*vo,8.)/100.,
'k-',loglog=True,
xlabel=r'$R\,(\mathrm{kpc})$',
ylabel=r'$M(<R)\,(10^{12}\,M_\odot)$',
yrange=[0.01,1.2],
xrange=[3.,400.])
if _USE_ALL_XUE:
plotx= [10.]
plotx.extend(list(_XUER))
ploty= [4.5/100.]
ploty.extend(list(_XUEMASS/100.))
plotyerr= [1.5/100]
plotyerr.extend(list(_XUEMASS_ERR/100.))
pyplot.errorbar(plotx,ploty,yerr=plotyerr,marker='o',ls='none',
color='k')
else:
pyplot.errorbar([10.,60.],[4.5/100.,3.5/10.],yerr=[1.5/100.,0.7/10.],
marker='o',ls='none',color='k')
pyplot.errorbar([150.],[7.5/10.],[2.5/10.],marker='None',color='k')
dx= .5
arr= FancyArrowPatch(posA=(7.,4./100.),posB=(numpy.exp(numpy.log(7.)+dx),numpy.exp(numpy.log(4./100.)+1.5*dx)),arrowstyle='->',connectionstyle='arc3,rad=%4.2f' % (0.),shrinkA=2.0, shrinkB=2.0,mutation_scale=20.0, mutation_aspect=None,fc='k')
ax = pyplot.gca()
ax.add_patch(arr)
#Sample MCMC to get virial mass uncertainty
samples= bovy_mcmc.markovpy(p,
0.05,
lnlike,
(wcprior,wmassprior),
isDomainFinite=[[False,False],[False,False]],
domain=[[0.,0.],[0.,0.]],
nsamples=10000,
nwalkers=6)
mvirs= numpy.array([mvir(x) for x in samples])
concs= numpy.array([conc(x) for x in samples])
indx= True-numpy.isnan(mvirs)
mvirs= mvirs[indx]
indx= True-numpy.isnan(concs)
concs= concs[indx]
rvirs= concs[indx]*numpy.array([numpy.exp(x[1]) for x in samples])*8.
bovy_plot.bovy_text(r'$M_{\mathrm{vir}} = %.2f\pm%.2f\times10^{12}\,M_\odot$' % (numpy.median(mvirs),1.4826*numpy.median(numpy.fabs(mvirs-numpy.median(mvirs)))) +'\n'+
r'$r_{\mathrm{vir}} = %i\pm%i\,\mathrm{kpc}$' % (numpy.median(rvirs),1.4826*numpy.median(numpy.fabs(rvirs-numpy.median(rvirs))))+'\n'+
r'$c = %.1f\pm%.1f$' % (numpy.median(concs),1.4826*numpy.median(numpy.fabs(concs-numpy.median(concs)))),
top_left=True,size=18.)
#Create inset with PDF
insetAxes= pyplot.axes([0.55,0.22,0.3,0.3])
pyplot.sca(insetAxes)
bovy_plot.bovy_hist(mvirs,range=[0.,3.],bins=51,histtype='step',
color='k',
normed=True,
overplot=True)
insetAxes.set_xlim(0.,3.)
insetAxes.set_ylim(0.,1.49)
insetAxes.set_xlabel(r'$M_{\mathrm{vir}}\,(10^{12}\,M_\odot)$')
bovy_plot._add_ticks()
bovy_plot.bovy_end_print(plotfilename)
def sampleGP(trainingSet,covar,mean=None,nsamples=100,
step=None,fix=None,metropolis=False,markovpy=False):
"""
NAME:
sampleGP
PURPOSE:
sample a GP
INPUT:
trainingSet - a trainingSet instance
covar - an instance of your covariance function of
choice, with initialized parameters
mean= an instance of your mean function of choice, with initialized
parameters
nsamples - number of samples desired
step= step-size for slice creation or metropolis sampling
(number or list)
fix= None or list of parameters to hold fixed
metropolis= if True, use Metropolis sampling
markovpy= if True, use markovpy sampling
OUTPUT:
list of outcovarFunc
HISTORY:
2010-08-08 - Written - Bovy (NYU)
"""
#Put in dummy mean if mean is None
if mean is None:
from flexgp.zeroMean import meanFunc
mean= meanFunc()
noMean= True
out= [covar]
else:
noMean= False
out= [(covar,mean)]
#Pack the covariance parameters
(params,packing)= pack_params(covar,mean,fix)
if step is None:
step= [0.1 for ii in range(len(params))]
#Grab the covariance class
covarFuncName= inspect.getmodule(covar).__name__
thisCovarClass= __import__(covarFuncName)
meanFuncName= inspect.getmodule(mean).__name__
thisMeanClass= __import__(meanFuncName)
#Set up isDomainFinite, domain, and create_method, even when metropolis
isDomainFinite, domain, create_method= [], [], []
covarIsDomainFinite= covar.isDomainFinite()
covarDomain= covar.paramsDomain()
covarCreate= covar.create_method()
meanIsDomainFinite= mean.isDomainFinite()
meanDomain= mean.paramsDomain()
meanCreate= mean.create_method()
for ii in range(len(packing.GPhyperPackingList)):
p= packing.GPhyperPackingList[ii]
try:
for jj in range(packing.GPhyperPackingDim[ii]):
isDomainFinite.append(covarIsDomainFinite[p])
domain.append(covarDomain[p])
create_method.append(covarCreate[p])
except KeyError:
for jj in range(len(packing.GPhyperPackingDim[ii])):
isDomainFinite.append(meanIsDomainFinite[p])
domain.append(meanDomain[p])
create_method.append(meanCreate[p])
if len(packing.GPhyperPackingList) == 1: #one-d
isDomainFinite= isDomainFinite[0]
domain= domain[0]
create_method= create_method[0]
if isinstance(step,(list,numpy.ndarray)): step= step[0]
if not metropolis and not markovpy:
#slice sample the marginal likelihood
samples= bovy_mcmc.slice(params,step,
_lnpdf,(trainingSet,packing,thisCovarClass,
thisMeanClass),
isDomainFinite=isDomainFinite,
domain=domain,
nsamples=nsamples,
create_method=create_method)
elif metropolis:
samples, faccept= bovy_mcmc.metropolis(params,step,
_lnpdf,(trainingSet,packing,
thisCovarClass,
thisMeanClass),
symmetric=True,
nsamples=nsamples)
if numpy.any((faccept < 0.15)) or numpy.any((faccept > 0.6)):
print "WARNING: Metropolis acceptance ratio was < 0.15 or > 0.6 for a direction"
print "Full acceptance ratio list:"
print faccept
elif markovpy:
samples= bovy_mcmc.markovpy(params,step,
_lnpdf,(trainingSet,packing,thisCovarClass,
thisMeanClass),
isDomainFinite=isDomainFinite,
domain=domain,
nsamples=nsamples)
print nsamples, len(samples)
if noMean:
for ii in range(nsamples):
hyperParamsDict= unpack_params(samples[ii],packing)
out.append(packing.covarFunc(**hyperParamsDict))
return out
else:
for ii in range(nsamples):
hyperParamsDict= unpack_params(samples[ii],packing)
out.append((packing.covarFunc(**hyperParamsDict),
packing.meanFunc(**hyperParamsDict)))
return out
