/TwoRegions/src/TwoRegionsExample.f90

http://github.com/xyan075/examples · Fortran Modern · 653 lines · 381 code · 73 blank · 199 comment · 52 complexity · 87e102af144003d52e3411b1d058acde MD5 · raw file 

    

  1. !> \file
    2. 

  2. !> \author Chris Bradley
    3. 

  3. !> \brief This is an example program which sets up a field in two regions using openCMISS calls.
    4. 

  4. !>
    5. 

  5. !> \section LICENSE
    6. 

  6. !>
    7. 

  7. !> Version: MPL 1.1/GPL 2.0/LGPL 2.1
    8. 

  8. !>
    9. 

  9. !> The contents of this file are subject to the Mozilla Public License
    10. 

  10. !> Version 1.1 (the "License"); you may not use this file except in
    11. 

  11. !> compliance with the License. You may obtain a copy of the License at
    12. 

  12. !> http://www.mozilla.org/MPL/
    13. 

  13. !>
    14. 

  14. !> Software distributed under the License is distributed on an "AS IS"
    15. 

  15. !> basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
    16. 

  16. !> License for the specific language governing rights and limitations
    17. 

  17. !> under the License.
    18. 

  18. !>
    19. 

  19. !> The Original Code is OpenCMISS
    20. 

  20. !>
    21. 

  21. !> The Initial Developer of the Original Code is University of Auckland,
    22. 

  22. !> Auckland, New Zealand and University of Oxford, Oxford, United
    23. 

  23. !> Kingdom. Portions created by the University of Auckland and University
    24. 

  24. !> of Oxford are Copyright (C) 2007 by the University of Auckland and
    25. 

  25. !> the University of Oxford. All Rights Reserved.
    26. 

  26. !>
    27. 

  27. !> Contributor(s):
    28. 

  28. !>
    29. 

  29. !> Alternatively, the contents of this file may be used under the terms of
    30. 

  30. !> either the GNU General Public License Version 2 or later (the "GPL"), or
    31. 

  31. !> the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
    32. 

  32. !> in which case the provisions of the GPL or the LGPL are applicable instead
    33. 

  33. !> of those above. If you wish to allow use of your version of this file only
    34. 

  34. !> under the terms of either the GPL or the LGPL, and not to allow others to
    35. 

  35. !> use your version of this file under the terms of the MPL, indicate your
    36. 

  36. !> decision by deleting the provisions above and replace them with the notice
    37. 

  37. !> and other provisions required by the GPL or the LGPL. If you do not delete
    38. 

  38. !> the provisions above, a recipient may use your version of this file under
    39. 

  39. !> the terms of any one of the MPL, the GPL or the LGPL.
    40. 

  40. !>
    41. 

  41. 

  42. !> \example TwoRegions/src/TwoRegionsExample.f90
    43. 

  43. !! Example program which sets up a field in two regions using OpenCMISS calls.
    44. 

  44. !! \par Latest Builds:
    45. 

  45. !! \li <a href='http://autotest.bioeng.auckland.ac.nz/opencmiss-build/logs_x86_64-linux/TwoRegions/build-intel'>Linux Intel Build</a>
    46. 

  46. !! \li <a href='http://autotest.bioeng.auckland.ac.nz/opencmiss-build/logs_x86_64-linux/TwoRegions/build-gnu'>Linux GNU Build</a>
    47. 

  47. !<
    48. 

  48. 

  49. !> Main program
    50. 

  50. PROGRAM TWOREGIONSEXAMPLE
    51. 

  51. 

  52.   USE OPENCMISS
    53. 

  53.   USE MPI
    54. 

  54.   
    55. 

  55. #ifdef WIN32
    56. 

  56.   USE IFQWIN
    57. 

  57. #endif
    58. 

  58. 

  59.   IMPLICIT NONE
    60. 

  60. 

  61.   !Test program parameters
    62. 

  62. 

  63.   REAL(CMISSDP), PARAMETER :: HEIGHT=1.0_CMISSDP
    64. 

  64.   REAL(CMISSDP), PARAMETER :: WIDTH=2.0_CMISSDP
    65. 

  65.   REAL(CMISSDP), PARAMETER :: LENGTH=3.0_CMISSDP
    66. 

  66. 

  67.   INTEGER(CMISSIntg), PARAMETER :: CoordinateSystem1UserNumber=1
    68. 

  68.   INTEGER(CMISSIntg), PARAMETER :: CoordinateSystem2UserNumber=2
    69. 

  69.   INTEGER(CMISSIntg), PARAMETER :: Region1UserNumber=3
    70. 

  70.   INTEGER(CMISSIntg), PARAMETER :: Region2UserNumber=4
    71. 

  71.   INTEGER(CMISSIntg), PARAMETER :: Basis1UserNumber=5
    72. 

  72.   INTEGER(CMISSIntg), PARAMETER :: Basis2UserNumber=6
    73. 

  73.   INTEGER(CMISSIntg), PARAMETER :: InterfaceBasisUserNumber=7
    74. 

  74.   INTEGER(CMISSIntg), PARAMETER :: GeneratedMesh1UserNumber=8
    75. 

  75.   INTEGER(CMISSIntg), PARAMETER :: GeneratedMesh2UserNumber=9
    76. 

  76.   INTEGER(CMISSIntg), PARAMETER :: InterfaceGeneratedMeshUserNumber=10
    77. 

  77.   INTEGER(CMISSIntg), PARAMETER :: Mesh1UserNumber=11
    78. 

  78.   INTEGER(CMISSIntg), PARAMETER :: Mesh2UserNumber=12
    79. 

  79.   INTEGER(CMISSIntg), PARAMETER :: InterfaceMeshUserNumber=13
    80. 

  80.   INTEGER(CMISSIntg), PARAMETER :: Decomposition1UserNumber=14
    81. 

  81.   INTEGER(CMISSIntg), PARAMETER :: Decomposition2UserNumber=15
    82. 

  82.   INTEGER(CMISSIntg), PARAMETER :: InterfaceDecompositionUserNumber=16
    83. 

  83.   INTEGER(CMISSIntg), PARAMETER :: GeometricField1UserNumber=17
    84. 

  84.   INTEGER(CMISSIntg), PARAMETER :: GeometricField2UserNumber=18
    85. 

  85.   INTEGER(CMISSIntg), PARAMETER :: InterfaceGeometricFieldUserNumber=19
    86. 

  86.   INTEGER(CMISSIntg), PARAMETER :: EquationsSet1UserNumber=20
    87. 

  87.   INTEGER(CMISSIntg), PARAMETER :: EquationsSet2UserNumber=21
    88. 

  88.   INTEGER(CMISSIntg), PARAMETER :: DependentField1UserNumber=22
    89. 

  89.   INTEGER(CMISSIntg), PARAMETER :: DependentField2UserNumber=23
    90. 

  90.   INTEGER(CMISSIntg), PARAMETER :: InterfaceUserNumber=24
    91. 

  91.   INTEGER(CMISSIntg), PARAMETER :: InterfaceConditionUserNumber=25
    92. 

  92.   INTEGER(CMISSIntg), PARAMETER :: LagrangeFieldUserNumber=26
    93. 

  93.   INTEGER(CMISSIntg), PARAMETER :: CoupledProblemUserNumber=27
    94. 

  94.   INTEGER(CMISSIntg), PARAMETER :: EquationsSetField1UserNumber=40
    95. 

  95.   INTEGER(CMISSIntg), PARAMETER :: EquationsSetField2UserNumber=41
    96. 

  96.   !Program types
    97. 

  97.   
    98. 

  98.   !Program variables
    99. 

  99. 

  100.   INTEGER(CMISSIntg) :: NUMBER_GLOBAL_X_ELEMENTS,NUMBER_GLOBAL_Y_ELEMENTS,NUMBER_GLOBAL_Z_ELEMENTS
    101. 

  101.   INTEGER(CMISSIntg) :: NUMBER_OF_DOMAINS
    102. 

  102.   
    103. 

  103.   INTEGER(CMISSIntg) :: MPI_IERROR
    104. 

  104. 

  105.   LOGICAL :: EXPORT_FIELD
    106. 

  106.   
    107. 

  107.   INTEGER(CMISSIntg) :: EquationsSet1Index,EquationsSet2Index
    108. 

  108.   INTEGER(CMISSIntg) :: FirstNodeNumber,LastNodeNumber
    109. 

  109.   INTEGER(CMISSIntg) :: FirstNodeDomain,LastNodeDomain
    110. 

  110.   INTEGER(CMISSIntg) :: InterfaceConditionIndex
    111. 

  111.   INTEGER(CMISSIntg) :: Mesh1Index,Mesh2Index
    112. 

  112.   INTEGER(CMISSIntg) :: NumberOfComputationalNodes,ComputationalNodeNumber
    113. 

  113. 

  114.   !CMISS variables
    115. 

  115. 

  116.   TYPE(CMISSBasisType) :: Basis1,Basis2,InterfaceBasis
    117. 

  117.   TYPE(CMISSBoundaryConditionsType) :: BoundaryConditions
    118. 

  118.   TYPE(CMISSCoordinateSystemType) :: CoordinateSystem1,CoordinateSystem2,WorldCoordinateSystem
    119. 

  119.   TYPE(CMISSDecompositionType) :: Decomposition1,Decomposition2,InterfaceDecomposition
    120. 

  120.   TYPE(CMISSEquationsType) :: Equations1,Equations2
    121. 

  121.   TYPE(CMISSEquationsSetType) :: EquationsSet1,EquationsSet2
    122. 

  122.   TYPE(CMISSFieldType) :: GeometricField1,GeometricField2,InterfaceGeometricField,DependentField1, &
    123. 

  123.     & DependentField2,LagrangeField,EquationsSetField1,EquationsSetField2
    124. 

  124.   TYPE(CMISSFieldsType) :: Fields1,Fields2,InterfaceFields
    125. 

  125.   TYPE(CMISSGeneratedMeshType) :: GeneratedMesh1,GeneratedMesh2,InterfaceGeneratedMesh
    126. 

  126.   TYPE(CMISSInterfaceType) :: Interface
    127. 

  127.   TYPE(CMISSInterfaceConditionType) :: InterfaceCondition
    128. 

  128.   TYPE(CMISSInterfaceEquationsType) :: InterfaceEquations
    129. 

  129.   TYPE(CMISSInterfaceMeshConnectivityType) :: InterfaceMeshConnectivity
    130. 

  130.   TYPE(CMISSMeshType) :: Mesh1,Mesh2,InterfaceMesh
    131. 

  131.   TYPE(CMISSProblemType) :: CoupledProblem
    132. 

  132.   TYPE(CMISSRegionType) :: Region1,Region2,WorldRegion
    133. 

  133.   TYPE(CMISSSolverType) :: CoupledSolver
    134. 

  134.   TYPE(CMISSSolverEquationsType) :: CoupledSolverEquations
    135. 

  135.   
    136. 

  136. #ifdef WIN32
    137. 

  137.   !Quickwin type
    138. 

  138.   LOGICAL :: QUICKWIN_STATUS=.FALSE.
    139. 

  139.   TYPE(WINDOWCONFIG) :: QUICKWIN_WINDOW_CONFIG
    140. 

  140. #endif
    141. 

  141.   
    142. 

  142.   !Generic CMISS variables
    143. 

  143.   
    144. 

  144.   INTEGER(CMISSIntg) :: Err
    145. 

  145.   
    146. 

  146. #ifdef WIN32
    147. 

  147.   !Initialise QuickWin
    148. 

  148.   QUICKWIN_WINDOW_CONFIG%TITLE="General Output" !Window title
    149. 

  149.   QUICKWIN_WINDOW_CONFIG%NUMTEXTROWS=-1 !Max possible number of rows
    150. 

  150.   QUICKWIN_WINDOW_CONFIG%MODE=QWIN$SCROLLDOWN
    151. 

  151.   !Set the window parameters
    152. 

  152.   QUICKWIN_STATUS=SETWINDOWCONFIG(QUICKWIN_WINDOW_CONFIG)
    153. 

  153.   !If attempt fails set with system estimated values
    154. 

  154.   IF(.NOT.QUICKWIN_STATUS) QUICKWIN_STATUS=SETWINDOWCONFIG(QUICKWIN_WINDOW_CONFIG)
    155. 

  155. #endif
    156. 

  156. 

  157.   !Intialise OpenCMISS
    158. 

  158.   CALL CMISSInitialise(WorldCoordinateSystem,WorldRegion,Err)
    159. 

  159. 

  160.   !Set error handling mode
    161. 

  161.   CALL CMISSErrorHandlingModeSet(CMISS_ERRORS_TRAP_ERROR,Err)
    162. 

  162.  
    163. 

  163.   !Set diganostics for testing
    164. 

  164.   !CALL CMISSDiagnosticsSetOn(CMISS_FROM_DIAG_TYPE,(/1,2,3,4,5/),"Diagnostics",(/"FIELD_MAPPINGS_CALCULATE", &
    165. 

  165.   !  & "SOLVER_MAPPING_CALCULATE"/),Err)
    166. 

  166.   
    167. 

  167.   !Get the computational nodes information
    168. 

  168.   CALL CMISSComputationalNumberOfNodesGet(NumberOfComputationalNodes,Err)
    169. 

  169.   CALL CMISSComputationalNodeNumberGet(ComputationalNodeNumber,Err)
    170. 

  170.   
    171. 

  171.   NUMBER_GLOBAL_X_ELEMENTS=2
    172. 

  172.   NUMBER_GLOBAL_Y_ELEMENTS=2
    173. 

  173.   NUMBER_GLOBAL_Z_ELEMENTS=0
    174. 

  174.   NUMBER_OF_DOMAINS=NumberOfComputationalNodes
    175. 

  175.     
    176. 

  176.   !Broadcast the number of elements in the X & Y directions and the number of partitions to the other computational nodes
    177. 

  177.   CALL MPI_BCAST(NUMBER_GLOBAL_X_ELEMENTS,1,MPI_INTEGER,0,MPI_COMM_WORLD,MPI_IERROR)
    178. 

  178.   CALL MPI_BCAST(NUMBER_GLOBAL_Y_ELEMENTS,1,MPI_INTEGER,0,MPI_COMM_WORLD,MPI_IERROR)
    179. 

  179.   CALL MPI_BCAST(NUMBER_GLOBAL_Z_ELEMENTS,1,MPI_INTEGER,0,MPI_COMM_WORLD,MPI_IERROR)
    180. 

  180.   CALL MPI_BCAST(NUMBER_OF_DOMAINS,1,MPI_INTEGER,0,MPI_COMM_WORLD,MPI_IERROR)
    181. 

  181. 

  182.   !Start the creation of a new RC coordinate system for the first region
    183. 

  183.   PRINT *, ' == >> CREATING COORDINATE SYSTEM(1) << == '
    184. 

  184.   CALL CMISSCoordinateSystem_Initialise(CoordinateSystem1,Err)
    185. 

  185.   CALL CMISSCoordinateSystem_CreateStart(CoordinateSystem1UserNumber,CoordinateSystem1,Err)
    186. 

  186.   IF(NUMBER_GLOBAL_Z_ELEMENTS==0) THEN
    187. 

  187.     !Set the coordinate system to be 2D
    188. 

  188.     CALL CMISSCoordinateSystem_DimensionSet(CoordinateSystem1,2,Err)
    189. 

  189.   ELSE
    190. 

  190.     !Set the coordinate system to be 3D
    191. 

  191.     CALL CMISSCoordinateSystem_DimensionSet(CoordinateSystem1,3,Err)
    192. 

  192.   ENDIF
    193. 

  193.   !Finish the creation of the coordinate system
    194. 

  194.   CALL CMISSCoordinateSystem_CreateFinish(CoordinateSystem1,Err)
    195. 

  195. 

  196.   !Start the creation of a new RC coordinate system for the second region
    197. 

  197.   PRINT *, ' == >> CREATING COORDINATE SYSTEM(2) << == '
    198. 

  198.   CALL CMISSCoordinateSystem_Initialise(CoordinateSystem2,Err)
    199. 

  199.   CALL CMISSCoordinateSystem_CreateStart(CoordinateSystem2UserNumber,CoordinateSystem2,Err)
    200. 

  200.   IF(NUMBER_GLOBAL_Z_ELEMENTS==0) THEN
    201. 

  201.     !Set the coordinate system to be 2D
    202. 

  202.     CALL CMISSCoordinateSystem_DimensionSet(CoordinateSystem2,2,Err)
    203. 

  203.   ELSE
    204. 

  204.     !Set the coordinate system to be 3D
    205. 

  205.     CALL CMISSCoordinateSystem_DimensionSet(CoordinateSystem2,3,Err)
    206. 

  206.   ENDIF
    207. 

  207.   !Finish the creation of the coordinate system
    208. 

  208.   CALL CMISSCoordinateSystem_CreateFinish(CoordinateSystem2,Err)
    209. 

  209.   
    210. 

  210.   !Start the creation of the first region
    211. 

  211.   PRINT *, ' == >> CREATING REGION(1) << == '
    212. 

  212.   CALL CMISSRegion_Initialise(Region1,Err)
    213. 

  213.   CALL CMISSRegion_CreateStart(Region1UserNumber,WorldRegion,Region1,Err)
    214. 

  214.   !Set the regions coordinate system to the RC coordinate system that we have created
    215. 

  215.   CALL CMISSRegion_CoordinateSystemSet(Region1,CoordinateSystem1,Err)
    216. 

  216.   !Finish the creation of the first region
    217. 

  217.   CALL CMISSRegion_CreateFinish(Region1,Err)
    218. 

  218. 

  219.   !Start the creation of the second region
    220. 

  220.   PRINT *, ' == >> CREATING REGION(2) << == '
    221. 

  221.   CALL CMISSRegion_Initialise(Region2,Err)
    222. 

  222.   CALL CMISSRegion_CreateStart(Region2UserNumber,WorldRegion,Region2,Err)
    223. 

  223.   !Set the regions coordinate system to the RC coordinate system that we have created
    224. 

  224.   CALL CMISSRegion_CoordinateSystemSet(Region2,CoordinateSystem2,Err)
    225. 

  225.   !Finish the creation of the second region
    226. 

  226.   CALL CMISSRegion_CreateFinish(Region2,Err)
    227. 

  227. 

  228.   !Start the creation of a bI/tri-linear-Lagrange basis
    229. 

  229.   PRINT *, ' == >> CREATING BASIS(1) << == '
    230. 

  230.   CALL CMISSBasis_Initialise(Basis1,Err)
    231. 

  231.   CALL CMISSBasis_CreateStart(Basis1UserNumber,Basis1,Err)
    232. 

  232.   IF(NUMBER_GLOBAL_Z_ELEMENTS==0) THEN
    233. 

  233.     !Set the basis to be a bilinear Lagrange basis
    234. 

  234.     CALL CMISSBasis_NumberOfXiSet(Basis1,2,Err)
    235. 

  235.   ELSE
    236. 

  236.     !Set the basis to be a trilinear Lagrange basis
    237. 

  237.     CALL CMISSBasis_NumberOfXiSet(Basis1,3,Err)
    238. 

  238.   ENDIF
    239. 

  239.   !Finish the creation of the basis
    240. 

  240.   CALL CMISSBasis_CreateFinish(Basis1,Err)
    241. 

  241.    
    242. 

  242.   !Start the creation of a bI/tri-quadratic-Lagrange basis
    243. 

  243.   PRINT *, ' == >> CREATING BASIS(2) << == '
    244. 

  244.   CALL CMISSBasis_Initialise(Basis2,Err)
    245. 

  245.   CALL CMISSBasis_CreateStart(Basis2UserNumber,Basis2,Err)
    246. 

  246.   IF(NUMBER_GLOBAL_Z_ELEMENTS==0) THEN
    247. 

  247.     !Set the basis to be a bilinear Lagrange basis
    248. 

  248.     CALL CMISSBasis_NumberOfXiSet(Basis2,2,Err)
    249. 

  249.     CALL CMISSBasis_InterpolationXiSet(Basis2,(/CMISS_BASIS_QUADRATIC_LAGRANGE_INTERPOLATION, &
    250. 

  250.       & CMISS_BASIS_QUADRATIC_LAGRANGE_INTERPOLATION/),Err)
    251. 

  251.   ELSE
    252. 

  252.     !Set the basis to be a trilinear Lagrange basis
    253. 

  253.     CALL CMISSBasis_NumberOfXiSet(Basis2,3,Err)
    254. 

  254.     CALL CMISSBasis_InterpolationXiSet(Basis2,(/CMISS_BASIS_QUADRATIC_LAGRANGE_INTERPOLATION, &
    255. 

  255.       & CMISS_BASIS_QUADRATIC_LAGRANGE_INTERPOLATION,CMISS_BASIS_QUADRATIC_LAGRANGE_INTERPOLATION/),Err)
    256. 

  256.   ENDIF
    257. 

  257.   !Finish the creation of the basis
    258. 

  258.   CALL CMISSBasis_CreateFinish(Basis2,Err)
    259. 

  259.   
    260. 

  260.   !Start the creation of a generated mesh in the first region
    261. 

  261.   PRINT *, ' == >> CREATING GENERATED MESH(1) << == '
    262. 

  262.   CALL CMISSGeneratedMesh_Initialise(GeneratedMesh1,Err)
    263. 

  263.   CALL CMISSGeneratedMesh_CreateStart(GeneratedMesh1UserNumber,Region1,GeneratedMesh1,Err)
    264. 

  264.   !Set up a regular x*y*z mesh
    265. 

  265.   CALL CMISSGeneratedMesh_TypeSet(GeneratedMesh1,CMISS_GENERATED_MESH_REGULAR_MESH_TYPE,Err)
    266. 

  266.   !Set the default basis
    267. 

  267.   CALL CMISSGeneratedMesh_BasisSet(GeneratedMesh1,Basis1,Err)   
    268. 

  268.   !Define the mesh on the first region
    269. 

  269.   IF(NUMBER_GLOBAL_Z_ELEMENTS==0) THEN
    270. 

  270.     CALL CMISSGeneratedMesh_ExtentSet(GeneratedMesh1,(/WIDTH,HEIGHT/),Err)
    271. 

  271.     CALL CMISSGeneratedMesh_NumberOfElementsSet(GeneratedMesh1,(/NUMBER_GLOBAL_X_ELEMENTS, &
    272. 

  272.       & NUMBER_GLOBAL_Y_ELEMENTS/),Err)
    273. 

  273.   ELSE
    274. 

  274.     CALL CMISSGeneratedMesh_ExtentSet(GeneratedMesh1,(/WIDTH,HEIGHT,LENGTH/),Err)
    275. 

  275.     CALL CMISSGeneratedMesh_NumberOfElementsSet(GeneratedMesh1,(/NUMBER_GLOBAL_X_ELEMENTS, &
    276. 

  276.       & NUMBER_GLOBAL_Y_ELEMENTS,NUMBER_GLOBAL_Z_ELEMENTS/),Err)
    277. 

  277.   ENDIF    
    278. 

  278.   !Finish the creation of a generated mesh in the first region
    279. 

  279.   CALL CMISSMesh_Initialise(Mesh1,Err)
    280. 

  280.   CALL CMISSGeneratedMesh_CreateFinish(GeneratedMesh1,Mesh1UserNumber,Mesh1,Err)
    281. 

  281. 

  282.   !Start the creation of a generated mesh in the second region
    283. 

  283.   PRINT *, ' == >> CREATING GENERATED MESH(2) << == '
    284. 

  284.   CALL CMISSGeneratedMesh_Initialise(GeneratedMesh2,Err)
    285. 

  285.   CALL CMISSGeneratedMesh_CreateStart(GeneratedMesh2UserNumber,Region2,GeneratedMesh2,Err)
    286. 

  286.   !Set up a regular x*y*z mesh
    287. 

  287.   CALL CMISSGeneratedMesh_TypeSet(GeneratedMesh2,CMISS_GENERATED_MESH_REGULAR_MESH_TYPE,Err)
    288. 

  288.   !Set the default basis
    289. 

  289.   CALL CMISSGeneratedMesh_BasisSet(GeneratedMesh2,Basis2,Err)   
    290. 

  290.   !Define the mesh on the second region
    291. 

  291.   IF(NUMBER_GLOBAL_Z_ELEMENTS==0) THEN
    292. 

  292.     CALL CMISSGeneratedMesh_OriginSet(GeneratedMesh2,(/WIDTH,0.0_CMISSDP/),Err)
    293. 

  293.     CALL CMISSGeneratedMesh_ExtentSet(GeneratedMesh2,(/WIDTH,HEIGHT/),Err)
    294. 

  294.     CALL CMISSGeneratedMesh_NumberOfElementsSet(GeneratedMesh2,(/NUMBER_GLOBAL_X_ELEMENTS, &
    295. 

  295.       & NUMBER_GLOBAL_Y_ELEMENTS/),Err)
    296. 

  296.   ELSE
    297. 

  297.     CALL CMISSGeneratedMesh_OriginSet(GeneratedMesh2,(/WIDTH,0.0_CMISSDP,0.0_CMISSDP/),Err)
    298. 

  298.     CALL CMISSGeneratedMesh_ExtentSet(GeneratedMesh2,(/WIDTH,HEIGHT,LENGTH/),Err)
    299. 

  299.     CALL CMISSGeneratedMesh_NumberOfElementsSet(GeneratedMesh2,(/NUMBER_GLOBAL_X_ELEMENTS, &
    300. 

  300.       & NUMBER_GLOBAL_Y_ELEMENTS,NUMBER_GLOBAL_Z_ELEMENTS/),Err)
    301. 

  301.   ENDIF    
    302. 

  302.   !Finish the creation of a generated mesh in the second region
    303. 

  303.   CALL CMISSMesh_Initialise(Mesh2,Err)
    304. 

  304.   CALL CMISSGeneratedMesh_CreateFinish(GeneratedMesh2,Mesh2UserNumber,Mesh2,Err)
    305. 

  305. 

  306.   !Create an interface between the two meshes
    307. 

  307.   PRINT *, ' == >> CREATING INTERFACE << == '
    308. 

  308.   CALL CMISSInterface_Initialise(Interface,Err)
    309. 

  309.   CALL CMISSInterface_CreateStart(InterfaceUserNumber,WorldRegion,Interface,Err)
    310. 

  310.   !Add in the two meshes
    311. 

  311.   CALL CMISSInterface_MeshAdd(Interface,Mesh1,Mesh1Index,Err)
    312. 

  312.   CALL CMISSInterface_MeshAdd(Interface,Mesh2,Mesh2Index,Err)
    313. 

  313.   !Finish creating the interface
    314. 

  314.   CALL CMISSInterface_CreateFinish(INTERFACE,Err)
    315. 

  315. 

  316.   !Start the creation of a (bi)-linear-Lagrange basis
    317. 

  317.   PRINT *, ' == >> CREATING INTERFACE BASIS << == '
    318. 

  318.   CALL CMISSBasis_Initialise(InterfaceBasis,Err)
    319. 

  319.   CALL CMISSBasis_CreateStart(InterfaceBasisUserNumber,InterfaceBasis,Err)
    320. 

  320.   IF(NUMBER_GLOBAL_Z_ELEMENTS==0) THEN
    321. 

  321.     !Set the basis to be a linear Lagrange basis
    322. 

  322.     CALL CMISSBasis_NumberOfXiSet(InterfaceBasis,1,Err)
    323. 

  323.     CALL CMISSBasis_InterpolationXiSet(InterfaceBasis,(/CMISS_BASIS_LINEAR_LAGRANGE_INTERPOLATION/),Err)
    324. 

  324.   ELSE
    325. 

  325.     !Set the basis to be a bilinear Lagrange basis
    326. 

  326.     CALL CMISSBasis_NumberOfXiSet(InterfaceBasis,2,Err)
    327. 

  327.     CALL CMISSBasis_InterpolationXiSet(InterfaceBasis,(/CMISS_BASIS_QUADRATIC_LAGRANGE_INTERPOLATION, &
    328. 

  328.       & CMISS_BASIS_QUADRATIC_LAGRANGE_INTERPOLATION/),Err)
    329. 

  329.   ENDIF
    330. 

  330.   !Finish the creation of the basis
    331. 

  331.   CALL CMISSBasis_CreateFinish(InterfaceBasis,Err)
    332. 

  332.   
    333. 

  333.   !Start the creation of a generated mesh for the interface
    334. 

  334.   PRINT *, ' == >> CREATING INTERFACE GENERATED MESH << == '
    335. 

  335.   CALL CMISSGeneratedMesh_Initialise(InterfaceGeneratedMesh,Err)
    336. 

  336.   CALL CMISSGeneratedMesh_CreateStart(InterfaceGeneratedMeshUserNumber,Interface,InterfaceGeneratedMesh,Err)
    337. 

  337.   !Set up a regular x*y*z mesh
    338. 

  338.   CALL CMISSGeneratedMesh_TypeSet(InterfaceGeneratedMesh,CMISS_GENERATED_MESH_REGULAR_MESH_TYPE,Err)
    339. 

  339.   !Set the default basis
    340. 

  340.   CALL CMISSGeneratedMesh_BasisSet(InterfaceGeneratedMesh,InterfaceBasis,Err)   
    341. 

  341.   !Define the mesh on the interface
    342. 

  342.   CALL CMISSGeneratedMesh_OriginSet(InterfaceGeneratedMesh,(/WIDTH,0.0_CMISSDP,0.0_CMISSDP/),Err)
    343. 

  343.   IF(NUMBER_GLOBAL_Z_ELEMENTS==0) THEN
    344. 

  344.     CALL CMISSGeneratedMesh_ExtentSet(InterfaceGeneratedMesh,(/WIDTH,HEIGHT,0.0_CMISSDP/),Err)
    345. 

  345.     CALL CMISSGeneratedMesh_NumberOfElementsSet(InterfaceGeneratedMesh,(/NUMBER_GLOBAL_Y_ELEMENTS/),Err)
    346. 

  346.   ELSE
    347. 

  347.     CALL CMISSGeneratedMesh_ExtentSet(InterfaceGeneratedMesh,(/WIDTH,HEIGHT,LENGTH/),Err)
    348. 

  348.     CALL CMISSGeneratedMesh_NumberOfElementsSet(InterfaceGeneratedMesh,(/NUMBER_GLOBAL_Y_ELEMENTS, &
    349. 

  349.       & NUMBER_GLOBAL_Z_ELEMENTS/),Err)
    350. 

  350.   ENDIF    
    351. 

  351.   !Finish the creation of a generated mesh in interface
    352. 

  352.   CALL CMISSMesh_Initialise(InterfaceMesh,Err)
    353. 

  353.   CALL CMISSGeneratedMesh_CreateFinish(InterfaceGeneratedMesh,InterfaceMeshUserNumber,InterfaceMesh,Err)
    354. 

  354. 

  355.   !Couple the interface meshes
    356. 

  356. !  CALL CMISSInterfaceMeshConnectivity_CreateStart(Interface,InterfaceMeshConnectivity,Err)
    357. 

  357. ! <<>> CALL COMMAND TO ADD MESHES CONNECTIVITY INFORMATION <<>> Dave + Sebo april 7.
    358. 

  358. !      CMISSInterfaceMeshConnectivityMeshAdd()
    359. 

  359. !      CMISSInterfaceMeshConnectivityElementsAdd()
    360. 

  360. !      CMISSInterfaceMeshConnectivityXiPoint()
    361. 

  361. !  CALL CMISSInterfaceMeshConnectivity_CreateFinish(InterfaceMeshConnectivity,Err)
    362. 

  362. 

  363. 

  364. 

  365. 

  366. 

  367. 

  368. 

  369.   !Create a decomposition for mesh1
    370. 

  370.   PRINT *, ' == >> CREATING MESH(1) DECOMPOSITION << == '
    371. 

  371.   CALL CMISSDecomposition_Initialise(Decomposition1,Err)
    372. 

  372.   CALL CMISSDecomposition_CreateStart(Decomposition1UserNumber,Mesh1,Decomposition1,Err)
    373. 

  373.   !Set the decomposition to be a general decomposition with the specified number of domains
    374. 

  374.   CALL CMISSDecomposition_TypeSet(Decomposition1,CMISS_DECOMPOSITION_CALCULATED_TYPE,Err)
    375. 

  375.   CALL CMISSDecomposition_NumberOfDomainsSet(Decomposition1,NUMBER_OF_DOMAINS,Err)
    376. 

  376.   !Finish the decomposition
    377. 

  377.   CALL CMISSDecomposition_CreateFinish(Decomposition1,Err)
    378. 

  378. 

  379.   !Create a decomposition for mesh2
    380. 

  380.   PRINT *, ' == >> CREATING MESH(2) DECOMPOSITION << == '
    381. 

  381.   CALL CMISSDecomposition_Initialise(Decomposition2,Err)
    382. 

  382.   CALL CMISSDecomposition_CreateStart(Decomposition2UserNumber,Mesh2,Decomposition2,Err)
    383. 

  383.   !Set the decomposition to be a general decomposition with the specified number of domains
    384. 

  384.   CALL CMISSDecomposition_TypeSet(Decomposition2,CMISS_DECOMPOSITION_CALCULATED_TYPE,Err)
    385. 

  385.   CALL CMISSDecomposition_NumberOfDomainsSet(Decomposition2,NUMBER_OF_DOMAINS,Err)
    386. 

  386.   !Finish the decomposition
    387. 

  387.   CALL CMISSDecomposition_CreateFinish(Decomposition2,Err)
    388. 

  388.   
    389. 

  389.   !Create a decomposition for the interface mesh
    390. 

  390.   PRINT *, ' == >> CREATING INTERFACE DECOMPOSITION << == '
    391. 

  391.   CALL CMISSDecomposition_Initialise(InterfaceDecomposition,Err)
    392. 

  392.   CALL CMISSDecomposition_CreateStart(InterfaceDecompositionUserNumber,InterfaceMesh,InterfaceDecomposition,Err)
    393. 

  393.   !Set the decomposition to be a general decomposition with the specified number of domains
    394. 

  394.   CALL CMISSDecomposition_TypeSet(InterfaceDecomposition,CMISS_DECOMPOSITION_CALCULATED_TYPE,Err)
    395. 

  395.   CALL CMISSDecomposition_NumberOfDomainsSet(InterfaceDecomposition,NUMBER_OF_DOMAINS,Err)
    396. 

  396.   !Finish the decomposition
    397. 

  397.   CALL CMISSDecomposition_CreateFinish(InterfaceDecomposition,Err)
    398. 

  398. 

  399.   !Start to create a default (geometric) field on the first region
    400. 

  400.   PRINT *, ' == >> CREATING MESH(1) GEOMETRIC FIELD << == '
    401. 

  401.   CALL CMISSField_Initialise(GeometricField1,Err)
    402. 

  402.   CALL CMISSField_CreateStart(GeometricField1UserNumber,Region1,GeometricField1,Err)
    403. 

  403.   !Set the decomposition to use
    404. 

  404.   CALL CMISSField_MeshDecompositionSet(GeometricField1,Decomposition1,Err)
    405. 

  405.   !Set the domain to be used by the field components.
    406. 

  406.   CALL CMISSField_ComponentMeshComponentSet(GeometricField1,CMISS_FIELD_U_VARIABLE_TYPE,1,1,Err)
    407. 

  407.   CALL CMISSField_ComponentMeshComponentSet(GeometricField1,CMISS_FIELD_U_VARIABLE_TYPE,2,1,Err)
    408. 

  408.   IF(NUMBER_GLOBAL_Z_ELEMENTS/=0) THEN
    409. 

  409.     CALL CMISSField_ComponentMeshComponentSet(GeometricField1,CMISS_FIELD_U_VARIABLE_TYPE,3,1,Err)
    410. 

  410.   ENDIF
    411. 

  411.   !Finish creating the first field
    412. 

  412.   CALL CMISSField_CreateFinish(GeometricField1,Err)
    413. 

  413. 

  414.   !Start to create a default (geometric) field on the second region
    415. 

  415.   PRINT *, ' == >> CREATING MESH(2) GEOMETRIC FIELD << == '
    416. 

  416.   CALL CMISSField_Initialise(GeometricField2,Err)
    417. 

  417.   CALL CMISSField_CreateStart(GeometricField2UserNumber,Region2,GeometricField2,Err)
    418. 

  418.   !Set the decomposition to use
    419. 

  419.   CALL CMISSField_MeshDecompositionSet(GeometricField2,Decomposition2,Err)
    420. 

  420.   !Set the domain to be used by the field components.
    421. 

  421.   CALL CMISSField_ComponentMeshComponentSet(GeometricField2,CMISS_FIELD_U_VARIABLE_TYPE,1,1,Err)
    422. 

  422.   CALL CMISSField_ComponentMeshComponentSet(GeometricField2,CMISS_FIELD_U_VARIABLE_TYPE,2,1,Err)
    423. 

  423.   IF(NUMBER_GLOBAL_Z_ELEMENTS/=0) THEN
    424. 

  424.     CALL CMISSField_ComponentMeshComponentSet(GeometricField2,CMISS_FIELD_U_VARIABLE_TYPE,3,1,Err)
    425. 

  425.   ENDIF
    426. 

  426.   !Finish creating the second field
    427. 

  427.   CALL CMISSField_CreateFinish(GeometricField2,Err)
    428. 

  428. 

  429.   !Update the geometric field parameters for the first field
    430. 

  430.   CALL CMISSGeneratedMesh_GeometricParametersCalculate(GeneratedMesh1,GeometricField1,Err)
    431. 

  431.   !Update the geometric field parameters for the second field
    432. 

  432.   CALL CMISSGeneratedMesh_GeometricParametersCalculate(GeneratedMesh2,GeometricField2,Err)
    433. 

  433. 

  434.  !Create the equations set for the first region
    435. 

  435.   PRINT *, ' == >> CREATING EQUATION SET(1) << == '
    436. 

  436.   CALL CMISSField_Initialise(EquationsSetField1,Err)
    437. 

  437.   CALL CMISSEquationsSet_Initialise(EquationsSet1,Err)
    438. 

  438.   CALL CMISSEquationsSet_CreateStart(EquationsSet1UserNumber,Region1,GeometricField1,CMISS_EQUATIONS_SET_CLASSICAL_FIELD_CLASS, &
    439. 

  439.     & CMISS_EQUATIONS_SET_LAPLACE_EQUATION_TYPE,CMISS_EQUATIONS_SET_STANDARD_LAPLACE_SUBTYPE,EquationsSetField1UserNumber,&
    440. 

  440.     & EquationsSetField1,EquationsSet1,Err)
    441. 

  441.   !Set the equations set to be a standard Laplace problem
    442. 

  442.   !Finish creating the equations set
    443. 

  443.   CALL CMISSEquationsSet_CreateFinish(EquationsSet1,Err)
    444. 

  444. 

  445.   !Create the equations set for the second region
    446. 

  446.   PRINT *, ' == >> CREATING EQUATION SET(2) << == '
    447. 

  447.   CALL CMISSField_Initialise(EquationsSetField2,Err)
    448. 

  448.   CALL CMISSEquationsSet_Initialise(EquationsSet2,Err)
    449. 

  449.   CALL CMISSEquationsSet_CreateStart(EquationsSet2UserNumber,Region2,GeometricField2,CMISS_EQUATIONS_SET_CLASSICAL_FIELD_CLASS, &
    450. 

  450.     & CMISS_EQUATIONS_SET_LAPLACE_EQUATION_TYPE,CMISS_EQUATIONS_SET_STANDARD_LAPLACE_SUBTYPE,EquationsSetField2UserNumber,&
    451. 

  451.     & EquationsSetField2,EquationsSet2,Err)
    452. 

  452.   !Finish creating the equations set
    453. 

  453.   CALL CMISSEquationsSet_CreateFinish(EquationsSet2,Err)
    454. 

  454. 

  455.   !Create the equations set dependent field variables for the first equations set
    456. 

  456.   PRINT *, ' == >> CREATING DEPENDENT FIELD(1) << == '
    457. 

  457.   CALL CMISSField_Initialise(DependentField1,Err)
    458. 

  458.   CALL CMISSEquationsSet_DependentCreateStart(EquationsSet1,DependentField1UserNumber,DependentField1,Err)
    459. 

  459.   !Finish the equations set dependent field variables
    460. 

  460.   CALL CMISSEquationsSet_DependentCreateFinish(EquationsSet1,Err)
    461. 

  461. 

  462.   !Create the equations set dependent field variables for the second equations set
    463. 

  463.   PRINT *, ' == >> CREATING DEPENDENT FIELD(2) << == '
    464. 

  464.   CALL CMISSField_Initialise(DependentField2,Err)
    465. 

  465.   CALL CMISSEquationsSet_DependentCreateStart(EquationsSet2,DependentField2UserNumber,DependentField2,Err)
    466. 

  466.   !Finish the equations set dependent field variables
    467. 

  467.   CALL CMISSEquationsSet_DependentCreateFinish(EquationsSet2,Err)
    468. 

  468. 

  469.   !Create the equations set equations for the first equations set
    470. 

  470.   PRINT *, ' == >> CREATING EQUATIONS(1) << == '
    471. 

  471.   CALL CMISSEquations_Initialise(Equations1,Err)
    472. 

  472.   CALL CMISSEquationsSet_EquationsCreateStart(EquationsSet1,Equations1,Err)
    473. 

  473.   !Set the equations matrices sparsity type
    474. 

  474.   CALL CMISSEquations_SparsityTypeSet(Equations1,CMISS_EQUATIONS_SPARSE_MATRICES,Err)
    475. 

  475.   !Set the equations set output
    476. 

  476.   !CALL CMISSEquations_OutputTypeSet(Equations1,CMISS_EQUATIONS_NO_OUTPUT,Err)
    477. 

  477.   CALL CMISSEquations_OutputTypeSet(Equations1,CMISS_EQUATIONS_TIMING_OUTPUT,Err)
    478. 

  478.   !CALL CMISSEquations_OutputTypeSet(Equations1,CMISS_EQUATIONS_MATRIX_OUTPUT,Err)
    479. 

  479.   !CALL CMISSEquations_OutputTypeSet(Equations1,CMISS_EQUATIONS_ELEMENT_MATRIX_OUTPUT,Err)
    480. 

  480.   !Finish the equations set equations
    481. 

  481.   CALL CMISSEquationsSet_EquationsCreateFinish(EquationsSet1,Err)
    482. 

  482. 

  483.   !Create the equations set equations for the second equations set
    484. 

  484.   PRINT *, ' == >> CREATING EQUATIONS(2) << == '
    485. 

  485.   CALL CMISSEquations_Initialise(Equations2,Err)
    486. 

  486.   CALL CMISSEquationsSet_EquationsCreateStart(EquationsSet2,Equations2,Err)
    487. 

  487.   !Set the equations matrices sparsity type
    488. 

  488.   CALL CMISSEquations_SparsityTypeSet(Equations2,CMISS_EQUATIONS_SPARSE_MATRICES,Err)
    489. 

  489.   !Set the equations set output
    490. 

  490.   !CALL CMISSEquations_OutputTypeSet(Equations2,CMISS_EQUATIONS_NO_OUTPUT,Err)
    491. 

  491.   CALL CMISSEquations_OutputTypeSet(Equations2,CMISS_EQUATIONS_TIMING_OUTPUT,Err)
    492. 

  492.   !CALL CMISSEquations_OutputTypeSet(Equations2,CMISS_EQUATIONS_MATRIX_OUTPUT,Err)
    493. 

  493.   !CALL CMISSEquations_OutputTypeSet(Equations2,CMISS_EQUATIONS_ELEMENT_MATRIX_OUTPUT,Err)
    494. 

  494.   !Finish the equations set equations
    495. 

  495.   CALL CMISSEquationsSet_EquationsCreateFinish(EquationsSet2,Err)
    496. 

  496. 

  497.   !Start to create a default (geometric) field on the Interface
    498. 

  498.   PRINT *, ' == >> CREATING INTERFACE GEOMETRIC FIELD << == '
    499. 

  499.   CALL CMISSField_Initialise(InterfaceGeometricField,Err)
    500. 

  500.   CALL CMISSField_CreateStart(InterfaceGeometricFieldUserNumber,Interface,InterfaceGeometricField,Err)
    501. 

  501.   !Set the decomposition to use
    502. 

  502.   CALL CMISSField_MeshDecompositionSet(InterfaceGeometricField,InterfaceDecomposition,Err)
    503. 

  503.   !Set the domain to be used by the field components.
    504. 

  504.   CALL CMISSField_ComponentMeshComponentSet(InterfaceGeometricField,CMISS_FIELD_U_VARIABLE_TYPE,1,1,Err)
    505. 

  505.   CALL CMISSField_ComponentMeshComponentSet(InterfaceGeometricField,CMISS_FIELD_U_VARIABLE_TYPE,2,1,Err)
    506. 

  506.   IF(NUMBER_GLOBAL_Z_ELEMENTS/=0) THEN
    507. 

  507.     CALL CMISSField_ComponentMeshComponentSet(InterfaceGeometricField,CMISS_FIELD_U_VARIABLE_TYPE,3,1,Err)
    508. 

  508.   ENDIF
    509. 

  509.   !Finish creating the first field
    510. 

  510.   CALL CMISSField_CreateFinish(InterfaceGeometricField,Err)
    511. 

  511. 

  512.   !Update the geometric field parameters for the interface field
    513. 

  513.   CALL CMISSGeneratedMesh_GeometricParametersCalculate(InterfaceGeneratedMesh,InterfaceGeometricField,Err)
    514. 

  514.   
    515. 

  515. ! <<  ACCESS LATER  >>>
    516. 

  516.   
    517. 

  517.   !Create an interface condition between the two meshes
    518. 

  518.   CALL CMISSInterfaceCondition_Initialise(InterfaceCondition,Err)
    519. 

  519.   CALL CMISSInterfaceCondition_CreateStart(InterfaceConditionUserNumber,Interface,InterfaceGeometricField, &
    520. 

  520.     & InterfaceCondition,Err)
    521. 

  521.   !Specify the method for the interface condition
    522. 

  522.   CALL CMISSInterfaceCondition_MethodSet(InterfaceCondition,CMISS_INTERFACE_CONDITION_LAGRANGE_MULTIPLIERS_METHOD,Err)
    523. 

  523.   !Specify the type of interface condition operator
    524. 

  524.   CALL CMISSInterfaceCondition_OperatorSet(InterfaceCondition,CMISS_INTERFACE_CONDITION_FIELD_CONTINUITY_OPERATOR,Err)
    525. 

  525.   !Add in the dependent variables
    526. 

  526.   CALL CMISSInterfaceCondition_DependentVariableAdd(InterfaceCondition,Mesh1Index,DependentField1, &
    527. 

  527.     & CMISS_FIELD_U_VARIABLE_TYPE,Err)
    528. 

  528.   CALL CMISSInterfaceCondition_DependentVariableAdd(InterfaceCondition,Mesh2Index,DependentField2, &
    529. 

  529.     & CMISS_FIELD_U_VARIABLE_TYPE,Err)
    530. 

  530.   !Finish creating the interface condition
    531. 

  531.   CALL CMISSInterfaceCondition_CreateFinish(InterfaceCondition,Err)
    532. 

  532. 

  533.   !Create the Lagrange multipliers field
    534. 

  534.   PRINT *, ' == >> CREATING INTERFACE LAGRANGE FIELD << == '
    535. 

  535.   CALL CMISSField_Initialise(LagrangeField,Err)
    536. 

  536.   CALL CMISSInterfaceCondition_LagrangeFieldCreateStart(InterfaceCondition,LagrangeFieldUserNumber, &
    537. 

  537.     & LagrangeField,Err)
    538. 

  538.   !Finish the Lagrange multipliers field
    539. 

  539.   CALL CMISSInterfaceCondition_LagrangeFieldCreateFinish(InterfaceCondition,Err)
    540. 

  540. 

  541.   !Create the interface condition equations
    542. 

  542.   PRINT *, ' == >> CREATING INTERFACE EQUATIONS << == '
    543. 

  543.   CALL CMISSInterfaceEquations_Initialise(InterfaceEquations,Err)
    544. 

  544.   CALL CMISSInterfaceCondition_EquationsCreateStart(InterfaceCondition,InterfaceEquations,Err)
    545. 

  545.   !Set the interface equations sparsity
    546. 

  546.   CALL CMISSInterfaceEquations_SparsitySet(InterfaceEquations,CMISS_EQUATIONS_SPARSE_MATRICES,Err)
    547. 

  547.   !Set the interface equations output
    548. 

  548.   CALL CMISSInterfaceEquations_OutputTypeSet(InterfaceEquations,CMISS_EQUATIONS_TIMING_OUTPUT,Err)
    549. 

  549.   !Finish creating the interface equations
    550. 

  550.   CALL CMISSInterfaceCondition_EquationsCreateFinish(InterfaceCondition,Err)
    551. 

  551.   
    552. 

  552.   !Start the creation of a coupled problem.
    553. 

  553.   CALL CMISSProblem_Initialise(CoupledProblem,Err)
    554. 

  554.   CALL CMISSProblem_CreateStart(CoupledProblemUserNumber,CoupledProblem,Err)
    555. 

  555.   !Set the problem to be a standard Laplace problem
    556. 

  556.   CALL CMISSProblem_SpecificationSet(CoupledProblem,CMISS_PROBLEM_CLASSICAL_FIELD_CLASS, &
    557. 

  557.     & CMISS_PROBLEM_LAPLACE_EQUATION_TYPE,CMISS_PROBLEM_STANDARD_LAPLACE_SUBTYPE,Err)
    558. 

  558.   !Finish the creation of a problem.
    559. 

  559.   CALL CMISSProblem_CreateFinish(CoupledProblem,Err)
    560. 

  560. 

  561.   !Start the creation of the problem control loop for the coupled problem
    562. 

  562.   CALL CMISSProblem_ControlLoopCreateStart(CoupledProblem,Err)
    563. 

  563.   !Finish creating the problem control loop
    564. 

  564.   CALL CMISSProblem_ControlLoopCreateFinish(CoupledProblem,Err)
    565. 

  565.  
    566. 

  566.   !Start the creation of the problem solver for the coupled problem
    567. 

  567.   CALL CMISSSolver_Initialise(CoupledSolver,Err)
    568. 

  568.   CALL CMISSProblem_SolversCreateStart(CoupledProblem,Err)
    569. 

  569.   CALL CMISSProblem_SolverGet(CoupledProblem,CMISS_CONTROL_LOOP_NODE,1,CoupledSolver,Err)
    570. 

  570.   !CALL CMISSSolver_OutputTypeSet(CoupledSolver,CMISS_SOLVER_NO_OUTPUT,Err)
    571. 

  571.   !CALL CMISSSolver_OutputTypeSet(CoupledSolver,CMISS_SOLVER_PROGRESS_OUTPUT,Err)
    572. 

  572.   !CALL CMISSSolver_OutputTypeSet(CoupledSolver,CMISS_SOLVER_TIMING_OUTPUT,Err)
    573. 

  573.   !CALL CMISSSolver_OutputTypeSet(CoupledSolver,CMISS_SOLVER_SOLVER_OUTPUT,Err)
    574. 

  574.   CALL CMISSSolver_OutputTypeSet(CoupledSolver,CMISS_SOLVER_MATRIX_OUTPUT,Err)
    575. 

  575.   !Finish the creation of the problem solver
    576. 

  576.   CALL CMISSProblem_SolversCreateFinish(CoupledProblem,Err)
    577. 

  577. 

  578.   !Start the creation of the problem solver equations for the coupled problem
    579. 

  579.   CALL CMISSSolver_Initialise(CoupledSolver,Err)
    580. 

  580.   CALL CMISSSolverEquations_Initialise(CoupledSolverEquations,Err)
    581. 

  581.   CALL CMISSProblem_SolverEquationsCreateStart(CoupledProblem,Err)
    582. 

  582.   !Get the solve equations
    583. 

  583.   CALL CMISSProblem_SolverGet(CoupledProblem,CMISS_CONTROL_LOOP_NODE,1,CoupledSolver,Err)
    584. 

  584.   CALL CMISSSolver_SolverEquationsGet(CoupledSolver,CoupledSolverEquations,Err)
    585. 

  585.   !Set the solver equations sparsity
    586. 

  586.   CALL CMISSSolverEquations_SparsityTypeSet(CoupledSolverEquations,CMISS_SOLVER_SPARSE_MATRICES,Err)
    587. 

  587.   !CALL CMISSSolverEquations_SparsityTypeSet(CoupledSolverEquations,CMISS_SOLVER_FULL_MATRICES,Err)  
    588. 

  588.   !Add in the first equations set
    589. 

  589.   CALL CMISSSolverEquations_EquationsSetAdd(CoupledSolverEquations,EquationsSet1,EquationsSet1Index,Err)
    590. 

  590.   !Add in the second equations set
    591. 

  591.   CALL CMISSSolverEquations_EquationsSetAdd(CoupledSolverEquations,EquationsSet2,EquationsSet2Index,Err)
    592. 

  592.   !Add in the interface condition
    593. 

  593.   CALL CMISSSolverEquations_InterfaceConditionAdd(CoupledSolverEquations,InterfaceCondition, &
    594. 

  594.     & InterfaceConditionIndex,Err)
    595. 

  595.   !Finish the creation of the problem solver equations
    596. 

  596.   CALL CMISSProblem_SolverEquationsCreateFinish(CoupledProblem,Err)
    597. 

  597. 

  598.   !Start the creation of the equations set boundary conditions for both equations sets
    599. 

  599.   PRINT *, ' == >> CREATING BOUNDARY CONDITIONS << == '
    600. 

  600.   CALL CMISSBoundaryConditions_Initialise(BoundaryConditions,Err)
    601. 

  601.   CALL CMISSSolverEquations_BoundaryConditionsCreateStart(CoupledSolverEquations,BoundaryConditions,Err)
    602. 

  602.   !Set the first node to 0.0
    603. 

  603.   FirstNodeNumber=1
    604. 

  604.   CALL CMISSDecomposition_NodeDomainGet(Decomposition1,FirstNodeNumber,1,FirstNodeDomain,Err)
    605. 

  605.   IF(FirstNodeDomain==ComputationalNodeNumber) THEN
    606. 

  606.     CALL CMISSBoundaryConditions_SetNode(BoundaryConditions,DependentField1,CMISS_FIELD_U_VARIABLE_TYPE,1,1,FirstNodeNumber,1, &
    607. 

  607.       & CMISS_BOUNDARY_CONDITION_FIXED,0.0_CMISSDP,Err)
    608. 

  608.   ENDIF
    609. 

  609. 

  610.   !Set the last node to 1.0
    611. 

  611.   IF(NUMBER_GLOBAL_Z_ELEMENTS==0) THEN
    612. 

  612.     LastNodeNumber=(NUMBER_GLOBAL_X_ELEMENTS+1)*(NUMBER_GLOBAL_Y_ELEMENTS+1)
    613. 

  613.   ELSE
    614. 

  614.     LastNodeNumber=(NUMBER_GLOBAL_X_ELEMENTS+1)*(NUMBER_GLOBAL_Y_ELEMENTS+1)*(NUMBER_GLOBAL_Z_ELEMENTS+1)
    615. 

  615.   ENDIF
    616. 

  616.   CALL CMISSDecomposition_NodeDomainGet(Decomposition2,LastNodeNumber,1,LastNodeDomain,Err)
    617. 

  617.   IF(LastNodeDomain==ComputationalNodeNumber) THEN
    618. 

  618.     CALL CMISSBoundaryConditions_SetNode(BoundaryConditions,DependentField2,CMISS_FIELD_U_VARIABLE_TYPE,1,1,LastNodeNumber,1, &
    619. 

  619.       & CMISS_BOUNDARY_CONDITION_FIXED,1.0_CMISSDP,Err)
    620. 

  620.   ENDIF
    621. 

  621.   !Finish the creation of the equations set boundary conditions
    622. 

  622.   CALL CMISSSolverEquations_BoundaryConditionsCreateFinish(CoupledSolverEquations,Err)
    623. 

  623. 

  624.   !Solve the problem
    625. 

  625.   CALL CMISSProblem_Solve(CoupledProblem,Err)
    626. 

  626. 

  627.   EXPORT_FIELD=.TRUE.
    628. 

  628.   IF(EXPORT_FIELD) THEN
    629. 

  629.     CALL CMISSFields_Initialise(Fields1,Err)
    630. 

  630.     CALL CMISSFields_Create(Region1,Fields1,Err)
    631. 

  631.     CALL CMISSFields_NodesExport(Fields1,"TwoRegion_1","FORTRAN",Err)
    632. 

  632.     CALL CMISSFields_ElementsExport(Fields1,"TwoRegion_1","FORTRAN",Err)
    633. 

  633.     CALL CMISSFields_Finalise(Fields1,Err)
    634. 

  634.     CALL CMISSFields_Initialise(Fields2,Err)
    635. 

  635.     CALL CMISSFields_Create(Region2,Fields2,Err)
    636. 

  636.     CALL CMISSFields_NodesExport(Fields2,"TwoRegion_2","FORTRAN",Err)
    637. 

  637.     CALL CMISSFields_ElementsExport(Fields2,"TwoRegion_2","FORTRAN",Err)
    638. 

  638.     CALL CMISSFields_Finalise(Fields2,Err)
    639. 

  639.     CALL CMISSFields_Initialise(InterfaceFields,Err)
    640. 

  640.     CALL CMISSFields_Create(Interface,InterfaceFields,Err)
    641. 

  641.     CALL CMISSFields_NodesExport(InterfaceFields,"TwoRegion_Interface","FORTRAN",Err)
    642. 

  642.     CALL CMISSFields_ElementsExport(InterfaceFields,"TwoRegion_Interface","FORTRAN",Err)
    643. 

  643.     CALL CMISSFields_Finalise(InterfaceFields,Err)
    644. 

  644.   ENDIF
    645. 

  645.     
    646. 

  646.   !Finialise CMISS
    647. 

  647.   !CALL CMISSFinalise(Err)
    648. 

  648. 

  649.   WRITE(*,'(A)') "Program successfully completed."
    650. 

  650. 

  651.   STOP
    652. 

  652.  
    653. 

  653. END PROGRAM TWOREGIONSEXAMPLE
    654.