In [4]:

```
import math
# variable declaration
F = 10*10**9; # radar operating frequency in Hz
Vo = 3*10**8; # vel in m/s
G = 20; # antenna gain in dBi
R = 20*10**3; # distance of radar reflected signal from target
Pt = 10*10**3 # Tx power in watts
CS = 10; # cross sectional area in m^2
# Calculations
Gain = 10**(G/10) # G = 10log(Gain) ==>gain - antilog(20/10)
Gr = Gain; # gain of tx antenna and Rx antenna
Gt = Gain;
lamda = float(Vo)/F;
Pr = (lamda*lamda*Pt*Gt*Gr*CS)/((4*4*4*math.pi*math.pi*math.pi)*(R**4)); #received power in watts
# result
print'Received signal Power is %3.5g' %Pr;
print'Note : Calculation error in Textbook';
```

In [18]:

```
import math
#variable declaration
Vo = 3*10**8; #velocity of EM wave in m/s
t = 20*10**-6; #echo time in sec
# calculations
R = (Vo*t)/2; #distance b/n target and Radar in m
# Output
print'Distance of Target from the Radar is ', R/1000,'km' ;
```

In [5]:

```
import math
# variable declaration
Vo = 3*10**8; #velocity of EM wave in m/s
F = 0.8*10**3; #pulse repetitive frequency
Tp = 1.2*10**-6; #pulse width in sec
# calculations
Rmax = Vo/(2*F); # maximum Range of Radar in m
Rmin = (Vo*Tp)/2; # minimum Range of radar in m
# Output
print'Maximum Range of Radar is ',Rmax/1000,'Km';
print'Minimum Range of the Radar is',Rmin,'m';
```

In [6]:

```
import math
# variable declaration
PW = 1.5*10**-6; #pulse width in sec
PRF = 2000; #per second
# calculations
Dc = PW*PRF; #duty cycle
# Output
print'Duty Cycle is %3.4e' %Dc;
```

In [38]:

```
import math
# variable declaration
PW = 2*10**-6; #pulse width in sec
PRF = 1000; #pulse repetitive frequency
Pp = 1*10**6; #peak power in watts
# Calculations
Dc = PW*PRF; # duty cycle
AvgTp = Pp*Dc; # average transmitted power in watts
# Output
print'Average Transmitted power is ',AvgTp/1000,'KW';
```

In [41]:

```
import math
#variable declaration
PW = 2*10**-6; #pulse width in sec
Vo = 3*10**8; #velocity of EM wave in m/s
#Calculations
RR = (Vo*PW)/2; #Range Resolution in m
# result
print'Range Resolution is ',RR,'m';
```

In [44]:

```
import math
# variable declaration
t = 50*10**-6; #echo time in sec
Vo = 3*10**8; #velocity of EM wave in m/s
# Calculations
R = (Vo*t)/2; #Range in m
# result
print'Target Range is ',R/1000,'Kms';
```

In [178]:

```
import math
# variable declaration
Tvel = 1000; #target speed in kmph
F = float(10*10**9); #radar operating frequency in hz
Vo = 3*10**8; #velocity of EM wave in m/s
#Calculations
Vr = 1000*(5/float(18)); #target speed in m/s
Fd = float(2*Vr*F)/float(Vo); #Doppler Frequency shift in Hz
#result
print'Doppler Frequency shift Caused by aircraft is %g' %(Fd/1000),'KHz';
```

In [196]:

```
import math
# variable declaration
F = 6*10**9; # Transmitting Frequency of Radar
Vr = 250; # velocity of automobile in Kmph
Vo = 3*10**8; #velocity of EM wave in m/s
#Calculations
Va = Vr*(5/float(18)); #velocity of automobile in m/s
Fd = (2*Va*F)/float(Vo); #Doppler Frequency shift in Hz
#result
print'Doppler Frequency shift is %3.3f ' %(Fd/10**3),'KHz';
```

In [7]:

```
import math
# variable declaration
F = 9*10**9; #Transmitting Frequency of Radar
Vr = 800; #velocity of aircraft in Kmph
Vo = 3*10**8; #velocity of EM wave in m/s
#Calculations
Va = Vr*(5/float(18)); #velocity of aircraft in m/s
Fd = (2*Va*F)/float(Vo); #Doppler Frequency shift in Hz
Fr = F+Fd; #frequency of reflected echo in Hz
#result
print'Doppler Frequency shift is %3.2e'%Fd,'Hz';
print'frequency of reflectedecho is %4e'%(Fr/1000),'Khz';
print'Note: doppler frequency shift wrongly printed in Text Book as 1333.3 Hz';
```

In [9]:

```
import math
#variable declaration
F = 2*10**9; #Transmitting Frequency of Radar
Vr = 350; #velocity of sports Car in Kmph
Vo = 3*10**8; #velocity of EM wave in m/s
#Calculations
Va = Vr*(5/float(18)); #velocity of aircraft in m/s
Fd = (2*Va*F)/float(Vo); #Doppler Frequency shift in Hz
#Car moving away from Radar
Fr = F-Fd; #frequency of reflected signal in Hz
#result
print'Doppler Frequency shift is %g'%Fd,'Hz';
print'frequency of reflected echo is %3.3g'%(Fr/10**9),'GHz','-',Fd,'Hz';
print'Note: doppler frequency shift wrongly printed in Text Book as 129.6 Hz\nVr is printed as 9.72 m/s instead of 97.2 m/s';
```

In [10]:

```
import math
#variable declaration
PRF = 2000; #pulse repetition frequency per second
PW = 1*10**-6; #pulse width in sec
Pp = 500*10**3; #Peak power in watts
#Calculations
Dc = PW*PRF; #Duty Cycle
Pav = Pp*Dc; #average power in watts
pavdB = 10*math.log10(Pav);
#result
print'Average power is ',Pav/1000,'KW';
print'Average Power is ',pavdB,'dB';
```

In [11]:

```
import math
#variable declaration
PRF = 1000; #pulse repetition frequency per second
PW = 0.8*10**-6; #pulse width in sec
Pp = 10*10**6; #Peak power in watts
Vo = 3*10**8; #velocity of EM wave in m/s;
#Calculations
Dc = PW*PRF; #Duty Cycle
Pav = Pp*Dc; #average power in watts
Rmax = Vo/(2*PRF);
#result
print'Average power is ',Pav/1000,' KW';
print'Maximum Radar Range is ',Rmax/1000,'Km';
```

In [37]:

```
import math
# variable declaration
Rmax = 500*10**3; #maximum Range of Radar in ms
Vo = 3*10**8; #Velocity of EM wave in m/s
#Calculations
PRF = Vo/(2*Rmax); #pulse repetitive frequency in Hz
#result
print'Pulse repetive frequency required for the range of 500km is ',PRF,'Hz';
```

In [12]:

```
import math
#variable declaration
Te = 0.2*10**-3; #echo time in sec
PRF = 1000; #pulse repetitive Frequency in Hz
Vo = 3*10**8; #Velocity of EM wave in m/s
#Calculations
R = (Vo*Te)/2; #Range of the target in m
Runamb = (Vo/(2*PRF)); #Maximum unambiguous Range in m
#result
print'Target range is ',R/1000,' Km';
print'Maximum Unambiguous Range is ',Runamb/1000,'Km';
```

In [13]:

```
import math
#variable declaration
F = 10*10**9; #operating frequency of radar in Hz
Vo = 3*10**8; #Velocity of EM wave in m/s
Vr = 100; #velocity of car in kmph
#Calculations
lamda = Vo/float(F); #wavelength in m
Vc = Vr*(5/float(18)); #velocity of car in m/s
Fd = (2*Vc)/float(lamda); #doppler shift in Hz
#result
print'Doppler Shift is %3.2f '%(Fd/1000),' KHz';
print'Frequency of the Received echo when car is approaching radar is %g'%(F/10^9),'Ghz','+',Fd/1000,' Khz';
print'Frequency of the Received echo when car is moving away from radar is %g '%(F/10^9),'Ghz','-',Fd/1000,'Khz';
```

In [18]:

```
import math
#variable declaration
D = 200; #azimuth distance between two radars
R = 10*10**3; #Range of radar
#Calculations
BWdB = (float(D)/R)*(180/math.pi); #3dB beam width in degrees
#result
print'Maximum 3db beamwidth of radar resolving the target is %3.3f'%BWdB, 'degrees';
```

In [19]:

```
import math
#variable declaration
F = 10*10**9; #operating frequency of radar in Hz
Vo = 3*10**8; #Velocity of EM wave in m/s
Vr1 = 100; #velocity of one aircraft in m/s
theta = 45; #angle b/n velocity vector and radar axis for second aircraft
Vr = 200; #vel in m/s
#Calculations
lamda = Vo/float(F); #wavelength in m
Fd1 = (2*Vr1)/float(lamda); #doppler shift due to 1st aircraft
Vr2 = Vr*math.cos(45*math.pi/180); #radial velocity of the second aircraft
Fd2 = (2*Vr2)/float(lamda); #doppler shift due to 2nd aircraft
Fd = Fd2-Fd1; #difference in doppler shift in Hz
T = 1/float(Fd); #time required to resolve the aircraft in sec
#result
print'Minimum time required to resolve the aircrafts is %g'%(T*10**6),'usec';
print'Note: in textbook there is a mistake in the calculation of doppler shift Fd1';
```

In [22]:

```
import math
#variable declareation
Pp = 100*10**3; #peak power in watts
Pav = 100; #average power in watts
#Calculations
PdB = 10*math.log10(Pp); #peak power in dB
PavdB = 10*math.log10(Pav); #average power in dB;
DCC = PdB-PavdB; #Duty Cycle Correction factor
#result
print'Duty Cycle Correction Factor is ',DCC, 'dB';
print'Note: In question given peak power is 100KW but while solving 1KW is taken instead of 100KW';
```

In [25]:

```
import math
#variable declaration
Pp = 1*10**6; #peak power in watts
PW = 1*10**-6; #pulse width in sec
NPd = 20; #pulses in one dwell period
PRF = 1000; #pulse repetitive frequency
#calculations
PE = Pp*PW; #pulse energy in joule
PED = NPd*PE; #pulse energy in one dwell period
D = PW*PRF; #Duty cycle
Pav = Pp*D; #average power in watts
#output
print'Average Power is ',Pav,'watts';
print'Duty Cycle is %2.2e'%D;
print'Pulse Energy is ',PE,' Joules';
print'Pulse Energy in one Dwell Period is ',PED,'Joules';
print'Note: In textbook Values of PRF and pulses in one dwell period are varied from given values in question while solving ' ;
```

In [23]:

```
import math
#variable declaration
Noise_power = -50; #noise power in dBm
Fl = 1*10**6;#lower cutoff frequency in Hz
Fh = 21*10**6;#upper cutoff frequency in Hz
#calculation
BW = Fh-Fl;#bandwidth
NP =10**-8;#noise power in watts; -50dBm = 10log10(NP) =>10^-5 mwatts
NPSD = NP/BW;#noise power spectral density in W/Hz
#result
print'Noise Power Spectral Density is %3.0e'%NPSD,' W/Hz';
```

In [26]:

```
import math
#variable declaration
Ra = 1000; #Range of target A in Kms
#Calculations
Rb =Ra*math.cos(45*math.pi/180); #range of target B in kms
#result
print'Range of target B is %g '%Rb,'Kms';
print'Note:value of cos(45) is incorrectly taken as 1/2 in textbook';
```

In [35]:

```
import math
#variable declaration
Az = 60; #azimuth angle of the target in degrees
Height = 10;#height of target in kms
#Calculations
R = 10/math.sin(Az*math.pi/180);
#result
print'Range of the Target is %g '%R,'Kms';
```

In [210]:

```
import math
#variable declaration
F = 10*10**9; #MTI radar operating Frequency
Vo = 3*10**8; #velocity of EM wave in m/s;
PRF = 2*10**3; #pulse repetitive frequency in hz
n=1; #for lowest blind speed
#Calculations
lamda = Vo/float(F); #wavelength in m
BS =((n*lamda)/float(2))*PRF; #blind speed
#result
print'Lowest Blind Speed is ',BS,'m/s';
```

In [58]:

```
import math
# variable declaration
PRF = 2*10**3; # pulse repetitive frequency in Hz
Vo = 3*10**8; #velocity of EM wave in m/s
print'f1 = first operating frequency of MTI Radar\n';
print' f2 = second operating frequency of MTI Radar\n';
print' 2nd blind speed of 1st radar = (2Vo/2f1)*PRF\n 5th blind speed of 2nd radar = (5Vo/2f2)*PRF\n';
print' PRF(V0/f1) = (5/2)*(Vo/f2)*PRF\n';
print' (f2/f1) = 5/2\n';
```

In [59]:

```
import math
print'(PRF1) = 2(PRF2)\n';
print' Vb3 = 4Vb5\n';
print' (3Vo/2F1)(PRF1)) = 4(5Vo/2F2)(2PRF2)\n';
print' 3/2F1 = 20/F2\n';
print' Ratio of operating frequencies is F2/F1 = 40/3\n';
```

In [27]:

```
import math
#variable declaration
PW = 5; #FM pulse width before compression in us
Fl = 40; #lower cut off Frequency in Mhz
Fh = 60; #upper cut off Frequency in Mhz
#Calculations
BW = Fh-Fl; #bandwidth of signal in Mhz
CPW = 1/float(BW); #Compression pulse width in us
CR = PW/float(CPW); #compression ratio
#result
print'Compression ratio is %g'%CR;
print'Compression Pulse Width is %g'%CPW,'us';
```

In [28]:

```
import math
#variable declaration
BW = 100; #band width in Mhz
PW = 4; #pulse width in us
#Calculations
CPW = 1/float(BW); #compressed pulse width in us
CR = PW/float(CPW); #compression ratio
#result
print'compressed pulse width is %g'%CPW,' us';
print'compression ratio is %g'%CR;
print'Note: In textbook compression ratio is wrongly printed as 40';
```

In [29]:

```
import math
#variable declaration
CR = 50; #compression ratio
PW = 2; #pulse width in us
#Calculations
CPW = PW/float(CR); #compression pulse width in us
BW = 1/float(CPW); # compression band width in Mhz
#result
print'compressed pulse width is %g'%CPW,'us';
print'compression Bandwidth is %g'%BW,'MHz'
```

