예제 #1
0
def getMohoEvePA(t):
    moho = tk.Moho.eph(t)[0][:2]
    eve = tk.Eve.eph(t)[0][:2]
    
    moho = moho / norm(moho)
    eve = eve / norm(eve)
    
    return degrees(arccos(moho.dot(eve)))
예제 #2
0
def getMohoKerbinPA(t):
    moho = tk.Moho.eph(t)[0][:2]
    kerbin = tk.Kerbin.eph(t)[0][:2]
    
    moho = moho / norm(moho)
    kerbin = kerbin / norm(kerbin)
    
    return degrees(arccos(moho.dot(kerbin)))
예제 #3
0
파일: dsp.py 프로젝트: mwalde/davepy
def view_filter(h, fp=None, fs=None):
    '''view filter'''
    w, H = signal.freqz(h, 1)
    H_phase = pl.unwrap([pl.degrees(cmath.phase(H[i])) for i in range(len(H))],
                        180)
    H = 20 * pl.log10(abs(H[:]))
    x = range(0, len(h))
    step = pl.cumsum(h)

    pl.figure(figsize=(16, 6.6), dpi=80)

    pl.subplot(221)
    pl.stem(x, h)
    pl.ylabel('Amplitude')
    pl.xlabel(r'n (samples)')
    pl.title(r'Impulse response')
    pl.text(0.2, 0.7, 'N_taps = {0}'.format(len(h)))

    pl.subplot(222)
    pl.stem(x, step)
    pl.ylabel('Amplitude')
    pl.xlabel(r'n (samples)')
    pl.title(r'Step response')

    pl.subplot(223)
    pl.plot(w / (2.0 * pl.pi), H)
    pl.ylabel('Magnitude (db)')
    pl.xlabel(r'Normalized Frequency (x$\pi$rad/sample)')
    pl.title(r'Frequency response')
    if fp != None:
        pl.axvline(fp, linewidth=1, color='k', ls='-')
    if fs != None:
        pl.axvline(fs, linewidth=1, color='k', ls='-')

    pl.subplot(224)
    pl.plot(w / (2.0 * pl.pi), H_phase)
    pl.ylabel('Phase (radians)')
    pl.xlabel(r'Normalized Frequency (Hz)')
    pl.title(r'Phase response')
예제 #4
0
파일: dsp.py 프로젝트: dave2pi/davepy
def view_filter(h, fp=None, fs=None):
	'''view filter'''
	w, H = signal.freqz(h,1)
	H_phase = pl.unwrap([pl.degrees(cmath.phase(H[i])) for i in range(len(H))], 180)
	H = 20 * pl.log10 (abs(H[:]))
	x = range(0,len(h))
	step = pl.cumsum(h)
	
	pl.figure(figsize=(16, 6.6), dpi=80)
	
	pl.subplot(221)
	pl.stem(x, h)
	pl.ylabel('Amplitude')
	pl.xlabel(r'n (samples)')
	pl.title(r'Impulse response')
	pl.text(0.2, 0.7, 'N_taps = {0}'.format(len(h)))
	
	pl.subplot(222)
	pl.stem(x, step)
	pl.ylabel('Amplitude')
	pl.xlabel(r'n (samples)')
	pl.title(r'Step response')	

	pl.subplot(223)
	pl.plot(w/(2.0*pl.pi), H)
	pl.ylabel('Magnitude (db)')
	pl.xlabel(r'Normalized Frequency (x$\pi$rad/sample)')
	pl.title(r'Frequency response')
	if fp != None:
		pl.axvline(fp, linewidth=1, color='k', ls='-')
	if fs != None:
		pl.axvline(fs, linewidth=1, color='k', ls='-')
	
	pl.subplot(224)
	pl.plot(w/(2.0*pl.pi), H_phase)
	pl.ylabel('Phase (radians)')
	pl.xlabel(r'Normalized Frequency (Hz)')
	pl.title(r'Phase response')
예제 #5
0
 def __init__(self,celestialFrom,celestialTo,timeRange,multiplier=86400.0):
     self.figure = figure(figsize=(8,8))
     self.axis = self.figure.gca(projection="rectilinear")#,aspect='equal')
     
     X = []
     Y = []        
     
     for t in timeRange:
         t *= multiplier
         
         ephFrom = celestialFrom.eph(t)
         ephTo= celestialTo.eph(t)
         
         pFrom = ephFrom[0] / norm(ephFrom[0])
         pTo = ephTo[0] / norm(ephTo[0])
         print pFrom
         print pTo
         print "ye",t
         angle = degrees(arccos(pFrom.dot(pTo)))
         
         X.append(t/multiplier)
         Y.append(angle)
         
     self.axis.plot(X,Y)
