diff --git a/CMakeLists.txt b/CMakeLists.txt index d7462f4..8996315 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -7,3 +7,4 @@ project(${ExampleName} VERSION 1.0 LANGUAGES C Fortran) find_package(OpenCMISSLibs 1.3.0 REQUIRED COMPONENTS Iron CONFIG) add_subdirectory(src/fortran) +add_subdirectory(src/c) diff --git a/src/c/CMakeLists.txt b/src/c/CMakeLists.txt new file mode 100644 index 0000000..38f2735 --- /dev/null +++ b/src/c/CMakeLists.txt @@ -0,0 +1,7 @@ +add_executable(${ExampleName}_C ${ExampleName}.c) + +target_link_libraries(${ExampleName}_C PRIVATE opencmisslibs) + +install(TARGETS ${ExampleName}_C DESTINATION bin) + +configure_file(visualise.cmgui visualise.cmgui) diff --git a/src/c/expected_results/LaplaceEquation.part0.exelem b/src/c/expected_results/LaplaceEquation.part0.exelem new file mode 100644 index 0000000..edaa7a6 --- /dev/null +++ b/src/c/expected_results/LaplaceEquation.part0.exelem @@ -0,0 +1,154 @@ + Group name: LaplaceEquation + Shape. Dimension=3 + #Scale factor sets= 1 + l.Lagrange*l.Lagrange*l.Lagrange, #Scale factors=8 + #Nodes= 8 + #Fields=3 + 1) Coordinate, coordinate, rectangular cartesian, #Components=3 + x. l.Lagrange*l.Lagrange*l.Lagrange, no modify, standard node based. + #Nodes= 8 + 1. #Values=1 + Value indices: 1 + Scale factor indices: 1 + 2. #Values=1 + Value indices: 1 + Scale factor indices: 2 + 3. #Values=1 + Value indices: 1 + Scale factor indices: 3 + 4. #Values=1 + Value indices: 1 + Scale factor indices: 4 + 5. #Values=1 + Value indices: 1 + Scale factor indices: 5 + 6. #Values=1 + Value indices: 1 + Scale factor indices: 6 + 7. #Values=1 + Value indices: 1 + Scale factor indices: 7 + 8. #Values=1 + Value indices: 1 + Scale factor indices: 8 + y. l.Lagrange*l.Lagrange*l.Lagrange, no modify, standard node based. + #Nodes= 8 + 1. #Values=1 + Value indices: 1 + Scale factor indices: 1 + 2. #Values=1 + Value indices: 1 + Scale factor indices: 2 + 3. #Values=1 + Value indices: 1 + Scale factor indices: 3 + 4. #Values=1 + Value indices: 1 + Scale factor indices: 4 + 5. #Values=1 + Value indices: 1 + Scale factor indices: 5 + 6. #Values=1 + Value indices: 1 + Scale factor indices: 6 + 7. #Values=1 + Value indices: 1 + Scale factor indices: 7 + 8. #Values=1 + Value indices: 1 + Scale factor indices: 8 + z. l.Lagrange*l.Lagrange*l.Lagrange, no modify, standard node based. + #Nodes= 8 + 1. #Values=1 + Value indices: 1 + Scale factor indices: 1 + 2. #Values=1 + Value indices: 1 + Scale factor indices: 2 + 3. #Values=1 + Value indices: 1 + Scale factor indices: 3 + 4. #Values=1 + Value indices: 1 + Scale factor indices: 4 + 5. #Values=1 + Value indices: 1 + Scale factor indices: 5 + 6. #Values=1 + Value indices: 1 + Scale factor indices: 6 + 7. #Values=1 + Value indices: 1 + Scale factor indices: 7 + 8. #Values=1 + Value indices: 1 + Scale factor indices: 8 + 2) Phi, field, rectangular cartesian, #Components=1 + 1. l.Lagrange*l.Lagrange*l.Lagrange, no modify, standard node based. + #Nodes= 8 + 1. #Values=1 + Value indices: 1 + Scale factor indices: 1 + 2. #Values=1 + Value indices: 1 + Scale factor indices: 2 + 3. #Values=1 + Value indices: 1 + Scale factor indices: 3 + 4. #Values=1 + Value indices: 1 + Scale factor indices: 4 + 5. #Values=1 + Value indices: 1 + Scale factor indices: 5 + 6. #Values=1 + Value indices: 1 + Scale factor indices: 6 + 7. #Values=1 + Value indices: 1 + Scale factor indices: 7 + 8. #Values=1 + Value indices: 1 + Scale factor indices: 8 + 3) del Phi_del n, field, rectangular cartesian, #Components=1 + 1. l.Lagrange*l.Lagrange*l.Lagrange, no modify, standard node based. + #Nodes= 8 + 1. #Values=1 + Value indices: 1 + Scale factor indices: 1 + 2. #Values=1 + Value indices: 1 + Scale factor indices: 2 + 3. #Values=1 + Value indices: 1 + Scale factor indices: 3 + 4. #Values=1 + Value indices: 1 + Scale factor indices: 4 + 5. #Values=1 + Value indices: 1 + Scale factor indices: 5 + 6. #Values=1 + Value indices: 1 + Scale factor indices: 6 + 7. #Values=1 + Value indices: 1 + Scale factor indices: 7 + 8. #Values=1 + Value indices: 1 + Scale factor indices: 8 + Element: 1 0 0 + Nodes: + 1 2 3 4 9 10 11 12 + Scale factors: + 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 + Element: 2 0 0 + Nodes: + 3 4 5 6 11 12 13 14 + Scale factors: + 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 + Element: 3 0 0 + Nodes: + 5 6 7 8 13 14 15 16 + Scale factors: + 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 1.0000000000000000E+00 diff --git a/src/c/expected_results/LaplaceEquation.part0.exnode b/src/c/expected_results/LaplaceEquation.part0.exnode new file mode 100644 index 0000000..7bdf6fc --- /dev/null +++ b/src/c/expected_results/LaplaceEquation.part0.exnode @@ -0,0 +1,106 @@ + Group name: LaplaceEquation + #Fields=3 + 1) Coordinate, coordinate, rectangular cartesian, #Components=3 + x. Value index= 1, #Derivatives= 0 + y. Value index= 2, #Derivatives= 0 + z. Value index= 3, #Derivatives= 0 + 2) Phi, field, rectangular cartesian, #Components=1 + 1. Value index= 4, #Derivatives= 0 + 3) del Phi_del n, field, rectangular cartesian, #Components=1 + 1. Value index= 5, #Derivatives= 0 + Node: 1 + 0.0000000000000000E+00 + 0.0000000000000000E+00 + 0.0000000000000000E+00 + 0.0000000000000000E+00 + -3.2707901429383768E-01 + Node: 2 + 2.0000000000000000E+00 + 0.0000000000000000E+00 + 0.0000000000000000E+00 + 5.1441697033516798E-01 + 1.0143463773488193E-01 + Node: 3 + 0.0000000000000000E+00 + 3.3333333333333331E-01 + 0.0000000000000000E+00 + 1.7891898861256758E-01 + 7.1059119943811921E-01 + Node: 4 + 2.0000000000000000E+00 + 3.3333333333333331E-01 + 0.0000000000000000E+00 + 4.2342691170625335E-01 + 6.2093061073913491E-01 + Node: 5 + 0.0000000000000000E+00 + 6.6666666666666663E-01 + 0.0000000000000000E+00 + 2.7840556692655594E-01 + 7.1059119943811921E-01 + Node: 6 + 2.0000000000000000E+00 + 6.6666666666666663E-01 + 0.0000000000000000E+00 + 3.5372850150917595E-01 + 6.2093061073913502E-01 + Node: 7 + 0.0000000000000000E+00 + 1.0000000000000000E+00 + 0.0000000000000000E+00 + 3.4274305408244493E-01 + 2.5370520868685476E-01 + Node: 8 + 2.0000000000000000E+00 + 1.0000000000000000E+00 + 0.0000000000000000E+00 + 2.6103842060345522E-01 + -3.4680425042767582E-02 + Node: 9 + 0.0000000000000000E+00 + 0.0000000000000000E+00 + 3.0000000000000000E+00 + 7.3896157939653973E-01 + -1.8309866618667348E-01 + Node: 10 + 2.0000000000000000E+00 + 0.0000000000000000E+00 + 3.0000000000000000E+00 + 6.5725694591755268E-01 + 1.4064952969343414E-01 + Node: 11 + 0.0000000000000000E+00 + 3.3333333333333331E-01 + 3.0000000000000000E+00 + 6.4627149849081977E-01 + 1.4088754611866103E+00 + Node: 12 + 2.0000000000000000E+00 + 3.3333333333333331E-01 + 3.0000000000000000E+00 + 7.2159443307344184E-01 + 1.2147895567375782E+00 + Node: 13 + 0.0000000000000000E+00 + 6.6666666666666663E-01 + 3.0000000000000000E+00 + 5.7657308829374232E-01 + 1.4088754611866103E+00 + Node: 14 + 2.0000000000000000E+00 + 6.6666666666666663E-01 + 3.0000000000000000E+00 + 8.2108101138743061E-01 + 1.2147895567375782E+00 + Node: 15 + 0.0000000000000000E+00 + 1.0000000000000000E+00 + 3.0000000000000000E+00 + 4.8558302966482708E-01 + 1.6240457247709605E-01 + Node: 16 + 2.0000000000000000E+00 + 1.0000000000000000E+00 + 3.0000000000000000E+00 + 1.0000000000000000E+00 + -1.1333584306898714E-01 diff --git a/src/c/laplace_equation.c b/src/c/laplace_equation.c new file mode 100644 index 0000000..e529e33 --- /dev/null +++ b/src/c/laplace_equation.c @@ -0,0 +1,368 @@ +/* + * + * This is an example program to solve Laplace's equation using OpenCMISS calls from C. + * by Chris Bradley + * + */ +#include +#include + +#include "opencmiss/iron.h" + +#define STRING_SIZE 255 + +#define HEIGHT 1.0 +#define WIDTH 2.0 +#define LENGTH 3.0 + +#define COORDINATE_SYSTEM_USER_NUMBER 1 +#define REGION_USER_NUMBER 2 +#define BASIS_USER_NUMBER 3 +#define GENERATED_MESH_USER_NUMBER 4 +#define MESH_USER_NUMBER 5 +#define DECOMPOSITION_USER_NUMBER 6 +#define GEOMETRIC_FIELD_USER_NUMBER 7 +#define EQUATIONS_SET_USER_NUMBER 8 +#define EQUATIONS_SET_FIELD_USER_NUMBER 9 +#define DEPENDENT_FIELD_USER_NUMBER 10 +#define PROBLEM_USER_NUMBER 11 + +#define MAX_COORDINATES 3 + +#define CHECK_ERROR(S) \ + if(err != CMFE_NO_ERROR) { \ + if(err == CMFE_ERROR_CONVERTING_POINTER) { \ + fprintf(stderr,"Error: %s: Error converting pointer.\n",(S)); \ + } \ + else if(err == CMFE_POINTER_IS_NULL) { \ + fprintf(stderr,"Error: %s: Pointer is null.\n",(S)); \ + } \ + else if(err == CMFE_POINTER_NOT_NULL) { \ + fprintf(stderr,"Error: %s: Pointer is not null.\n",(S)); \ + } \ + else if(err == CMFE_COULD_NOT_ALLOCATE_POINTER) { \ + fprintf(stderr,"Error: %s: Could not allocate pointer.\n",(S)); \ + } \ + exit(err); \ + } + +int main(int argc, char *argv[]) +{ + cmfe_BasisType basis = (cmfe_BasisType)NULL; + cmfe_BoundaryConditionsType boundaryConditions=(cmfe_BoundaryConditionsType)NULL; + cmfe_CoordinateSystemType coordinateSystem=(cmfe_CoordinateSystemType)NULL,worldCoordinateSystem=(cmfe_CoordinateSystemType)NULL; + cmfe_DecompositionType decomposition=(cmfe_DecompositionType)NULL; + cmfe_EquationsType equations=(cmfe_EquationsType)NULL; + cmfe_EquationsSetType equationsSet=(cmfe_EquationsSetType)NULL; + cmfe_FieldsType fields=(cmfe_FieldsType)NULL; + cmfe_FieldType geometricField=(cmfe_FieldType)NULL,dependentField=(cmfe_FieldType)NULL,equationsSetField=(cmfe_FieldType)NULL; + cmfe_GeneratedMeshType generatedMesh=(cmfe_GeneratedMeshType)NULL; + cmfe_MeshType mesh=(cmfe_MeshType)NULL; + cmfe_ProblemType problem=(cmfe_ProblemType)NULL; + cmfe_RegionType region=(cmfe_RegionType)NULL,worldRegion=(cmfe_RegionType)NULL; + cmfe_SolverType solver=(cmfe_SolverType)NULL; + cmfe_SolverEquationsType solverEquations=(cmfe_SolverEquationsType)NULL; + + int numberOfGlobalXElements,numberOfGlobalYElements,numberOfGlobalZElements,interpolationType; + + int numberOfComputationalNodes,computationalNodeNumber; + int equationsSetIndex; + int firstNodeNumber,lastNodeNumber; + int firstNodeDomain,lastNodeDomain; + + int basisInterpolation[MAX_COORDINATES]; + int numberOfDimensions; + int numberOfGauss[MAX_COORDINATES]; + int numberOfGaussXi; + int numberXiElements[MAX_COORDINATES]; + int controlLoopIdentifier[1]; + double meshExtent[MAX_COORDINATES]; + + int equationsSetSpecification[3]; + int problemSpecification[3]; + + char filename[STRING_SIZE],format[STRING_SIZE],regionName[STRING_SIZE]; + + int err; + + controlLoopIdentifier[0]=CMFE_CONTROL_LOOP_NODE; + + if(argc >= 4) + { + numberOfGlobalXElements = atoi(argv[1]); + numberOfGlobalYElements = atoi(argv[2]); + numberOfGlobalZElements = atoi(argv[3]); + interpolationType = atoi(argv[4]); + } + else + { + numberOfGlobalXElements = 1; + numberOfGlobalYElements = 3; + numberOfGlobalZElements = 1; + interpolationType = CMFE_BASIS_LINEAR_LAGRANGE_INTERPOLATION; + } + + err = cmfe_CoordinateSystem_Initialise(&worldCoordinateSystem); + CHECK_ERROR("Initialising world coordinate system"); + err = cmfe_Region_Initialise(&worldRegion); + CHECK_ERROR("Initialising world region"); + err = cmfe_Initialise(worldCoordinateSystem,worldRegion); + CHECK_ERROR("Initialising OpenCMISS-Iron"); + err = cmfe_ErrorHandlingModeSet(CMFE_ERRORS_TRAP_ERROR); + + sprintf(filename,"%s_%dx%dx%d_%d","Laplace",numberOfGlobalXElements,numberOfGlobalYElements,numberOfGlobalZElements,interpolationType); + + err = cmfe_OutputSetOn(STRING_SIZE,filename); + + /* Get the computational nodes information */ + err = cmfe_ComputationalNumberOfNodesGet(&numberOfComputationalNodes); + err = cmfe_ComputationalNodeNumberGet(&computationalNodeNumber); + + /* Start the creation of a new RC coordinate system */ + err = cmfe_CoordinateSystem_Initialise(&coordinateSystem); + err = cmfe_CoordinateSystem_CreateStart(COORDINATE_SYSTEM_USER_NUMBER,coordinateSystem); + if(numberOfGlobalZElements == 0) + { + /* Set the coordinate system to be 2D */ + numberOfDimensions = 2; + } + else + { + /* Set the coordinate system to be 3D */ + numberOfDimensions = 3; + } + err = cmfe_CoordinateSystem_DimensionSet(coordinateSystem,numberOfDimensions); + /* Finish the creation of the coordinate system */ + err = cmfe_CoordinateSystem_CreateFinish(coordinateSystem); + + /* Start the creation of the region */ + sprintf(regionName,"%s","LaplaceEquation"); + err = cmfe_Region_Initialise(®ion); + err = cmfe_Region_CreateStart(REGION_USER_NUMBER,worldRegion,region); + /* Set the regions coordinate system to the 2D RC coordinate system that we have created */ + err = cmfe_Region_CoordinateSystemSet(region,coordinateSystem); + /* Set the regions name */ + err = cmfe_Region_LabelSet(region,STRING_SIZE,regionName); + /* Finish the creation of the region */ + err = cmfe_Region_CreateFinish(region); + + /* Start the creation of a basis (default is trilinear lagrange) */ + err = cmfe_Basis_Initialise(&basis); + err = cmfe_Basis_CreateStart(BASIS_USER_NUMBER,basis); + switch(interpolationType) + { + case 1: + case 2: + case 3: + case 4: + err = cmfe_Basis_TypeSet(basis,CMFE_BASIS_LAGRANGE_HERMITE_TP_TYPE); + break; + case 7: + case 8: + case 9: + err = cmfe_Basis_TypeSet(basis,CMFE_BASIS_SIMPLEX_TYPE); + break; + default: + CHECK_ERROR("Invalid interpolation type"); + } + switch(interpolationType) + { + case 1: + numberOfGaussXi = 2; + break; + case 2: + numberOfGaussXi = 3; + break; + case 3: + case 4: + numberOfGaussXi = 4; + break; + default: + numberOfGaussXi = 0; + } + basisInterpolation[0] = interpolationType; + basisInterpolation[1] = interpolationType; + numberOfGauss[0] = numberOfGaussXi; + numberOfGauss[1] = numberOfGaussXi; + if(numberOfGlobalZElements != 0) + { + basisInterpolation[2] = interpolationType; + numberOfGauss[2] = numberOfGaussXi; + } + err = cmfe_Basis_NumberOfXiSet(basis,numberOfDimensions); + err = cmfe_Basis_InterpolationXiSet(basis,numberOfDimensions,basisInterpolation); + err = cmfe_Basis_QuadratureNumberOfGaussXiSet(basis,numberOfDimensions,numberOfGauss); + /* Finish the creation of the basis */ + err = cmfe_Basis_CreateFinish(basis); + + /* Start the creation of a generated mesh in the region */ + err = cmfe_GeneratedMesh_Initialise(&generatedMesh); + err = cmfe_GeneratedMesh_CreateStart(GENERATED_MESH_USER_NUMBER,region,generatedMesh); + /* Set up a regular x*y*z mesh */ + err = cmfe_GeneratedMesh_TypeSet(generatedMesh,CMFE_GENERATED_MESH_REGULAR_MESH_TYPE); + /* Set the default basis */ + err = cmfe_GeneratedMesh_BasisSet(generatedMesh,1,&basis); + /* Define the mesh on the region */ + meshExtent[0] = WIDTH; + meshExtent[1] = HEIGHT; + numberXiElements[0] = numberOfGlobalXElements; + numberXiElements[1] = numberOfGlobalYElements; + if(numberOfGlobalZElements != 0) + { + meshExtent[2] = LENGTH; + numberXiElements[2] = numberOfGlobalZElements; + } + err = cmfe_GeneratedMesh_ExtentSet(generatedMesh,MAX_COORDINATES,meshExtent); + err = cmfe_GeneratedMesh_NumberOfElementsSet(generatedMesh,MAX_COORDINATES,numberXiElements); + /* Finish the creation of a generated mesh in the region */ + err = cmfe_Mesh_Initialise(&mesh); + /* Finish the creation of a generated mesh in the region */ + err = cmfe_GeneratedMesh_CreateFinish(generatedMesh,MESH_USER_NUMBER,mesh); + + /* Create a decomposition */ + err = cmfe_Decomposition_Initialise(&decomposition); + err = cmfe_Decomposition_CreateStart(DECOMPOSITION_USER_NUMBER,mesh,decomposition); + /* Set the decomposition to be a general decomposition with the specified number of domains */ + err = cmfe_Decomposition_TypeSet(decomposition,CMFE_DECOMPOSITION_CALCULATED_TYPE); + err = cmfe_Decomposition_NumberOfDomainsSet(decomposition,numberOfComputationalNodes); + /* Finish the decomposition */ + err = cmfe_Decomposition_CreateFinish(decomposition); + + /* Start to create a default (geometric) field on the region */ + err = cmfe_Field_Initialise(&geometricField); + err = cmfe_Field_CreateStart(GEOMETRIC_FIELD_USER_NUMBER,region,geometricField); + /* Set the decomposition to use */ + err = cmfe_Field_MeshDecompositionSet(geometricField,decomposition); + /* Set the domain to be used by the field components. */ + err = cmfe_Field_ComponentMeshComponentSet(geometricField,CMFE_FIELD_U_VARIABLE_TYPE,1,1); + err = cmfe_Field_ComponentMeshComponentSet(geometricField,CMFE_FIELD_U_VARIABLE_TYPE,2,1); + if(numberOfGlobalZElements != 0) + { + err = cmfe_Field_ComponentMeshComponentSet(geometricField,CMFE_FIELD_U_VARIABLE_TYPE,3,1); + } + /* Finish creating the field */ + err = cmfe_Field_CreateFinish(geometricField); + + /* Update the geometric field parameters */ + err = cmfe_GeneratedMesh_GeometricParametersCalculate(generatedMesh,geometricField); + + /* Create the equations_set */ + err = cmfe_EquationsSet_Initialise(&equationsSet); + err = cmfe_Field_Initialise(&equationsSetField); + equationsSetSpecification[0] = CMFE_EQUATIONS_SET_CLASSICAL_FIELD_CLASS; + equationsSetSpecification[1] = CMFE_EQUATIONS_SET_LAPLACE_EQUATION_TYPE; + equationsSetSpecification[2] = CMFE_EQUATIONS_SET_STANDARD_LAPLACE_SUBTYPE; + err = cmfe_EquationsSet_CreateStart(EQUATIONS_SET_USER_NUMBER,region,geometricField, \ + 3,equationsSetSpecification,EQUATIONS_SET_FIELD_USER_NUMBER, \ + equationsSetField,equationsSet); + /* Finish creating the equations set */ + err = cmfe_EquationsSet_CreateFinish(equationsSet); + + /* Create the equations set dependent field variables */ + err = cmfe_Field_Initialise(&dependentField); + err = cmfe_EquationsSet_DependentCreateStart(equationsSet,DEPENDENT_FIELD_USER_NUMBER,dependentField); + /* Finish the equations set dependent field variables */ + err = cmfe_EquationsSet_DependentCreateFinish(equationsSet); + + /* Create the equations set equations */ + err = cmfe_Equations_Initialise(&equations); + err = cmfe_EquationsSet_EquationsCreateStart(equationsSet,equations); + /* Set the equations matrices sparsity type */ + err = cmfe_Equations_SparsityTypeSet(equations,CMFE_EQUATIONS_SPARSE_MATRICES); + /* Set the equations set output */ + /* err = cmfe_Equations_OutputTypeSet(equations,CMFE_EQUATIONS_NO_OUTPUT); */ + err = cmfe_Equations_OutputTypeSet(equations,CMFE_EQUATIONS_TIMING_OUTPUT); + /* err = cmfe_Equations_OutputTypeSet(equations,CMFE_EQUATIONS_MATRIX_OUTPUT); */ + /* err = cmfe_Equations_OutputTypeSet(equations,CMFE_EQUATIONS_ELEMENT_MATRIX_OUTPUT); */ + /* Finish the equations set equations */ + err = cmfe_EquationsSet_EquationsCreateFinish(equationsSet); + + /* Start the creation of a problem, setting the problem to be a standard Laplace problem. */ + err = cmfe_Problem_Initialise(&problem); + problemSpecification[0] = CMFE_PROBLEM_CLASSICAL_FIELD_CLASS; + problemSpecification[1] = CMFE_PROBLEM_LAPLACE_EQUATION_TYPE; + problemSpecification[2] = CMFE_PROBLEM_STANDARD_LAPLACE_SUBTYPE; + err = cmfe_Problem_CreateStart(PROBLEM_USER_NUMBER,3,problemSpecification,problem); + /* Finish the creation of a problem. */ + err = cmfe_Problem_CreateFinish(problem); + + /* Start the creation of the problem control loop */ + err = cmfe_Problem_ControlLoopCreateStart(problem); + /* Finish creating the problem control loop */ + err = cmfe_Problem_ControlLoopCreateFinish(problem); + + /* Start the creation of the problem solvers */ + err = cmfe_Solver_Initialise(&solver); + err = cmfe_Problem_SolversCreateStart(problem); + err = cmfe_Problem_SolverGet(problem,1,controlLoopIdentifier,1,solver); + /* err = cmfe_Solver_OutputTypeSet(solver,CMFE_SOLVER_NO_OUTPUT); */ + /* err = cmfe_Solver_OutputTypeSet(solver,CMFE_SOLVER_PROGRESS_OUTPUT); */ + /* err = cmfe_Solver_OutputTypeSet(solver,CMFE_SOLVER_TIMING_OUTPUT); */ + /* err = cmfe_Solver_OutputTypeSet(solver,CMFE_SOLVER_SOLVER_OUTPUT); */ + err = cmfe_Solver_OutputTypeSet(solver,CMFE_SOLVER_MATRIX_OUTPUT); + err = cmfe_Solver_LinearTypeSet(solver,CMFE_SOLVER_LINEAR_DIRECT_SOLVE_TYPE); + err = cmfe_Solver_LibraryTypeSet(solver,CMFE_SOLVER_MUMPS_LIBRARY); + /* Finish the creation of the problem solver */ + err = cmfe_Problem_SolversCreateFinish(problem); + + /* Start the creation of the problem solver equations */ + solver=(cmfe_SolverType)NULL; + err = cmfe_Solver_Initialise(&solver); + err = cmfe_SolverEquations_Initialise(&solverEquations); + err = cmfe_Problem_SolverEquationsCreateStart(problem); + /* Get the solve equations */ + err = cmfe_Problem_SolverGet(problem,1,controlLoopIdentifier,1,solver); + err = cmfe_Solver_SolverEquationsGet(solver,solverEquations); + /* Set the solver equations sparsity */ + err = cmfe_SolverEquations_SparsityTypeSet(solverEquations,CMFE_SOLVER_SPARSE_MATRICES); + /* err = cmfe_SolverEquations_SparsityTypeSet(solverEquations,CMFE_SOLVER_FULL_MATRICES); */ + /* Add in the equations set */ + err = cmfe_SolverEquations_EquationsSetAdd(solverEquations,equationsSet,&equationsSetIndex); + /* Finish the creation of the problem solver equations */ + err = cmfe_Problem_SolverEquationsCreateFinish(problem); + + /* Start the creation of the equations set boundary conditions */ + err = cmfe_BoundaryConditions_Initialise(&boundaryConditions); + err = cmfe_SolverEquations_BoundaryConditionsCreateStart(solverEquations,boundaryConditions); + /* Set the first node to 0.0 and the last node to 1.0 */ + firstNodeNumber = 1; + if(numberOfGlobalZElements == 0) + { + lastNodeNumber = (numberOfGlobalXElements+1)*(numberOfGlobalYElements+1); + } + else + { + lastNodeNumber = (numberOfGlobalXElements+1)*(numberOfGlobalYElements+1)*(numberOfGlobalZElements+1); + } + err = cmfe_Decomposition_NodeDomainGet(decomposition,firstNodeNumber,1,&firstNodeDomain); + err = cmfe_Decomposition_NodeDomainGet(decomposition,lastNodeNumber,1,&lastNodeDomain); + if(firstNodeDomain == computationalNodeNumber) + { + err = cmfe_BoundaryConditions_SetNode(boundaryConditions,dependentField,CMFE_FIELD_U_VARIABLE_TYPE,1,1,firstNodeNumber,1, \ + CMFE_BOUNDARY_CONDITION_FIXED,0.0); + } + if(lastNodeDomain == computationalNodeNumber) + { + err = cmfe_BoundaryConditions_SetNode(boundaryConditions,dependentField,CMFE_FIELD_U_VARIABLE_TYPE,1,1,lastNodeNumber,1, \ + CMFE_BOUNDARY_CONDITION_FIXED,1.0); + } + /* Finish the creation of the equations set boundary conditions */ + err = cmfe_SolverEquations_BoundaryConditionsCreateFinish(solverEquations); + + /* Solve the problem */ + err = cmfe_Problem_Solve(problem); + + /* Output results */ + sprintf(filename,"%s","LaplaceEquation"); + sprintf(format,"%s","FORTRAN"); + err = cmfe_Fields_Initialise(&fields); + err = cmfe_Fields_CreateRegion(region,fields); + err = cmfe_Fields_NodesExport(fields,STRING_SIZE,filename,STRING_SIZE,format); + err = cmfe_Fields_ElementsExport(fields,STRING_SIZE,filename,STRING_SIZE,format); + err = cmfe_Fields_Finalise(&fields); + + /* Finalise OpenCMISS */ + err = cmfe_Finalise(); + + return err; +} diff --git a/src/c/visualise.cmgui b/src/c/visualise.cmgui new file mode 100644 index 0000000..df26b86 --- /dev/null +++ b/src/c/visualise.cmgui @@ -0,0 +1,30 @@ +$name = "LaplaceEquation"; +$numProcs = 1; + +for($rank=0; $rank < $numProcs; $rank=$rank+1) + { + $filename = sprintf("./%s.part%d.exnode", $name, $rank); + gfx read node "$filename"; + } +for($rank=0; $rank < $numProcs; $rank=$rank+1) + { + $filename = sprintf("./%s.part%d.exelem", $name, $rank); + gfx read elem "$filename"; + } + +gfx def faces egroup $name; + +gfx modify g_element $name general clear circle_discretization 6 default_coordinate Coordinate element_discretization "4*4*4" native_discretization none; +gfx modify g_element $name lines select_on invisible material default selected_material default_selected; +gfx modify g_element $name surfaces select_on material default data Phi spectrum default selected_material default_selected render_shaded; +gfx modify g_element $name node_points glyph sphere general size "0.025*0.025*0.025" centre 0,0,0 font default label cmiss_number select_on material blue selected_material default_selected; +gfx modify g_element $name cylinders constant_radius 0.005 select_on material gold selected_material default_selected render_shaded; + +gfx create window 1 double_buffer; +gfx modify window 1 image scene default light_model default; +gfx modify window 1 image add_light default; +gfx modify window 1 layout simple ortho_axes z -y eye_spacing 0.25 width 567 height 653; +gfx modify window 1 set current_pane 1; +gfx modify window 1 background colour 0 0 0 texture none; +gfx modify window 1 view parallel eye_point -4.0 -4.0 4.0 interest_point 1.0 0.5 1.5 up_vector 0.3 0.3 0.9 view_angle 40.0 near_clipping_plane 0.01 far_clipping_plane 15.0 relative_viewport ndc_placement -1 1 2 2 viewport_coordinates 0 0 1 1; +gfx modify window 1 set transform_tool current_pane 1 std_view_angle 40 normal_lines no_antialias depth_of_field 0.0 fast_transparency blend_normal; diff --git a/src/fortran/CMakeLists.txt b/src/fortran/CMakeLists.txt index 69c6b95..3cf827a 100644 --- a/src/fortran/CMakeLists.txt +++ b/src/fortran/CMakeLists.txt @@ -1,7 +1,7 @@ -add_executable(${ExampleName} ${ExampleName}.F90) +add_executable(${ExampleName}_Fortran ${ExampleName}.F90) -target_link_libraries(${ExampleName} PRIVATE opencmisslibs) +target_link_libraries(${ExampleName}_Fortran PRIVATE opencmisslibs) -install(TARGETS ${ExampleName} DESTINATION bin) +install(TARGETS ${ExampleName}_Fortran DESTINATION bin) configure_file(visualise.cmgui visualise.cmgui) diff --git a/src/fortran/laplace_equation.F90 b/src/fortran/laplace_equation.F90 index f13c6bb..01aacb0 100644 --- a/src/fortran/laplace_equation.F90 +++ b/src/fortran/laplace_equation.F90 @@ -1,15 +1,9 @@ -PROGRAM LAPLACE_EQUATION +PROGRAM LaplaceEquation USE OpenCMISS USE OpenCMISS_Iron - -#ifndef NOMPIMOD - USE MPI -#endif + IMPLICIT NONE -#ifdef NOMPIMOD -#include "mpif.h" -#endif !----------------------------------------------------------------------------------------------------------- ! PROGRAM VARIABLES AND TYPES @@ -17,399 +11,398 @@ PROGRAM LAPLACE_EQUATION !Test program parameters REAL(CMISSRP), PARAMETER :: HEIGHT=1.0_CMISSRP - REAL(CMISSRP), PARAMETER :: WIDTH=1.0_CMISSRP - REAL(CMISSRP), PARAMETER :: LENGTH=1.0_CMISSRP - - INTEGER(CMISSIntg), PARAMETER :: CoordinateSystemUserNumber=1 - INTEGER(CMISSIntg), PARAMETER :: RegionUserNumber=2 - INTEGER(CMISSIntg), PARAMETER :: BasisUserNumber=3 - INTEGER(CMISSIntg), PARAMETER :: GeneratedMeshUserNumber=4 - INTEGER(CMISSIntg), PARAMETER :: MeshUserNumber=5 - INTEGER(CMISSIntg), PARAMETER :: DecompositionUserNumber=6 - INTEGER(CMISSIntg), PARAMETER :: GeometricFieldUserNumber=7 - INTEGER(CMISSIntg), PARAMETER :: EquationsSetFieldUserNumber=8 - INTEGER(CMISSIntg), PARAMETER :: DependentFieldUserNumber=9 - INTEGER(CMISSIntg), PARAMETER :: EquationsSetUserNumber=10 - INTEGER(CMISSIntg), PARAMETER :: ProblemUserNumber=11 + REAL(CMISSRP), PARAMETER :: WIDTH=2.0_CMISSRP + REAL(CMISSRP), PARAMETER :: LENGTH=3.0_CMISSRP + + INTEGER(CMISSIntg), PARAMETER :: COORDINATE_SYSTEM_USER_NUMBER=1 + INTEGER(CMISSIntg), PARAMETER :: REGION_USER_NUMBER=2 + INTEGER(CMISSIntg), PARAMETER :: BASIS_USER_NUMBER=3 + INTEGER(CMISSIntg), PARAMETER :: GENERATED_MESH_USER_NUMBER=4 + INTEGER(CMISSIntg), PARAMETER :: MESH_USER_NUMBER=5 + INTEGER(CMISSIntg), PARAMETER :: DECOMPOSITION_USER_NUMBER=6 + INTEGER(CMISSIntg), PARAMETER :: GEOMETRIC_FIELD_USER_NUMBER=7 + INTEGER(CMISSIntg), PARAMETER :: EQUATIONS_SET_FIELD_USER_NUMBER=8 + INTEGER(CMISSIntg), PARAMETER :: DEPENDENT_FIELD_USER_NUMBER=9 + INTEGER(CMISSIntg), PARAMETER :: EQUATIONS_SET_USER_NUMBER=10 + INTEGER(CMISSIntg), PARAMETER :: PROBLEM_USER_NUMBER=11 !Program types !Program variables - INTEGER(CMISSIntg) :: NUMBER_OF_ARGUMENTS,ARGUMENT_LENGTH,STATUS - INTEGER(CMISSIntg) :: NUMBER_GLOBAL_X_ELEMENTS,NUMBER_GLOBAL_Y_ELEMENTS,NUMBER_GLOBAL_Z_ELEMENTS, & - & INTERPOLATION_TYPE,NUMBER_OF_GAUSS_XI - CHARACTER(LEN=255) :: COMMAND_ARGUMENT,Filename + INTEGER(CMISSIntg) :: numberOfArguments,argumentLength,status + INTEGER(CMISSIntg) :: numberOfGlobalXElements,numberOfGlobalYElements,numberOfGlobalZElements, & + & interpolationType,numberOfGaussXi + CHARACTER(LEN=255) :: commandArgument,filename !CMISS variables - TYPE(cmfe_BasisType) :: Basis - TYPE(cmfe_BoundaryConditionsType) :: BoundaryConditions - TYPE(cmfe_CoordinateSystemType) :: CoordinateSystem,WorldCoordinateSystem - TYPE(cmfe_DecompositionType) :: Decomposition - TYPE(cmfe_EquationsType) :: Equations - TYPE(cmfe_EquationsSetType) :: EquationsSet - TYPE(cmfe_FieldType) :: GeometricField,EquationsSetField,DependentField - TYPE(cmfe_FieldsType) :: Fields - TYPE(cmfe_GeneratedMeshType) :: GeneratedMesh - TYPE(cmfe_MeshType) :: Mesh - TYPE(cmfe_NodesType) :: Nodes - TYPE(cmfe_ProblemType) :: Problem - TYPE(cmfe_RegionType) :: Region,WorldRegion - TYPE(cmfe_SolverType) :: Solver - TYPE(cmfe_SolverEquationsType) :: SolverEquations + TYPE(cmfe_BasisType) :: basis + TYPE(cmfe_BoundaryConditionsType) :: boundaryConditions + TYPE(cmfe_CoordinateSystemType) :: coordinateSystem,worldCoordinateSystem + TYPE(cmfe_DecompositionType) :: decomposition + TYPE(cmfe_EquationsType) :: equations + TYPE(cmfe_EquationsSetType) :: equationsSet + TYPE(cmfe_FieldType) :: geometricField,equationsSetField,dependentField + TYPE(cmfe_FieldsType) :: fields + TYPE(cmfe_GeneratedMeshType) :: generatedMesh + TYPE(cmfe_MeshType) :: mesh + TYPE(cmfe_NodesType) :: nodes + TYPE(cmfe_ProblemType) :: problem + TYPE(cmfe_RegionType) :: region,worldRegion + TYPE(cmfe_SolverType) :: solver + TYPE(cmfe_SolverEquationsType) :: solverEquations !Generic CMISS variables - INTEGER(CMISSIntg) :: NumberOfComputationalNodes,ComputationalNodeNumber - INTEGER(CMISSIntg) :: EquationsSetIndex - INTEGER(CMISSIntg) :: FirstNodeNumber,LastNodeNumber - INTEGER(CMISSIntg) :: FirstNodeDomain,LastNodeDomain - INTEGER(CMISSIntg) :: Err + INTEGER(CMISSIntg) :: numberOfComputationalNodes,computationalNodeNumber + INTEGER(CMISSIntg) :: equationsSetIndex + INTEGER(CMISSIntg) :: firstNodeNumber,lastNodeNumber + INTEGER(CMISSIntg) :: firstNodeDomain,lastNodeDomain + INTEGER(CMISSIntg) :: err !----------------------------------------------------------------------------------------------------------- ! PROBLEM CONTROL PANEL !----------------------------------------------------------------------------------------------------------- - NUMBER_OF_ARGUMENTS = COMMAND_ARGUMENT_COUNT() - IF(NUMBER_OF_ARGUMENTS >= 4) THEN + numberOfArguments = COMMAND_ARGUMENT_COUNT() + IF(numberOfArguments >= 4) THEN !If we have enough arguments then use the first four for setting up the problem. The subsequent arguments may be used to !pass flags to, say, PETSc. - CALL GET_COMMAND_ARGUMENT(1,COMMAND_ARGUMENT,ARGUMENT_LENGTH,STATUS) - IF(STATUS>0) CALL HANDLE_ERROR("Error for command argument 1.") - READ(COMMAND_ARGUMENT(1:ARGUMENT_LENGTH),*) NUMBER_GLOBAL_X_ELEMENTS - IF(NUMBER_GLOBAL_X_ELEMENTS<=0) CALL HANDLE_ERROR("Invalid number of X elements.") - CALL GET_COMMAND_ARGUMENT(2,COMMAND_ARGUMENT,ARGUMENT_LENGTH,STATUS) - IF(STATUS>0) CALL HANDLE_ERROR("Error for command argument 2.") - READ(COMMAND_ARGUMENT(1:ARGUMENT_LENGTH),*) NUMBER_GLOBAL_Y_ELEMENTS - IF(NUMBER_GLOBAL_Y_ELEMENTS<=0) CALL HANDLE_ERROR("Invalid number of Y elements.") - CALL GET_COMMAND_ARGUMENT(3,COMMAND_ARGUMENT,ARGUMENT_LENGTH,STATUS) - IF(STATUS>0) CALL HANDLE_ERROR("Error for command argument 3.") - READ(COMMAND_ARGUMENT(1:ARGUMENT_LENGTH),*) NUMBER_GLOBAL_Z_ELEMENTS - IF(NUMBER_GLOBAL_Z_ELEMENTS<0) CALL HANDLE_ERROR("Invalid number of Z elements.") - CALL GET_COMMAND_ARGUMENT(4,COMMAND_ARGUMENT,ARGUMENT_LENGTH,STATUS) - IF(STATUS>0) CALL HANDLE_ERROR("Error for command argument 4.") - READ(COMMAND_ARGUMENT(1:ARGUMENT_LENGTH),*) INTERPOLATION_TYPE - IF(INTERPOLATION_TYPE<=0) CALL HANDLE_ERROR("Invalid Interpolation specification.") + CALL GET_COMMAND_ARGUMENT(1,commandArgument,argumentLength,status) + IF(status>0) CALL HandleError("Error for command argument 1.") + READ(commandArgument(1:argumentLength),*) numberOfGlobalXElements + IF(numberOfGlobalXElements<=0) CALL HandleError("Invalid number of X elements.") + CALL GET_COMMAND_ARGUMENT(2,commandArgument,argumentLength,status) + IF(status>0) CALL HandleError("Error for command argument 2.") + READ(commandArgument(1:argumentLength),*) numberOfGlobalYElements + IF(numberOfGlobalYElements<=0) CALL HandleError("Invalid number of Y elements.") + CALL GET_COMMAND_ARGUMENT(3,commandArgument,argumentLength,status) + IF(status>0) CALL HandleError("Error for command argument 3.") + READ(commandArgument(1:argumentLength),*) numberOfGlobalZElements + IF(numberOfGlobalZElements<0) CALL HandleError("Invalid number of Z elements.") + CALL GET_COMMAND_ARGUMENT(4,commandArgument,argumentLength,status) + IF(status>0) CALL HandleError("Error for command argument 4.") + READ(commandArgument(1:argumentLength),*) interpolationType + IF(interpolationType<=0) CALL HandleError("Invalid Interpolation specification.") ELSE !If there are not enough arguments default the problem specification - NUMBER_GLOBAL_X_ELEMENTS=1 - NUMBER_GLOBAL_Y_ELEMENTS=3 - NUMBER_GLOBAL_Z_ELEMENTS=1 -! INTERPOLATION_TYPE=1 - - INTERPOLATION_TYPE=CMFE_BASIS_LINEAR_LAGRANGE_INTERPOLATION -! INTERPOLATION_TYPE=CMFE_BASIS_QUADRATIC_LAGRANGE_INTERPOLATION -! INTERPOLATION_TYPE=CMFE_BASIS_CUBIC_LAGRANGE_INTERPOLATION + numberOfGlobalXElements=1 + numberOfGlobalYElements=3 + numberOfGlobalZElements=1 + interpolationType=CMFE_BASIS_LINEAR_LAGRANGE_INTERPOLATION +! interpolationType=CMFE_BASIS_QUADRATIC_LAGRANGE_INTERPOLATION +! interpolationType=CMFE_BASIS_CUBIC_LAGRANGE_INTERPOLATION ENDIF !Intialise OpenCMISS - CALL cmfe_Initialise(WorldCoordinateSystem,WorldRegion,Err) - CALL cmfe_ErrorHandlingModeSet(CMFE_ERRORS_TRAP_ERROR,Err) - CALL cmfe_RandomSeedsSet(9999,Err) - !CALL cmfe_DiagnosticsSetOn(CMFE_IN_DIAG_TYPE,[1,2,3,4,5],"Diagnostics",["DOMAIN_MAPPINGS_LOCAL_FROM_GLOBAL_CALCULATE"],Err) + CALL cmfe_Initialise(worldCoordinateSystem,worldRegion,err) + CALL cmfe_ErrorHandlingModeSet(CMFE_ERRORS_TRAP_ERROR,err) + CALL cmfe_RandomSeedsSet(9999,err) + !CALL cmfe_DiagnosticsSetOn(CMFE_IN_DIAG_TYPE,[1,2,3,4,5],"Diagnostics",["Laplace_FiniteElementCalculate"],err) - WRITE(Filename,'(A,"_",I0,"x",I0,"x",I0,"_",I0)') "Laplace",NUMBER_GLOBAL_X_ELEMENTS,NUMBER_GLOBAL_Y_ELEMENTS, & - & NUMBER_GLOBAL_Z_ELEMENTS,INTERPOLATION_TYPE + WRITE(filename,'(A,"_",I0,"x",I0,"x",I0,"_",I0)') "Laplace",numberOfGlobalXElements,numberOfGlobalYElements, & + & numberOfGlobalZElements,interpolationType - CALL cmfe_OutputSetOn(Filename,Err) + CALL cmfe_OutputSetOn(filename,err) !Get the computational nodes information - CALL cmfe_ComputationalNumberOfNodesGet(NumberOfComputationalNodes,Err) - CALL cmfe_ComputationalNodeNumberGet(ComputationalNodeNumber,Err) + CALL cmfe_ComputationalNumberOfNodesGet(numberOfComputationalNodes,err) + CALL cmfe_ComputationalNodeNumberGet(computationalNodeNumber,err) !----------------------------------------------------------------------------------------------------------- ! COORDINATE SYSTEM !----------------------------------------------------------------------------------------------------------- !Start the creation of a new RC coordinate system - CALL cmfe_CoordinateSystem_Initialise(CoordinateSystem,Err) - CALL cmfe_CoordinateSystem_CreateStart(CoordinateSystemUserNumber,CoordinateSystem,Err) - IF(NUMBER_GLOBAL_Z_ELEMENTS==0) THEN + CALL cmfe_CoordinateSystem_Initialise(coordinateSystem,err) + CALL cmfe_CoordinateSystem_CreateStart(COORDINATE_SYSTEM_USER_NUMBER,coordinateSystem,err) + IF(numberOfGlobalZElements==0) THEN !Set the coordinate system to be 2D - CALL cmfe_CoordinateSystem_DimensionSet(CoordinateSystem,2,Err) + CALL cmfe_CoordinateSystem_DimensionSet(coordinateSystem,2,err) ELSE !Set the coordinate system to be 3D - CALL cmfe_CoordinateSystem_DimensionSet(CoordinateSystem,3,Err) + CALL cmfe_CoordinateSystem_DimensionSet(coordinateSystem,3,err) ENDIF !Finish the creation of the coordinate system - CALL cmfe_CoordinateSystem_CreateFinish(CoordinateSystem,Err) + CALL cmfe_CoordinateSystem_CreateFinish(coordinateSystem,err) !----------------------------------------------------------------------------------------------------------- ! REGION !----------------------------------------------------------------------------------------------------------- !Start the creation of the region - CALL cmfe_Region_Initialise(Region,Err) - CALL cmfe_Region_CreateStart(RegionUserNumber,WorldRegion,Region,Err) - CALL cmfe_Region_LabelSet(Region,"laplace_equation",Err) + CALL cmfe_Region_Initialise(region,err) + CALL cmfe_Region_CreateStart(REGION_USER_NUMBER,worldRegion,region,err) !Set the regions coordinate system to the 2D RC coordinate system that we have created - CALL cmfe_Region_CoordinateSystemSet(Region,CoordinateSystem,Err) + CALL cmfe_Region_CoordinateSystemSet(region,coordinateSystem,err) + !Set the region label + CALL cmfe_Region_LabelSet(region,"LaplaceEquation",err) !Finish the creation of the region - CALL cmfe_Region_CreateFinish(Region,Err) + CALL cmfe_Region_CreateFinish(region,err) !----------------------------------------------------------------------------------------------------------- ! BASIS !----------------------------------------------------------------------------------------------------------- !Start the creation of a basis (default is trilinear lagrange) - CALL cmfe_Basis_Initialise(Basis,Err) - CALL cmfe_Basis_CreateStart(BasisUserNumber,Basis,Err) - SELECT CASE(INTERPOLATION_TYPE) + CALL cmfe_Basis_Initialise(basis,err) + CALL cmfe_Basis_CreateStart(BASIS_USER_NUMBER,basis,err) + SELECT CASE(interpolationType) CASE(1,2,3,4) - CALL cmfe_Basis_TypeSet(Basis,CMFE_BASIS_LAGRANGE_HERMITE_TP_TYPE,Err) + CALL cmfe_Basis_TypeSet(basis,CMFE_BASIS_LAGRANGE_HERMITE_TP_TYPE,err) CASE(7,8,9) - CALL cmfe_Basis_TypeSet(Basis,CMFE_BASIS_SIMPLEX_TYPE,Err) + CALL cmfe_Basis_TypeSet(basis,CMFE_BASIS_SIMPLEX_TYPE,err) CASE DEFAULT - CALL HANDLE_ERROR("Invalid interpolation type.") + CALL HandleError("Invalid interpolation type.") END SELECT - SELECT CASE(INTERPOLATION_TYPE) + SELECT CASE(interpolationType) CASE(1) - NUMBER_OF_GAUSS_XI=2 + numberOfGaussXi=2 CASE(2) - NUMBER_OF_GAUSS_XI=3 + numberOfGaussXi=3 CASE(3,4) - NUMBER_OF_GAUSS_XI=4 + numberOfGaussXi=4 CASE DEFAULT - NUMBER_OF_GAUSS_XI=0 !Don't set number of Gauss points for tri/tet + numberOfGaussXi=0 !Don't set number of Gauss points for tri/tet END SELECT - IF(NUMBER_GLOBAL_Z_ELEMENTS==0) THEN + IF(numberOfGlobalZElements==0) THEN !Set the basis to be a bi-interpolation basis - CALL cmfe_Basis_NumberOfXiSet(Basis,2,Err) - CALL cmfe_Basis_InterpolationXiSet(Basis,[INTERPOLATION_TYPE,INTERPOLATION_TYPE],Err) - IF(NUMBER_OF_GAUSS_XI>0) THEN - CALL cmfe_Basis_QuadratureNumberOfGaussXiSet(Basis,[NUMBER_OF_GAUSS_XI,NUMBER_OF_GAUSS_XI],Err) + CALL cmfe_Basis_NumberOfXiSet(basis,2,err) + CALL cmfe_Basis_InterpolationXiSet(basis,[interpolationType,interpolationType],err) + IF(numberOfGaussXi>0) THEN + CALL cmfe_Basis_QuadratureNumberOfGaussXiSet(basis,[numberOfGaussXi,numberOfGaussXi],err) ENDIF ELSE !Set the basis to be a tri-interpolation basis - CALL cmfe_Basis_NumberOfXiSet(Basis,3,Err) - CALL cmfe_Basis_InterpolationXiSet(Basis,[INTERPOLATION_TYPE,INTERPOLATION_TYPE,INTERPOLATION_TYPE],Err) - IF(NUMBER_OF_GAUSS_XI>0) THEN - CALL cmfe_Basis_QuadratureNumberOfGaussXiSet(Basis,[NUMBER_OF_GAUSS_XI,NUMBER_OF_GAUSS_XI,NUMBER_OF_GAUSS_XI],Err) + CALL cmfe_Basis_NumberOfXiSet(basis,3,err) + CALL cmfe_Basis_InterpolationXiSet(basis,[interpolationType,interpolationType,interpolationType],err) + IF(numberOfGaussXi>0) THEN + CALL cmfe_Basis_QuadratureNumberOfGaussXiSet(basis,[numberOfGaussXi,numberOfGaussXi,numberOfGaussXi],err) ENDIF ENDIF !Finish the creation of the basis - CALL cmfe_Basis_CreateFinish(Basis,Err) + CALL cmfe_Basis_CreateFinish(basis,err) !----------------------------------------------------------------------------------------------------------- ! MESH !----------------------------------------------------------------------------------------------------------- !Start the creation of a generated mesh in the region - CALL cmfe_GeneratedMesh_Initialise(GeneratedMesh,Err) - CALL cmfe_GeneratedMesh_CreateStart(GeneratedMeshUserNumber,Region,GeneratedMesh,Err) + CALL cmfe_GeneratedMesh_Initialise(generatedMesh,err) + CALL cmfe_GeneratedMesh_CreateStart(GENERATED_MESH_USER_NUMBER,region,generatedMesh,err) !Set up a regular x*y*z mesh - CALL cmfe_GeneratedMesh_TypeSet(GeneratedMesh,CMFE_GENERATED_MESH_REGULAR_MESH_TYPE,Err) + CALL cmfe_GeneratedMesh_TypeSet(generatedMesh,CMFE_GENERATED_MESH_REGULAR_MESH_TYPE,err) !Set the default basis - CALL cmfe_GeneratedMesh_BasisSet(GeneratedMesh,Basis,Err) + CALL cmfe_GeneratedMesh_BasisSet(generatedMesh,basis,err) !Define the mesh on the region - IF(NUMBER_GLOBAL_Z_ELEMENTS==0) THEN - CALL cmfe_GeneratedMesh_ExtentSet(GeneratedMesh,[WIDTH,HEIGHT],Err) - CALL cmfe_GeneratedMesh_NumberOfElementsSet(GeneratedMesh,[NUMBER_GLOBAL_X_ELEMENTS,NUMBER_GLOBAL_Y_ELEMENTS],Err) + IF(numberOfGlobalZElements==0) THEN + CALL cmfe_GeneratedMesh_ExtentSet(generatedMesh,[WIDTH,HEIGHT],err) + CALL cmfe_GeneratedMesh_NumberOfElementsSet(generatedMesh,[numberOfGlobalXElements,numberOfGlobalYElements],err) ELSE - CALL cmfe_GeneratedMesh_ExtentSet(GeneratedMesh,[WIDTH,HEIGHT,LENGTH],Err) - CALL cmfe_GeneratedMesh_NumberOfElementsSet(GeneratedMesh,[NUMBER_GLOBAL_X_ELEMENTS,NUMBER_GLOBAL_Y_ELEMENTS, & - & NUMBER_GLOBAL_Z_ELEMENTS],Err) + CALL cmfe_GeneratedMesh_ExtentSet(generatedMesh,[WIDTH,HEIGHT,LENGTH],err) + CALL cmfe_GeneratedMesh_NumberOfElementsSet(generatedMesh,[numberOfGlobalXElements,numberOfGlobalYElements, & + & numberOfGlobalZElements],err) ENDIF !Finish the creation of a generated mesh in the region - CALL cmfe_Mesh_Initialise(Mesh,Err) - CALL cmfe_GeneratedMesh_CreateFinish(GeneratedMesh,MeshUserNumber,Mesh,Err) + CALL cmfe_Mesh_Initialise(mesh,err) + CALL cmfe_GeneratedMesh_CreateFinish(generatedMesh,MESH_USER_NUMBER,mesh,err) !Create a decomposition - CALL cmfe_Decomposition_Initialise(Decomposition,Err) - CALL cmfe_Decomposition_CreateStart(DecompositionUserNumber,Mesh,Decomposition,Err) + CALL cmfe_Decomposition_Initialise(decomposition,err) + CALL cmfe_Decomposition_CreateStart(DECOMPOSITION_USER_NUMBER,mesh,decomposition,err) ! Set the decomposition to be a general decomposition with the specified number of domains - CALL cmfe_Decomposition_TypeSet(Decomposition,CMFE_DECOMPOSITION_CALCULATED_TYPE,Err) - CALL cmfe_Decomposition_NumberOfDomainsSet(Decomposition,NumberOfComputationalNodes,Err) + CALL cmfe_Decomposition_TypeSet(decomposition,CMFE_DECOMPOSITION_CALCULATED_TYPE,err) + CALL cmfe_Decomposition_NumberOfDomainsSet(decomposition,numberOfComputationalNodes,err) !Finish the decomposition - CALL cmfe_Decomposition_CreateFinish(Decomposition,Err) + CALL cmfe_Decomposition_CreateFinish(decomposition,err) !Destory the mesh now that we have decomposed it -! CALL cmfe_Mesh_Destroy(Mesh,Err) +! CALL cmfe_Mesh_Destroy(mesh,err) !----------------------------------------------------------------------------------------------------------- ! GEOMETRIC FIELD !----------------------------------------------------------------------------------------------------------- !Start to create a default (geometric) field on the region - CALL cmfe_Field_Initialise(GeometricField,Err) - CALL cmfe_Field_CreateStart(GeometricFieldUserNumber,Region,GeometricField,Err) + CALL cmfe_Field_Initialise(geometricField,err) + CALL cmfe_Field_CreateStart(GEOMETRIC_FIELD_USER_NUMBER,region,geometricField,err) !Set the decomposition to use - CALL cmfe_Field_MeshDecompositionSet(GeometricField,Decomposition,Err) + CALL cmfe_Field_MeshDecompositionSet(geometricField,decomposition,err) !Set the domain to be used by the field components. - CALL cmfe_Field_ComponentMeshComponentSet(GeometricField,CMFE_FIELD_U_VARIABLE_TYPE,1,1,Err) - CALL cmfe_Field_ComponentMeshComponentSet(GeometricField,CMFE_FIELD_U_VARIABLE_TYPE,2,1,Err) - IF(NUMBER_GLOBAL_Z_ELEMENTS/=0) THEN - CALL cmfe_Field_ComponentMeshComponentSet(GeometricField,CMFE_FIELD_U_VARIABLE_TYPE,3,1,Err) + CALL cmfe_Field_ComponentMeshComponentSet(geometricField,CMFE_FIELD_U_VARIABLE_TYPE,1,1,err) + CALL cmfe_Field_ComponentMeshComponentSet(geometricField,CMFE_FIELD_U_VARIABLE_TYPE,2,1,err) + IF(numberOfGlobalZElements/=0) THEN + CALL cmfe_Field_ComponentMeshComponentSet(geometricField,CMFE_FIELD_U_VARIABLE_TYPE,3,1,err) ENDIF !Finish creating the field - CALL cmfe_Field_CreateFinish(GeometricField,Err) + CALL cmfe_Field_CreateFinish(geometricField,err) !Update the geometric field parameters - CALL cmfe_GeneratedMesh_GeometricParametersCalculate(GeneratedMesh,GeometricField,Err) + CALL cmfe_GeneratedMesh_GeometricParametersCalculate(generatedMesh,geometricField,err) !----------------------------------------------------------------------------------------------------------- ! EQUATIONS SETS !----------------------------------------------------------------------------------------------------------- - !Create the Standard Laplace Equations set - CALL cmfe_EquationsSet_Initialise(EquationsSet,Err) - CALL cmfe_Field_Initialise(EquationsSetField,Err) - CALL cmfe_EquationsSet_CreateStart(EquationsSetUserNumber,Region,GeometricField,[CMFE_EQUATIONS_SET_CLASSICAL_FIELD_CLASS, & - & CMFE_EQUATIONS_SET_LAPLACE_EQUATION_TYPE,CMFE_EQUATIONS_SET_STANDARD_LAPLACE_SUBTYPE],EquationsSetFieldUserNumber, & - & EquationsSetField,EquationsSet,Err) + !Create the Standard Laplace equations set + CALL cmfe_EquationsSet_Initialise(equationsSet,err) + CALL cmfe_Field_Initialise(equationsSetField,err) + CALL cmfe_EquationsSet_CreateStart(EQUATIONS_SET_USER_NUMBER,region,geometricField,[CMFE_EQUATIONS_SET_CLASSICAL_FIELD_CLASS, & + & CMFE_EQUATIONS_SET_LAPLACE_EQUATION_TYPE,CMFE_EQUATIONS_SET_STANDARD_LAPLACE_SUBTYPE],EQUATIONS_SET_FIELD_USER_NUMBER, & + & equationsSetField,equationsSet,err) !Finish creating the equations set - CALL cmfe_EquationsSet_CreateFinish(EquationsSet,Err) + CALL cmfe_EquationsSet_CreateFinish(equationsSet,err) !----------------------------------------------------------------------------------------------------------- ! DEPENDENT FIELD !----------------------------------------------------------------------------------------------------------- !Create the equations set dependent field variables - CALL cmfe_Field_Initialise(DependentField,Err) - CALL cmfe_EquationsSet_DependentCreateStart(EquationsSet,DependentFieldUserNumber,DependentField,Err) + CALL cmfe_Field_Initialise(dependentField,err) + CALL cmfe_EquationsSet_DependentCreateStart(equationsSet,DEPENDENT_FIELD_USER_NUMBER,dependentField,err) !Set the DOFs to be contiguous across components - CALL cmfe_Field_DOFOrderTypeSet(DependentField,CMFE_FIELD_U_VARIABLE_TYPE,CMFE_FIELD_SEPARATED_COMPONENT_DOF_ORDER,Err) - CALL cmfe_Field_DOFOrderTypeSet(DependentField,CMFE_FIELD_DELUDELN_VARIABLE_TYPE,CMFE_FIELD_SEPARATED_COMPONENT_DOF_ORDER,Err) + CALL cmfe_Field_DOFOrderTypeSet(dependentField,CMFE_FIELD_U_VARIABLE_TYPE,CMFE_FIELD_SEPARATED_COMPONENT_DOF_ORDER,err) + CALL cmfe_Field_DOFOrderTypeSet(dependentField,CMFE_FIELD_DELUDELN_VARIABLE_TYPE,CMFE_FIELD_SEPARATED_COMPONENT_DOF_ORDER,err) !Finish the equations set dependent field variables - CALL cmfe_EquationsSet_DependentCreateFinish(EquationsSet,Err) + CALL cmfe_EquationsSet_DependentCreateFinish(equationsSet,err) !Initialise the field with an initial guess - CALL cmfe_Field_ComponentValuesInitialise(DependentField,CMFE_FIELD_U_VARIABLE_TYPE,CMFE_FIELD_VALUES_SET_TYPE,1,0.5_CMISSRP, & - & Err) + CALL cmfe_Field_ComponentValuesInitialise(dependentField,CMFE_FIELD_U_VARIABLE_TYPE,CMFE_FIELD_VALUES_SET_TYPE,1,0.5_CMISSRP, & + & err) !----------------------------------------------------------------------------------------------------------- ! EQUATIONS !----------------------------------------------------------------------------------------------------------- !Create the equations set equations - CALL cmfe_Equations_Initialise(Equations,Err) - CALL cmfe_EquationsSet_EquationsCreateStart(EquationsSet,Equations,Err) + CALL cmfe_Equations_Initialise(equations,err) + CALL cmfe_EquationsSet_EquationsCreateStart(equationsSet,equations,err) !Set the equations matrices sparsity type - CALL cmfe_Equations_SparsityTypeSet(Equations,CMFE_EQUATIONS_SPARSE_MATRICES,Err) -! CALL cmfe_Equations_SparsityTypeSet(Equations,CMFE_EQUATIONS_FULL_MATRICES,Err) + CALL cmfe_Equations_SparsityTypeSet(equations,CMFE_EQUATIONS_SPARSE_MATRICES,err) +! CALL cmfe_Equations_SparsityTypeSet(equations,CMFE_EQUATIONS_FULL_MATRICES,err) !Set the equations set output - CALL cmfe_Equations_OutputTypeSet(Equations,CMFE_EQUATIONS_NO_OUTPUT,Err) -! CALL cmfe_Equations_OutputTypeSet(Equations,CMFE_EQUATIONS_TIMING_OUTPUT,Err) -! CALL cmfe_Equations_OutputTypeSet(Equations,CMFE_EQUATIONS_MATRIX_OUTPUT,Err) -! CALL cmfe_Equations_OutputTypeSet(Equations,CMFE_EQUATIONS_ELEMENT_MATRIX_OUTPUT,Err) + CALL cmfe_Equations_OutputTypeSet(equations,CMFE_EQUATIONS_NO_OUTPUT,err) +! CALL cmfe_Equations_OutputTypeSet(equations,CMFE_EQUATIONS_TIMING_OUTPUT,err) +! CALL cmfe_Equations_OutputTypeSet(equations,CMFE_EQUATIONS_MATRIX_OUTPUT,err) +! CALL cmfe_Equations_OutputTypeSet(equations,CMFE_EQUATIONS_ELEMENT_MATRIX_OUTPUT,err) !Finish the equations set equations - CALL cmfe_EquationsSet_EquationsCreateFinish(EquationsSet,Err) + CALL cmfe_EquationsSet_EquationsCreateFinish(equationsSet,err) !----------------------------------------------------------------------------------------------------------- ! PROBLEM !----------------------------------------------------------------------------------------------------------- !Start the creation of a problem. - CALL cmfe_Problem_Initialise(Problem,Err) - CALL cmfe_Problem_CreateStart(ProblemUserNumber,[CMFE_PROBLEM_CLASSICAL_FIELD_CLASS,CMFE_PROBLEM_LAPLACE_EQUATION_TYPE, & - & CMFE_PROBLEM_STANDARD_LAPLACE_SUBTYPE],Problem,Err) + CALL cmfe_Problem_Initialise(problem,err) + CALL cmfe_Problem_CreateStart(PROBLEM_USER_NUMBER,[CMFE_PROBLEM_CLASSICAL_FIELD_CLASS,CMFE_PROBLEM_LAPLACE_EQUATION_TYPE, & + & CMFE_PROBLEM_STANDARD_LAPLACE_SUBTYPE],problem,err) !Finish the creation of a problem. - CALL cmfe_Problem_CreateFinish(Problem,Err) + CALL cmfe_Problem_CreateFinish(problem,err) !Start the creation of the problem control loop - CALL cmfe_Problem_ControlLoopCreateStart(Problem,Err) + CALL cmfe_Problem_ControlLoopCreateStart(problem,err) !Finish creating the problem control loop - CALL cmfe_Problem_ControlLoopCreateFinish(Problem,Err) + CALL cmfe_Problem_ControlLoopCreateFinish(problem,err) !----------------------------------------------------------------------------------------------------------- ! SOLVER !----------------------------------------------------------------------------------------------------------- !Start the creation of the problem solvers - CALL cmfe_Solver_Initialise(Solver,Err) - CALL cmfe_Problem_SolversCreateStart(Problem,Err) - CALL cmfe_Problem_SolverGet(Problem,CMFE_CONTROL_LOOP_NODE,1,Solver,Err) - CALL cmfe_Solver_OutputTypeSet(Solver,CMFE_SOLVER_NO_OUTPUT,Err) -! CALL cmfe_Solver_OutputTypeSet(Solver,CMFE_SOLVER_PROGRESS_OUTPUT,Err) -! CALL cmfe_Solver_OutputTypeSet(Solver,CMFE_SOLVER_TIMING_OUTPUT,Err) -! CALL cmfe_Solver_OutputTypeSet(Solver,CMFE_SOLVER_SOLVER_OUTPUT,Err) -! CALL cmfe_Solver_OutputTypeSet(Solver,CMFE_SOLVER_MATRIX_OUTPUT,Err) - -! CALL cmfe_Solver_LinearTypeSet(Solver,CMFE_SOLVER_LINEAR_ITERATIVE_SOLVE_TYPE,Err) -! CALL cmfe_Solver_LinearIterativeAbsoluteToleranceSet(Solver,1.0E-12_CMISSRP,Err) -! CALL cmfe_Solver_LinearIterativeRelativeToleranceSet(Solver,1.0E-12_CMISSRP,Err) - - CALL cmfe_Solver_LinearTypeSet(Solver,CMFE_SOLVER_LINEAR_DIRECT_SOLVE_TYPE,Err) - -! CALL cmfe_Solver_LinearTypeSet(Solver,CMFE_SOLVER_LINEAR_DIRECT_SOLVE_TYPE,Err) -! CALL cmfe_Solver_LibraryTypeSet(Solver,CMFE_SOLVER_MUMPS_LIBRARY,Err) -! CALL cmfe_Solver_LibraryTypeSet(Solver,CMFE_SOLVER_LAPACK_LIBRARY,Err) -! CALL cmfe_Solver_LibraryTypeSet(Solver,CMFE_SOLVER_SUPERLU_LIBRARY,Err) -! CALL cmfe_Solver_LibraryTypeSet(Solver,CMFE_SOLVER_PASTIX_LIBRARY,Err) + CALL cmfe_Solver_Initialise(solver,err) + CALL cmfe_Problem_SolversCreateStart(problem,err) + CALL cmfe_Problem_SolverGet(problem,CMFE_CONTROL_LOOP_NODE,1,solver,err) + CALL cmfe_Solver_OutputTypeSet(solver,CMFE_SOLVER_NO_OUTPUT,err) +! CALL cmfe_Solver_OutputTypeSet(solver,CMFE_SOLVER_PROGRESS_OUTPUT,err) +! CALL cmfe_Solver_OutputTypeSet(solver,CMFE_SOLVER_TIMING_OUTPUT,err) +! CALL cmfe_Solver_OutputTypeSet(solver,CMFE_SOLVER_SOLVER_OUTPUT,err) +! CALL cmfe_Solver_OutputTypeSet(solver,CMFE_SOLVER_MATRIX_OUTPUT,err) + +! CALL cmfe_Solver_LinearTypeSet(solver,CMFE_SOLVER_LINEAR_ITERATIVE_SOLVE_TYPE,err) +! CALL cmfe_Solver_LinearIterativeAbsoluteToleranceSet(solver,1.0E-12_CMISSRP,err) +! CALL cmfe_Solver_LinearIterativeRelativeToleranceSet(solver,1.0E-12_CMISSRP,err) + + CALL cmfe_Solver_LinearTypeSet(solver,CMFE_SOLVER_LINEAR_DIRECT_SOLVE_TYPE,err) + +! CALL cmfe_Solver_LinearTypeSet(solver,CMFE_SOLVER_LINEAR_DIRECT_SOLVE_TYPE,err) +! CALL cmfe_Solver_LibraryTypeSet(solver,CMFE_SOLVER_MUMPS_LIBRARY,err) +! CALL cmfe_Solver_LibraryTypeSet(solver,CMFE_SOLVER_LAPACK_LIBRARY,err) +! CALL cmfe_Solver_LibraryTypeSet(solver,CMFE_SOLVER_SUPERLU_LIBRARY,err) +! CALL cmfe_Solver_LibraryTypeSet(solver,CMFE_SOLVER_PASTIX_LIBRARY,err) !Finish the creation of the problem solver - CALL cmfe_Problem_SolversCreateFinish(Problem,Err) + CALL cmfe_Problem_SolversCreateFinish(problem,err) !----------------------------------------------------------------------------------------------------------- ! SOLVER EQUATIONS !----------------------------------------------------------------------------------------------------------- !Start the creation of the problem solver equations - CALL cmfe_Solver_Initialise(Solver,Err) - CALL cmfe_SolverEquations_Initialise(SolverEquations,Err) - CALL cmfe_Problem_SolverEquationsCreateStart(Problem,Err) + CALL cmfe_Solver_Initialise(solver,err) + CALL cmfe_SolverEquations_Initialise(solverEquations,err) + CALL cmfe_Problem_SolverEquationsCreateStart(problem,err) !Get the solve equations - CALL cmfe_Problem_SolverGet(Problem,CMFE_CONTROL_LOOP_NODE,1,Solver,Err) - CALL cmfe_Solver_SolverEquationsGet(Solver,SolverEquations,Err) + CALL cmfe_Problem_SolverGet(problem,CMFE_CONTROL_LOOP_NODE,1,solver,err) + CALL cmfe_Solver_SolverEquationsGet(solver,solverEquations,err) !Set the solver equations sparsity - CALL cmfe_SolverEquations_SparsityTypeSet(SolverEquations,CMFE_SOLVER_SPARSE_MATRICES,Err) - !CALL cmfe_SolverEquations_SparsityTypeSet(SolverEquations,CMFE_SOLVER_FULL_MATRICES,Err) + CALL cmfe_SolverEquations_SparsityTypeSet(solverEquations,CMFE_SOLVER_SPARSE_MATRICES,err) + !CALL cmfe_SolverEquations_SparsityTypeSet(solverEquations,CMFE_SOLVER_FULL_MATRICES,err) !Add in the equations set - CALL cmfe_SolverEquations_EquationsSetAdd(SolverEquations,EquationsSet,EquationsSetIndex,Err) + CALL cmfe_SolverEquations_EquationsSetAdd(solverEquations,equationsSet,equationsSetIndex,err) !Finish the creation of the problem solver equations - CALL cmfe_Problem_SolverEquationsCreateFinish(Problem,Err) + CALL cmfe_Problem_SolverEquationsCreateFinish(problem,err) !----------------------------------------------------------------------------------------------------------- ! BOUNDARY CONDITIONS !----------------------------------------------------------------------------------------------------------- !Start the creation of the equations set boundary conditions - CALL cmfe_BoundaryConditions_Initialise(BoundaryConditions,Err) - CALL cmfe_SolverEquations_BoundaryConditionsCreateStart(SolverEquations,BoundaryConditions,Err) + CALL cmfe_BoundaryConditions_Initialise(boundaryConditions,err) + CALL cmfe_SolverEquations_BoundaryConditionsCreateStart(solverEquations,boundaryConditions,err) !Set the first node to 0.0 and the last node to 1.0 - FirstNodeNumber=1 - CALL cmfe_Nodes_Initialise(Nodes,Err) - CALL cmfe_Region_NodesGet(Region,Nodes,Err) - CALL cmfe_Nodes_NumberOfNodesGet(Nodes,LastNodeNumber,Err) - CALL cmfe_Decomposition_NodeDomainGet(Decomposition,FirstNodeNumber,1,FirstNodeDomain,Err) - CALL cmfe_Decomposition_NodeDomainGet(Decomposition,LastNodeNumber,1,LastNodeDomain,Err) - IF(FirstNodeDomain==ComputationalNodeNumber) THEN - CALL cmfe_BoundaryConditions_SetNode(BoundaryConditions,DependentField,CMFE_FIELD_U_VARIABLE_TYPE,1,1,FirstNodeNumber,1, & - & CMFE_BOUNDARY_CONDITION_FIXED,0.0_CMISSRP,Err) + firstNodeNumber=1 + CALL cmfe_Nodes_Initialise(nodes,err) + CALL cmfe_Region_NodesGet(region,nodes,err) + CALL cmfe_Nodes_NumberOfNodesGet(nodes,lastNodeNumber,err) + CALL cmfe_Decomposition_NodeDomainGet(decomposition,firstNodeNumber,1,firstNodeDomain,err) + CALL cmfe_Decomposition_NodeDomainGet(decomposition,lastNodeNumber,1,lastNodeDomain,err) + IF(firstNodeDomain==computationalNodeNumber) THEN + CALL cmfe_BoundaryConditions_SetNode(boundaryConditions,dependentField,CMFE_FIELD_U_VARIABLE_TYPE,1,1,firstNodeNumber,1, & + & CMFE_BOUNDARY_CONDITION_FIXED,0.0_CMISSRP,err) ENDIF - IF(LastNodeDomain==ComputationalNodeNumber) THEN - CALL cmfe_BoundaryConditions_SetNode(BoundaryConditions,DependentField,CMFE_FIELD_U_VARIABLE_TYPE,1,1,LastNodeNumber,1, & - & CMFE_BOUNDARY_CONDITION_FIXED,1.0_CMISSRP,Err) + IF(lastNodeDomain==computationalNodeNumber) THEN + CALL cmfe_BoundaryConditions_SetNode(boundaryConditions,dependentField,CMFE_FIELD_U_VARIABLE_TYPE,1,1,lastNodeNumber,1, & + & CMFE_BOUNDARY_CONDITION_FIXED,1.0_CMISSRP,err) ENDIF !Finish the creation of the equations set boundary conditions - CALL cmfe_SolverEquations_BoundaryConditionsCreateFinish(SolverEquations,Err) + CALL cmfe_SolverEquations_BoundaryConditionsCreateFinish(solverEquations,err) !----------------------------------------------------------------------------------------------------------- ! SOLVE !----------------------------------------------------------------------------------------------------------- !Solve the problem - CALL cmfe_Problem_Solve(Problem,Err) + CALL cmfe_Problem_Solve(problem,err) !----------------------------------------------------------------------------------------------------------- ! OUTPUT !----------------------------------------------------------------------------------------------------------- !Export results - CALL cmfe_Fields_Initialise(Fields,Err) - CALL cmfe_Fields_Create(Region,Fields,Err) - CALL cmfe_Fields_NodesExport(Fields,"laplace_equation","FORTRAN",Err) - CALL cmfe_Fields_ElementsExport(Fields,"laplace_equation","FORTRAN",Err) - CALL cmfe_Fields_Finalise(Fields,Err) - - !Finialise CMISS - CALL cmfe_Finalise(Err) + CALL cmfe_Fields_Initialise(fields,err) + CALL cmfe_Fields_Create(region,fields,err) + CALL cmfe_Fields_NodesExport(fields,"LaplaceEquation","FORTRAN",err) + CALL cmfe_Fields_ElementsExport(fields,"LaplaceEquation","FORTRAN",err) + CALL cmfe_Fields_Finalise(fields,err) + + !Finialise OpenCMISS + CALL cmfe_Finalise(err) WRITE(*,'(A)') "Program successfully completed." STOP CONTAINS - SUBROUTINE HANDLE_ERROR(ERROR_STRING) - CHARACTER(LEN=*), INTENT(IN) :: ERROR_STRING - WRITE(*,'(">>ERROR: ",A)') ERROR_STRING(1:LEN_TRIM(ERROR_STRING)) + SUBROUTINE HandleError(errorString) + CHARACTER(LEN=*), INTENT(IN) :: errorString + WRITE(*,'(">>ERROR: ",A)') errorString(1:LEN_TRIM(errorString)) STOP - END SUBROUTINE HANDLE_ERROR + END SUBROUTINE HandleError -END PROGRAM LAPLACE_EQUATION +END PROGRAM LaplaceEquation diff --git a/src/fortran/visualise.cmgui b/src/fortran/visualise.cmgui index 59d26a2..df26b86 100644 --- a/src/fortran/visualise.cmgui +++ b/src/fortran/visualise.cmgui @@ -1,7 +1,16 @@ -$name = "laplace_equation"; +$name = "LaplaceEquation"; +$numProcs = 1; -gfx read node $name.part0.exnode; -gfx read elem $name.part0.exelem; +for($rank=0; $rank < $numProcs; $rank=$rank+1) + { + $filename = sprintf("./%s.part%d.exnode", $name, $rank); + gfx read node "$filename"; + } +for($rank=0; $rank < $numProcs; $rank=$rank+1) + { + $filename = sprintf("./%s.part%d.exelem", $name, $rank); + gfx read elem "$filename"; + } gfx def faces egroup $name; @@ -17,6 +26,5 @@ gfx modify window 1 image add_light default; gfx modify window 1 layout simple ortho_axes z -y eye_spacing 0.25 width 567 height 653; gfx modify window 1 set current_pane 1; gfx modify window 1 background colour 0 0 0 texture none; -gfx modify window 1 view parallel eye_point -1.32423 -1.97615 2.23909 interest_point 0.5 0.5 0.5 up_vector 0.305326 0.386341 0.870354 view_angle 37.5028 near_clipping_plane 0.0353321 far_clipping_plane 12.6265 relative_viewport ndc_placement -1 1 2 2 viewport_coordinates 0 0 1 1; -gfx modify window 1 overlay scene none; +gfx modify window 1 view parallel eye_point -4.0 -4.0 4.0 interest_point 1.0 0.5 1.5 up_vector 0.3 0.3 0.9 view_angle 40.0 near_clipping_plane 0.01 far_clipping_plane 15.0 relative_viewport ndc_placement -1 1 2 2 viewport_coordinates 0 0 1 1; gfx modify window 1 set transform_tool current_pane 1 std_view_angle 40 normal_lines no_antialias depth_of_field 0.0 fast_transparency blend_normal; diff --git a/src/python/expected_results/laplace_equation.component1.connectivity b/src/python/expected_results/LaplaceEquation.component1.connectivity similarity index 100% rename from src/python/expected_results/laplace_equation.component1.connectivity rename to src/python/expected_results/LaplaceEquation.component1.connectivity diff --git a/src/python/expected_results/laplace_equation.geometric.dofs.node b/src/python/expected_results/LaplaceEquation.dofs.node similarity index 100% rename from src/python/expected_results/laplace_equation.geometric.dofs.node rename to src/python/expected_results/LaplaceEquation.dofs.node diff --git a/src/python/expected_results/laplace_equation.part0.exelem b/src/python/expected_results/LaplaceEquation.part0.exelem similarity index 100% rename from src/python/expected_results/laplace_equation.part0.exelem rename to src/python/expected_results/LaplaceEquation.part0.exelem diff --git a/src/python/expected_results/laplace_equation.part0.exnode b/src/python/expected_results/LaplaceEquation.part0.exnode similarity index 100% rename from src/python/expected_results/laplace_equation.part0.exnode rename to src/python/expected_results/LaplaceEquation.part0.exnode diff --git a/src/python/expected_results/laplace_equation.phi.dofs.node b/src/python/expected_results/LaplaceEquation.phi.dofs.node similarity index 100% rename from src/python/expected_results/laplace_equation.phi.dofs.node rename to src/python/expected_results/LaplaceEquation.phi.dofs.node diff --git a/src/python/expected_results/LaplaceEquation.xml b/src/python/expected_results/LaplaceEquation.xml new file mode 100644 index 0000000..6af43cd --- /dev/null +++ b/src/python/expected_results/LaplaceEquation.xml @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 3 8 + 3 8 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 16 3 + 16 3 + + + + + + + + + + + + + + + + + + + + + + + + + + + 16 + 16 + + + + + + + + + + + + + + + + diff --git a/src/python/laplace_equation.py b/src/python/laplace_equation.py index 7143e1b..c9897a8 100644 --- a/src/python/laplace_equation.py +++ b/src/python/laplace_equation.py @@ -10,8 +10,8 @@ #----------------------------------------------------------------------------------------------------------- height = 1.0 -width = 1.0 -length = 1.0 +width = 2.0 +length = 3.0 (coordinateSystemUserNumber, regionUserNumber, @@ -33,7 +33,7 @@ # DIAGNOSTICS AND COMPUTATIONAL NODE INFORMATION #----------------------------------------------------------------------------------------------------------- -iron.DiagnosticsSetOn(iron.DiagnosticTypes.IN,[1,2,3,4,5],"Diagnostics",["DOMAIN_MAPPINGS_LOCAL_FROM_GLOBAL_CALCULATE"]) +#iron.DiagnosticsSetOn(iron.DiagnosticTypes.IN,[1,2,3,4,5],"Diagnostics",["Laplace_FiniteElementCalculate"]) # Get the computational nodes information numberOfComputationalNodes = iron.ComputationalNumberOfNodesGet() @@ -53,7 +53,7 @@ #----------------------------------------------------------------------------------------------------------- region = iron.Region() region.CreateStart(regionUserNumber,iron.WorldRegion) -region.label = "laplace_equation" +region.label = "LaplaceEquation" region.coordinateSystem = coordinateSystem region.CreateFinish() @@ -218,20 +218,20 @@ #----------------------------------------------------------------------------------------------------------- # Export results -baseName = "laplace_equation" +baseName = "LaplaceEquation" dataFormat = "PLAIN_TEXT" fml = iron.FieldMLIO() fml.OutputCreate(mesh, "", baseName, dataFormat) fml.OutputAddFieldNoType(baseName+".geometric", dataFormat, geometricField,iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES) fml.OutputAddFieldNoType(baseName+".phi", dataFormat, dependentField,iron.FieldVariableTypes.U, iron.FieldParameterSetTypes.VALUES) -fml.OutputWrite("laplace_equation.xml") +fml.OutputWrite("LaplaceEquation.xml") fml.Finalise() fields = iron.Fields() fields.CreateRegion(region) -fields.NodesExport("laplace_equation","FORTRAN") -fields.ElementsExport("laplace_equation","FORTRAN") +fields.NodesExport("LaplaceEquation","FORTRAN") +fields.ElementsExport("LaplaceEquation","FORTRAN") fields.Finalise() # Finalise OpenCMISS-Iron diff --git a/src/python/visualise.cmgui b/src/python/visualise.cmgui new file mode 100644 index 0000000..df26b86 --- /dev/null +++ b/src/python/visualise.cmgui @@ -0,0 +1,30 @@ +$name = "LaplaceEquation"; +$numProcs = 1; + +for($rank=0; $rank < $numProcs; $rank=$rank+1) + { + $filename = sprintf("./%s.part%d.exnode", $name, $rank); + gfx read node "$filename"; + } +for($rank=0; $rank < $numProcs; $rank=$rank+1) + { + $filename = sprintf("./%s.part%d.exelem", $name, $rank); + gfx read elem "$filename"; + } + +gfx def faces egroup $name; + +gfx modify g_element $name general clear circle_discretization 6 default_coordinate Coordinate element_discretization "4*4*4" native_discretization none; +gfx modify g_element $name lines select_on invisible material default selected_material default_selected; +gfx modify g_element $name surfaces select_on material default data Phi spectrum default selected_material default_selected render_shaded; +gfx modify g_element $name node_points glyph sphere general size "0.025*0.025*0.025" centre 0,0,0 font default label cmiss_number select_on material blue selected_material default_selected; +gfx modify g_element $name cylinders constant_radius 0.005 select_on material gold selected_material default_selected render_shaded; + +gfx create window 1 double_buffer; +gfx modify window 1 image scene default light_model default; +gfx modify window 1 image add_light default; +gfx modify window 1 layout simple ortho_axes z -y eye_spacing 0.25 width 567 height 653; +gfx modify window 1 set current_pane 1; +gfx modify window 1 background colour 0 0 0 texture none; +gfx modify window 1 view parallel eye_point -4.0 -4.0 4.0 interest_point 1.0 0.5 1.5 up_vector 0.3 0.3 0.9 view_angle 40.0 near_clipping_plane 0.01 far_clipping_plane 15.0 relative_viewport ndc_placement -1 1 2 2 viewport_coordinates 0 0 1 1; +gfx modify window 1 set transform_tool current_pane 1 std_view_angle 40 normal_lines no_antialias depth_of_field 0.0 fast_transparency blend_normal;