In [30]:

```
import math
#variable declaration
PW = 1*10**-6; #transmitted pulse width in sec
Vo = 3*10**8; #velocity of EM wave in m/s
#Calculations
RR = (Vo*PW)/2;
#result
print'Range Resolution is ',RR,' m';
print'As the targets are separated by 100m it is possible to resolve';
```

In [33]:

```
import math
# variable declaration
F = 10*10**9; #operating frequency in Hz
PRF = 1000; #pulse repetitive frequency in Hz
Fm = PRF; #modulating frequency
#Calculations
Fc1 = float(F+Fm); #closest frequency in Hz
Fc2 = float(F-Fm); #closest frequency in Hz
#result
print'Closest Frequencies are %3.3f'%(Fc1/10**6),' Mhz';
print'Closest Frequencies are %3.3f'%(Fc2/10**6),' Mhz';
```

In [36]:

```
import math
#variable declaration
F1 = 490; #freq shift lower limit in Mhz
F2 = 510; #freq shift upper limit in Mhz
#calculations
SC = (F1+F2)/2; #Spectrum Centre in Mhz
BW = F2-F1; #bandwidth in Mhz
CPW = float(1)/BW; #compressed bandwidth in us
#result
print'Spectrum centre is %g'%SC,' MHz';
print'BandWidth is %g'%BW,' MHz';
print'Compressed pulse Width is %3.2f'%CPW,'us';
```

In [217]:

```
import math
#variable declaration
F = 9; #Noise figure in dB
BW = 2*10**6; # Bandwidth
To = 300; # Temperature in kelvin
K = 1.38*10**-23; # Boltzman constant
#Calculations
F1 = 10**(F/float(10)); #antilog calculation
Pmin = (K*To*BW)*(F1-1); #minimum receivable power
#result
print'Minimum receivable power Pmin %3.3e'%Pmin,' W';
```

In [38]:

```
import math
#variable declaration
Pt = 500*10**3; #peal pulse power in watts
Pmin = 1*10**-12; #minimum receivable power
Ac = 5; #area of capture in m^s
RCS = 16; #radar cross sectional area in m^2
F = 10*10**9; #radar operating frequency
Vo = 3*10**8; #vel of Em wave in m/s;
#calculations
lamda = Vo/float(F); #wavelength
Rmax = ((Pt*Ac*Ac*RCS)/float((4*math.pi*lamda*lamda*Pmin)))**0.25;
#result
print'Maximum Radar range of the Radar system is %g'%(Rmax/1000),' Kms';
print'Note:Calculation mistake in textbook instead of RCS,RCS^2 is calculated';
```

In [42]:

```
import math
#variable declaration
lamda = 0.03; #wavelength in m
RCS = 5; # Radar cross section in m^2
D = 1; # antenna diameter in m
F = 5; # noise figure in dB
Rmax = 10*10**3 # Radar range
BW = 500*10**3; # bandwidth
#Calculation
F1 = 10**(F/float(10)); # antilog calculation
#Rmax = 48*((Pt*D**(4*RCS))/float((BW*lamda*lamda(F-1))))**(0.25);
Pt = ((Rmax/float(48))**(4))*((BW*lamda*lamda*(F1-1))/float(((D**4)*RCS)));
#result
print'Peak Transmitted Power is %e' %Pt;
print'Note: Antilog Calculation error in textbook at F'
```

In [60]:

```
import math;
# variable Declaration
Pt = float(20*10**6); #peak pulse power in watts
RCS = 1; # radar cross sectional area in m^2
f = 3*(10**9); #radar operating frequency
Vo = 3*(10**8); #vel of Em wave in m/s;
D = 50; #diameter of antenna in m
F = 2; #receiver noise figure
BW = 5000; #receiver bandwidth
# calculations
lamda = float(Vo)/float(f) # wavelength in m
Rmax = 48*((Pt*(D**4)*RCS)/(BW*lamda*lamda*(F-1)))**0.25;
# output
print 'Maximum Radar range of the Radar system is %f kms' %(Rmax/1000);
print 'Note:In textbook All values are correctly substituted in calculating Rmax but incorrect final answer is printed in the book'
```

In [61]:

```
import math
#variable declaration
lamda = 6*10**-2; #Wavelength in m
PRF = 800; #Pulse Repetitive frequency in Hz
n1 = 1 ; #n value for first blind speed
n2 = 2 ; #n value for first blind speed
n3 = 3 ; #n value for first blind speed
#Calculations
#Vb = (n*lamda/2)*PRF; Blind speed of the Radar
#For n = 1
Vb1 = ((n1*lamda)/float(2))*PRF; #Blind speed of the Radar in m/s
Vb2 = ((n2*lamda)/float(2))*PRF; #Blind speed of the Radar in m/s
Vb3 = ((n3*lamda)/float(2))*PRF; #Blind speed of the Radar in m/s
#multiply by 18/5 to convert from m/s to kmph
#result
print'The lowest Blind speeds are %3.1f' %(Vb1*(18/float(5))),'Km/hr';
print'The lowest Blind speeds are %3.2f' %(Vb2*(18/float(5))),'Km/hr';
print'The lowest Blind speeds are %3.2f' %(Vb3*(18/float(5))),'Km/hr';
```