예제 #6
0
def generate_datafile(name,departures,depart_planet,arrive_planet,errors=0):
    f = open(name,'w')
    last = departures[-1]
    lasty = int(last[0] / 60.0 / 60.0 / 24.0 / 365.0)
    inacc = 0.0
    for departure in departures:
        if departure[1]:
            inacc += 1.0
            
    f.write("// Phase angles for the next %i years for %s - %s Hohmann transfers\n"%(lasty,depart_planet.name,arrive_planet.name))
    f.write("// Calculated using the KSP Mission Control toolkit\n")
    f.write("// Angles are valid for Kerbal Space Program 0.19\n")
    f.write("// Total windows: %i\n"%len(departures))
    f.write("// Inaccuracies during calculation: %i (%i%%)\n\n"%(inacc,inacc / len(departures) * 100))
    f.write("UT Departure\tPhase angle\tDate time\tAccurate (Error in seconds)\n")
    for departure in departures:
        accurate = departure[1]
        if accurate == 0:
            accurate = "Yes"
        else:
            accurate = str(accurate)
            
        departure = departure[0]
        
        e1 = depart_planet.eph(departure)[0]
        e2 = arrive_planet.eph(departure)[0]
        e1 /= norm(e1)
        e2 /= norm(e2)
        PA = degrees(arccos(e1.dot(e2))) * sign(cross(e1,e2)[2])
        
        years = floor(departure/60.0/60.0/24.0/365.0)+1
        days = floor((departure/60.0/60.0/24.0)%365.0)+1
        
        f.write("%f\t%f\tYear %i, Day %i\t%s\n"%(departure,PA,years,days,accurate))
        
    f.close()
예제 #7
0
파일: test7.py 프로젝트: suracefm/dynXRD
crystal=reflectivity.Sample(Sub, layer1)
crystal.set_Miller(R)
crystal.calc_g0_gH(Energy)
thBragg= float(layer1.calc_Bragg_angle(Energy).subs(layer1.structure.subs).evalf())
angle=pl.linspace(0.988, 1.012,501)*thBragg

crystal.calc_reflectivity(angle, Energy)
layer1.calc_amplitudes(angle, Energy)
Sub.calc_amplitudes(angle, Energy)

XRl = layer1.XR
XRs = Sub.XR
XT = layer1.XT


crystal.print_values(angle, Energy)

pl.plot(data[:,0], data[:,1], label='GID_sl', color='red')
# pl.plot(angle-thBragg,abs(XT)**2-1)
pl.plot(pl.degrees(angle-thBragg),abs(XRl)**2, label='dynXRD', color='black')
# pl.plot(angle-thBragg,1 - abs(XT)**2 - abs(XRl)**2)

pl.xlabel('Angle (degrees)')
pl.ylabel('Reflectivity')
pl.xlim(-0.1,0.1)
pl.yscale('log')
pl.rc('font', size=18)
pl.legend(loc="upper left", prop={'size':19})

pl.savefig('pics/test7.eps')
pl.show()
예제 #8
0
thBragg = float(
    layer1.calc_Bragg_angle(Energy).subs(layer1.structure.subs).evalf())
angle = pl.linspace(0.9955, 1.0045, 501) * thBragg

crystal.calc_reflectivity(angle, Energy)
layer1.calc_amplitudes(angle, Energy)
Sub.calc_amplitudes(angle, Energy)

XRl = layer1.XR
XRs = Sub.XR
XT = layer1.XT

crystal.print_values(angle, Energy)

pl.plot(data[:, 0], data[:, 1], label='GID_sl', color='red')
# pl.plot(angle-thBragg,abs(XT)**2-1)
pl.plot(pl.degrees(angle - thBragg),
        abs(XRl)**2,
        label='dynXRD',
        color='black')
# pl.plot(angle-thBragg,1 - abs(XT)**2 - abs(XRl)**2)

pl.xlabel('Angle (degrees)')
pl.ylabel('Reflectivity')
pl.xlim(-0.1, 0.1)
pl.yscale('log')
pl.rc('font', size=18)
pl.legend(loc="upper left", prop={'size': 19})

