def y(self):
"""
Define the function in terms of x to return some value
"""
Rc = self.params['Rc'].value
D = self.params['D'].value
Zo = self.params['Zo'].value
cov = self.params['cov'].value
sig = self.params['roughness'].value
xi = self.params['decay'].value
rhoc = self.params['rhoc'].value
qoff = self.params['qoff'].value
rhos = [self.rho_up, self.rho_down]
lam = self.lam
z = np.arange(self.zmin, self.zmax, self.dz)
d = np.ones_like(z) * self.dz
edp = self.decayNp(z,
Rc=Rc,
z0=Zo,
xi=xi,
cov=cov,
rhos=rhos,
rhoc=rhoc,
sig=sig,
D=D)
self.output_params['EDP'] = {'x': z, 'y': edp}
beta = np.zeros_like(z)
rho = np.array(edp, dtype='float')
refq, r2 = parratt(self.x + qoff, lam, d, rho, beta)
if self.rrf > 0:
ref, r2 = parratt(self.x + qoff, lam, [0.0, 1.0], rhos, [0.0, 0.0])
refq = refq / ref
return refq
def y(self):
"""
Define the function in terms of x to return some value
"""
self.output_params = {}
self.calcProfile()
x = self.x + self.qoff
lam = 6.62607004e-34 * 2.99792458e8 * 1e10 / self.E / 1e3 / 1.60217662e-19
refq, r2 = parratt(x, lam, self.__d__, self.__rho__,
np.zeros_like(self.__rho__))
if self.rrf > 0:
rhos = [self.__rho__[0], self.__rho__[-1]]
betas = [0, 0]
ref, r2 = parratt(x, lam, [0.0, 1.0], rhos, betas)
refq = refq / ref
return refq
def refCalFun(d,rho,mu,sigma,syspara,x,rrf=True):
if sigma[0] <= 0: sigma[0] = 1e-5 # eliminate zero
sigma = sigma[0] * np.ones(len(sigma)) # fixed sigma
qoff = syspara[0]
yscale = syspara[1]
qres = syspara[2]
erad = e_radius
slab=0.25
k0=2*np.pi*float(energy)/12.3984 # wave vector
theta=x/2/k0 # convert q to theta
# total length of inner slabs plus 4 times roughness for both sides
length = np.sum(d) + 4* (sigma[0]+sigma[-1])
steps=int(length/slab) # each sliced box has thickness of ~ 0.25 A
xsld=np.linspace(-4*sigma[0],np.sum(d)+4*sigma[-1],steps) # get the z-axis for sld
sd=length/steps # thickness for each slab
intrho=sldCalFun(d,rho,sigma,xsld) # rho for all the steps
intmu=sldCalFun(d,mu,sigma,xsld) # mu for all the steps
sdel=[]
sbet=[]
sdel.append(erad*2.0*np.pi/k0/k0*rho[0]) # delta for the top phase
sbet.append(mu[0]/2/k0/1e8) # beta for the top phase
# add delta for the interface
sdel=sdel+[intrho[i]*erad*2.0*np.pi/k0/k0 for i in range(len(intrho))]
sbet=sbet+[intmu[i]/2/k0/1e8 for i in range(len(intmu))] # add beta for the interface
sdel.append(erad*2.0*np.pi/k0/k0*rho[-1]) # delta for the bottom phase
sbet.append(mu[-1]/2/k0/1e8) # beta for the bottom phase
d=slab*np.ones_like(sdel)
lamda=2*np.pi/k0
fdel=erad*2.0*np.pi/k0/k0
sdelf=np.array(sdel)/fdel
ref,refr=xr.parratt(x+qoff,lamda,d,sdelf,sbet)
frsnll,frsnl1=xr.parratt(x,lamda,[0,1],[sdelf[0],sdelf[-1]],[sbet[0],sbet[-1]])
if rrf == True:
return yscale*ref/frsnll
else:
return yscale*ref
def y(self):
"""
Define the function in terms of x to return some value
"""
self.output_params = {'scaler_parameters': {}}
rhos=(self.rho_up,self.rho_down)
lam=self.lam
z=np.arange(self.zmin,self.zmax,self.dz)
d=np.ones_like(z)*self.dz
edp=self.decayNp(tuple(z),Rc=self.Rc,z0=self.Zo,xi=self.decay,cov=self.cov,rhos=rhos,rhoc=self.rhoc,sig=self.roughness,D=self.D)
if not self.__fit__:
self.output_params['EDP']={'x':z,'y':edp}
beta=np.zeros_like(z)
rho=np.array(edp,dtype='float')
refq,r2=parratt(self.x+self.qoff,lam,d,rho,beta)
if self.rrf:
ref,r2=parratt(self.x,lam,[0.0,1.0],rhos,[0.0,0.0])
refq=refq/ref
return refq
def y(self):
"""
Define the function in terms of x to return some value
"""
n = self.calcProfile()
x = self.x + self.qoff
lam = 6.62607004e-34 * 2.99792458e8 * 1e10 / self.E / 1e3 / 1.60217662e-19
refq, r2 = parratt(x, lam, self.__d__, self.__rho__, self.__beta__)
if self.rrf > 0:
rhos = [
self.params['__rho__000'].value,
self.params['__rho__%03d' % (n - 1)].value
]
betas = [
self.params['__beta__000'].value,
self.params['__beta__%03d' % (n - 1)].value
]
ref, r2 = parratt(x, lam, [0.0, 1.0], rhos, betas)
refq = refq / ref
return refq
def py_parratt(self, x, lam, d, rho, beta):
return parratt(np.array(x), lam, np.array(d), np.array(rho),
np.array(beta))
def py_parratt(self, x, lam, d, rho, beta):
return parratt(x, lam, d, rho, beta)
sbet=[]
sdel.append(erad*2.0*np.pi/k0/k0*rho[0]) # delta for the top phase
sbet.append(mu[0]/2/k0/1e8) # beta for the top phase
# add delta for the interface
sdel=sdel+[intrho[i]*erad*2.0*np.pi/k0/k0 for i in range(len(intrho))]
sbet=sbet+[intmu[i]/2/k0/1e8 for i in range(len(intmu))] # add beta for the interface
sdel.append(erad*2.0*np.pi/k0/k0*rho[-1]) # delta for the bottom phase
sbet.append(mu[-1]/2/k0/1e8) # beta for the bottom phase
d=slab*np.ones_like(sdel)
lamda=2*np.pi/k0
fdel=erad*2.0*np.pi/k0/k0
sdelf=np.array(sdel)/fdel
<<<<<<< HEAD
ref,refr=xr.parratt(x+qoff,lamda,d,sdelf,sbet)
frsnll,frsnl1=xr.parratt(x,lamda,[0,1],[sdelf[0],sdelf[-1]],[sbet[0],sbet[-1]])
if rrf == True:
return yscale*ref/frsnll
else:
return yscale*ref
=======
ref,refr=xr.parratt(x,lamda,d,sdelf,sbet)
frsnll,frsnl1=xr.parratt(x,lamda,[0,1],[sdelf[0],sdelf[-1]],[sbet[0],sbet[-1]])
if rrf == True:
return ref/frsnll
else:
return ref
>>>>>>> master
def ref2min(params,x,y,yerr,fit=True):