In [62]:

```
import math
# variable declaration
Pt = 500*10**3; # Peak pulse power in Watts
pt = 50; # peak power transmitted by beacon in watts
f = 2500*10**6; # Radar Operating frequency in Hz
lamda = 0.12; # wavelength in m
D = 64; # antenna diameter in m
BW = 5000; # Radar Bandwidth
Ab = 0.51;
k = 1.38*10**-23; # Boltzmann constant
F = 20 # Noise figure
Fb = 1.1 # Noise figure of beacon
To = 290; # Temperature in kelvin
#Calculations
Ar = (0.65*math.pi*D*D)/float(4);
Rmax = math.sqrt((Ar*Pt*Ab)/float((lamda*lamda*k*To*BW*(F-1)))); # Max tracking range of radar
Rmax1 = math.sqrt((Ar*pt*Ab)/float((lamda*lamda*k*To*BW*(Fb-1)))); # Max tracking range of radar if Fb = 1.1
#result
print'Maximum Tracking Range of Radar is %3.3e'%(Rmax/1000),' Km';
print'Range of beacon if noise figure is 1.1 %3.3e'%(Rmax1/1000),'Km';
print'Note: Calculation mistake in textbook in calculating Range of beacon instead of 1.36*10^9 km range is wrongly printed as 136*10^6 km';
```

In [63]:

```
import math;
# Variable Declaration
lamda = 0.06; # wavelength in m
Vr = 100 ; # Radial velocity of target in kmph
#Calculations
Vr1 = Vr*(float(5)/18); #Radial vel. in m/s
fd = (2*Vr1)/lamda; #doppler shift
#Output
print 'Doppler Shift is %3.3f Khz' %(fd/1000);
```

In [65]:

```
import math
#variable declaration
F = 9.5*10**9; #radar operating frequency in Hz
Vo = 3*10**8; #vel in m/s;
G = 20; #antenna gain in dBi;
R = 50*10**3; #distance of radar reflected signal from target
Pt = 10*10**3 #Tx power in watts
CS = 10; #cross sectional area in m^2
#Calculations
Gain = 10**(G/float(10)); #G = 10log(Gain) ==>gain - antilog(20/10);
Gr = Gain; #gain of tx antenna and Rx antenna
Gt = Gain
lamda = float(Vo)/F
Pr= (lamda*lamda*Pt*Gt*Gr*CS)/((4*4*4*math.pi*math.pi*math.pi)*(R**4))
#result
print'Received signal Power is %g'%Pr,' Watts';
```

In [60]:

```
import math
#variable declaration
Vo = 3*10**8; #vel of EM wave m/s;
t = 10*10**-6; # time taken to rx echo
#Calculations
R = (Vo*t)/2; #Distance of the Target
#result
print'Distance of the target is ',R/1000,' Km';
```

In [66]:

```
import math
# variable declaration
PW = 10**-6; # Pulse Width in sec
PRF = 1000; #Pulse Repetitive Freq in Hz
Vo = 3*10**8; # vel of EM wave m/s;
#Calculations
Rmax = Vo/(2*PRF); #max range of radar
Rmin = (Vo*PW)/2 ; # min range of radar
#result
print'Maximum Range of radar is %e'%Rmax,' m';
print'Minimum Range of radar is ',Rmin,'m';
```

In [68]:

```
import math
#variable declaration
Vr = 100; # speed of car in kmph
f = 10*10**9; # Radar operating frequency
Vo = 3*10**8; # vel. of EM wave
#Calculations
Vr1 = Vr*(5/float(18)); # kmph to m/s conversion
fd = (2*Vr1*f)/float(Vo); # Doppler shift in Hz
#result
print'Doppler shift %3.3g'%(fd/1000),'Khz';
```

In [235]:

```
import math
#variable declaration
Vo = 3*10**8; # vel of EM wave m/s;
t = 200*10**-6; # time taken to rx echo
#Calculations
R = (Vo*t)/2; # Distance of the Target
#result
print'Distance of the target is ',R/1000,'Km';
```

In [69]:

```
import math
#variable declaration
Pt = 100*10**3; # Peak tx. power
PRF = 1000; # pulse repetitive freq. in Hz
PW = 1.2*10**-6; # Pulse Width in sec
#Calculations
DC = PRF*PW # Duty cycle
Pav = Pt*DC # Avg. power
#Output
print'Duty cycle is ',DC;
print'Average power is ',Pav,' Watts';
```

In [80]:

```
import math
#variable declaration
Runamb = 300*10**3; # unambiguous range in m
Vo = 3*10**8; # Vel. of EM wave in m/s
#Calculations
PRF = Vo/(2*(Runamb)); # Pulse repetitive freq.
#result
print'Pulse repetitive frequency ',PRF,'Hz';
```

In [70]:

```
import math
#variable declartation
Vo = 3*10**8; #vel of EM wave m/s;
PRF = 1000; # pulse repetitive freq. in Hz
PW = 10**-6; # Pulse width in sec
#Calculations
DC = PRF*PW; # Duty cycle
Runamb = Vo/(2*PRF); # Distance of the Target
#result
print'Duty cycle ',DC;
print'Maximum unambiguous range', Runamb/1000,'Km' ;
```

In [71]:

```
import math
#variable declaration
Vo = 3*10**8; # vel of EM wave m/s;
PRF = 1000; # pulse repetitive freq. in Hz
PW = 4*10**-6; # Pulse width in sec
#Calculations
Runamb = Vo/(2*PRF); # Distance of the Target
RR = (Vo*PW)/2; # Range Resolution
#result
print'Maximum unambiguous range ',Runamb/1000,' Km';
print'Range Resolution ',RR,'m';
```

In [75]:

```
import math
# variable declaration
f = 6*10**9; # Radar operating freq. in Hz
Vo = 3*10**8; # vel of EM wave m/s;
PRF = 1000; # pulse repetitive freq. in Hz
PW = 1.2*10**-6; # Pulse width in sec
DC = 10**-3; # Duty Cycle
Smin = 5*10**-12; # min. detectable signal
R = 60*10**3; # Max. Range in m
G = 4000; #power gain of antenna
Ae = 1 # effective area in m*2
RCS = 2 # Radar cross sec. in m*2
#Calculations
lamda = Vo/float(f); # Wavelength in m
PRT = PW/float(DC); # pulse repetitive time
PRF = 1/float(PRT); # Pulse repetitive freq.
Pt = ((Smin*(4*math.pi*R*R)**2))/(float((Ae*G*RCS))); #Peak power
Pav = Pt*DC; # average power
Runamb = Vo/float((2*PRF)); # Distance of the Target
RR = (Vo*PW)/float(2); # Range Resolution
#result
print' Operating Wavelength = %g'%lamda,' m';
print'\n PRT %3.2f'%(PRT*1000),' ms';
print'\n PRF %3.1f'%PRF,'Hz';
print'\n Peak power %3.3f'%(Pt/1000),' KW';
print'\n Average power %3.3f'%Pav,' Watts';
print'\n unambiguous range %g'%(Runamb/1000),' Km';
print'\n Range Resolution %g'%RR ,'m';
print '\n Note: Calculation error in textbook for Pt and Pav';
```

In [76]:

```
import math
#variable declaration
Vo = 3*10**8; # vel of EM wave m/s;
PRT = 1.4*10**-3; # pulse repetitive time. in sec
PW = 5 *10**-6; # Pulse width in sec
Pt = 1000*10**3; #Peak power in watts
#Calculations
DC = PW/float(PRT); # Duty cycle
Pav = Pt*DC # avg. power in W
#result
print'Duty cycle %3.3e'%DC;
print'Average power %g '%Pav,'W' ;
```

In [77]:

```
import math
#variable declaration
F = 5; # Noise Figure in dB
BW = 1.2*10**6; # Bandwidth in Hz
T = 290; # Ambient temp in kelvin
K = 1.38*10**-23; # boltzmann constant
#Calculations
F1 = 10**(5/float(10)) ; # antilog calc of noise figure
Prmin = K*(F1-1)*T*BW; # min. rx. signal
#result
print'Minimum Receivable signal %3.4e'%Prmin,' W\n ';
print'Note:In textbook All values are correctly substituted in calculating Prmin.\nbut incorrect final answer is printed in the book';
```

In [98]:

```
import math
#variable declaration
Pt = 1*10**6; #peak pulse power in watts
Pmin = 1*10**-12; #minimum receivable power
Ae = 16; #effective area in m^s
RCS = 4; #radar cross sectional area in m^2
F = 9*10**9; #radar operating frequency
Vo = 3*10**8; #vel of Em wave in m/s;
G = 5000; #Power gain of antenna
#calculations
Rmax = ((Pt*G*Ae*RCS)/(16*math.pi*math.pi*Pmin))**(0.25);
#result
print'Maximum Radar range of the Radar is %g'%(Rmax/1000),'Kms';
```

In [102]:

```
import math
#variable declaration
Pt = 500*10**3; #peal pulse power in watts
Pmin = 1*10**-12; #minimum receivable power
Ac = 5; #area of capture in m^s
RCS = 20; #radar cross sectional area in m^2
F = 10*10**9; #radar operating frequency
Vo = 3*10**8; #vel of Em wave in m/s;
lamda = 3*10**-2; # wavelength in cms
#calculations
Rmax = ((Pt*Ac*Ac*RCS)/(4*math.pi*lamda*lamda*Pmin))**(0.25);
#result
print'Maximum Radar range of the Radar system is %g'%(Rmax/1000),' Kms';
```

In [242]:

```
import math
#variable declaration
f = 10*10**9; # operating freq. of radar in Hz
Vo = 3*10**8; #vel of Em wave in m/s;
D = 5; #Diameter of antenna in m
#calculations
lamda = Vo/float(f); # wavelength in m
BW = 70*(lamda/float(D)); # BeamWidth in degrees
#result
print'Beamwidth = %3.3g'%BW,' degrees';
```

In [78]:

```
import math
#variable declaration
Pav = 200; #average power in watts
PRF = 1000; #pulse repetitive frequency in Hz
PW = 1*10**-6; #pulse width in sec
Pmin = 1*10**-12; #minimum receivable power
Ac = 10; #area of capture in m^s
RCS = 2; #radar cross sectional area in m^2
Vo = 3*10**8; #vel of Em wave in m/s;
lamda = 0.1; #wavelength in cms
#calculations
F = Vo/float(lamda); #operating frequency in hz
Pt = Pav/float(PRF*PW);
Rmax = ((Pt*Ac*Ac*RCS)/float((4*math.pi*lamda*lamda*Pmin)))**(0.25);
#result
print'Operating frequency is %g'%(F/10**9),'Ghz';
print'Radar peak power is %g'%(Pt/1000),'KW';
print'Maximum Radar range of the Radar system is %g'%(Rmax/1000),' Km';
```

In [245]:

```
import math
#variable declaration
f = 9*10**9; # operating freq. of radar in Hz
Vo = 3*10**8; # vel of Em wave in m/s;
fd = 1000; #doppler shift freq. in Hz
#Calculations
lamda = Vo/float(f); # Wavelength in m
Vr = lamda*fd/float(2); # radial velocity of target
#result
print'Radial velocity of target Vr %g'%Vr,' m/s';
```

In [250]:

```
import math
#variable declaration
f = 10*10**9; # operating freq. of radar in Hz
Vr = 800; # radial ve. of of aircraft in kmph
Vo = 3*10**8; #vel of Em wave in m/s;
#calculations
lamda = Vo/float(f); # Wavelength in m
Vr1 = Vr*5/float(18); # kmph to m/s conversion
fd = 2*Vr1/float(lamda); # Doppler shift freq, in Hz
#result
print'Doppler shift frequency fd = %3.2e'%fd,' Hz';
```

In [80]:

```
import math
#variable declaration
f = 6*10**9; # operating freq. of radar in Hz
Vr = 600; # radial ve. of of aircraft in kmph
Vo = 3*10**8; #vel of Em wave in m/s;
#calculations
lamda = Vo/float(f); # Wavelength in m
Vr1 = Vr*5/float(18); # kmph to m/s conversion
fd = 2*Vr1/float(lamda); # Doppler shift freq, in Hz
V = Vr1*math.cos((45*math.pi/float(180))); # vel in direction of radar if target direction changes by 45 deg
fd1 = 2*V/float(lamda); #doppler shift freq. in Hz
#result
print'Doppler shift frequency fd = %3.3g'%(fd/1000),'KHz';
print'Doppler shift frequency if the target changes its direction by 45deg %3.2f'%(fd1/1000),'KHz';
```

In [254]:

```
import math
#variable declaration
lamda = 3*10**-2; #Wavelength in m
PRF = 1000; # Pulse Repetitive frequency in Hz
n = 1; # n value for lowest blind speed
#Calculations
Vb = (n*lamda/float(2))*PRF; #Blind speed of the Radar in m/s
#result
print'Lowet blind speed %g'%Vb,'m/s';
```

In [123]:

```
import math
#variable declaration
PRF = 1000; # pulse repetitive frequency
print'V1b1 = (1* λ1*PRF1)/2';
print'V1b1 = (Vo*PRF1)/(2*f1)';
print'V2b3 = (3* λ1*PRF2)/2';
print'V2b3 = (3*Vo*PRF2)/(2*f2)';
print'But PRF1 = PRF2 and V1b1 = V2b3';
print'(Vo*PRF)/(2*f1) = (3*Vo*PRF)/(2*f2)' ;
print'f1/f2 = 1/3';
```

In [81]:

```
import math
#variable declaration
PRF1 = 10*10**3; #pulse repetitive freq.1
PRF2 = 20*10**3; #pulse repetitive freq.2
Pav = 1000; # average tx. power
Pt = 10*10**3; # peak power
#Calculations
PRT1 = 1/float(PRF1); # pulse repetitive interval in sec
PRT2 = 1/float(PRF2); # pulse repetitive interval in sec
DC = Pav/float(Pt); # duty cycle
PW1 = DC*PRT1 # pulse width for freq1
PW2 = DC*PRT2 # pulse width for freq2
E1 = Pt*PW1; # energy of first pulse
E2 = Pt*PW2; # energy of second pulse
#result
print'PW1 = ',PW1*1000,' ms';
print'PW2 =',PW2*1000,' ms';
print'Pulse Energy for PRF 10KHz is ',E1,' Joules';
print'Pulse Energy for PRF 20KHz is ',E2 ,' Joules';
```

In [84]:

```
import math
#variable declaration
Runamb = 150*10**3; # unambigiuous range in m
BW = 10**6; # bandwidth in Hz
Vo = 3*10**8; #vel of Em wave in m/s;
#Calculations
PRF = Vo/float((2*Runamb)) ; #pulse repetitive freq. in Hz
PRT = 1/float(PRF); # pulse repetition interval
RR = Vo/float((2*BW)); # Range Resolution
PW = (2*RR)/float(Vo); #Pulse width in sec
#result
print'PRF = %3.2f' %PRF,'Hz';
print'pulse repetition interval %3.3g'%(PRT*1000),' ms';
print'Range Resolution = %d' %RR,'m';
print'PulseWidth = %3.2f' %(PW*10**6),'us';
```

In [259]:

```
import math
#variable declaration
Vr = 300; # Velocity of radar in m/s
Vair = 200; # velocty of aircraft in m/s
f = 10*10**9; # Radar operating frequency
Vo = 3*10**8; # vel of Em wave in m/s;
#Calculations
lamda = Vo/float(f); # wavelength in m
Vrel = Vr+Vair; #relative radial vel. b/w radar and aircraft when approaching each other
fd = (2*Vrel)/float(lamda); #Doppler frequency
#result
print'Doppler frequency = %3.2f'%(fd/1000),'KHz';
```

In [262]:

```
import math
#variable declaration
Pt = 2*10**6; # Peak power in Watts
G = 45; # antenna gain in dB
f = 6*10**9; # operating frequency
Te = 290; # effective temp in kelvin
SNRmin = 20; # min SNR in dB
PW = 0.2*10**-3 # pulse width in sec
F = 3; # Noise Figure
B = 10*10**3; # bandwidth in KHz
RCS = 0.1; # Radar cross section in m^2
K = 1.38*10**-23; # boltzman constant
Vo = 3*10**8; #vel of Em wave in m/s;
#antilog acalculations
G1 = 10**(45/float(10)); # antilog conversion of gain
SNR = 10**(20/float(10)); # antilog conversion of SNRmin
F1 = 10**(3/float(10)); # antilog conversion of Noise Figure
lamda = Vo/float(f); #wavelength in m
Rmax = ((Pt*G1*G1*lamda*lamda*RCS)/float(((64*math.pi*math.pi*math.pi)*(K*Te*B*F1*SNR))))**(0.25);
#pt1 = 10*log10(Pt)
#lamda1 = 10*log10(lamda^2)
#G2 = 2*G
#KTB = 10*log10(K*Te*B)
#RCS1 = 10*log10(RCS)
#p = 10*log10((4*%pi)^3)
#R4max = [pt1+G1+lamda1+RCS1-p-KTB-F-SNRmin];
#result
print'Maximum Range of the Radar is %3.2f'%(Rmax/100),'Km';
print'\n Note: Calculation error is Textbook in multiplying K*Te*B';
```

In [90]:

```
import math
#variable declaration
G = 50; # antenna gain in dB
f = 6*10**9; # operating frequency
Te = 1000; # Noise temp in kelvin
SNR = 20; # min SNR in dB
L = 10; # Losses in dB
F = 3; # Noise Figure in dB
RCS = -10; # Radar cross section in dB
K = 1.38*10**-23; # boltzman constant
Vo = 3*10**8; # vel of Em wave in m/s;
DC = 0.3; # Duty cycle
R = 300*10**3; # Range in kms
Pav = 1000; # Average power in watts
SV = 20; # search volume
Ts = 3; # Scan time
#calculations
Pav1 = 10*math.log10(Pav) #conversion to dB
KT = 10*math.log10(Te*K) #conversion to dB
R4 = 10*math.log10(R**4) #conversion to dB
Ts1 = 10*math.log10(Ts) #conversion to dB
#SNR = (Pav*A*RCS*Ts)/(16*R**(4)*KT*L*F*SV));
A = (SNR-Pav1-Ts-RCS+16+R4+KT+L+F+SV); #aperture
Pt = Pav/DC; #peak ower in watts
#A1 =10^(A/10); # antilog calculation
#result
print'A = %3.4g' %A,'dB';
print'Peak power Pt = %3.2f'%(Pt/1000),'KW';
print'Note: calculation error in textbook at KT';
```

In [147]:

```
```

In [ ]:

```
```