pl.savefig('pics/test9.eps')
pl.show()
예제 #9
0
파일: test5.py 프로젝트: suracefm/dynXRD
Sub.calc_orientation(v_par, v_perp)
layer1 = reflectivity.Epitaxial_Layer(struct, thickness)
layer1.calc_orientation(v_par, v_perp)
crystal = reflectivity.Sample(Sub, layer1)
crystal.set_Miller(R)
crystal.calc_g0_gH(Energy)
thBragg = float(
    layer1.calc_Bragg_angle(Energy).subs(layer1.structure.subs).evalf())
angle = pl.linspace(0.99, 1.01, 501) * thBragg

crystal.calc_reflectivity(angle, Energy)
layer1.calc_amplitudes(angle, Energy)
Sub.calc_amplitudes(angle, Energy)

XRl = layer1.XR
XRs = Sub.XR
XT = layer1.XT

crystal.print_values(angle, Energy)

pl.plot(data[:, 0], data[:, 1])
# pl.plot(angle-thBragg,abs(XT)**2)
pl.plot(pl.degrees(angle - thBragg), abs(XRl)**2)
# pl.plot(angle-thBragg,1 - abs(XT)**2 - abs(XRl)**2)

pl.xlabel('Angle (degrees)')
pl.ylabel('Reflectivity')
pl.xlim(-0.2, 0.2)
pl.ylim(1e-9, 1e-2)
pl.yscale('log')
pl.show()
예제 #10
0
    def eph2D(self,epoch):
        
        if self.ref == None:
            return ([0,0,0],[0,0,0])
                
        dt = epoch-self.epoch  
        #print "dT",dt
        
        # Step 1 - Determine mean anomaly at epoch
        if self.e == 0:
            M = self.M0 + dt * sqrt(self.ref.mu / self.a**3)
            M %= PI2
            E = M
            ta = E
            r3 = (self.h**2/self.ref.mu)
            rv = r3 * array([cos(ta),sin(ta),0])
            v3 = self.ref.mu / self.h
            vv = v3 * array([-sin(ta),self.e+cos(ta),0])
            
            return (rv,vv)
            
        if self.e < 1:
            if epoch == self.epoch:
                M = self.M0
            else:
                M = self.M0 + dt * sqrt(self.ref.mu / self.a**3)
                M %= PI2
             
             # Step 2a - Eccentric anomaly
            try:
                E = so.newton(lambda x: x-self.e * sin(x) - M,M)
            except RuntimeError: # Debugging a bug here, disregard
                print "Eccentric anomaly failed for",self.obj.name
                print "On epoch",epoch
                print "Made error available at self.ERROR"
                self.ERROR = [lambda x: x-self.e * sin(x) - M,M]
                raise
            
            # Step 3a - True anomaly, method 1
            ta = 2 * arctan2(sqrt(1+self.e)*sin(E/2.0), sqrt(1-self.e)*cos(E/2.0))
            #print "Ta:",ta
            # Method b is faster
            cosE = cos(E)
            
            ta2 = arccos((cosE - self.e) / (1-self.e*cosE))
            #print "e",self.e
            #print "M",M
            #print "E",E
            #print "TA:",ta
            #print "T2:",ta2
            
            # Step 4a - distance to central body (eccentric anomaly).
            r = self.a*(1-self.e * cos(E))
            
            # Alternative (true anomaly)
            r2 = (self.a*(1-self.e**2) / (1.0 + self.e * cos(ta)))
            
            # Things get crazy
            #h = sqrt(self.a*self.ref.mu*(1-self.e**2))
            r3 = (self.h**2/self.ref.mu)*(1.0/(1.0+self.e*cos(ta)))
            
        
            #print "R1:",r
            #print "R2:",r2
            #print "R3:",r3
            rv = r3 * array([cos(ta),sin(ta),0])
            
            #v1 = sqrt(self.ref.mu * (2.0/r - 1.0/self.a))
            #v2 = sqrt(self.ref.mu * self.a) / r
            v3 = self.ref.mu / self.h
            #meanmotion = sqrt(self.ref.mu / self.a**3)
            #v2 = sqrt(self.ref.mu * self.a)/r
            
            #print "v1",v1
            #print "v2",v2
            #print "v3",v3
            #print "mm",meanmotion
            
            
            # Velocity can be calculated from the eccentric anomaly            
            #vv = v1 * array([-sin(E),sqrt(1-self.e**2) * cos(E),0])
            
            # Or from the true anomaly (this one has an error..)
            #vv = sqrt(self.ref.mu * self.a)/r * array([-sin(ta),self.e+cos(ta),0])
            
            vv = v3 * array([-sin(ta),self.e+cos(ta),0])
            
            #print "rv",rv
            #print "vv",vv
            #print "check",E,-sin(E),v1*-sin(E)
            #print "V1:",vv
            #print "V2:",vv2

            return (rv,vv)
            
        elif self.e > 1:
            # Hyperbolic orbits
            # Reference: Stephen Kemble: Interplanetary Mission Analysis and Design, Pg 220-221
            M = self.M0 + dt * sqrt(-(self.ref.mu / self.a**3))
            #print "M0",self.M0
            #print "M",M
            #print "M",M
            #print "M0",self.M0
            # Step 2b - Hyperbolic eccentric anomaly
            #print "Hyperbolic mean anomaly:",M
            F = so.newton(lambda x: self.e * sinh(x) - x - M,M,maxiter=1000)
            #F = -F
            H = M / (self.e-1)
            #print "AAAA"*10
            #print "F:",F
            #print "H:",H
            #F=H
            #print "Hyperbolic eccentric anomaly:",F
            
            # Step 3b - Hyperbolic true anomaly?
            # This is wrong prooobably            
            #hta = arccos((cosh(F) - self.e) / (1-self.e*cosh(F)))
            #hta = arccos((self.e-cosh(F)) / (self.e*cosh(F) - 1))
            # TÄSSÄ ON BUGI
            hta = arccos((cosh(F) - self.e) / (1 - self.e*cosh(F)))
            hta2 = 2 * arctan2(sqrt(self.e+1)*sinh(F/2.0),sqrt(self.e-1)*cosh(F/2.0))
            hta3 = 2 * arctan2(sqrt(1+self.e)*sinh(F/2.0),sqrt(self.e-1)*cosh(F/2.0))
            hta4 = 2 * arctan2(sqrt(self.e-1)*cosh(F/2.0),sqrt(1+self.e)*sinh(F/2.0))
            #print "Hyperbolic true anomaly:",degrees(hta)
            # This is wrong too            
            #hta2 = 2 * arctan2(sqrt(1+self.e)*sin(F/2.0), sqrt(1-self.e)*cos(F/2.0))
            if M == self.M0:
                print "HTA1:",degrees(hta)
                print "HTA2:",degrees(hta2)
                print "HTA3:",degrees(hta3)
                print "HTA4:",degrees(hta4)
            
            # According to http://mmae.iit.edu/~mpeet/Classes/MMAE441/Spacecraft/441Lecture17.pdf
            # this is right..
            hta = hta2
            #print cos(hta)
            #print cosh(hta)
            
            #####hta = arctan(sqrt((self.e-1.0)/self.e+1.0) * tanh(F/2.0)) / 2.0
            #print "Mean anomaly:",M
            #print "Hyperbolic eccentric anomaly:",F
            #print "HTA:",hta
            #raise
            # Step 4b - Distance from central body?
            # Can calculate it from hyperbolic true anomaly..
            #p = self.a*(1-self.e**2)
            #r = p / (1+self.e * cos(hta))
            r3 = (self.h**2/self.ref.mu)*(1.0/(1.0+self.e*cos(hta)))
            v3 = self.ref.mu / self.h
            # But it's faster to calculate from eccentric anomaly
            #r = self.a*(1-self.e * cos(F))
            
            #print "Hyper r1:",r
            #print "Hyper r2:",r2
            
            rv = r3 * array([cos(hta),sin(hta),0])
            #http://en.wikipedia.org/wiki/Hyperbola
            #rv = array([ r * sin(hta),-self.a*self.e + r * cos(hta), 0])
            #sinhta = sin(hta)
            #coshta = cos(hta)
            #print self.ref.mu,r,self.a,hta
            #vv = sqrt(self.ref.mu *(2.0/r - 1.0/self.a)) * array([-sin(hta),self.e+cos(hta),0])
            vv = v3 * array([-sin(hta),self.e+cos(hta),0])
            
            return (rv,vv)
