PageRenderTime 32ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 0ms

/VF/parallel_of_all_3/ParallelPole.for

http://ua-fwlis.googlecode.com/
FORTRAN Legacy | 498 lines | 303 code | 125 blank | 70 comment | 16 complexity | 834be950f8d7745becbd09fc721d6caa MD5 | raw file
Possible License(s): GPL-3.0 
    

  1. !!=========================================================================

    2. 

  2.       module init

    3. 

  3. 

    4. 

  4.       DOUBLE PRECISION Freq,OMega,Mu1,Mu2,Mu0,Mur1,Mur2,Pi  

    5. 

  5.       DOUBLE PRECISION Epsilonr1,Epsilonr2,Epsilon0,Zn1,Zn2,d

    6. 

  6. 	DOUBLE PRECISION tanDelta1, tanDelta2, Error,lambda

    7. 

  7. 	COMPLEX*16 Epsilon1, Epsilon2,Kp, Kz1,Kz2,j, Diff, K1,K2,DDa, DDb

    8. 

  8. 	INTEGER Iteration	

    9. 

  9. 	

    10. 

  10. 	end module init

    11. 

  11. 	

    12. 

  12. !!=========================================================================

    13. 

  13.       subroutine initValue

    14. 

  14.       

    15. 

  15.       use init

    16. 

  16.       implicit none

    17. 

  17. 	  

    18. 

  18. 	j          =(0.0d0,1.0d0)

    19. 

  19. 	!Pi         = 3.141592653589793d0

    20. 

  20. 	Pi         = acos(0.d0)*2

    21. 

  21. 	Mu0        = 4*Pi*1d-7

    22. 

  22. 	Mur1       = 1.00d0

    23. 

  23. 	Mur2       = 1.00d0

    24. 

  24. 	Mu1        = Mur1*Mu0

    25. 

  25.       Mu2        = Mur2*Mu0	

    26. 

  26. 	Epsilon0   = 8.854d-12

    27. 

  27. 	Epsilonr1  = 1.000d0

    28. 

  28. 	Epsilonr2  = 4.000d0

    29. 

  29. 	tanDelta1  = 0.05d0

    30. 

  30. 	tanDelta2  = 0.05d0

    31. 

  31. !	Epsilon1   = Epsilon0*Epsilonr1*((1.0d0,0.0d0)-tanDelta1*j)

    32. 

  32. !	Epsilon2   = Epsilon0*Epsilonr2*((1.0d0,0.0d0)-tanDelta2*j) 

    33. 

  33. 	Epsilon1   = Epsilon0*(Epsilonr1*(1.0d0,0.0d0)-1.d-6*j)

    34. 

  34. 	Epsilon2   = Epsilon0*(Epsilonr2*(1.0d0,0.0d0)-1.d-4*j) 

    35. 

  35.       

    36. 

  36. 	Freq       = 12.0e+9

    37. 

  37. 	Lambda     = 3.e8/Freq

    38. 

  38. 	Omega      = 2.0d0*Pi*Freq

    39. 

  39. 	Diff       = (Omega**2)*(Mu2*Epsilon2-Mu1*Epsilon1)

    40. 

  40.       

    41. 

  41. 	K1=(Omega**2)*Mu1*Epsilon1  

    42. 

  42. 	K2=(Omega**2)*Mu2*Epsilon2

    43. 

  43. 

    44. 

  44. !	Zn1=0.0007620d0

    45. 

  45. !	Zn2=0.0000762d0

    46. 

  46.       zn1=Lambda/10

    47. 

  47.       zn2=10*Zn1

    48. 

  48. 	d  =ZN1+ZN2

    49. 

  49. 	

    50. 

  50. 

    51. 

  51. 	Error     = 1e-4

    52. 

  52. 	Iteration = 100 !1e+4

    53. 

  53. 	

    54. 

  54. 

    55. 

  55. 	end subroutine initValue	

    56. 

  56.      

    57. 

  57. !!=========================================================================

    58. 

  58.      

    59. 

  59.       module Parallel_POLE

    60. 

  60.       

    61. 

  61.        !use init_module

    62. 

  62.        use init

    63. 

  63.        implicit none

    64. 

  64.        

    65. 

  65.        contains

    66. 

  66.        

    67. 

  67. !!!*********************************************************** 

    68. 

  68. 	FUNCTION TheMerge(A,B)

    69. 

  69. 	DOUBLE PRECISION  A(:),B(:)

    70. 

  70. 	DOUBLE PRECISION  TheMerge(1:size(A)+size(B))

    71. 

  71. 

    72. 

  72. 	TheMerge(1:size(A))=A

    73. 

  73. 	TheMerge(size(A)+1:size(A)+size(B))=B

    74. 

  74. 	end FUNCTION TheMerge

    75. 

  75. 	

    76. 

  76. !!!***********************************************************

    77. 

  77.       FUNCTION TheSort (A)

    78. 

  78. 	DOUBLE PRECISION  A(:)

    79. 

  79. 	DOUBLE PRECISION  TheSort(1:size(A))

    80. 

  80. 	INTEGER sizeA,  nn,mm

    81. 

  81. 	DOUBLE PRECISION tmp

    82. 

  82. 

    83. 

  83. 	sizeA  = size (A)

    84. 

  84. 	TheSort(1:sizeA)=A

    85. 

  85.         

    86. 

  86. 	do nn=1, sizeA

    87. 

  87. 	 do mm=nn+1, sizeA

    88. 

  88. 	   if (TheSort(nn) > TheSort(mm)) then 

    89. 

  89. 	      tmp=TheSort(nn)

    90. 

  90. 	      TheSort(nn)=TheSort(mm)

    91. 

  91. 	      TheSort(mm)=tmp

    92. 

  92. 	   end if

    93. 

  93. 	 end do

    94. 

  94.       end do 

    95. 

  95. 	end FUNCTION TheSort

    96. 

  96. 

    97. 

  97. !!!***********************************************************

    98. 

  98. 

    99. 

  99.       subroutine TEtheDb(theMu1, theMu2,theEpsilon1,theEpsilon2,theZn1,

    100. 

  100.      &               theZn2, theKz2, theFreq,thedb,thedfdr)

    101. 

  101. 

    102. 

  102.       

    103. 

  103.       DOUBLE PRECISION theMu1, theMu2,thePi, theFreq, theOmega,

    104. 

  104.      &	                 theZn1, theZn2

    105. 

  105.       complex*16,intent(inout) :: thedb,thedfdr

    106. 

  106.      

    107. 

  107.       COMPLEX*16 theEpsilon1, theEpsilon2,theKz2,theKZ1,theDiff

    108. 

  108.      & ,tan_kz1,tan_kz2

    109. 

  109. 	thePi      = PI

    110. 

  110. 	!theOmega   = 2.0d0*thePi*theFreq

    111. 

  111. 	theOmega   = Omega

    112. 

  112. 	theDiff    = diff

    113. 

  113. 	theKZ1     = sqrt(theKz2**2-theDiff)

    114. 

  114. 	tan_kz1    = tan(thekz1*theZn2)

    115. 

  115. 	tan_kz2    = tan(thekz2*theZn1)

    116. 

  116. 	

    117. 

  117. 	!TEtheDb  = tan_kz1*theKz2+tan_kz2*theKz1

    118. 

  118. 	

    119. 

  119. 	thedb     = tan_kz1*theKz2+tan_kz2*theKz1

    120. 

  120. 	thedfdr   = tan_kz2*thekz2/thekz1+thekz1*(1+tan_kz2*tan_kz2)*theZn1

    121. 

  121.      &+tan_kz1+(1+tan_kz1*tan_kz1)*thezn2*thekz2*thekz2/thekz1 

    122. 

  122. 	

    123. 

  123. 	

    124. 

  124. 	

    125. 

  125.   	end subroutine TEtheDb

    126. 

  126. 		     

    127. 

  127. !!!***********************************************************

    128. 

  128. 

    129. 

  129. 	 COMPLEX*16 FUNCTION TEtheSearchRoot(tMu1, tMu2, tEpsilon1

    130. 

  130.      & , tEpsilon2, tZn1,tZn2, tFreq, start_val, end_val, iter, err)

    131. 

  131. 

    132. 

  132. 	DOUBLE PRECISION     tMu1, tMu2, tZn1, tZn2 , InitGuess     

    133. 

  133.      &					 tPi, tFreq, tOmega, err, mag, magD,                 

    134. 

  134.      &	                 start_val, end_val,tKz2r, tKz2i,InitGuess 

    135. 

  135.      &                   ,startVal,endVal 

    136. 

  136.      

    137. 

  137.       COMPLEX*16           tEpsilon1, tEpsilon2, tkz1,tKz2, tDiff,

    138. 

  138.      &                     tDb, tDfdr 

    139. 

  139. 	INTEGER              iter, n

    140. 

  140. 	

    141. 

  141. 	!!! tzn1=d2,tzn2=d1   !*** Important ***

    142. 

  142. 	!theDiff    = theOmega**2*(theMu2*theEpsilon2-theMu1*theEpsilon1)

    143. 

  143. 	!!!tdb=FU, tdfdr=DFU

    144. 

  144. 	

    145. 

  145. 	startVal=start_val

    146. 

  146. 	endval  =end_val

    147. 

  147. 		

    148. 

  148. 	tdiff=Diff

    149. 

  149.       n=0      

    150. 

  150.       InitGuess= (startVal+endval)/2.0d0     

    151. 

  151.       	

    152. 

  152. 	tKz2r = InitGuess

    153. 

  153. 	

    154. 

  154. 	tKz2i =0.0d0  

    155. 

  155. 	tKz2  =tKz2r*(1.0d0,0.0d0)+tKz2i*(0.0d0,1.0d0)

    156. 

  156. 	tkz1  = sqrt(tKz2**2-tDiff)

    157. 

  157. 

    158. 

  158.       CALL TEtheDb (tMu1,tMu2,tEpsilon1,tEpsilon2,

    159. 

  159.      & tZn1,tZn2,tKz2,tFreq,tDb,tDfdr)

    160. 

  160. 	

    161. 

  161. 	!mag= sqrt(REAL(tDb)**2+AIMAG(tDb)**2)

    162. 

  162. 	mag= abs(tDb)

    163. 

  163.       magD= REAL(tDfdr)**2-AIMAG(tDfdr)**2

    164. 

  164. 

    165. 

  165. 	do while  ( (n<=iter) .AND. (mag>err*1.e-4*abs(tan(tkz1*tZn2)*tkz2)) )

    166. 

  166.       

    167. 

  167.       if(REAL(tKz2)<startVal) then

    168. 

  168.       

    169. 

  169.       endval=InitGuess

    170. 

  170.       InitGuess= (startVal+endval)/2.0d0

    171. 

  171.       

    172. 

  172. 	tKz2r = InitGuess

    173. 

  173. 	tKz2i =0.0d0  

    174. 

  174. 	tKz2  =tKz2r*(1.0d0,0.0d0)+tKz2i*(0.0d0,1.0d0)

    175. 

  175. 	tkz1  = sqrt(tKz2**2-tDiff)

    176. 

  176. 

    177. 

  177.       CALL TEtheDb (tMu1,tMu2,tEpsilon1,tEpsilon2,

    178. 

  178.      & tZn1,tZn2,tKz2,tFreq,tDb,tDfdr)

    179. 

  179. 	

    180. 

  180. 	mag= abs(tDb)

    181. 

  181.       magD= REAL(tDfdr)**2-AIMAG(tDfdr)**2

    182. 

  182.       n=n+1     

    183. 

  183.       

    184. 

  184.       else if(REAL(tKz2)>endval) then

    185. 

  185.       

    186. 

  186.       startVal=InitGuess

    187. 

  187.       InitGuess= (startVal+endval)/2.0d0

    188. 

  188. 	tKz2r = InitGuess

    189. 

  189. 	tKz2i =0.0d0  

    190. 

  190. 	tKz2  =tKz2r*(1.0d0,0.0d0)+tKz2i*(0.0d0,1.0d0)

    191. 

  191. 	tkz1  = sqrt(tKz2**2-tDiff)

    192. 

  192. 

    193. 

  193.       CALL TEtheDb (tMu1,tMu2,tEpsilon1,tEpsilon2,

    194. 

  194.      & tZn1,tZn2,tKz2,tFreq,tDb,tDfdr)

    195. 

  195.      

    196. 

  196. 	mag= abs(tDb)

    197. 

  197.       magD= REAL(tDfdr)**2-AIMAG(tDfdr)**2

    198. 

  198.       

    199. 

  199.       n=n+1     

    200. 

  200.       

    201. 

  201.       else	

    202. 

  202.        

    203. 

  203.       tKz2r=tKz2r-(REAL(tDb)*REAL(tDfdr)-j*AIMAG(tDb)*AIMAG(tDfdr))/magD

    204. 

  204. 	tKz2i=tKz2i-(j*REAL(tDb)*AIMAG(tDfdr)+AIMAG(tDb)*REAL(tDfdr))/magD

    205. 

  205. 	tKz2  =tKz2r*(1.0d0,0.0d0)+tKz2i*(0.0d0,1.0d0)

    206. 

  206. 	! 

    207. 

  207. 	!evaluate again

    208. 

  208.       CALL TEtheDb (tMu1,tMu2,tEpsilon1,tEpsilon2,

    209. 

  209.      & tZn1,tZn2,tKz2,tFreq,tDb,tDfdr)

    210. 

  210. 	

    211. 

  211. 	!mag= sqrt(REAL(tDb)**2+AIMAG(tDb)**2)

    212. 

  212. 	mag= abs(tDb)

    213. 

  213.       magD= REAL(tDfdr)**2-AIMAG(tDfdr)**2

    214. 

  214.       n=n+1

    215. 

  215.       

    216. 

  216. 	end if  ! if-else-if

    217. 

  217. 	end do  ! while

    218. 

  218. 

    219. 

  219. 	TEtheSearchRoot=tKz2

    220. 

  220. 

    221. 

  221. 	end function TEtheSearchRoot	

    222. 

  222. 	

    223. 

  223.  !!!***********************************************************

    224. 

  224.       Subroutine TMtheDa(theMu1, theMu2, theEpsilon1, theEpsilon2

    225. 

  225.      & ,theZn1,theZn2, theKz2, theFreq,theda,thedfdr)

    226. 

  226.       

    227. 

  227.       DOUBLE PRECISION     theMu1, theMu2,       

    228. 

  228.      &					 thePi, theFreq, theOmega,theZn1, theZn2

    229. 

  229.       complex*16,intent(inout)::theda,thedfdr

    230. 

  230.       COMPLEX*16           theEpsilon1, theEpsilon2, theKz2,  theDiff, 

    231. 

  231.      &                     thekz1,tan_kz1,tan_kz2,Er   

    232. 

  232. 	thePi      = PI

    233. 

  233. 	!theOmega   = 2.0d0*thePi*theFreq

    234. 

  234. 	theOmega   = Omega

    235. 

  235. 	!theDiff    = theOmega**2*(theMu2*theEpsilon2-theMu1*theEpsilon1)

    236. 

  236. 	theDiff    = Diff

    237. 

  237. 	theKZ1     = sqrt(theKz2**2-theDiff)

    238. 

  238. 	tan_kz1    = tan(thekz1*theZn2)

    239. 

  239. 	tan_kz2    = tan(thekz2*theZn1)

    240. 

  240. 	Er         = theEpsilon2/theEpsilon1

    241. 

  241. 	

    242. 

  242. 	theda  = Er*thekz1*tan_kz1+thekz2*tan_kz2

    243. 

  243. 	thedfdr= Er*tan_kz1*thekz2/thekz1+Er*(1+tan_kz1**2)*thekz2*thezn2

    244. 

  244.      & +tan_kz2+(1+tan_kz2**2)*thekz2*thezn1

    245. 

  245. 	

    246. 

  246. 	

    247. 

  247.   	end Subroutine TMtheDa

    248. 

  248. 

    249. 

  249.  

    250. 

  250. !!!***********************************************************

    251. 

  251. 

    252. 

  252.       COMPLEX*16 FUNCTION TMtheSearchRoot(tMu1, tMu2, tEpsilon1, 

    253. 

  253.      & tEpsilon2, tZn1,tZn2, tFreq, start_Val, end_Val, iter, err)

    254. 

  254. 

    255. 

  255. 	DOUBLE PRECISION     tMu1, tMu2, tZn1, tZn2 , InitGuess    

    256. 

  256.      &					 tPi, tFreq, tOmega, err, mag, magD,

    257. 

  257.      &                   start_Val, end_Val,                 

    258. 

  258.      &	                 startVal, endVal,tKz2r, tKz2i,InitGuess

    259. 

  259.      

    260. 

  260.       COMPLEX*16::         tEpsilon1, tEpsilon2, tKz2,tkz1,tDiff,

    261. 

  261.      &                     tDa, tMdfdr 

    262. 

  262. 	INTEGER              iter, n

    263. 

  263. 

    264. 

  264.       tdiff=Diff

    265. 

  265.       startVal=start_val

    266. 

  266. 	endval  =end_val

    267. 

  267.       n=0      

    268. 

  268.       InitGuess= (startVal+endVal)/2.0d0     

    269. 

  269.       	

    270. 

  270. 	tKz2r = InitGuess

    271. 

  271. 	

    272. 

  272. 	tKz2i =0.0d0  

    273. 

  273. 	tKz2  =tKz2r*(1.0d0,0.0d0)+tKz2i*(0.0d0,1.0d0)

    274. 

  274. 	tkz1  = sqrt(tKz2**2-tDiff)

    275. 

  275. 

    276. 

  276.       CALL TMtheDa (tMu1,tMu2,tEpsilon1,tEpsilon2,

    277. 

  277.      & tZn1,tZn2,tKz2,tFreq,tDa,tMdfdr)

    278. 

  278. 	

    279. 

  279. 	!mag= sqrt(REAL(tDb)**2+AIMAG(tDb)**2)

    280. 

  280. 	mag= abs(tDa)

    281. 

  281.       magD= REAL(tMdfdr)**2-AIMAG(tMdfdr)**2

    282. 

  282. 

    283. 

  283. 	do while  ( (n<=iter) .AND. (mag>err*1.e-4*abs(tan(tkz1*tZn2)*tkz2)) )

    284. 

  284.       

    285. 

  285.       if(REAL(tKz2)<startVal) then

    286. 

  286.       

    287. 

  287.       endVal=InitGuess

    288. 

  288.       InitGuess= (startVal+endVal)/2.0d0

    289. 

  289. 	tKz2r = InitGuess

    290. 

  290. 	tKz2i =0.0d0  

    291. 

  291. 	tKz2  =tKz2r*(1.0d0,0.0d0)+tKz2i*(0.0d0,1.0d0)

    292. 

  292. 	tkz1  = sqrt(tKz2**2-tDiff)

    293. 

  293. 

    294. 

  294.       CALL TMtheDa(tMu1,tMu2,tEpsilon1,tEpsilon2,

    295. 

  295.      & tZn1,tZn2,tKz2,tFreq,tDa,tMdfdr)

    296. 

  296. 	

    297. 

  297. 	mag= abs(tDa)

    298. 

  298.       magD= REAL(tMdfdr)**2-AIMAG(tMdfdr)**2

    299. 

  299.       n=n+1    

    300. 

  300.       

    301. 

  301.       else if(REAL(tKz2)>endVal) then

    302. 

  302.       

    303. 

  303.       startVal=InitGuess

    304. 

  304.       InitGuess= (startVal+endVal)/2.0d0

    305. 

  305. 	tKz2r = InitGuess

    306. 

  306. 	tKz2i =0.0d0  

    307. 

  307. 	tKz2  =tKz2r*(1.0d0,0.0d0)+tKz2i*(0.0d0,1.0d0)

    308. 

  308. 	tkz1  = sqrt(tKz2**2-tDiff)

    309. 

  309. 

    310. 

  310.       CALL TMtheDa (tMu1,tMu2,tEpsilon1,tEpsilon2,

    311. 

  311.      & tZn1,tZn2,tKz2,tFreq,tDa,tMdfdr)

    312. 

  312.      

    313. 

  313. 	mag= abs(tDa)

    314. 

  314.       magD= REAL(tMdfdr)**2-AIMAG(tMdfdr)**2

    315. 

  315.       

    316. 

  316.       n=n+1     

    317. 

  317.       

    318. 

  318.       else	

    319. 

  319.        

    320. 

  320.       tKz2r=tKz2r-(REAL(tDa)*REAL(tMdfdr)-j*AIMAG(tDa)

    321. 

  321.      &                      *AIMAG(tMdfdr))/magD

    322. 

  322. 	tKz2i=tKz2i-(j*REAL(tDa)*AIMAG(tMdfdr)+AIMAG(tDa)

    323. 

  323.      &                      *REAL(tMdfdr))/magD

    324. 

  324. 	tKz2 =tKz2r*(1.0d0,0.0d0)+tKz2i*(0.0d0,1.0d0)

    325. 

  325. 	! 

    326. 

  326. 	!evaluate again

    327. 

  327.       CALL TMtheDa (tMu1,tMu2,tEpsilon1,tEpsilon2,

    328. 

  328.      & tZn1,tZn2,tKz2,tFreq,tDa,tMdfdr)

    329. 

  329. 	

    330. 

  330. 	!mag= sqrt(REAL(tDa)**2+AIMAG(tDa)**2)

    331. 

  331. 	mag= abs(tDa)

    332. 

  332.       magD= REAL(tMdfdr)**2-AIMAG(tMdfdr)**2

    333. 

  333.       n=n+1

    334. 

  334.       

    335. 

  335. 	end if

    336. 

  336. 	end do

    337. 

  337. 

    338. 

  338. 	TMtheSearchRoot=tKz2

    339. 

  339. 

    340. 

  340. 	end function TMtheSearchRoot      

    341. 

  341.  !!!***********************************************************

    342. 

  342.   

    343. 

  343.       FUNCTION foundKpforTE(N)

    344. 

  344. 

    345. 

  345. !    For calculating the poles of TE mode for Horizontal Dipole in stripline

    346. 

  346. 

    347. 

  347.       !use init

    348. 

  348. *********************************** 

    349. 

  349.       INTEGER              N,i,ii

    350. 

  350.       DOUBLE PRECISION     tmag, testStart, testEnd

    351. 

  351. 	                               

    352. 

  352.       COMPLEX*16          Db, Dfdr,foundKpforTE(1:N), Kp1,Kp2  

    353. 

  353. 	DOUBLE PRECISION, ALLOCATABLE :: Asys1(:), Asys2(:),

    354. 

  354.      &                                 Asys(:), SortedAys(:)

    355. 

  355. 

    356. 

  356. 

    357. 

  357. ***********************************

    358. 

  358.       call initValue

    359. 

  359. *********************************

    360. 

  360.       allocate (Asys1(1:(N+5)))

    361. 

  361. 	allocate (Asys2(1:(N+5)))

    362. 

  362. 	allocate (Asys(1:2*(N+5)))

    363. 

  363. 	allocate (SortedAys(1:2*(N+5)))

    364. 

  364. ****************************************

    365. 

  365. 	Do i=1, N+5

    366. 

  366. 	 Asys1(i)=(i-0.5d0)*Pi/Zn1

    367. 

  367. 	 Asys2(i)=sqrt(((i-0.5d0)*Pi/Zn2)**2+Diff)

    368. 

  368. 	end Do

    369. 

  369. 	Asys=TheMerge(Asys1,Asys2)

    370. 

  370. 	SortedAys=TheSort(Asys)    

    371. 

  371. c	print *, SortedAys

    372. 

  372. 

    373. 

  373.       open (2, FILE="./results/theResultTE.txt",STATUS='replace')

    374. 

  374. 

    375. 

  375.       ii=1

    376. 

  376.       Do i=1,2*(N+5)-1

    377. 

  377. 	 testStart= SortedAys(i)

    378. 

  378. 	 testEnd  = SortedAys(i+1)

    379. 

  379. 

    380. 

  380.        Kz2=  TEtheSearchRoot(Mu1, Mu2, Epsilon1, Epsilon2, Zn1, 

    381. 

  381.      &            Zn2, Freq, testStart, testEnd, Iteration, Error)

    382. 

  382. 

    383. 

  383.       Call TEtheDb(Mu1,Mu2,Epsilon1,Epsilon2,

    384. 

  384.      & Zn1,Zn2,Kz2,Freq,db,Dfdr)

    385. 

  385.      

    386. 

  386. 	 tmag= sqrt(REAL(Db)**2+AIMAG(Db)**2)

    387. 

  387. 	 Kz1= sqrt(Kz2**2-Diff)

    388. 

  388. 	 Kp1=sqrt(Omega**2*Mu1*Epsilon1-Kz1**2)

    389. 

  389.        Kp2=sqrt(Omega**2*Mu2*Epsilon2-Kz2**2)

    390. 

  390. 

    391. 

  391.        write   (2,"(A20)" ) ""

    392. 

  392. 	 write   (2,"('the start point=',F25.15)") (testStart)	

    393. 

  393. 	 write   (2,"('the end   point=',F25.15)") (testEnd)	

    394. 

  394.        write (2,"('Kz2=  ', F24.15, F24.15,'j')") (REAL(Kz2),AIMAG(Kz2))

    395. 

  395.        write (2,"('Kz1=  ', F24.15, F24.15,'j')") (REAL(Kz1),AIMAG(Kz1))

    396. 

  396.        write   (2,"('Db =', F25.15, F25.15,'j')") (REAL(Db),AIMAG(Db))

    397. 

  397. 	 write   (2,"('the error=',F25.15)") (tmag)	

    398. 

  398. 

    399. 

  399.       write   (2,"('Kp1(derived from K_z1)=', F22.15, F22.15,'j')") 

    400. 

  400.      &                                    	   (REAL(Kp1),AIMAG(Kp1)) 

    401. 

  401.        write   (2,"('Kp2(derived from K_z2)=', F22.15, F22.15,'j')") 

    402. 

  402.      &                                           (REAL(Kp2),AIMAG(Kp2)) 

    403. 

  403.       

    404. 

  404. 	 if (tmag<Error) then

    405. 

  405. 	  write (2, "(A10)") "ROOT FOUND"

    406. 

  406. 	  if (ii<=N) then

    407. 

  407. 	   foundKpforTE(ii)=Kp1

    408. 

  408. 	   ii=ii+1

    409. 

  409. 	  end if

    410. 

  410. 	 end if

    411. 

  411. 	 

    412. 

  412. 	 if (tmag>=Error) then

    413. 

  413. 	 write (2, "(A19)") "ROOT NOT FOUND  !!!"

    414. 

  414. 	 end if

    415. 

  415. 

    416. 

  416. 	end Do

    417. 

  417. 	end FUNCTION foundKpforTE 

    418. 

  418. 	

    419. 

  419.  !!!***********************************************************

    420. 

  420.  	

    421. 

  421. 	FUNCTION foundKpforTM(N)

    422. 

  422. !    For calculating the poles of TM mode for Horizontal Dipole in stripline

    423. 

  423. 

    424. 

  424.       !use init

    425. 

  425. *********************************** 

    426. 

  426.       INTEGER              N,i,ii

    427. 

  427.       DOUBLE PRECISION     tmag, testStart, testEnd

    428. 

  428. 	                               

    429. 

  429.       COMPLEX*16          Da, Dfdr,foundKpforTM(1:N), Kp1,Kp2  

    430. 

  430. 	DOUBLE PRECISION, ALLOCATABLE :: Asys1(:), Asys2(:),

    431. 

  431.      &                                 Asys(:), SortedAys(:)

    432. 

  432. 

    433. 

  433. 

    434. 

  434. ***********************************

    435. 

  435.       call initValue

    436. 

  436. *********************************

    437. 

  437.       allocate (Asys1(1:(N+5)))

    438. 

  438. 	allocate (Asys2(1:(N+5)))

    439. 

  439. 	allocate (Asys(1:2*(N+5)))

    440. 

  440. 	allocate (SortedAys(1:2*(N+5)))

    441. 

  441. ****************************************

    442. 

  442. 	Do i=1, N+5

    443. 

  443. 	 Asys1(i)=(i-0.5)*Pi/Zn1

    444. 

  444. 	 Asys2(i)=real(sqrt(((i-0.5)*Pi/Zn2)**2+Diff))

    445. 

  445. 	end Do

    446. 

  446. 	Asys=TheMerge(Asys1,Asys2)

    447. 

  447. 	SortedAys=TheSort(Asys)    

    448. 

  448. c	print *, SortedAys

    449. 

  449. 

    450. 

  450. 	open (2, FILE="./results/theResultTM.txt",STATUS='replace')

    451. 

  451. 

    452. 

  452.       ii=1

    453. 

  453.       Do i=1,2*(N+5)-1

    454. 

  454. 	 testStart= SortedAys(i)

    455. 

  455. 	 testEnd  = SortedAys(i+1)

    456. 

  456. 

    457. 

  457.        Kz2=  TMtheSearchRoot(Mu1, Mu2, Epsilon1, Epsilon2, Zn1, 

    458. 

  458.      &            Zn2, Freq, testStart, testEnd, Iteration, Error)

    459. 

  459. 

    460. 

  460.       Call TMtheDa(Mu1,Mu2,Epsilon1,Epsilon2,

    461. 

  461.      & Zn1,Zn2,Kz2,Freq,Da,Dfdr)

    462. 

  462.      

    463. 

  463. 	 tmag= sqrt(REAL(Da)**2+AIMAG(Da)**2)

    464. 

  464. 	 Kz1= sqrt(Kz2**2-Diff)

    465. 

  465. 	 Kp1=sqrt(Omega**2*Mu1*Epsilon1-Kz1**2)

    466. 

  466.        Kp2=sqrt(Omega**2*Mu2*Epsilon2-Kz2**2)

    467. 

  467. 

    468. 

  468.        write   (2,"(A20)" ) ""

    469. 

  469.        write   (2,"('the start point=',F25.15)") (testStart)	

    470. 

  470. 	  write   (2,"('the end   point=',F25.15)") (testEnd)	

    471. 

  471.        write (2,"('Kz2=  ', F24.15, F24.15,'j')") (REAL(Kz2),AIMAG(Kz2))

    472. 

  472.        write (2,"('Kz1=  ', F24.15, F24.15,'j')") (REAL(Kz1),AIMAG(Kz1))

    473. 

  473.        write   (2,"('Da =', F25.15, F25.15,'j')") (REAL(Da),AIMAG(Da))

    474. 

  474.        write   (2,"('the error=',F25.15)") (tmag)	

    475. 

  475. 

    476. 

  476.        write   (2,"('Kp1(derived from Kz1)=', F22.15, F22.15,'j')") 

    477. 

  477.      &                                    	   (REAL(Kp1),AIMAG(Kp1)) 

    478. 

  478.        write   (2,"('Kp2(derived from Kz2)=', F22.15, F22.15,'j')") 

    479. 

  479.      &                                           (REAL(Kp2),AIMAG(Kp2)) 

    480. 

  480.       

    481. 

  481. 	 if (tmag<Error) then

    482. 

  482. 	  write (2, "(A10)") "ROOT FOUND"

    483. 

  483. 	  if (ii<=N) then

    484. 

  484. 	   foundKpforTM(ii)=Kp1

    485. 

  485. 	   ii=ii+1

    486. 

  486. 	  end if

    487. 

  487. 	 end if

    488. 

  488. 	 

    489. 

  489. 	 if (tmag>=Error) then

    490. 

  490. 	 write (2, "(A19)") "ROOT NOT FOUND  !!!"

    491. 

  491. 	 end if

    492. 

  492. 

    493. 

  493. 	end Do

    494. 

  494. 	end FUNCTION foundKpforTM   

    495. 

  495.       

    496. 

  496.       

    497. 

  497.       

    498. 

  498.       end module Parallel_POLE

    499. 

  499.