예제 #11
0
 def initFromStateVectors(self,epoch,pV,vV):
     self.epoch = epoch
     
     # 1) Calculate auxilary vector h
     hV = cross(pV,vV)
     
     
     # 2) Normalize position,velocity, specific angular momentum, calculate radial velocity 
     
     p = linalg.norm(pV)
     v = linalg.norm(vV)
     h = linalg.norm(hV)
     print "H:",h
     radv = pV.dot(vV) / p
     hVu = hV / h
     pVu = pV / p
     nV = cross(array([0,0,1]),hV)
     n = linalg.norm(nV)
     if n == 0:
         nVu = array([0,0,0])
     else:
         nVu = nV/n
     # 3) Calculate inclination
     #self.i = arccos(hV[2]/h)
     self.i = arcsin(linalg.norm(cross(array([0,0,1]),hVu)))
     print "i1",self.i
     print "RADVEL",radv
     self.i = arccos(array([0,0,1]).dot(hV)/h)
     #if radv < 0:
     #    self.i = PI2 - self.i 
     print "i2",self.i
     # 4) Calculate node line
     
     
     # 5) Calculate longitude of ascending node = right ascension of ascending node
     '''
     if self.i == 0:
         self.lan=0
     elif nV[1] >= 0:
         self.lan = arccos(nV[0] / n)
     else:
         self.lan = PI2 - arccos(nV[0] / n)
     '''
     
     if self.i == 0:
         self.lan = 0
     else:
         self.lan = arcsin(cross(array([1,0,0]),nVu).dot(array([0,0,1])))
         print "lan1",self.lan
         self.lan = arccos(array([1,0,0]).dot(nV)/n)
         if nV[1] < 0:
             self.lan = PI2-self.lan
         print "lan2",self.lan
     
     # 6) Eccentricity vector
     #eV = (1.0 / self.ref.mu)*((v**2 - (self.ref.mu / p))*pV - radv*vV)
     #eV2 = (1.0 / self.ref.mu) * ( hV - self.ref.mu * (pV/p))
     #eV3 = hV/self.ref.mu - (pV/p)
     
     # Source: cdeagle
     eV = cross(vV,hV)/self.ref.mu - pVu
     #print "eV1:",eV,linalg.norm(eV)
     #print "eV2:",eV2,linalg.norm(eV2)
     #print "eV3:",eV3,linalg.norm(eV3)
     print "eV3:",eV,linalg.norm(eV)
     self._e = linalg.norm(eV)
     #eVu = eV / self.e
     
     print "h",h
     print "u",self.ref.mu
     print "v",v
     print "r",p
     
     print "alte:",sqrt(1+(h**2/self.ref.mu**2)*(v**2-(2*self.ref.mu)/p)**2)
     # 7) Argument of perigree
     '''
     if self.e == 0:
         self.aop = 0
     elif self.i == 0:
       self.aop = arccos(eV[0] / self.e)  
     elif eV[2] >= 0:
         print "AOP AOP AOP"
         #self.aop = arccos(nV.dot(eV) / (n*self.e))
         print cross(nV,eV).dot(hV)
         self.aop = arcsin(cross(nVu,eVu).dot(hVu))
         #self.aop = arccos(n*self.e)
     else:
         self.aop = PI2 - arccos(nV.dot(eV) / (n*self.e))
     '''
     #CDEagle method
     # TODO CHECK how KSP handles this. 
     if self.e == 0:
         self.aop = 0
     elif self.i == 0 and self.e != 0:            
         #self.aop = arccos(eV[0] / self.e)
         #self.aop = arctan2(eV[1],eV[0])
         self.aop = arccos(array([1,0,0]).dot(eV) / self.e)
         print eV
         if eV[2] < 0:
             #self.aop = -self.aop
             self.aop = PI2-self.aop
         
         #print "BOOM",eV
         #if eV[2] < 0:
         #    print "BAM N***A"
         #    self.aop = PI2 - self.aop
     elif self.i == 0 and self.e == 0:
         #raise AttributeError("Perfectly circular orbits are not supported atm")
         self.aop = 0
     else:
         #self.aop = arcsin(cross(nVu,eVu).dot(hVu))
         self.aop = arccos(nV.dot(eV)/(n*self.e))
         if eV[2] < 0:
             self.aop = PI2-self.aop
     
     # 8) Semi major axis
     aE = v**2/2.0 - self.ref.mu / p
     self._a = -self.ref.mu / (2*aE)
     print "Old method for semi-major",self.a
     self._a = h**2 / (self.ref.mu * (1-self.e**2))
     print "New method for semi-major",self.a  
     #if self.e > 1:
     #    self._a = h**2 / (self.ref.mu * (self.e**2 - 1))
     
     if self.e == 0:
         if self.i == 0: #TODO update document to this
             print "JEA JEA JEA JEA"*10
             
             ta = arccos(array([1,0,0]).dot(pV) / p)
             if pV[1] < 0: # Vallado pg. 111
                 ta = PI2 - ta
         else: #TODO VERIFY THIS CASE
             ta = arccos((nV.dot(pV))/(n*p))
             if pV[2] < 0: # Vallado pg. 110
                 ta = PI2 - ta
         E = ta
         self.M0 = E
           
     elif self.e < 1:
         # 9) True anomaly, eccentric anomaly and mean anomaly
         if radv >= 0:
             ta = arccos((eV / self.e).dot(pV/p))
         else:
             ta = PI2 - arccos((eV / self.e).dot(pV/p))
         
         
         E = arccos((self.e+cos(ta))/(1+ self.e*cos(ta)))
         if radv < 0:
             E = PI2 - E
     
         self.M0 = E - self.e * sin(E)
         
     elif self.e > 1:
         # 9) Hyperbolic True anomaly, eccentric anomaly and mean anomaly
         # http://scienceworld.wolfram.com/physics/HyperbolicOrbit.html
         V = arccos((abs(self.a)*(self.e**2 - 1)) /(self.e * p) - 1/self.e)
         ta = arccos((eV / self.e).dot(pV/p))
         
         if radv < 0: #TODO: Should affect F too?
             # Negative = heading towards periapsis
             print "PI2"
             V = PI2 - V
             ta = PI2-ta
         print "V",V
         print "TA",ta
         # http://www.bogan.ca/orbits/kepler/orbteqtn.html In you I trust
         # Hyperbolic eccentric anomaly
         cosV = cos(V)
         F = arccosh((self.e+cosV)/(1+self.e*cosV))
         if radv < 0:
             F = -F
         F2 = arcsinh((sqrt(self.e-1)*sin(V))/(1+self.e*cos(V)))
         ##F1 = F2
         print "F1:",F
         print "F2:",F2
         self.M0 = self.e * sinh(F) - F
         
     
  
     
     
     self.h = h
     
     print "Semi-major:",self.a
     print "Eccentricity:",self.e
     print "Inclination:",degrees(self.i),"deg"
     print "LAN:",degrees(self.lan),"deg"
     print "AoP:",degrees(self.aop),"deg"
     print "Mean anomaly:",self.M0
     print "Specific angular momentum:",self.h
     if self.e < 1:
         print "Eccentric anomaly",E
         print "True anomaly",ta
     else:
         print "Hyperbolic eccentric anomaly",F
         print "Hyperbolic true anomaly",degrees(V)
         
     print "Distance from object:",p
     print "Velocity:",v
예제 #12
0
파일: test14.py 프로젝트: suracefm/dynXRD
layer1.calc_orientation_from_angle(psi, v_perp)
crystal=reflectivity.Sample(Sub, layer1)
#crystal.calc_layer_Miller()
crystal.set_Miller(R)
crystal.calc_g0_gH(Energy)
thBragg= float(Sub.calc_Bragg_angle(Energy).subs(Sub.structure.subs).evalf())
angle=pl.linspace(0.987, 1.013,501)*thBragg

#XRl = layer1.calc_reflection_amplitude(angle, Energy)
#XRs = Sub.calc_reflection_amplitude(angle, Energy)
# XT = layer1.calc_transmission_amplitude(angle, Energy)
XR=crystal.calc_reflectivity(angle, Energy)
crystal.print_values(angle, Energy)

pl.plot(data[:,0], data[:,1] , label='GID_sl', color='red')
# pl.plot(angle-thBragg,abs(XT)**2)
# pl.plot(angle-thBragg,abs(XRl)**2)
# pl.plot(angle-thBragg,1 - abs(XT)**2 - abs(XRl)**2)
pl.plot(pl.degrees(angle-thBragg),abs(XR)**2, label='dynXRD', color='black')
#pl.plot(angle-thBragg,abs(XRs)**2)
#pl.plot(angle-thBragg,abs(XRl)**2)
pl.yscale('log')
pl.xlabel('Angle (degrees)')
pl.ylabel('Reflectivity')
pl.xlim(-0.2,0.2)
pl.rc('font', size=18)
pl.legend(loc="upper left", prop={'size':19})
pl.locator_params(axis = 'x', nbins=4)

pl.savefig('pics/test14.eps')
pl.show()
예제 #13
0
crystal.calc_reflectivity(angle, Energy)
layer1.calc_amplitudes(angle, Energy)
layer2.calc_amplitudes(angle, Energy)
layer3.calc_amplitudes(angle, Energy)
Sub.calc_amplitudes(angle, Energy)

XR1 = layer1.XR
XR2 = layer2.XR
XR3 = layer3.XR
XRs = Sub.XR
#XT = layer1.XT

crystal.print_values(angle, Energy)

#pl.plot(data[:,0], data[:,1], label='GID_sl', color='red')
# pl.plot(angle-thBragg,abs(XT)**2-1)
pl.plot(pl.degrees(angle-thBragg),abs(XRs)**2, label='$\infty$', color='black')
pl.plot(pl.degrees(angle-thBragg),abs(XR1)**2, label='$500$ nm', color='red')
pl.plot(pl.degrees(angle-thBragg),abs(XR2)**2, label='$1000$ nm', color='blue')
pl.plot(pl.degrees(angle-thBragg),abs(XR3)**2, label='$2000$ nm', color='green')
# pl.plot(angle-thBragg,1 - abs(XT)**2 - abs(XRl)**2)

pl.xlabel('Angle (degrees)')
pl.ylabel('Reflectivity')
pl.xlim(-0.005,0.008)
#pl.yscale('log')
pl.legend(loc="upper left", title="Thickness", prop={'size':11})

pl.savefig('pics/dynamical.eps')
pl.show()
예제 #14
0
파일: test5.py 프로젝트: suracefm/dynXRD
layer1.calc_orientation(v_par, v_perp)
crystal = reflectivity.Sample(Sub, layer1)
crystal.set_Miller(R)
crystal.calc_g0_gH(Energy)
thBragg = float(layer1.calc_Bragg_angle(Energy).subs(layer1.structure.subs).evalf())
angle = pl.linspace(0.99, 1.01, 501) * thBragg

crystal.calc_reflectivity(angle, Energy)
layer1.calc_amplitudes(angle, Energy)
Sub.calc_amplitudes(angle, Energy)

XRl = layer1.XR
XRs = Sub.XR
XT = layer1.XT


crystal.print_values(angle, Energy)

pl.plot(data[:, 0], data[:, 1])
# pl.plot(angle-thBragg,abs(XT)**2)
pl.plot(pl.degrees(angle - thBragg), abs(XRl) ** 2)
# pl.plot(angle-thBragg,1 - abs(XT)**2 - abs(XRl)**2)


pl.xlabel("Angle (degrees)")
pl.ylabel("Reflectivity")
pl.xlim(-0.2, 0.2)
pl.ylim(1e-9, 1e-2)
pl.yscale("log")
pl.show()
예제 #15
0
파일: test2.py 프로젝트: buguen/minf
#show()



vx = array([1.0,0.0,0.0]).reshape(-1,1)
vy = array([0.0,1.0,0.0]).reshape(-1,1)
vz = array([0.0,0.0,1.0]).reshape(-1,1)
error_angles_x = empty((l,))
error_angles_y = empty((l,))
error_angles_z = empty((l,))
for i in range(l):
    q1 = imu_quaternions[i]
    q2 = original_quaternions[i]
    v1x = transpose(q1.rotateVector(vx))
    v2x = transpose(q2.rotateVector(vx))
    ax = degrees(angle(v1x[0],v2x[0]))
    v1y = transpose(q1.rotateVector(vy))
    v2y = transpose(q2.rotateVector(vy))
    ay = degrees(angle(v1y[0],v2y[0]))
    v1z = transpose(q1.rotateVector(vz))
    v2z = transpose(q2.rotateVector(vz))
    az = degrees(angle(v1z[0],v2z[0]))

    error_angles_x[i] = ax
    error_angles_y[i] = ay
    error_angles_z[i] = az

figure()
plot(error_angles_x,label='x')
plot(error_angles_y,label='y')
plot(error_angles_z,label='z')